Lecture 3 C++ Types of Data and Playing with Bits

0x0A03

ADMUX = (analog_reference << 6) | (pin & 0x0f) | ((left_adjust & 0x01) << 5);

note: if left_adjust is zero ADLAR bit stays at zero.

TCCR2A &= ~_BV(COM2A0)

TCCR2A = TCCR2A&~(_BV(WGM21) | _BV(COM2A0)) | _BV(WGM20) | _BV(COM2A1);

TCCR2A |= (output_mode << 6) | (waveform & 0x03); // analogRead

Appendix A: The Arduino Family Tree

The Arduino language (based on Wiring) is implemented in C/C++, and therefore has some differences from the Processing language, which is based on Java.

A Visual Paradigm for Programming – Processing

Source: Wikipedia – Processing (programming language)

• Processing was designed to get non-programmers (originally electronic artists) started with software programming, using a visual context, and to serve as the foundation for electronic sketchbooks.
  • The concept of “visual context” makes Processing comparable to Adobe’s ActionScript and Lingo scripting based languages.
  • A “sketchbook”, is a minimal alternative to an integrated development environment (IDE)
• Processing is an open source programming language and integrated development environment (IDE)
  • The project was initiated in 2001 by Casey Reas and Benjamin Fry, both formerly of the Aesthetics and Computation Group at the MIT Media Lab.
  • The language builds on the Java programming language, but uses a simplified syntax and graphics programming model.

From Programming to Microcontrollers – Wiring

• Wiring was design to teach non-programmers (originally electronic artists) how to program microcontrollers.
• Wiring, uses the Processing IDE (sketchbook) together with a simplified version of the C++ programming language (gcc compiler)
• There are now two separate hardware projects, Wiring and Arduino, using the Wiring IDE (sketchbook) and language.
• Fritzing is another software environment of the same sort, which helps designers and artists to document their interactive prototypes and to take the step from physical prototyping to actual product.

From Programming Microcontrollers to the Arduino

Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It’s intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments.

• The C/C++ language is the foundation upon which the Arduino language (like Wiring on which it is based) is built.
• The C/C++ language is implemented using the GCC Compiler and links against the AVR C library AVR Libc and allows the use of any of its functions; see its user manual for details.
• The AVR C Library has its own family tree (nongnu, gcc)

APPENDIX B: Standard Libraries

• EEPROM – reading and writing to “permanent” storage (EEPROM)
• Ethernet – for connecting to the internet using the Arduino Ethernet Shield
• Firmata – for communicating with applications on the computer using a standard serial protocol.
• LiquidCrystal – for controlling liquid crystal displays (LCDs)
• SD – for reading and writing SD cards
• Servo – for controlling servo motors
• SPI – for communicating with devices using the Serial Peripheral Interface (SPI) Bus
• SoftwareSerial – for serial communication on any digital pins
• Stepper – for controlling stepper motors
• Wire – Two Wire Interface (TWI/I2C) for sending and receiving data over a net of devices or sensors.

APPENDIX C: C++ OPERATOR PRECEDENCE

When we start constructing compound assignment statements in order to assign values to fields within a peripheral subsystem register, also known as a special function register (SFR), it is important to remember operator precedence.

APPENDIX D: ARDUINO ANALOGREAD FUNCTION

int analogRead(uint8_t pin)
{

uint8_t low, high;

// set the analog reference (high two bits of ADMUX) and select the
// channel (low 4 bits). this also sets ADLAR (left-adjust result)
// to 0 (the default).
ADMUX = (analog_reference << 6) | (pin & 0x0f);

// without a delay, we seem to read from the wrong channel
//delay(1);

// start the conversion
sbi(ADCSRA, ADSC);

// ADSC is cleared when the conversion finishes
while (bit_is_set(ADCSRA, ADSC));

// we hto read ADCL first; doing so locks both ADCL
// and ADave CH until ADCH is read. reading ADCL second would
// cause the results of each conversion to be discarded,
// as ADCL and ADCH would be locked when it completed.
low = ADCL;
high = ADCH;

// combine the two bytes
return (high << 8) | low;

}

