main.c

/* ********************************************************************

 *               Melodiegenerator fuer ATtiny85

 *               ==============================

 *                     Uwe Berger; 2009

 * 

 * Software:

 * ---------

 * Inputformat der Melodien ist Nokias RTTTL-Format.

 * Der Rest ist aus dem Quelltext ersichtlich!

 * 

 * Idee: http://hackvalue.de/hv_atmel_rtttl

 * 

 * Wobei im vorliegenden Programm aber der RTTTL-Parser gleich mit drin 

 * ist und somit ohne externen Konverter auskommt.

 * 

 * Vorteil: man kann RTTTL-Klingeltoene ohne Anpassung an der 

 *          entsprechenden Stelle im Programm eingefuegt werden

 * 

 * Nachteil: es wird etwas mehr Speicherplatz fuer das Programm verbraucht

 * 

 * 

 * Hardware:

 * ---------

 * Ein ATtiny85 in Standardbeschaltung, also ohne externen Quarz, reicht

 * aus. Folgende Peripherie:

 *  - an PB1 ist ein Lautsprecher angeschlossen. Ich habe dazu eine dieser

 *    laermenden Geburtstagskarten gepluendert. Dieser Lautsprecher wurde

 *    direkt angeschlossen, eventuell sollten aber bei anderen Modellen

 *    Strombegrenzungswiderstaende vorgesehen werden.

 *  - an PB2 ist ein Taster angeschlossen, der den Tiny aus dem Schlaf

 *    reisst und ihn die naechste Melodie dudeln laesst. Der geschlossene

 *    Taster legt GND an den Pin, es sollte ein PullUp-Widerstand von

 *    10kOhm vorgesehen werden.

 * 

 * --------------------------------------------------------------------

 *  

 * RTTTL-Formatbeschreibung z.B.:

 *     http://de.wikipedia.org/wiki/Ringing_Tones_Text_Transfer_Language

 * 

 * freie Nokia-Klingeltoene (RTTTL-Format):

 * http://www.2thumbswap.com/members/tones/nokia/tones_nokia_main.html

 * 

 *********************************************************************/

#ifndef F_CPU

#define F_CPU 1000000UL           

#endif

#include <avr/io.h>

#include <util/delay.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <avr/sleep.h>

// Lautsprecherport

#define SPEAKER_DDR    DDRB

#define SPEAKER_PORT  PORTB

#define SPEAKER      PB1

// Taster

#define TASTER_DDR  DDRB

#define TASTER_PORT PORTB

#define TASTER_PIN  PB2

#define TASTER_INT  PCINT2

// Vorteiler fuer Timer0 (in ctc_on() TCCR0B entsprechend mit anpassen!)

#define PRESCALE 8

// Tonfrequenzen

const uint16_t freq[] PROGMEM = {

  //   C,   C#,    D,   D#,    E,    F,   F#,    G,   G#,    A,   A#,    B

   262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494, //Oktave 5

   523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988, //Oktave 6

  1046, 1109, 1175, 1244, 1328, 1397, 1480, 1568, 1661, 1760, 1865, 1975, //Oktave 7

  2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951  //Oktave 8

};

const char m1[] PROGMEM = "99luv:d=4,o=5,b=180:d6,8e6,c6,e.6,d6,8c6,a.,8p,8a,8f6,f6,f6,f.6,8f6,e6,d6,c.6,d6,8e6,c6,e.6,d6,8c6,a.,8p,8a,f6,f6,f6,f6,8f6,e6,d.6,8c6,8d6,e6,c6,e.6,d6,8c6,a.,8p,8a,c6,8a,c6,f6,f6,e6,d.6,8c6,d6,e6,c6,e.6,d6,8c6,a.,8p,8f6,f6,8f6,f6,f6,f6,e6,2d6";

const char m2[] PROGMEM = "letitbe:d=4,o=5,b=112:16g.,8g,g,8g,a,8e,8g,g.,8c6,d.6,e6,8e6,e6,8d6,8d6,8c6,2c6,e6,8e6,f6,8e6,8e6,d.6,8e6,8d6,2c6";

