week05.md

LilyPad Buzzer Example, modified by Loes Bogers
SparkFun Electronics

This example code shows how to hook up a LilyPad Buzzer to play a simple song
using the tone() function and setting variables for each note.

Buzzer connections:
   * + pin to 5
   * - to -

const int buttonPin = 8;     // the number of the pushbutton pin
const int ledPin =  10;      // the number of the LED pin > has PWM
const int buzzerPin = 5;    // the number of the buzzer pin
int delayTime = 100;
int delayTime2 = 150;
int delayTime3 = 200;


// Notes and their frequencies
const int C = 1046;
const int D = 1175;
const int E = 1319;
const int F = 1397;
const int G = 1568;
const int A = 1760;
const int B = 1976;
const int C1 = 2093;
const int D1 = 2349;

int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
  // Set the buzzer pin as an OUTPUT
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == LOW) {

      //To use LED uncomment sentence below
     digitalWrite(ledPin, LOW);

     //play notes (delayTime in this case is how long it's played)
     tone(buzzerPin, C);
     delay(delayTime);
     tone(buzzerPin, E);
     delay(delayTime2);
//     tone(buzzerPin, C);
//     delay(delayTime);
//     tone(buzzerPin, G);
//     delay(delayTime3);
//     tone(buzzerPin, F);
//     delay(delayTime);
  }else{
//stop sound
     noTone(buzzerPin);
     digitalWrite(ledPin, HIGH);
  }
}

/*

Code from http://www.technoblogy.com/show?20MO
Playing Notes on the ATtiny85
31st January 2018

Modified by Loes Bogers
November 2019

This article describes a simple function for playing notes on the ATtiny85.
I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.

The note function uses Timer/Counter1 in the ATtiny85,
leaving Timer/Counter0 free for delay() and millis().
It doesn't use interrupts, so the sound output is unaffected by other interrupt-driven processes,
and it includes a lookup table for the well-tempered scale divisors, so you don't need to remember frequency values.

It's an improved version of my earlier article Simple Tones for ATtiny.
For a similar routine for the ATmega328 or ATmega32u4 see A Lightweight Alternative to tone.

The note function takes two parameters:

    A note number, from 0 to 11, representing the note in the well-tempered scale,
    where 0 represents C, 1 represents C#, and so on up to 11 for B.
    The octave, which can be from 0 to 7 with a 1MHz clock,
    0 to 10 with an 8MHz clock,
    and 0 to 11 with a 16MHz clock.

*/

const int Output = 4;               // Can be pin 1 or 4

// Cater for 16MHz, 8MHz, or 1MHz clock:
const int Clock = ((F_CPU/1000000UL) == 16) ? 4 : ((F_CPU/1000000UL) == 8) ? 3 : 0;
const uint8_t scale[] PROGMEM = {239,226,213,201,190,179,169,160,151,142,134,127};

void setup(){

  }

void loop() {
  for (int n=0; n<=12; n++) {       //n = 12 is number of notes in octave.
    note(n, 4);                    // start at note 4
    if (n!=4 && n!=11) n++;       // if note is not for and not 11 add one to n (plays 8 notes)
    delay(100);                   // delay between each note
  }
  note(0, 0);
  delay(1000);  // time in milliseconds before loop starts again
}

void note (int n, int octave) {
  int prescaler = 8 + Clock - (octave + n/12);
  if (prescaler<1 || prescaler>15 || octave==0) prescaler = 0;
  DDRB = (DDRB & ~(1<<Output)) | (prescaler != 0)<<Output;
  OCR1C = pgm_read_byte(&scale[n % 12]) - 1;
  GTCCR = (Output == 4)<<COM1B0;
  TCCR1 = 1<<CTC1 | (Output == 1)<<COM1A0 | prescaler<<CS10;
}
/*

Code from http://www.technoblogy.com/show?20MO
Playing Notes on the ATtiny85
31st January 2018

Modified by Loes Bogers
November 2019

This article describes a simple function for playing notes on the ATtiny85.
I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.

The note function uses Timer/Counter1 in the ATtiny85,
leaving Timer/Counter0 free for delay() and millis().
It doesn't use interrupts, so the sound output is unaffected by other interrupt-driven processes, and it includes a lookup table for the well-tempered scale divisors, so you don't need to remember frequency values.

It's an improved version of my earlier article Simple Tones for ATtiny.
For a similar routine for the ATmega328 or ATmega32u4 see A Lightweight Alternative to tone.

The note function takes two parameters:

    A note number, from 0 to 11, representing the note in the well-tempered scale,
    where 0 represents C, 1 represents C#, and so on up to 11 for B.
    The octave, which can be from 0 to 7 with a 1MHz clock,
    0 to 10 with an 8MHz clock,
    and 0 to 11 with a 16MHz clock.

*/

const int ledPin =  0;      // the number of the LED pin > has PWM
const int Output = 4;      // Can be pin 1 or 4

// Cater for 16MHz, 8MHz, or 1MHz clock:
const int Clock = ((F_CPU/1000000UL) == 16) ? 4 : ((F_CPU/1000000UL) == 8) ? 3 : 0;
const uint8_t scale[] PROGMEM = {239,226,213,201,190,179,169,160,151,142,134,127};

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

void loop() {
  for (int n=0; n<=12; n++) {       //n = 12 is number of notes in octave.
    note(n, 4);                    // start at note 4
    if (n!=4 && n!=11) n++;       // if note is not 4 and not 11: add one to n (plays 8 notes)
    delay(100);                   // delay between each note
  }
  note(0, 0);

  digitalWrite(ledPin, HIGH);		//visual feedback from LED, to see if program runs
  delay(1000);  						// time in milliseconds before loop starts again
  digitalWrite(ledPin, LOW);
}

