Nu op het Weblog

Nu op het fotoblog

Nu op het Videoblog

Nu op het Muziekblog

Nu op het Kookblog

Nu op het Liveblog

26 juli 2010

Tesla Muse (Synth test 1)



Ben bezig om de behuizing van mijn Elektrieken draailier te ontwerpen, die wil ik gaan opbouwen rond een buis (PVC of Aluminium). Wou even testen hoe het zou klinken, Arduino to the rescue.

In de buis zit een kleine speaker gemonteerd. In het definitieve model zal ik waarschijnlijk een piezo element hiervoor gebruiken omdat daar altijd een sine wave uitkomt, is wel zo makkelijk als je digitale oscillatoren wilt gaan gebruiken die vooral square waves opleveren. Vind persoonlijk een sine wave iets gemoedelijker klinken.

Ik zou genoeg hebben gehad aan de Tone functie van de Arduino, maar "if it's worth doing it's worth overdoing". Heb nog een hele batterij TCA0372DP1 IC's uit een oude Philips radio liggen die ik eens wou gaan proberen.

Ik voed de TCA372DP1 een Toon met de Arduino die ik met een potmeter kan manipuleren in hoogte. Met dezelfde Arduino stuur ik een signaal naar de TCA372DP1 waarmee ik de IC snel aan en uit schakel ook dit signaal kan ik met een potmeter instellen. Hier komt de modulatie die je hoort in de video vandaan. Voor de lol ook nog een derde potmeter aangesloten, die de derde parameter voor de toon vormt.

Het circuit ziet er alvolgt uit:


De code:

#define TESTTOON 3

#define POT_1 1
#define POT_2 2
#define POT_3 3

#define TOETSENBORD 0

#define OPAMP_1 4

int potwaarde_1 = 0;
int potwaarde_2 = 0;
int potwaarde_3 = 0;

int toetsenbord_waarde = 0;

