Art 106

Human Machine Interface, San Jose State University, Spring 2011

Final Prototype

Published May 20, 2011 at 19:30 | By Oksana

The final prototype and the work process are posted under Projects/Interactive Sculpture, since this project grew from a class assignment into a major creation. Most likely, I will build my BFA show on this project in the upcoming semester.

Posted in Art 106 | Tagged BFA show, Final Prototype, Interactive sculpture | Leave a comment

Interactive Sculpture progress

Published April 28, 2011 at 14:37 | By Oksana

While working on the puzzle pieces for the mermaid sculpture, I came up with an idea of making a test copy of the sculpture from cardboard. The plexiglass is a pretty expensive material and it would be a shame if some pieces wouldn’t go together or the sculpture would come out wrong.

I noticed an interesting thing by accident a while ago when I stepped on my headphones and one of the speakers stopped working. Since I didn’t have a replacement, I continued to use the broken set. While listening to a favorite song that has the words divided between right and left channels, I was able to hear only the left channel, but my brain completed the rest of the song and instead I heard all of the words. This is just a food for thought about the abilities and functions of human brain.

Posted in Art 106 | Tagged Brain, Interactive sculpture, Interesting | Leave a comment

Interactive Sculpture

Published April 21, 2011 at 14:29 | By Oksana

I started this project with a mere sketch of a cyber mermaid.

There are stories about half-humans and half-robots all over the place, but all the mermaid stories are about half-fish and half-human. I decided to sketch a combination of these three creatures. The question was raised about the ability of a cyborg to live under water, but I believe with proper insolation it would not be an issue.

Following the design of the sketch, I decided to laser cut such a cyber mermaid out of translucent blue or transparent plexiglass. Since the laser works with flat sheets of material, I would have to cut up a 3D model of the mermaid in small flat pieces and then glue them together like a jigsaw puzzle. The additional pieces of the sculpture will be a swing that the mermaid will sit on and a base which will house arduino and other electronic components.

The mermaid will be hollow inside to decrease the weight of the sculpture. It will be equipped with LEDs to illuminate the curves of the mermaid. In addition, the sculpture will incorporate a distance sensor which will trigger movement of the swing as well as change the speed of the swing and the color of LEDs. The closer one gets, the faster the swing goes. The swing movement will be controlled by a servo, a belt, and a pulley.

Posted in Art 106 | Tagged Concept, Cyber mermaid, Idea, Interactive sculpture | Leave a comment

Servo, Pololu Controller & Two PIR

Published April 12, 2011 at 13:48 | By Oksana

Code

Show ▼

// old servo position
int oldPos;

// current servo position (-1 = 90, 0 = 0, 1 = 180 degrees)
int servoPos = -1;

// function to set a particular servo on pololu (0-7) to an angle
// the angle from 0 to 180 is loosely transformed into absolute servo position
void setServo (unsigned int servoNum, unsigned int angle) {

  // command array (6 bytes)
  unsigned char command[6];
  // remap the angle to pololu operational range (500-5500)
  unsigned int tempAngle = map (angle, 0, 180, 500, 4400);

  // calculate the "high" position byte
  // by zeroing out the 7 lest significant bits
  // and shifting the other bits right by 7 bits
  unsigned int posHigh = (tempAngle&0x1F80)>>7;
  // calculate the "low" position byte
  // by zeroing out everything but the 7 least significant bits
  unsigned int posLow = tempAngle&0x7F;

  command[0] = 0x80; // start byte
  command[1] = 0x01; // device ID
  command[2] = 0x04; // set absolute position command
  command[3] = servoNum; // servo number
  command[4] = posHigh; // position (high byte)
  command[5] = posLow; // position (low byte)

  // write the command to pololu via serial port
  Serial.write(command,6);

  // wait for pololu to process
  delay(500);

}

// motion sensors
const int sensorPins[] = {1, 2};
// LEDs
const int ledPins[] = {3, 4};