void note (int n, int octave) {
  int prescaler = 8 + Clock - (octave + n/12);
  if (prescaler<1 || prescaler>15 || octave==0) prescaler = 0;
  DDRB = (DDRB & ~(1<<Output)) | (prescaler != 0)<<Output;
  OCR1C = pgm_read_byte(&scale[n % 12]) - 1;
  GTCCR = (Output == 4)<<COM1B0;
  TCCR1 = 1<<CTC1 | (Output == 1)<<COM1A0 | prescaler<<CS10;
}
/*

  Buzzer ATtiny Code from http://www.technoblogy.com/show?20MO
  Playing Notes on the ATtiny85
  31st January 2018

  Modified by Loes Bogers
  Nov 2019

  This article describes a simple function for playing notes on the ATtiny85.
  I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.

  The note function uses Timer/Counter1 in the ATtiny85,
  leaving Timer/Counter0 free for delay() and millis().
  It doesn't use interrupts, so the sound buzzerPinPinPinPin is unaffected by other interrupt-driven processes,
  and it includes a lookup table for the well-tempered scale divisors, so you don't need to remember frequency values.

  It's an improved version of my earlier article Simple Tones for ATtiny.
  For a similar routine for the ATmega328 or ATmega32u4 see A Lightweight Alternative to tone.

  The note function takes two parameters:

    A note number, from 0 to 11, representing the note in the well-tempered scale,
    where 0 represents C, 1 represents C#, and so on up to 11 for B.
    The octave, which can be from 0 to 7 with a 1MHz clock,
    0 to 10 with an 8MHz clock,
    and 0 to 11 with a 16MHz clock.

*/

const int ledPin =  0;      // the number of the LED pin > has PWM
const int buzzerPin = 4;    // Can be pin 1 or 4
const int buttonPin = 2;     // the number of the pushbutton pin

// Cater for 16MHz, 8MHz, or 1MHz clock:
const int Clock = ((F_CPU / 1000000UL) == 16) ? 4 : ((F_CPU / 1000000UL) == 8) ? 3 : 0;
const uint8_t scale[] PROGMEM = {239, 226, 213, 201, 190, 179, 169, 160, 151, 142, 134, 127};

int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
  //  // Set the buzzerPinPinPin pin as an OUTPUT   //not necessary, programmed globally?
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is LOW:

  if (buttonState == LOW) {

    digitalWrite(ledPin, HIGH);
    digitalWrite(buzzerPin, LOW); // set to low to avoid shorts

  } else {

    digitalWrite(ledPin, LOW);

    for (int n = 0; n <= 12; n++) {   //n = 12 is number of notes in octave.
      note(n, 4);
      if (n != 4 && n != 11) n++;   //
      delay(100);                   // delay between each note
    }
    note(0, 0);
    delay(1000);  // time in milliseconds before loop starts again
  }
}


void note (int n, int octave) {
  int prescaler = 8 + Clock - (octave + n / 12);
  if (prescaler < 1 || prescaler > 15 || octave == 0) prescaler = 0;
  DDRB = (DDRB & ~(1 << buzzerPin)) | (prescaler != 0) << buzzerPin;
  OCR1C = pgm_read_byte(&scale[n % 12]) - 1;
  GTCCR = (buzzerPin == 4) << COM1B0;
  TCCR1 = 1 << CTC1 | (buzzerPin == 1) << COM1A0 | prescaler << CS10;
}
//Code taken from these tutorials and modified by Loes Bogers
//https://www.instructables.com/id/Capacitive-Sensing-for-Dummies/
//https://www.arduino.cc/en/Tutorial/Smoothing

#include <CapacitiveSensor.h>

#include <SoftwareSerial.h>   when using ATtiny and FTDI cable

#define rxPin 1   //    if using FTDI cable and attiny > connect to TX of other device
#define txPin 0   //  if using FTDI cable and attiny  > connect to RX of other device
SoftwareSerial serial(rxPin, txPin);  //if using FTDI cable and attiny

//send at pin 4, receive at pin 3, 1-10M ohm resistor between
CapacitiveSensor cs_3_4 = CapacitiveSensor(3, 4); // 1-10 megohm resistor between pins 4 & 3, pin 3 is sensor pin, add wire, foil

const int numReadings = 10;     // size of array/number of readings to keep track of (higher = slower)
int readings[numReadings];      // the readings from the analog input
int readIndex = 0;              // the index of the current reading
int total = 0;                  // the running total
int average = 0;                // the average

void setup() {

  // initialize serial communication with computer:
//  Serial.begin(9600);           //start serial communication via USB cable
  serial.begin(115200);       //if using FTDI cable and attiny

  cs_3_4.set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1 - just as an example Serial.begin(9600);

  //initatialize readings array setting all values to 0
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readings[thisReading] = 0;
  }
}

void loop() {

  // subtract the last reading:
  total = total - readings[readIndex];

  // read from the sensor:
  readings[readIndex] = cs_3_4.capacitiveSensor(30);

  // add the reading to the total:
  total = total + readings[readIndex];

  // advance to the next position in the array:
  readIndex = readIndex + 1;

  // if we're at the end of the array...wrap around to the beginning
  if (readIndex >= numReadings) {
    readIndex = 0;
  }

  // calculate the average:
  average = total / numReadings;

  // send it to the computer as ASCII digits
//  Serial.println(average);  // if using Arduino serial
  serial.println(average);       // if using FTDI cable and attiny

  delay(10); // arbitrary delay to limit data to serial port
}
CODE CODE CODE