void setup(){
  pinMode(TESTTOON, OUTPUT);

  pinMode(OPAMP_1, OUTPUT);

  pinMode(POT_1, INPUT);
  pinMode(POT_2, INPUT);
  pinMode(POT_3, INPUT);

void loop(){
  potwaarde_1 = analogRead(POT_1);
  potwaarde_2 = analogRead(POT_2);
  potwaarde_3 = analogRead(POT_3);
  toetsenbord_waarde = analogRead(TOETSENBORD);

  tone(TESTTOON, potwaarde_1);

  digitalWrite(OPAMP_1, HIGH);
  delayMicroseconds(potwaarde_2);
  digitalWrite(OPAMP_1, LOW);
  delayMicroseconds(potwaarde_3);
  
}

Ik ben eigenlijk heel erg blij met het geluid, met een beetje draaien aan de pot's en een paar software tweaks (Je kunt de Potmeterwaarden bijvoorbeeld delen of vermenigvuldigen) kun je mooie heldere tonen tevoorschijn toveren. Soms hebben die tonen een beetje een Balkan-achtige sfeer.

19 juli 2010

Tesla Muse (interface prototype)



Eindelijk constructief tijd kunnen besteden aan mijn "Tesla Muse" (Tesla is de uitvinder van de 3 fasen motor die het hart vormt van dit ding).

Op het filmpje is te zien dat ik (eindelijk!!!) een motor uit een hardeschijf veranderd heb in een, euhhh, draaiding input.

De LED's zijn eigenlijk bedoeld om straks een 16 staps sequencer mee te kunnen programmeren, heb even een progsel geschreven zodat ik de kon zien hou het draaiding werkt.

Nu opzoek naar een Commondore 64, zou heel graag een SID in handen krijgen om te testen als geluidsgenerator.


Ben de interface aan het documenteren, dus wordt waarschijnlijk vervolgd ->

27 mei 2010

Afstandsbediening voor Nikon met interval timer (concept II)





p.s Filmpje heeft een paar buggy overgangen. Geen idee waar die vandaan komen?! Simpel filmpje dus iMovie gebruikt.

Vervolg op dit ->

Heb weer eens mijn soldeerbout en Dremel ter hand genomen.

Op dit moment dus een functioneel kastje in mijn bezit. Nog lang niet tevreden, maar het werkt!

Het ding heb ik uitgerust met twee IR LED's. Ik heb nog niet de ruimte gevonden om het helemaal goed te testen, maar het bereik is mininimaal 15 meter.

Het is redelijk makkelijk in gebruik, heeft in ieder geval alle functie van de originele afstandsbediening van Nikon. Kan nu dus ook s'nacht lange sluitingstijden gebruiken zonder dat ik de ontspanner ingedrukt hoef te houden!

Met de originele Nikon afstandsbediening kun je op de D60, voor andere modellen weet ik het niet, twee seconden ontspanningsvertraging instellen (lijkt mij net te weinig om de afstandsbediening weg te werken als je een foto van je zelf zou willen maken). Met die van mij in principe een oneindige vertraging.

De interval functie heet de originele Nikon afstandsbediening niet.

Het videodoosje is makkelijk aan mijn statief te bevestigen als ik de interval functie wil gebruiken.

De totale prijs tot nu toe:

* Arduino 26,18 euri (De Arduino is te vervangen voor enkel en alleen de ATMega328 chip met een paar andere componenten)
* Een perforatiebordje 1,65 euri
* Vijf weerstanden (drie 220ohm voor de LED's twee 10k voor de schakelaars) a 0.05 cent stuk dus * 0,25 euri (Dick Best ->)
* Drie ledjes a 0.05 cent stuk dus 0,15 euri (Dick Best ->)

Totaal dus rond de 28,23 euri. Ik reken de tin (ooit eens gratis 250 gram ergens gekregen) en draadjes (uit oude VGA kabels etc. gesloopt) ook niet mee.

In vergelijk met de originele Nikon ML13 helemaal niet zo gek. Vooral niet als je kijkt wat voor functies ik extra heb. DIY loont dus in dit geval goed!

De rest van de onderdelen ergens uit kunnen slopen. Weerstanden waren ook niet echt nodig had ik ook nog tweede hands liggen. Maar wie het breed heeft laat het breed hangen! Voor de IR LED's trouwens wel een tweede hands 100k gebruikt.


Detail opname 1


Detail opname 2



Schema (Niet de mooiste. Heb het progsel Fritzing uitgeprobeerd. Het idee ervan is leuk, van breadboard naar PCB, maar de uitwerking?!?!?! Ik had helaas niet genoeg Deutsche scheldwoorden in mijn repetoire om met enige nut het programma te laten doen wat ik wou).

De code tot zover. Het is nog niet van comments voorzien omdat ik nog lang niet tevreden ben. Denk dat ik de helft nog efficienter kan herschrijven, onderstaande is fout op fout stapelen tot het werkt.


#include <NikonRemote.h>

//HARDWARE
const int intervalometerPotmeter = 0;
const int ontspannerSchakelaar = 4;
const int bewegingsensorSchakelaar = 7;
const int intervalometerSchakelaar = 8;
const int powerLed = 9;
const int intervalometerLed = 10;
const int bewegingsensorLed = 11;
const int irLed = 12;

int ontspannerStatus = HIGH;
int bewegingsensorStatus = LOW;
int intervalometerStatus = LOW;

//VARIABELEN
long interval = 0;
long laatsteFoto = 0;

int instellingTimer = 0;

int instelFunctieIntervalometerGeinitieerd = 0;
int instelFunctieIntervalometerBezig = 0;
int intervalometerIngesteld = 0;
int intervalometerReset = 0;

int instelFunctieOntspannerGeinitieerd = 0;
int instelFunctieOntspannerBezig = 0;
int ontspannerIngesteld = 0;
int ontspannerResetSignaal = 0;

long ontspannerSchakelaarTellerWaarde = 0;
long ontspannerSchakelaarTellerLaatsteStaat = 0;
long ontspannerSchakelaarTellerStaat = 0;
long ontspannerSchakelaarTellerGereset = 0;

long ontspannerVertraging = 0;

int instelTimer = 0;

int escapeLoop = 0;

int ontspannerVertragingIntervalometer = 0;

int standaardStaat = 0;
int ontspannerStaat = 0;
int intervalometerStaat = 0;
int bewegingsensorStaat = 0;
int stelOntspannerIn = 0;
int stelIntervalometerIn = 0; 

NikonRemote camera(irLed);

//SETUP
void setup(){
  pinMode (ontspannerSchakelaar, INPUT);
  pinMode (intervalometerSchakelaar, INPUT);
  pinMode (bewegingsensorSchakelaar, INPUT);

  pinMode (powerLed, OUTPUT);
  pinMode (intervalometerLed, OUTPUT);
  pinMode (bewegingsensorLed, OUTPUT);

  pinMode (irLed, OUTPUT);

  ledOpstartSequencie();
  powerLedAan();
}

void loop(){
  ontspannerStatus = !digitalRead(ontspannerSchakelaar);
  intervalometerStatus = !digitalRead(intervalometerSchakelaar);
  bewegingsensorStatus = !digitalRead(bewegingsensorSchakelaar);
  
  initieerSchakelaarStaat();
  long ontspannerVertraging = ontspannerSchakelaarTellerWaarde;
  
  if (intervalometerStaat == 0 && bewegingsensorStaat == 0 && ontspannerStaat == 1){
   zelfontspannerFunctie(ontspannerVertraging);
  }

  if (intervalometerStaat == 1 && instelTimer == 0){
    if (instelFunctieOntspannerBezig == 0 && instelFunctieIntervalometerBezig == 0 && instelTimer == 0){
      optelLedSignaal();
      instelTimer = 1;
      powerLedAan();
      initieerSchakelaarStaat();
    }
  }

  if (stelIntervalometerIn == 1 && instelTimer == 1 && intervalometerIngesteld == 0){

    if (stelIntervalometerIn == 1 && instelFunctieIntervalometerGeinitieerd == 0){
      instelFunctieIntervalometerGeinitieerd = 1;
      initieerSchakelaarStaat();
    }

    if (stelIntervalometerIn == 1 && instelFunctieIntervalometerGeinitieerd == 1){
      instelFunctieIntervalometerBezig = 1;
      initieerSchakelaarStaat();
    }

    if (stelIntervalometerIn == 1 && instelFunctieIntervalometerBezig == 1){
      intervalometerInstelFunctie();
      long x = (analogRead(intervalometerPotmeter));
      if(x != (analogRead(intervalometerPotmeter))){
        intervalometerIngesteld = 1;
      }
    }
  }

  if (intervalometerStaat == 1 && escapeLoop == 0){
    intervalometerStaat = 0;
    escapeLoop = 1;
  }
  if (ontspannerStaat == 0 && intervalometerStaat == 1){
    intervalometerReset = 1;
    intervalometerFunctie(ontspannerVertraging); 
  }

  if (stelOntspannerIn == 1 && instelTimer == 1){

    alleLedsUit();

    if (stelOntspannerIn == 1){
      instelFunctieOntspannerBezig = 1;
      ontspannerTellerInstelFunctie();
    }
  }

  if (stelOntspannerIn == 0 && instelFunctieOntspannerBezig == 1 && ontspannerIngesteld == 0){
    alleLedsUit();
    delay(1000);
    ontspannerIngesteld = 1;
    aftelLedSignaal();
    powerLedAan();
  }

}

void bepaalIntervalFunctie (){
  interval = map(analogRead(intervalometerPotmeter), 1023, 0, 1, 60);
  interval = interval * 1000; 
}

void intervalometerInstelFunctie(){
  bepaalIntervalFunctie();
  if (millis() - laatsteFoto > interval){
    ledFunctie(0, 0, bewegingsensorLed, 0, 0, 1, 10);
    laatsteFoto = millis(); 
  }
}

void intervalometerFunctie(long vertraging){
  if (vertraging == 0){
    bepaalIntervalFunctie();
    if (millis() - laatsteFoto > interval){
      camera.Snap();
      delay(1);
      ledFunctie(0, 0, bewegingsensorLed, 0, 0, 1, 10);
      laatsteFoto = millis();
    }
  }
  else if(vertraging != 0){
    bepaalIntervalFunctie();
    if(ontspannerVertragingIntervalometer == 0){
      ontspannerVertragingIntervalometer = 1;
      delay(vertraging*1000);
    } 
    if (millis() - laatsteFoto > interval){
      camera.Snap();
      delay(1);
      ledFunctie(0, 0, bewegingsensorLed, 0, 0, 1, 10);
      laatsteFoto = millis();
    }
  }
}

//ONTSPANNER

void ontspannerTellerInstelFunctie(){
  powerLedUit();
  ontspannerSchakelaarTellerStaat = !digitalRead(ontspannerSchakelaar);
  if(ontspannerSchakelaarTellerStaat != ontspannerSchakelaarTellerLaatsteStaat){
    if(ontspannerSchakelaarTellerStaat == LOW){
      ontspannerSchakelaarTellerWaarde++;
      instellingenLedSignaal();
    }
    ontspannerSchakelaarTellerLaatsteStaat = ontspannerSchakelaarTellerStaat;
  }
}

void zelfontspannerFunctie(long vertraging){
  if (vertraging == 0){
    powerLedUit();
    camera.Snap();
    ontspannerLedSignaal();
  }
  else if (vertraging <= 5 && vertraging != 0){
    powerLedUit();
    delay(vertraging*1000-500);
    camera.Snap();
    ontspannerLedSignaal();
  }
  else if(vertraging > 5){
    powerLedUit();
    delay(vertraging*1000-4500+500);
    optelLedSignaal();
    camera.Snap();
    ontspannerLedSignaal();
  }
  ontspannerReset();
}

void ontspannerReset(){
  ontspannerSchakelaarTellerLaatsteStaat = 0;
  ontspannerSchakelaarTellerStaat = 0;
  ontspannerSchakelaarTellerWaarde = 0;
}

//LED's
void ledFunctie (char ledId1, char ledId2, char ledId3, int beginStaat, int eindStaat, int aantal, long vertraging) {
  delay (vertraging);
  if (beginStaat == 0) {
    if (ledId1 != 0){
      digitalWrite(ledId1, LOW);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, LOW);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, LOW);
    }
  }
  if (beginStaat == 1) {
    if (ledId1 != 0){
      digitalWrite(ledId1, HIGH);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, HIGH);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, HIGH);
    }
  }
  for (int i=0; i < aantal; i++) {
    delay (vertraging);
    if (ledId1 != 0){
      digitalWrite(ledId1, HIGH);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, HIGH);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, HIGH);
    }
    delay (vertraging);
    if (ledId1 != 0){
      digitalWrite(ledId1, LOW);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, LOW);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, LOW);
    }
    delay (vertraging);
  }
  if (eindStaat == 0) {
    if (ledId1 != 0){
      digitalWrite(ledId1, LOW);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, LOW);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, LOW);
    }
  }  
  if (eindStaat == 1) {
    if (ledId1 != 0){
      digitalWrite(ledId1, HIGH);
    }
    if (ledId2 != 0){
      digitalWrite(ledId2, HIGH);
    }
    if (ledId3 != 0){
      digitalWrite(ledId3, HIGH);
    }
  }
}