void setup() {

  int i;

  // initialize the pins and LEDs
  for (i = 0; i < 2; i++) {
    // LEDs
    pinMode(ledPins[i],OUTPUT);
    digitalWrite(ledPins[i],LOW);  
  }
   
  // initialize serial port to pololu (38400 baud)
  Serial.begin(38400);
  // let pololu sync
  delay(200);

  // move servo 0 to angle 0
  setServo(0,0);
  delay(1000);
  // move servo 0 to angle 180
  setServo(0,180);
  delay(1000);
  // move servo 0 to angle 90
  setServo(0,90);
  delay(1000);
}

// same as befor but now work through pololu to move the servo 
void loop() {
  int i;

  // remember old servo position
  oldPos = servoPos;
  // reset servo position
  servoPos = -1;
  
  // step through the motion sensors
   for (i = 0; i < 2; i++)    
     // if motion sensor triggered
     if (analogRead(sensorPins[i])!=0) {
       // set the servo position
       servoPos = i;
       // stop scanning sensors
       break;
     }

   // if servo needs to be moved
   if (servoPos != oldPos) {
    if (servoPos != -1) {
       // turn off LEDs
        for (i = 0; i < 2; i++)
      digitalWrite(ledPins[i],LOW); 
       // light the LED
        digitalWrite(ledPins[servoPos],HIGH);
        // turn the servo to 0 or 180
        setServo(0,180*servoPos);
   } else {
     // otherwise, return servo to 90 degrees
     setServo(0,90);
     // turn off LEDs
     for (i = 0; i < 2; i++)
   digitalWrite(ledPins[i],LOW);   
   }
}

  // delay for a second
  delay(1000);
}

Posted in Art 106 | Tagged Arduino, Code, Micro Serial Controller, PIR, Pololu, Servo | Leave a comment

Pololu Micro Serial Controller

Published April 5, 2011 at 11:02 | By Oksana

My experiment with driving the servo from the Pololu micro serial controller was semi-successful. Nothing got burned this time; at least, the servo and the controller still work. However, there were some issues when using an external servo power supply.

It took a bit of wiggling with the serial interface to get things going. At first, I tried using SoftwareSerial module that would emulate the interface over one of the regular digital pins. However, I encountered clocking issues where the Pololu controller would not detect the serial baud rate correctly. So, I switched to the hardware serial console (pins 0 and 1) of the Arduino; the Pololu seems to be happy with 38400 baud rate.

The Pololu controller takes command in 5 or 6 byte blocks and requires the 8th most significant bit of every command byte to be 0. This required some bit shifting to split an absolute position value for the servo into two 7-bit numbers and fit them into the 8-bit byte holders. To get things working initially, I decided to set the absolute servo position (range from 500 to 5500) instead of letting the Pololu keep track of the relative position. It seems that my SG5010 servo may not support the complete range, so I may need to narrow it down a bit later.

When both the Pololu controller and the servo are powered from the Arduino, the code executes correctly and the servo moves right. However, it is best to power the servo from an external power supply. I got a generic household 5V/2A power supply and hooked it up to the servo while powering the Pololu controller from the Arduino. However, the servo would no longer move beyond the initial power-on cycle. I do not belive it’s the polarity, since I measure the +5V with the multimeter across the power supply. I think this is due to the different ground connections between the Pololu and the servo. I have not yet tried to power the Pololu controller from the external power supply as well because of fear of burning it out. I will wait until I demo it in class first :)

Code

Show ▼

// how much to turn each cycle
const int TURN_ANGLE = 30;

// dedicated function to initialize a particular servo on Pololu (0-7)
// not typically needed since the servo starts automatically once moved
void startServo (unsigned int servoNum) {

  // command array (5 bytes)
  unsigned char command[5];

  command[0] = 0x80; // start byte
  command[1] = 0x01; // pololu device ID
  command[2] = 0x00; // initialize command
  command[3] = servoNum; // servo number
  command[4] = 0x4F; // enable servo (forward dir, 15 steps per move)

  // write the command to pololu via serial port
  Serial.write(command,5);

  // wait for pololu to process
  delay(200);
} 