const char m3[] PROGMEM = "Peter Schilling - Major Tom:d=4,o=6,b=200:c.,8p,c,c,c.,8p,c.,8p,2a5,2c,c,8a#5,8a5,g.5,8p,2a#5,2d,2d,c.,8p,2a5,2c,c,8a#5,8a5,g.5,8p,2a#5,2d,2d,e.,8p,1f,2e,d,c,2d.,c,2d,e.,8p,1f,2e,d,c,2d.,c,2d,2";

const char m4[] PROGMEM = "yday:d=4,o=5,b=125:g,8f,f,p,8a,8b,8c#6,8d6,e6,8p,8f6,e6,8d6,d6,p,8d6,8d6,8c6,8a#,8a,8g,8a#,8a,8a,a,8p,g,f,8a,8g,g,8p,8d,f,8p,8a,a";

const char *ma[] PROGMEM = {m4,  m1,  m2,  m3};

//*********************************************************************

ISR(PCINT0_vect){

  // vorhanden, um MCU definiert aus dem Sleep-Mode zu holen

}

//*********************************************************************

static void ctc_on(void) {

  // CTC mode mit toggeln von OC0A/OC0B (Tiny85)

  TCCR0A |= (1<<COM0A0 | 1<<COM0B0 | 1<<WGM01);

  // Prescaler 8

  TCCR0B = 1<<CS01;

}

//*********************************************************************

static void ctc_off(void) {

  TCCR0A = 0;

  TCCR0B = 0;

}

//*********************************************************************

int f(int n, int o) {

  // lustiger Nebeneffekt des Zugriffs auf den Flash-RAM: die Zeit

  // die dazu notwendig ist, fuegt eine kleine Pause zwischen den 

  // Toenen ein, die auch ganz sinnvoll ist...

  //  

  // lt. Datenblatt fuer CTC-Mode ist

  // Focnx = Fclk / (2 * Prescale * (1 + OCRnx)

  // umgestellt nach OCRnx:

  // OCRnx = (Fclk / Focnx / 2 / Prescale) - 1

  return (F_CPU/pgm_read_word(&freq[n+(o-5)*12])/2/PRESCALE)-1;

}

//**********************************************************************

char rf(const char *p) {

  return pgm_read_byte(p);

}

//**********************************************************************

void my_delay_ms(uint16_t ms) {

  uint16_t i;

  // es ist mir nicht gelungen, die Pause via Timer zu

  // realsieren: es gab merkwuerdige Seiteneffekte, denen ich

  // nicht auf die Spur gekommen bin...

  //

  // _delay_ms generiert nur dann wenig Maschinencode, wenn 

  // es mit konstanten Werten gefuettert wird, also deshalb dieser

  // Konstrukt....

  for (i=0; i<ms; i++) _delay_ms(1);

}

//**********************************************************************