void ledOpstartSequencie() {
  ledFunctie(powerLed, 0, 0, 0, 0, 1, 50);
  delay(500);
  ledFunctie(powerLed, intervalometerLed, 0, 0, 0, 2, 50);
  delay(500);
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 3, 50);
  delay(500);
}

void ontspannerLedSignaal() {
  delay(100);
  ledFunctie(powerLed, 0, 0, 0, 0, 3, 5);
  ledFunctie(powerLed, intervalometerLed, 0, 0, 0, 3, 5);
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 3, 5);
  delay(100);
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 0, 0);
  delay(785);
  ledFunctie(powerLed, 0, 0, 0, 1, 0, 0); 
}

void instellingenLedSignaal() {
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 3, 20);
}

void optelLedSignaal() {
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 0, 0);
  delay(1000);
  ledFunctie(powerLed, 0, 0, 0, 1, 0, 0);
  delay(1000);
  ledFunctie(0, intervalometerLed, 0, 0, 1, 0, 0);
  delay(1000);
  ledFunctie(0, 0, bewegingsensorLed, 0, 1, 0, 0);
  delay(1000);
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 0, 0); 
  delay(500);
  powerLedAan();
}

void aftelLedSignaal() {
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 1, 1, 1, 0);
  delay(1000);
  ledFunctie(0, 0, bewegingsensorLed, 1, 0, 1, 0);
  delay(1000);
  ledFunctie(0, intervalometerLed, 1, 1, 0, 1, 0);
  delay(1000);
  ledFunctie(powerLed, 1, 1, 1, 0, 1, 0);
  delay(1000);
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 0, 0);
  delay(500);
  powerLedAan();  
}