// function to set a particular servo on pololu (0-7) to an angle
// the angle from 0 to 180 is loosely transformed into absolute servo
position
void setServo (unsigned int servoNum, unsigned int angle) {

  // command array (6 bytes)
  unsigned char command[6];
  // remap the angle to pololu operational range (500-5500)
  unsigned int tempAngle = map (angle, 0, 180, 500, 5500);

  // calculate the "high" position byte
  // by zeroing out the 7 lest significant bits
  // and shifting the other bits right by 7 bits
  unsigned int posHigh = (tempAngle&0x1F80)>>7;
  // calculate the "low" position byte
  // by zeroing out everything but the 7 least significant bits
  unsigned int posLow = tempAngle&0x7F;

  command[0] = 0x80; // start byte
  command[1] = 0x01; // device ID
  command[2] = 0x04; // set absolute position command
  command[3] = servoNum; // servo number
  command[4] = posHigh; // position (high byte)
  command[5] = posLow; // position (low byte)

  // write the command to pololu via serial port
  Serial.write(command,6);

  // wait for pololu to process
  delay(200);

}

void setup() {
   
  // initialize serial port to pololu (38400 baud)
  Serial.begin(38400);
  // let pololu sync
  delay(200);

  // start a servo (optional, for testing)
  // startServo(0);

  // move servo 0 to angle 0 
  setServo(0,0);
  // move servo 0 to angle 180
  setServo(0,180);
}

// same as befor but now work through pololu to move the servo 
void loop() {
  // direction (0 = forward, 1 = back)
  int dir = 0;
  // current angle (0-180)
  int angle = 0;

  // infinite loop
  while (1) {
     // turn the servo to the current angle
     setServo(0, angle);
     // pause to let the movement complete and arduino to recover
     delay(1000);
     // if moving forward
     if (dir == 0) {
       // move the angle by TURN_ANGLE degrees
       angle+=TURN_ANGLE;
       // if more than 180 degrees
       if (angle>180) {
         // change direction
         dir = 1;
         // go back two TURN_ANGLEs
         angle-=2*TURN_ANGLE;
       }
     // if moving backward
     } else {
       // move back by TURN_ANGLE
       angle-=TURN_ANGLE;
       // if less than 0
       if (angle<0) {
         // move forward
         dir = 0;
         // move forward twice TURN_ANGLE
         angle+=2*TURN_ANGLE;
       }
     }
  }
}

Posted in Art 106 | Tagged Arduino, Code, Micro Serial Controller, Pololu, Servo | Leave a comment

Servo & PIR experiment

Published March 24, 2011 at 12:00 | By Oksana

The latest experiment with a servo as a feedback mechanism for the motion sensors went rather wrong. The idea was to have two motion sensors pointing in different directions and the servo with an arrow that would point toward whichever motion sensor detects movement. Both the motion sensors and the servo modules were tested separately to work fine.

As described in the previous post, the one good servo I had was still having sporadic issues. It would either not move right away or “skip” through movements, reload the Arduino board, and so on. Since I had attributed it to the power issues, I connected an external 12V power supply to the Arduino. It was working fine with the motion sensor scheme and the servo separately.

Once the servo scheme and the motion sensors were connected together (same +5V output on Arduino), the overall system worked well for a little while. As I was debugging some issues, I noticed that the servo started to have sporadic issues again. Furthermore, the Arduino board was getting extremely hot even as the servo was not moving. After disconnecting the power and letting the board cool down, I tried testing the servo alone again but the board would still heat up in a big way even when the servo was simply connected with no program running.

I double checked the connections, but could not find any issues. After a few more tries, the servo was barely moving and the current drain from the Arduino was high enough to disrupt the program operation. At this point, it was obvious that the servo went bad as well. I am not sure of the specific trigger, but it did appear that it was draining too much current from the board which was even overloading the voltage regulator on the Arduino. I took the servo apart, but could not find any obviously fried components. I suspect that it was damaged during the previous projects which made it difficult for the motor to spin; this resulted in the additional drain of current that eventually degraded the component.

At this point, I have ordered a new servo to get the project back to an operational state.

Code

Two PIR sensors and servo
Show ▼

