Sketch for Janna's proposal

Download most of them here.

…oh, and here’s one more, from Daniel, and another from Justin.

Also, for anyone who’s trying to reconnect this model of LCD display and you’ve (understandably) forgotten the wiring, the datasheet for the device is now conveniently located here. LCD display datasheet

This afternoon’s PRO CHALLENGE:

Store 5 different patterns in arrays. Make the code choose randomly which patterns to follow.

For this afternoon’s code, click “Read More”

//   using arrays to store patterns

#include <Stepper.h>

#define NUM_STEPS 48

int steps1[11] =  { 20,  -5, 30,  20, 10, -10,   2, -10, 2, -10, 0
};

int delays1[11] = { 5, 20, 5, 8, 10,  3, 10, 3, 10, 3, 0
};

int steps2[5] =  {  10, -20, 5, -30, 0
};

int delays2[5] = { 50, 40, 100, 23, 0
};

Stepper stepper(NUM_STEPS, 2,3,4,5);

void setup(){
stepper.setSpeed(180);
}

void loop(){

play_arrays(steps1, delays1);
delay(500);
play_arrays(steps2, delays2);
delay(500);

}

void play_arrays(int step_array[], int delay_array[]){
int i;

for(i=0; i<1000; i++){     //  arbitrariy decide 1000 is larget sequence we will play

if(step_array[i] == 0 || delay_array[i] == 0){
break;
}
step_motor(step_array[i], delay_array[i]);
}
}

void step_motor(int step_count, int step_delay){
int counter;
int turn_amt;
int turn_dir;

turn_amt = abs(step_count);  // get post number of steps

if(step_count > 0){          // get direction to go, either -1 or 1
turn_dir = 1;
}
else{
turn_dir = -1;
}

for(counter = 0; counter < turn_amt; counter++){   //  loop num of steps times...
stepper.step(turn_dir);   // step either CW/CCW dep. on 1/-1
delay(step_delay);
}

}

The raw code for controlling a stepper can be found here on the website.

// PROJECT 18: MOTOR MAYHEM!
// This sketch makes our motor rotate in a random direction, at a random speed, for a random duration.
// It uses the motor controller chip included in your class kit.
#define A_IN1 5          // motor controller pins
#define A_IN2 4
#define A_PWM 3

#define H_SPEED 200
#define L_SPEED 40

#define H_DELAY 200
#define L_DELAY 10

#define speed_pot 0     // potentiometer

void setup(){
pinMode(A_IN1, OUTPUT);
pinMode(A_IN2, OUTPUT);
pinMode(A_PWM, OUTPUT);
}

void loop(){
random_speed(L_SPEED, H_SPEED);  // choose a random speed
random_direction();              // choose a random direction
random_delay(L_DELAY, H_DELAY);  // wait a random amount
a_brake();                       // stop
random_delay(L_DELAY, H_DELAY);  // wait a random amount

}

void a_cw(){
digitalWrite(A_IN1, HIGH);
digitalWrite(A_IN2, LOW);
}

void a_ccw(){
digitalWrite(A_IN1, LOW);
digitalWrite(A_IN2, HIGH);
}

void a_brake(){
digitalWrite(A_IN1, HIGH);
digitalWrite(A_IN2, HIGH);
}

void a_off(){
digitalWrite(A_IN1, LOW);
digitalWrite(A_IN2, LOW);
}

void random_speed(int low_val, int high_val){
int r_val;

r_val = random(low_val, high_val);
analogWrite(A_PWM, r_val);
}

void random_direction(){
int r_val;
r_val = random(2);
if (r_val ==0){
a_cw();
}
else{
a_ccw();
}
}

void random_delay(int low_val, int high_val){
int r_val;

r_val = random(low_val, high_val);
delay(r_val);
}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// THE WORLD'S MOST BORING TENNIS MATCH
// This sketch uses inputs from limit switches to send a motor back and forth, switching directions once
// it hits the switch at the terminus of either direction.

#define A_IN1 5          // motor controller pins
#define A_IN2 4
#define A_PWM 3

#define LS 7
#define RS 8

#define speed_pot 0     // potentiometer

void setup(){
pinMode(A_IN1, OUTPUT);
pinMode(A_IN2, OUTPUT);
pinMode(A_PWM, OUTPUT);
pinMode(LS, INPUT);
pinMode(RS, INPUT);
pinMode(speed_pot, INPUT);
}

void loop(){
int a_speed;
int switch_a, switch_b;

pot_val = analogRead(speed_pot);
a_speed = map(pot_val, 0, 1024, 20, 230);

analogWrite(A_PWM, a_speed);  // set speed
switch_a = digitalRead(LS);
switch_b = digitalRead(RS);

if (switch_a == 0){
a_cw();
}

else if(switch_b == 0){
a_ccw():
}
}

}

void a_cw(){
digitalWrite(A_IN1, HIGH);
digitalWrite(A_IN2, LOW);
}