void bevestigingsLedSignaal() {
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 1, 200);
}

void alleLedsUit() {
  ledFunctie(powerLed, intervalometerLed, bewegingsensorLed, 0, 0, 0, 0);
}

void powerLedAan() {
  delay(500);
  ledFunctie(powerLed, 0, 0, 0, 1, 0, 0); 
}

void powerLedUit() {
  delay(500);
  ledFunctie(powerLed, 0, 0, 0, 0, 0, 0); 
}

void intervalometerLedAan() {
  ledFunctie(0, intervalometerLed, 0, 0, 1, 0, 0);
}

void intervalometerLedUit() {
  ledFunctie(0, intervalometerLed, 0, 0, 0, 0, 0);
}

void bewegingsensorLedAan() {
  ledFunctie(0, 0, bewegingsensorLed, 0, 1, 0, 0);
}

void bewegingsensorLedUit() {
  ledFunctie(0, 0, bewegingsensorLed, 0, 0, 0, 0);
}

void initieerSchakelaarStaat() {
  if (ontspannerStatus == HIGH && intervalometerStatus == LOW && bewegingsensorStatus == LOW){
    standaardStaat = 1;
    ontspannerStaat = 0;
    intervalometerStaat = 0;
    bewegingsensorStaat = 0;
    stelOntspannerIn = 0;
    stelIntervalometerIn = 0; 
    powerLedAan();
    intervalometerLedUit();
    bewegingsensorLedUit();
  }
  else if (ontspannerStatus == LOW && intervalometerStatus == LOW && bewegingsensorStatus == LOW){
    standaardStaat = 0;
    ontspannerStaat = 1;
    intervalometerStaat = 0;
    bewegingsensorStaat = 0;
    stelOntspannerIn = 0;
    stelIntervalometerIn = 0;
    alleLedsUit();
  }
  else if (ontspannerStatus == HIGH && intervalometerStatus == HIGH && bewegingsensorStatus == HIGH){
    standaardStaat = 0;
    ontspannerStaat = 0;
    intervalometerStaat = 0;
    bewegingsensorStaat = 0;
    stelOntspannerIn = 1;
    stelIntervalometerIn = 0;
    alleLedsUit();
    }
  else if (ontspannerStatus == LOW && intervalometerStatus == HIGH && bewegingsensorStatus == LOW){
    standaardStaat = 0;
    ontspannerStaat = 0;
    intervalometerStaat = 0;
    bewegingsensorStaat = 0;
    stelOntspannerIn = 0;
    stelIntervalometerIn = 1;
    powerLedAan();
    intervalometerLedAan(); 
    bewegingsensorLedUit();
  }
  else if (ontspannerStatus == HIGH && intervalometerStatus == HIGH && bewegingsensorStatus == LOW){
    if (instelFunctieOntspannerBezig == 1){
      delay(200);
      instelFunctieOntspannerBezig = 0;
    }
    else if(instelFunctieOntspannerBezig == 0){
      standaardStaat = 0;
      ontspannerStaat = 0;
      intervalometerStaat = 1;
      bewegingsensorStaat = 0;
      stelOntspannerIn = 0;
      stelIntervalometerIn = 0;
      powerLedAan();
      intervalometerLedAan(); 
      bewegingsensorLedUit();
    }
  }
  else if (ontspannerStatus == HIGH && intervalometerStatus == LOW && bewegingsensorStatus == HIGH){
    standaardStaat = 0;
    ontspannerStaat = 0;
    intervalometerStaat = 0;
    bewegingsensorStaat = 1;
    stelOntspannerIn = 0;
    stelIntervalometerIn = 0;
    powerLedAan();
    intervalometerLedUit(); 
    bewegingsensorLedAan();
  }
}