#include <Servo.h>

// define the servo
Servo servo1;

// define the output PIN (only 9-11)
int servoPin = 10;

// motion sensors
const int sensorPins[] = {1, 2};
// LEDs
const int ledPins[] = {3, 4};

void setup() {
  int i;

  // initialize the pins
  for (i = 0; i < 2; i++) {
    // sensors
    pinMode(sensorPins[i],INPUT);
    // LEDs
    pinMode(ledPins[i],OUTPUT);
  }

  // initialize servo
  servo1.attach(servoPin);
  // move to initial position (90 degrees)
  servo1.write(90);

  Serial.begin(9600);
}

void loop() {
  int i;
  // current servo position (-1 = 90, 0 = 0, 1 = 180 degrees)
  int servoPos;

   // step through the motion sensors
   for (i = 0; i < 2; i++) {
     // reset servo position
     servoPos = -1;
     // if motion sensor triggered
     if (analogRead(sensorPins[i])!=0) {
       // set the servo position
       servoPos = i;
       // stop scanning sensors
       break;
     }
   }
   // if servo needs to be moved
   if (servoPos != -1) {
     // light the LED
     digitalWrite(ledPins[i],HIGH);
     // turn the servo to 0 or 180
     servo1.write(180*i);
   } else
     // otherwise, return servo to 90 degrees
     servo1.write(90);
   
    // turn off LEDs
    for (i = 0; i < 2; i++)
       digitalWrite(ledPins[i],LOW);   
  // delay for a second
  delay(1000);
}

Four PIR Sensors only
Show ▼

// motion sensors
const int sensorPins[] = {1, 2, 3, 4};
// LEDs
const int ledPins[] = {3, 4, 5, 6};
// number of sensors = number of LEDs
const int numSensors = 4;

void setup() {
  int i;

  // init the pins
  for (i = 0; i < numSensors; i++) {
    // input sensors
    pinMode(sensorPins[i],INPUT);
    // output LEDs
    pinMode(ledPins[i],OUTPUT);
  }

  // console
  Serial.begin(9600);
}

void loop() {
  int i;
  // motion detected (1) or not (0)
  int readValue;

  // step through all the sensors
  for (i = 0; i < numSensors; i++) {
     // if motion detected,
     if (readValue=analogRead(sensorPins[i])!=0)
       // light the appropriate LED
       digitalWrite(ledPins[i],HIGH);
     else
       // otherwise, turn LED off
       digitalWrite(ledPins[i],LOW);
     // print motion sensor state
     Serial.println(i,readValue);
   }
   // delay for half a second
   delay(500);
}

Posted in Art 106 | Tagged Arduino, Code, Experiment, PIR, Servo, Wrong | Leave a comment

Servos

Published March 15, 2011 at 14:47 | By Oksana

I had a few ideas for the exercise, but I hit some limitations.

You do not necessarily need an external servo controller for Arduino since it can control the servos directly. It may actually be more difficult to work with an external controller due to a need for a specialized serial interface and command language. There is a plug-in shield available specifically for Arduino that reduces the complexity:
http://www.ladyada.net/make/mshield/

For simplicity, I have decided to use Arudino to control the servos. It works great, but there are some gotchas that I am going to address later.

At first, I wanted to make a slingshot using the two servos, but after a few hours of trying to get the first servo to work, I realized that it’s not working. A good working servo will briefly spin when you connect power to it. If your servo does not do that, it may be faulty, too.

The second servo worked, but with some glitches due to power supply issues. If used without an external power supply, the servo drains too much power and Arduino shuts down or “slips” – it may skip certain instructions or delays, for example. If other components (sensors, speakers, and so on) are used, the Arduino may be unable to deliver enough power to it at all. You can measure voltage across the power and ground pins of the connected servo to see if it matches the minimum (typically, 5V). If it is much lower, you will absolutely need an external power supply. If the power is enough, you would need to make sure the movements are quick and there is enough post-movement delay built into the program to allow Arduino to recover. I used 30 degree turns and 5 second delay after each move to maintain stability.