void a_ccw(){
digitalWrite(A_IN1, LOW);
digitalWrite(A_IN2, HIGH);
}

void a_brake(){
digitalWrite(A_IN1, HIGH);
digitalWrite(A_IN2, HIGH);
}

void a_off(){
digitalWrite(A_IN1, LOW);
digitalWrite(A_IN2, LOW);
}

For the afternoon, get cracking on mid-term projects.

// FIRST SKETCH
// a motor cycles between speeding up and slowing down. Input from a potentiometer
// controls the rate at which this acceleration/decelration occurs

#define MOTOR 3
#define POT 0

void setup(){
pinMode(MOTOR, OUTPUT);
}

void loop(){
int motor_speed;
int pot_val;
int acceleration;     // how fast the motor speeds up or slows down

for (motor_speed = 0; motor_speed < 255; motor_speed++){
analogWrite(MOTOR, motor_speed);
// update acceleration value from potentiometer
pot_val = analogRead(POT);
acceleration = map(pot_val, 0, 1024, 5, 50);
delay(acceleration);
}

for (motor_speed = 255; motor_speed > 0; motor_speed--){
analogWrite(MOTOR, motor_speed);
// update acceleration value from potentiometer
pot_val = analogRead(POT);
acceleration = map(pot_val, 0, 1024, 5, 50);
delay(acceleration);
}

}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

// SECOND SKETCH
// this simple sketch controls the speed of the motor directly from
// the potentiometer knob

define POT 0

define MOTOR 3

void setup(){

pinMode(MOTOR, OUTPUT);

}

void loop(){

int motor_speed;

int pot_val;

pot_val = analogRead(POT;

motor_speed = map(pot_val, 0, 1024, 70, 230);

analogWrite(MOTOR,motor_speed);

}
//XXXXXXXXXXXXXXXXXXXXX

//THIRD SKETCH

// utilizes the random function to make our motor randomly accelerate

// or decelerate

 

#define MOTOR 3

int motor_speed = 128;

 

 

void setup(){

pinMode(MOTOR, OUTPUT);

 

 

}

 

void loop(){

int change_amt;

int random_num;

 

 

random_num = random(1000);

change_amt = map(random_num, 0, 1000, -5, 5);

motor_speed = (motor_speed + change_amt);

motor_speed = constrain(motor_speed, 0, 255);

delay(20);

analogWrite(MOTOR, motor_speed);

 

}

From here, we’re taking on Project 12 under the “Projects” heading of this site:

Using a colored RGB LED, connect each of the pins of the LED to three pins on the Arudino that supports PWM.  Now, construct a color mixer that varies the levels of Red, Green and Blue the LED displays using three potentiometers connected to pins 0, 1, and 2 of the board.  This essentially uses the ideas brought forward in Project 8, but applying them to three pins of a colored LED rather than a single pin.

Also note that there were two concepts we covered this morning that are not presented here in the code. These were two different ways of creating conditional loops:

• The “for” statement
• The “while” statement

Have fun!

#define LED1_B 3

#define LED1_G 5

#define LED1_R 6

int red_val, green_val, blue_val;    //current value of the LEDs 0-255

int red_inc, green_inc, blue_inc;    //amount to change each value per loop

int mapped_pwm;                      //vale of LEDs scaled down to useable levels

void setup()

{

pinMode(LED1_B, OUTPUT);

pinMode(LED1_G, OUTPUT);

pinMode(LED1_R, OUTPUT);

red_val = 0;                      //starting values

green_val = 0;

blue_val = 0;

red_inc = 4;                      //amount to change

green_inc = 1;

blue_inc = -2;

}

void loop()

{

red_val += red_inc;              //add increment to the LED values

green_val += green_inc;

blue_val += blue_inc;

if(red_val>255){

red_val = 0;

}

if(blue_val>255){

blue_val = 0;

}

if(green_val>255){

green_val = 0;

}

if(red_val<0){

red_val = 255;

}

if(blue_val<0){

blue_val = 255;

}

if(green_val<0){

green_val = 255;

}

rgb_led(red_val, green_val, blue_val, LED1_R, LED1_G, LED1_B);

delay(20);     // wait a little bit. This controls how fast everything happens

}

void rgb_led (int red, int green, int blue, int red_pin, int green_pin, int blue_pin)

{

mapped_pwm = map(red, 0, 255, 0, 125);

analogWrite(red_pin, mapped_pwm);

mapped_pwm = map(green, 0, 255, 0, 125);

analogWrite(green_pin, mapped_pwm);

mapped_pwm = map(blue, 0, 255, 0, 125);

analogWrite(blue_pin, mapped_pwm);

}

Note that there are three new concepts here:

1. Creating our own functions. Here, we create a “void” function called “blink.” This is a way of keeping a set of actions in one handy section of code, called a function. We can tell the program to jump to that function any time, and it saves us having to write the code out every single time we want to use it. Furthermore, we can pass along certain pieces of information, like values or variables, to use. We do this by including that information in the brackets when we call the function, and defining what we’ll use it for in the declaration of the function itself. More advanced info on functions at the Arduino Reference.
2. analogRead. This is a function that only works with the “analog in” pins running along one side of the Arduino board. It reads the voltage coming into that pin, and then gives us a number between 0 and 1023, where 1023 would be 5VDC, 512 would be 2.5 VDC, and 0 would be 0 VDC. This process is called Analog-to-Digital-Conversion (ADC).
3. analogWrite.  This writes a PWM value to your pin. PWM isn’t true analog, it’s faking it. What it really does is turn the pin on and off so fast that we can perceive it as outputing a lower voltage. We can control the “duty cycle” (i.e. what percentage of the time it’s flipped on vs. what percentage of the time it’s off to give a range of output values. It’s sort of the equivalent of flashing a white card and a black card at you back and forth really fast to trick you into think you’re seeing gray. This function only works on the Arduino pins marked with a ~ sign (Uno borads) or the letters PWM (on earlier Arduino boards).

For the afternoon, we’re going to try to make the changes to our code and circuit as outlined on this page: Project 9. Post your results in the comments section of that page!

#define POT1IN 0    // analog in 0 for pot 1
#define LED 13      // LED is on pin 13
#define PWMOUT 9    // pin for testing PWM output

int pot1Val;
int blinkSpeed;
int ledBrightness;

void setup()
{
pinMode(LED, OUTPUT);
Serial.begin(9600);
}

void loop()
{
pot1Val = analogRead(POT1IN);               // read the incoming pot value
blinkSpeed = map(pot1Val,0,1023,50,500);    // map the incoming pot value to an acceptable range of blinking speeds
ledBrightness = map(pot1Val,0,1023,0,255);  // map the incoming pot value to PWM values between 0 and 255 (this is the full range of numbers that PWM can output)
Serial.print(pot1Val);
Serial.print("   ");
Serial.println(blinkSpeed);
blink(LED, blinkSpeed);                      // call our "blink" function to make one LED blink
analogWrite(PWMOUT, ledBrightness);          // set LED brightness on another LED
}

/*
Some people prefer to put a lot of space in here, to keep their functions out of sight from
the rest of the code
*/

void blink(int pinNum, int duration)
{
digitalWrite(pinNum, HIGH);
delay(duration);
digitalWrite(pinNum, LOW);
delay(duration);
}

THIS WEEK’S ALL-STAR CHALLENGES

If you’ve worked through this code and feel like you understand it, try to add these wrinkles to your code:

1) Add limits to the blinking rate, so there’s a maximum and minimum speed (bonus: this will also save your Arduino from crashing when it gets to negative values for delay times)

2) Change the method of speeding up or slowing down the blinking to be more proportional. (i.e.

3) PRO CHALLENGE: Set it up so that the blinking light is, by default, cyclically  speeding up and then slowing down when you turn it on. Then use the two additional buttons to change the rate of speeding up and slowing down.