Ik wil proberen of ik het ding met losse modules kan gaan uitbreiden. b.v een kastje met een bewegingssensor of met een microfoon. Ook wil ik me gaan verdiepen in flitsbediening op afstand.

Verder wil ik kijken of ik het zo kan maken dat ik via mijn kastje de camera kan laten bracketten.

Ook lijkt me een kastje met aangestuurde motor voor 360 of panorama's me wel handig.

Verder moet er natuurlijk nog een veul mooier kastje komen. Maar dan moet ik eerst weten wat er allemaal aan elektronika in moet. Nu nog niet helemaal duidelijk. En dan moet ik natuurlijk weer eens na het tig jaren niet gedaan te hebben een printplaat gaan maken! Niet met Fritzing dat is in ieder geval duidelijk.

p.s Muziek is van Israel Vibrations nummer heet Try Again

12 mei 2010

Afstandsbediening voor Nikon met interval timer (concept)

Sinds kort een Arduino in bezit. Een soort van Zwitsers zakmes voor de gadget nerd.

Zocht een leuk beginners projectje dat werd een IR afstandsbediening voor mijn Nikon D60. Een UV ledje was snel genoeg in de weelde die grofvuil heet gevonden. Een afstandsbediening voor waarschijnlijk een videorecorder. Vond de zelfde dag ook nog een goedkope elektrische auto zonder de afstandsbediening (sjips geen joysticks) met een potmeter en een schakelaar!