This particular type of servo is very powerful and precise. It can only turn a total of 180 degrees; this could be useful for robotics. For example, one could create a slap-hand. While studying or writing a paper, the student activates the slap-hand and every time he or she visits Facebook, Twitter, or another social media site, the slap-hand slaps him or her! This is a way to become very productive : D

Another idea was to place a surveillance camera attached to the servo in a corner of the room and add three PIR sensors. If there’s motion, the camera will react to it and turn to the respective direction.

Code

Show ▼

#include <Servo.h>

// define the servo
Servo servo1;

// define the output PIN (only 9-11)
int servoPin = 10;

// how much to turn each cycle
const int TURN_ANGLE = 30;

void setup() {
  Serial.begin(9600);
  // attach the control signal to pin
  servo1.attach(servoPin);
  // move to position 0
  servo1.write(0);
  // delay for the servo to adjust
  delay(5000);
}

void loop() {
  // direction (0 = forward, 1 = back)
  int dir = 0;
  // current angle (0-180)
  int angle = 0;

  // infinite loop
  while (1) {
     // turn the servo to the current angle
     servo1.write(angle);
     // pause to let the movement complete and arduino to recover
     delay(4000);
     // if moving forward
     if (dir == 0) {
       // move the angle by TURN_ANGLE degrees
       angle+=TURN_ANGLE;
       // if more than 180 degrees
       if (angle>180) {
         // change direction
         dir = 1;
         // go back two TURN_ANGLEs
         angle-=2*TURN_ANGLE;
       }
     // if moving backward
     } else {
       // move back by TURN_ANGLE
       angle-=TURN_ANGLE;
       // if less than 0
       if (angle<0) {
         // move forward
         dir = 0;
         // move forward twice TURN_ANGLE
         angle+=2*TURN_ANGLE;
       }
     }
  }
}

Posted in Art 106 | Tagged Arduino, PIR, Servo | Leave a comment

Music Box

Published February 22, 2011 at 16:42 | By Oksana

Music box with two buttons, potentiometer and two LEDs.

Code

Show ▼

/*
  Plays one of 3 melodies depending on the buttons:

Button 1 ON,  Button 2 OFF : Ukraine's national anthem
Button 1 OFF, Button 2 ON  : Ascending Scale
Button 1 ON,  Button 2 ON  : Descending Scale

  circuit:
* 8-ohm speaker on digital pin 8

modified on 22 Feb 2011
by Oksana Sinelnik
originally created 21 Jan 2010
by Tom Igoe

The example code is in the public domain.

  http://arduino.cc/en/Tutorial/Tone

  */
#include "pitches.h"

// notes in the melodies 1, 2, and 3:
int melody1[] = {
      
NOTE_C5,NOTE_C5,NOTE_C5,NOTE_B4,NOTE_C5,NOTE_D5,NOTE_E5,NOTE_D5,NOTE_C5,NOTE_B4,NOTE_A4,NOTE_C5,NOTE_G4,NOTE_C5,NOTE_F4,NOTE_DS4,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_B4,
      
NOTE_C5,NOTE_C5,NOTE_C5,NOTE_B4,NOTE_C5,NOTE_D5,NOTE_E5,NOTE_D5,NOTE_C5,NOTE_B4,NOTE_A4,NOTE_F4,NOTE_C5,NOTE_DS4,NOTE_F4,NOTE_F4};
int melody2[] = {
      
NOTE_C3,NOTE_D3,NOTE_E3,NOTE_F3,NOTE_G3,NOTE_A3,NOTE_B3,NOTE_B3,NOTE_A3,NOTE_G3,NOTE_F3,NOTE_E3,NOTE_D3,NOTE_C3};
int melody3[] = {
      
NOTE_B7,NOTE_A7,NOTE_G7,NOTE_F7,NOTE_E7,NOTE_D7,NOTE_C7,NOTE_C7,NOTE_D7,NOTE_E7,NOTE_F7,NOTE_G7,NOTE_A7,NOTE_B7};

// the number of notes in every melody
int numberNotes1 = 36;
int numberNotes2 = 14;
int numberNotes3 = 14;

// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations1[] = {
     5,3,8,8,8,8,5,3,4,4,4,4,4,4,8,8,8,8,4,4,
     5,3,8,8,8,8,5,3,4,4,4,4,4,4,2,4};
int noteDurations2[] = {
     8,8,8,8,8,8,8,8,8,8,8,8,8,8};
int noteDurations3[] = {
     8,8,8,8,8,8,8,8,8,8,8,8,8,8};

// connect buttons to pins 1 and 2 respectively
int buttonPin1 = 3;
int buttonPin2 = 2;

// connect LEDs to pins 0 and 1
int ledPin1 = 4;
int ledPin2 = 5;

// Potentiometer for tempo
const int potPin = 4;

void setup() {
   Serial.begin(9600);
   // initialize the buttons
   pinMode(buttonPin1, INPUT);
   pinMode(buttonPin2, INPUT);

   // initialize the LEDs
   pinMode(ledPin1,OUTPUT);
   pinMode(ledPin2,OUTPUT);
}

// continuously scan the buttons and play the melody as appropriate
void loop() {
   // floating point variable to multiply the tempo
   float tempo;
   Serial.println(digitalRead(buttonPin1));
   Serial.println(digitalRead(buttonPin2));
   // if button 1 is pressed (high) and button 2 is not pressed (low), play melody 1
   if (digitalRead(buttonPin1) == HIGH && digitalRead(buttonPin2) == LOW) {
   // light LED
   digitalWrite(ledPin1,HIGH);
   // iterate over the notes of the melody; check that the same  buttons are still pressed on every iteration
     for (int thisNote = 0; thisNote < numberNotes1 &&  (digitalRead(buttonPin1) == HIGH && digitalRead(buttonPin2) == LOW); thisNote++) {
       // to calculate the note duration, take two seconds (slow tempo)
       // divided by the note type. 
       // e.g. quarter note = 2000 / 4, eighth note = 2000/8, etc.
       // read tempo based on potentiometer and adjust the duration accordingly
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       int noteDuration = tempo*2000/noteDurations1[thisNote];
       // play note
       tone(8, melody1[thisNote],noteDuration);
       // check the tempo again for the pause
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       // to distinguish the notes, set a minimum time between them.
       // the note's duration + 30% seems to work well:
       int pauseBetweenNotes = tempo*noteDuration * 1.30;
       delay(pauseBetweenNotes);
     }     
     // pause for 1 second * tempo after playing the melody
     tempo = 0.1 + ((float)analogRead(potPin))/512;
     delay(tempo*1000);
   }
   // turn off LED
   digitalWrite(ledPin1,LOW);
   // if button 1 is not pressed (low) and button 2 is pressed (high),  play melody 2
   if (digitalRead(buttonPin1) == LOW && digitalRead(buttonPin2) == HIGH) {
    digitalWrite(ledPin2,HIGH);
    // iterate over the notes of the melody; check that the same buttons are still pressed on every iteration
     for (int thisNote = 0; thisNote < numberNotes2 && (digitalRead(buttonPin1) == LOW && digitalRead(buttonPin2) == HIGH); thisNote++) {
       // to calculate the note duration, take two seconds (slow tempo)
       // divided by the note type.
       //e.g. quarter note = 2000 / 4, eighth note = 2000/8, etc.
       // adjust tempo as described above
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       int noteDuration = tempo*2000/noteDurations2[thisNote];
       tone(8, melody2[thisNote],noteDuration);

       // to distinguish the notes, set a minimum time between them.
       // the note's duration + 30% seems to work well:
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       int pauseBetweenNotes = tempo*noteDuration * 1.30;
       delay(pauseBetweenNotes);
     }
     // pause for 1 second after playing the melody
     tempo = 0.1 + ((float)analogRead(potPin))/512;
     delay(tempo*1000);
   }
   digitalWrite(ledPin1,LOW);
   // if both buttons 1 and 2 are pressed (high), play melody 3
   if (digitalRead(buttonPin1) == HIGH && digitalRead(buttonPin2) == HIGH) {
     digitalWrite(ledPin1,HIGH);
     digitalWrite(ledPin2,HIGH);
     // iterate over the notes of the melody; check that the same buttons are still pressed on every iteration
     for (int thisNote = 0; thisNote < numberNotes3 &&  (digitalRead(buttonPin1) == HIGH && digitalRead(buttonPin2) == HIGH); thisNote++) {
       // to calculate the note duration, take two seconds (slow tempo)
       // divided by the note type.
       //e.g. quarter note = 2000 / 4, eighth note = 2000/8, etc.
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       Serial.println(tempo);
       int noteDuration = tempo*2000/noteDurations3[thisNote];
       tone(8, melody3[thisNote],noteDuration);

       // to distinguish the notes, set a minimum time between them.
       // the note's duration + 30% seems to work well:
       tempo = 0.1 + ((float)analogRead(potPin))/512;
       Serial.println(tempo);
       int pauseBetweenNotes = tempo*noteDuration * 1.30;
       delay(pauseBetweenNotes);
     }
     // pause for 1 second after playing the melody
     tempo = 0.1 + ((float)analogRead(potPin))/512;
     Serial.println(tempo);
     delay(1000*tempo);
   }
   digitalWrite(ledPin1,LOW);
   digitalWrite(ledPin2,LOW);
}