#define LED_PIN 13            // LED
#define ONOFF_PIN 3           // toggle switch for on/off
#define INCREASE_PIN 4        // switches for inc/dec speed
#define DECREASE_PIN 5
#define ON 1                  // values for on/off variables used in program
#define OFF 0
#define STARTINGSPEED 500
#define SPEED_CHANGE 20

int current_state = LOW;
int previous_state = LOW;
int switch_pressed = OFF;     // did we just see a low/high switch transition?
int led_state = OFF;          // is the LED on?
int blink_speed = STARTINGSPEED;

void setup()
{
 pinMode(LED_PIN, OUTPUT);
 pinMode(ONOFF_PIN, INPUT);
}

void loop()
{

 /* Read the on/off switch */

 current_state = digitalRead(ONOFF_PIN);    // read the input pin

 if ((current_state == HIGH) && (previous_state == LOW))     // check for ON/OFF transition
 {
 switch_pressed = ON;
 }
 else
 {
 switch_pressed = OFF;
 }

 previous_state = current_state;

 /* read the other switches */

 if(digitalRead(INCREASE_PIN) == HIGH)    // if on, shorten the delay to speed up
 {
 blink_speed = blink_speed - SPEED_CHANGE;
 }

 if(digitalRead(DECREASE_PIN) == HIGH)   // if on, lengthen the delay to slow down
 {
 blink_speed = blink_speed + SPEED_CHANGE;
 }

 /* set the LED state */

 if(switch_pressed == ON)        // if switch was pressed - switch led state
 {
 if(led_state == ON)
 {

 led_state = OFF;
 }
 else
 {

 led_state = ON; 
 }
 }

 if(led_state == ON)              //if led is supposed to be on - then blink the LED
 {
 digitalWrite(LED_PIN, HIGH);
 delay(blink_speed);
 digitalWrite(LED_PIN, LOW);
 delay(blink_speed);
 }

}