In eerste instantie wou ik alleen dit project in elkaar knutselen. Heb het uitgebreid met de potmeter waarmee ik de interval snelheid kan instellen en een aan en uit schakelaar wat altijd wel handig is om te hebben op een gadget.

Tot zover ziet het monster er ongeveer zo uit:


Wil het nog gaan uitbreiden met een bewegingssensor en het lijkt me ook handig als ik een knopje heb om een enkele foto te maken.

De code tot zover (wel even de nikonIrControl bibliotheek installeren!):



#include <NikonRemote.h>

//De IR LED
const int irLedPin = 12;

//Intervalometer aan/uit
const int intervalometerPauzeWaardePin = 5;

//De potmeter om de intervals mee te setten
const int intervalometerPotmeter = 5;

//Ik verklaar hiebij dat er iets als een IntervaloleterPauzeWaarde bestaat
int intervalometerPauzeWaarde;

// Variabelen om de interval en de laatsteFoto in op te slaan
long interval = 0;
long laatsteFoto = 0;

//Functie uit de nikonIrControl bibliotheek die het allemaal mogelijk maakt aanroepen:
NikonRemote camera(irLedPin);

void setup()
{
  //Vertel hier de Arduino dat er zoiets als een IR LED bestaat
  pinMode(irLedPin, OUTPUT);
  
  //Er bestaat ook zoiets als een potmeter in het universum van deze specifieke Arduino
  pinMode(intervalometerPotmeter, OUTPUT);
}