pitches.h
Show ▼

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Posted in Art 106 | Tagged Arduino, button, Code, LED, Music box, potentiometer | Leave a comment

Three blinking lights with button control

Published February 10, 2011 at 17:57 | By Oksana

Code

Show ▼

const int numLeds = 3; // how many LEDs
const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPins[] = {10, 11, 12}; // what are the pins for the LEDs

int buttonState = 0;         // variable for reading the pushbutton status
int i, j, k;

void setup() {
  Serial.begin(9600);
   // initialize the digital pin as an output:
  for (i = 0; i < numLeds; i++)
      pinMode(ledPins[i], OUTPUT);      
   // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);     
}

void loop(){
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   //buttonState = HIGH;
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
     Serial.println("Button pressed\n");
     for (j = 0; j < numLeds; j++) {
   Serial.println("LED lit\n");
        digitalWrite(ledPins[j], HIGH);   // set the LEDs on  
        delay(100);                  // wait for 0.1 second
        digitalWrite(ledPins[j], LOW);    // set the LEDs off
    }
   } 
   else {
     // turn LED off:
      for (k = 0; k < numLeds; k++) {
        digitalWrite(ledPins[k], LOW);    // set the LEDs off
    }
   }
}

A typical use case for an array is to step through it and perform the same operation on each element. To accomplish that, you use an index variable that increments in a “for” loop; to access a particular element in an array, array_name[index] form is used. For instance, the following array of integers will contain the pin numbers (10, 11, and 12) for the respective LEDs:

int ledPins[] = {10, 11, 12};

Since we need to know how many elements there are in the array, we will use the following variable to keep track of how many LEDs we have:

int numLeds = 3;

Now, we use temprorary variable i (index) that starts and 0 and goes up to 2 (one less than the number of LEDs); here is a “for” loop for that:

for (i = 0; i < numLeds; i++)

Within the “for” loop, we set the pin for every LED as “OUTPUT” by calling pinMode() function and supplying the pin number retrieved from the current position in the array as the value:

pinMode(ledPins[i], OUTPUT);

With each iteration of the loop, the value returned by ledPins[i] changes as i increments (ledPins[0] returns 10, ledPins[1] returns 11, and ledPins[2] returns 12).

Posted in Art 106 | Tagged Arduino, Array, blinking lights, button control, LED | Leave a comment

Problem Uploading to Arduino (Windows users)

Published February 8, 2011 at 20:01 | By Oksana

If you are running Windows 7 OS (64 or 32 bit) and have problem uploading code to your Arduino, try installing these Virtual COM Port Drivers.

Download here
Installation guide here

Posted in Art 106 | Tagged Arduino, Help, Problem, Uploading, Windows 7 | Leave a comment

Art 106

Code

Code

Code

Code

Code

Code

Log In

Search