void play(uint8_t i) {

  const char *p;

  uint16_t def_noten_laenge = 4; 

  uint8_t def_oktave = 6;

  uint16_t def_bpm = 63;

  // Anfangspointer setzen

  p = (const char*)(pgm_read_word(&(ma[i])));

  // Titel ueberspringen

  while (rf(p) && rf(p) != ':') p++;

  if (!rf(p)) return;

  p++;

  // als naechstes kommen die Song-Defaults

  while (rf(p)) {

    uint8_t param;

    uint16_t value;

    // fuehrende Leerzeichen ueberspringen

    while (rf(p) == ' ') p++;

    if (!rf(p)) return;

    // hier ist das Ende des Default-Bereiches erreicht  

    if (rf(p) == ':') break;

    param = rf(p);

    p++;

    if (rf(p) != '=') return;

    p++;

    value = 0;

    while (rf(p) >= '0' && rf(p) <= '9') {

      value = value * 10 + (rf(p) - '0');

      p++;

    }

    switch (param) {

      //case 'd': def_noten_laenge = 32 / value; break;

      case 'd': def_noten_laenge = value; break;

      case 'o': def_oktave = value; break;

      case 'b': def_bpm = value; break;

    }

    // folgende Leerzeichen ueberspringen

    while (rf(p) == ' ') p++;

    if (rf(p) == ',') p++;

  }

  p++;

  // Noten selbst analysieren

  while (rf(p)) {

    uint8_t note = 63;

    uint16_t oktave = def_oktave;

    uint16_t noten_laenge = def_noten_laenge;

    uint16_t dauer_ms;

    uint8_t punkt_note = 0;

    // Leerzeichen ueberspringen

    while (rf(p) == ' ') p++;

    if (!rf(p)) return;

    // Notenlaenge bestimmen

    if (rf(p) >= '0' && rf(p) <= '9') {

      uint16_t value = 0;

      while (rf(p) >= '0' && rf(p) <= '9') {

        value = value * 10 + (rf(p) - '0');

        p++;

      }

      noten_laenge = value;

    }

    // Note bestimmen

    switch (rf(p)) {

      case 0: return;

      case 'C': case 'c': note = 0; break;

      case 'D': case 'd': note = 2; break;

      case 'E': case 'e': note = 4; break;

      case 'F': case 'f': note = 5; break;

      case 'G': case 'g': note = 7; break;

      case 'A': case 'a': note = 9; break;

      case 'H': case 'h': note = 11; break;

      case 'B': case 'b': note = 11; break;

      case 'P': case 'p': note = 63; break;

    }

    p++;

    // Halbnote hoeher

    if (rf(p) == '#') {

      note++;

      p++;

    }

    // Halbnote tiefer(?)

    if (rf(p) == 'b') {

      note--;

      p++;

    }

    // Punktnote=

    if (rf(p) == '.') {

      //noten_laenge += noten_laenge / 2;

      punkt_note = 1;

      p++;

    }

    // Oktave ermitteln

    if (rf(p) >= '0' && rf(p) <= '9') {

      oktave = (rf(p) - '0');

      p++;

    }

    // hier koennte auch ein Punkt sein...

    if (rf(p) == '.') {

      //noten_laenge += noten_laenge / 2;

      punkt_note = 1;

      p++;

    }

    // nachfolgende Leerzeichen ueberspringen

    while (rf(p) == ' ') p++;

    // Komma ist Notentrenner

    if (rf(p) == ',') p++;

    // Tondauer berechnen (60s = 60000ms)

    dauer_ms = (((60000 / def_bpm) * def_noten_laenge) / noten_laenge);

    // war eine Punktnote dabei?

    if (punkt_note) dauer_ms += dauer_ms/2;

    if (note != 63) {

      // Tonfrequenz einstellen

      OCR0A = f(note, oktave);

      OCR0B = f(note, oktave);

      ctc_on();        // Ton einschalten

      my_delay_ms(dauer_ms);  // Ton fuer berechnete Dauer halten

      ctc_off();        // Ton ausschalten      

    } else {

      // Pause fuer berechnete Dauer

      ctc_off();        // Ton ausschalten

      my_delay_ms(dauer_ms);

    }

  }

}

int main(void) {

  uint8_t i = 0;

  // Taster 

  TASTER_PORT &= ~(1 << TASTER_PIN);  // Taster-Pin als Eingang

  // PCINT0 initialisieren  

  PCMSK    |=  (1 << TASTER_INT);    // Taster-Pin maskieren

  GIMSK    |=  (1 << PCIE);      // Port Change Interrupt frei

  sei();                // Interrupts einschalten

  // Lautsprecher als Ausgang

  SPEAKER_DDR |= (1<<SPEAKER);

  while(1) {

    if (i >= (sizeof(ma)/sizeof(ma[0]))) i = 0;

      play(i);

      // Sleep-Mode

      set_sleep_mode(SLEEP_MODE_PWR_DOWN);

      sleep_mode();

      i++;

  }

  return 0;

}