void loop()
{
  intervalometerPauzeWaarde = !digitalRead(intervalometerPotmeter);
  
  if (intervalometerPauzeWaarde == HIGH) {
    
    //Breng de waarde van de potmeter op de analoge ingang in "kaart"
    interval = map(analogRead(intervalometerPotmeter), 1000, 0, 1, 60);
  
    //Potmeter waarde moet ik nog een beetje beter in kaart brengen moet de waarde
    //op dit moment nog met 1000 vermenigvuldigen om het een beetje werkend te krijgen
    //lelijke hack maar werkt voor nu.
    interval = interval * 1000;
    
    controleerIntervalometer();
  
  Serial.write(interval);
}
  
}

void controleerIntervalometer()
{
  //Reken uit of er alweer een nieuwe foto genomen moet worden 
  if (millis() - laatsteFoto > interval) {
    camera.Snap();
    laatsteFoto = millis();
  }
}
 
//Oude werkende!! code

 //delay(1000);
 //camera.Snap();

Het jongetje op de foto heet Sacha, maar ik noem hem mijn assistent Igor. Was de eerste foto die lukte met de afstandbediening.

17 april 2010

Adam or God (prototype II)


Het tweede prototype van mijn "Adam or God" project is klaar. Duurde langer dan ik had gedacht. (hier het eerste prototype -->)

Ik wilde geen geld aan dit project besteden, met de filosofie dat wat ik nodig heb mij wel door "???" beschikbaar zou worden gesteld. Dit is voor het grootste gedeelte gelukt!! Moest alleen een nettere print hebben van de Michelangelo schildering, dat heeft me een velletje fotopapier en een beetje inkt gekost, en de penis die nu als meternaald dient koste me een heel klein stukje gewoon print papier plus de liefde, tijd en het geduld om het te maken.

De rest van de onderdelen zijn mij door "voorzienigheid" gegeven! De 12V transformator, de variabele weerstanden die ik moest hebben, de toerenteller (draaispoel meter), de fotoweerstand, de draadjes, schroefjes etc.

Denk dat ik niet meer veel kan verbeteren. Moet het alleen nog op de één of andere manier ingelijst zien te krijgen.

Ik ga proberen binnenkort een uitleg te schrijven over het wat, hoe, waarom, etc.

p.s De muziek onder het filmpje is van The Beastie Boys - 33% God

8 april 2010

Adam or God (prototype I)

Het prototype van mijn kladprojectje "Adam or God" is in elkaar geschroefd (hier het eerste deel -->).




Ben nog niet helemaal gelukkig met de gevoeligheid van de fotoweerstand. Het lukt niet helemaal lekker om het ding geheel verduisterd te krijgen. Als ik mijn vinger erop leg dan dringt er nog licht door aan de zijkant van de weerstand. Dat moet ik nog even oplossen.

De meter kan nog een beetje krachtiger. Denk dat ik met 12 Volt moet gaan werken om er een andere naald op te kunnen monteren. Er moeten ook nog een paar "stootbumpers" gevonden worden zodat de naald naar Adam of God wijst en er niet voorbij schiet.

Voor de rest schijnt alles te werken. Nu opzoek naar materiaal om het mooi en stevig in te lijsten.

3 april 2010

Adam or God

Mijn volgende kladprojectje.

Heb de computer en alles wat er mee te maken heeft even een tijdje links laten liggen, en ben weer eens in de wonder wereld gedoken die als "echt" wordt aangeduid.

Vind het heerlijk om s'ochtends vroeg in het grofvuil aan de straat te duiken, tot ik een project bij elkaar heb verzameld. Meestal zijn het elektronica projectjes.

Had dit keer ergens een toerenteller uit een auto, en een nachtlampje die vanzelf aangaat als het donker wordt gevonden. Dus een draaispoel meter (geen verdere onderdeel info) en een fotoweerstand (ook geen verdere info). Die twee onderdelen brachten me op het volgende idee.

Een fotoweerstand laat meer Volts door naarmate het donkerde wordt, en met een draaispoel meter kun je die Volts "meten".

Licht, donker, het feit dat ik met mijn vinger de fotoweerstand moest afschermen van het licht om te testen of het werkte brachten me gedachten naar het schilderij "De Schepping" van Michelangelo in de Sixtijnse Kapel van Adam en God.