APPENDIX E: ADAFRUIT MOTOR SHIELD

Using the Motor Shield

DC Motors

#include

// motor is an instance of the AF_DCMotor class
AF_DCMotor motor(2, MOTOR12_64KHZ); // create motor #2, 64KHz pwm

void setup() {

Serial.begin(9600); // set up Serial library at 9600 bps
Serial.println(“Motor test!”);

motor.setSpeed(200); // set the speed to 200/255

}

void loop() {

Serial.print(“tick”);

motor.run(FORWARD); // turn it on going forward
delay(1000);

Serial.print(“tock”);
motor.run(BACKWARD); // the other way
delay(1000);

Serial.print(“tack”);
motor.run(RELEASE); // stopped
delay(1000);

}

Stepper Motor

#include

// motor is an instance of the AF_Stepper class
AF_Stepper motor(48, 2);

void setup() {

Serial.begin(9600); // set up Serial library at 9600 bps
Serial.println(“Stepper test!”);

motor.setSpeed(10); // 10 rpm

motor.step(100, FORWARD, SINGLE);
motor.release();
delay(1000);

}

void loop() {

motor.step(100, FORWARD, SINGLE);
motor.step(100, BACKWARD, SINGLE);

motor.step(100, FORWARD, DOUBLE);
motor.step(100, BACKWARD, DOUBLE);

motor.step(100, FORWARD, INTERLEAVE);
motor.step(100, BACKWARD, INTERLEAVE);

motor.step(100, FORWARD, MICROSTEP);
motor.step(100, BACKWARD, MICROSTEP);

}

Library Header
What is a Library?

// Adafruit Motor shield library
// copyright Adafruit Industries LLC, 2009
// this code is public domain, enjoy!

#ifndef _AFMotor_h_
#define _AFMotor_h_

#include
#include

//#define MOTORDEBUG 1

#define MICROSTEPS 16 // 8 or 16

#define MOTOR12_64KHZ _BV(CS20) // no prescale
#define MOTOR12_8KHZ _BV(CS21) // divide by 8
#define MOTOR12_2KHZ _BV(CS21) | _BV(CS20) // divide by 32
#define MOTOR12_1KHZ _BV(CS22) // divide by 64

#define MOTOR34_64KHZ _BV(CS00) // no prescale
#define MOTOR34_8KHZ _BV(CS01) // divide by 8
#define MOTOR34_1KHZ _BV(CS01) | _BV(CS00) // divide by 64

#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR4_A 0
#define MOTOR4_B 6
#define MOTOR3_A 5
#define MOTOR3_B 7

#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4

#define SINGLE 1
#define DOUBLE 2
#define INTERLEAVE 3
#define MICROSTEP 4

// Arduino pin names
#define MOTORLATCH 12
#define MOTORCLK 4
#define MOTORENABLE 7
#define MOTORDATA 8

class AFMotorController
{

public:

AFMotorController(void);
void enable(void);
friend class AF_DCMotor;
void latch_tx(void);

};

class AF_DCMotor
{

public:

AF_DCMotor(uint8_t motornum, uint8_t freq = MOTOR34_8KHZ);
void run(uint8_t);
void setSpeed(uint8_t);

private:

uint8_t motornum, pwmfreq;

};

class AF_Stepper {

public:

AF_Stepper(uint16_t, uint8_t);
void step(uint16_t steps, uint8_t dir, uint8_t style = SINGLE);
void setSpeed(uint16_t);
uint8_t onestep(uint8_t dir, uint8_t style);
void release(void);
uint16_t revsteps; // # steps per revolution
uint8_t steppernum;
uint32_t usperstep, steppingcounter;

private:

uint8_t currentstep;

};

uint8_t getlatchstate(void);

#endif

Adafruit Private Functions

latch_tx

#define _BV(bit) (1 << (bit))

/*

Send data located in 8-bit variable latch_state
to the 74HC595 on the Motor Shield.

*/

void AFMotorController::latch_tx(void) {

uint8_t i;

//LATCH_PORT &= ~_BV(LATCH);
digitalWrite(MOTORLATCH, LOW);     // – Output register clock low

//SER_PORT &= ~_BV(SER);
digitalWrite(MOTORDATA, LOW);      // – Serial data bit = 0

for (i=0; i<8; i++) {              // - Shift out 8-bits

//CLK_PORT &= ~_BV(CLK);
digitalWrite(MOTORCLK, LOW); //    – Shift clock low

   if (latch_state & _BV(7-i)) { //    – Is current bit of

   //SER_PORT |= _BV(SER);            latch_state == 1
digitalWrite(MOTORDATA, HIGH); //   –   Yes, serial data bit = 1

   } else {

   //SER_PORT &= ~_BV(SER);

   digitalWrite(MOTORDATA, LOW);  //   –   No, serial data bit = 0 

   }

   //CLK_PORT |= _BV(CLK);

   digitalWrite(MOTORCLK, HIGH); //    – Shift clock high, rising edge

}                              //    shift bit into shift register
//LATCH_PORT |= _BV(LATCH);
digitalWrite(MOTORLATCH, HIGH);    // – Output register clock high, rising

}                                   //   edge sends the stored bits to the

                                    //   output register.

enable

/*

   Configure DDR Registers B and D bits assigned to
the input of the 74HC595 on the Motor Shield. Output
all zeros and enable outputs.  

*/

void AFMotorController::enable(void) {

// setup the latch
/*
LATCH_DDR |= _BV(LATCH);
ENABLE_DDR |= _BV(ENABLE);
CLK_DDR |= _BV(CLK);
SER_DDR |= _BV(SER);
*/
pinMode(MOTORLATCH, OUTPUT);
pinMode(MOTORENABLE, OUTPUT);
pinMode(MOTORDATA, OUTPUT);
pinMode(MOTORCLK, OUTPUT);

latch_state = 0;

latch_tx();  // “reset”

//ENABLE_PORT &= ~_BV(ENABLE); // enable the chip outputs!
digitalWrite(MOTORENABLE, LOW);

}

Adafruit Motor Public Functions

run

void AF_DCMotor::run(uint8_t cmd) {

uint8_t a, b;

/* Section 1: choose two shift register outputs based on which
* motor this instance is associated with. motornum is the
* motor number that was passed to this instance’s constructor.
*/
switch (motornum) {
case 1:

a = MOTOR1_A; b = MOTOR1_B; break;

case 2:

a = MOTOR2_A; b = MOTOR2_B; break;

case 3:

a = MOTOR3_A; b = MOTOR3_B; break;

case 4:

a = MOTOR4_A; b = MOTOR4_B; break;

default:

return;

}

/* Section 2: set the selected shift register outputs to high/low,
* low/high, or low/low depending on the command. This is done
* by updating the appropriate bits of latch_state and then
* calling tx_latch() to send latch_state to the chip.
*/

switch (cmd) {

case FORWARD:                // high/low

latch_state |= _BV(a);
latch_state &= ~_BV(b);
MC.latch_tx();
break;

case BACKWARD:               // low/high

latch_state &= ~_BV(a);
latch_state |= _BV(b);
MC.latch_tx();
break;

case RELEASE:                // low/low

latch_state &= ~_BV(a);
latch_state &= ~_BV(b);
MC.latch_tx();
break;

}

}

setSpeed

void AF_DCMotor::setSpeed(uint8_t speed) {

switch (motornum) {
case 1:

OCR2A = speed; break;

case 2:

OCR2B = speed; break;

case 3:

OCR0A = speed; break;

case 4:

OCR0B = speed; break;

}

}

initPWM1

This is a brief excerpt of the AF_DCMotor constructor (subroutine initPWM1(freq)), which is initializing speed control for motor 1:

// use PWM from timer2A
TCCR2A |= _BV(COM2A1) | _BV(WGM20) | _BV(WGM21); // fast PWM, turn on oc0
TCCR2B = freq & 0x7;
OCR2A = 0;
DDRB |= _BV(3);
break;