Ik wil dus een soort van "Schilderij" maken waarin ik de fotoweerstand tussen de vinger van God en Adam monteer die je kunt afschermen van licht waardoor de meter naar Adam wijst (in rust toestand komt). Als er licht op de fotoweestand valt zal de meter uitslaan naar God.

Simpel electro circuit van vier onderdelen, draaispoel meter, fotoweestand, batterijclip (zit er aan te denken om het met een adapter te gaan doen) en natuurlijk een batterij (voorlopig 9V).

Ben nog opzoek naar iets om het geheel weg te werken in een mooi "lijstje" met natuurlijk een afbeelding van het schilderij van Michelangelo op de achtergrond.

Weet nog niet hoe ik de naald van de meter ga vormgeven. Een lul zoals Paul Hajenius voorstelde?

Enfin, nu de onderdelen verzamelen die ik nog niet heb en een middagje of wat klussen en dan moet het prototype klaar zijn.

3 maart 2010

Quartz Composer - Sound Reactive Engine V1


Dit is een project waar ik al een tijd mee in mijn hoofd zat. Nog steeds niet helemaal zoals ik het wil maar het begin is er.

Ik wil een soort "video orgel" maken waarbij omgevingsgeluid en beweging voor een camera een trigger zijn om videobeelden te generen. Ik wil dit doen met de Quartz Composer software die ingebakken zit in Mac OSX.

Het probleem was een beetje dat er op een makkelijke manier eigenlijk maar twee triggers zouden zijn. Er gebeurd iets voor de lens van de camera of niet en er wordt geluid opgevangen door de microfoon of niet. Da's een beetje weinig om echt iets interessants mee te kunnen doen.

De camera trigger laat ik nog even links liggen. Die wil ik gaan triggeren door Quartz te laten reageren op verschillende kleuren. Ben nog aan het denken hoe dat op een efficiënte manier te doen.

Voor het geluid heb ik bedacht om Quartz Composer bepaalde frequentie bereiken te laten meten, en ieder frequentie bereik geeft twee waarden (de positieve en negatieve waarde) af waarmee ik b.v 3d vormen kan laten bewegen, video lagen mee kan starten, een partikel generator mee kan aansturen etc. Ook kan ik de waarden nog bewerken met verschillende berekeningen of conditionals. Ook meet het progsel het volume van het geluid.

In totaal kan ik 13 frequentie bereiken meten:

30Hz - 200Hz
200Hz - 800Hz
800Hz - 1.15KHz
1.15KHz - 1.6Hz
1.6KHz - 1.75KHz
1.75KHz - 2.6-3KHz
2.6-3KHz - 5.15KHz
5.15KHz - 7.2KHz
7.2KHz - 9.6KHz
9.6KHz - 12KHz
12KHz - 14KHz
14KHz - 16.5KHz
16.5KHz - 18.8KHz

maal twee waarden die ik ook nog eens kan bewerken is dus genoeg data om verassende dingen mee te gaan doen. Plus nog de volume sterkte niet te vergeten!

Makkelijker gezegd dan gedaan. Alhoewel er in Quartz een zogenaamde patch bestaat die verschillende frequenties kan meten, was het één grote puzzel om uit die rauwe data waardes te halen waarmee wat gedaan kon worden. Ook was het lastig om de gevoeligheid van bepaalde frequentie bereiken iets bij te stellen. Hoge tonen worden "zachter" gemeten dan de lage tonen.

Ga proberen om later nog eens uit te leggen hoe en wat ik gedaan heb. Maar hieronder staat de eerste test met de "Quartz Composer - Sound Reactive Engine v1". Het is geen Screensaver of Visueel effect

Wou even testen hoe CPU / GPU intensief het zaakje is (dat wordt nog een probleem!) en hoe makkelijk het is om dingen op b.v YouTube te krijgen.

Het gaat dus nog niet om de vorm maar om de techniek!!

Kost je een vrije dag, maar dan heb je ook niets.

Nu nog de camera input (zit er aan te denken om die alleen op beweging te laten reageren. Hmmmm ...