RTTTL Player

[Achim S. (achims)]

Hallo Gemeinde
Den folgenden Code habe ich versucht anzupassen. Er wird ohne Fehler 
copieliert, bringt aber keine Funktion .- sagt gar nichts
Leider ist mir die Sache nicht klar was los ist.
Daten AT1284p, C, 16 MHZ, Taster PC2, Lsp. PC7

/* ********************************************************************
 Melodiegenerator fuer AT1284p (tiny8)           Uwe Berger; 2009 
 Inputformat der Melodien ist Nokias RTTTL-Format. Der Rest ist aus dem Quelltext ersichtlich!
 Wobei im vorliegenden Programm aber der RTTTL-Parser gleich mit drin ist und somit ohne externen   
 Konverter auskommt. 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:
 (ATtiny85) AT1284p in Standardbeschaltung Folgende Peripherie:
 - an PC7 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 PC2 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.
*********************************************************************/
#ifndef F_CPU
#define F_CPU 16000000UL           
#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    DDRC
#define SPEAKER_PORT  PORTC
#define SPEAKER      PC7

// Taster
#define TASTER_DDR  DDRC
#define TASTER_PORT PORTC
#define TASTER_PIN  PC2
#define TASTER_INT  PCINT18

// 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};
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) 
            {
              OCR0A = f(note, oktave);     // Tonfrequenz einstellen
              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  
    
  PCMSK2 |=  (1 << TASTER_INT);        // Taster-Pin maskieren
  PCICR |=  (1 << PCIE2);          // Port Change Interrupt frei
  
  sei();
    // 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;
  }

Sorry, habe gerade erst gesehen, das prescaler nicht angepasst. Gibt es 
sonst einen Grund?
Vielleicht könnte jemand drüber schauen
achim

[Achim (Gast)]

Hallo Peter
das ist das gesamte Programm zu dem RTTTL Player
achim

[Jürgen S. (jurs)]

Achim Seeger schrieb:
> Vielleicht könnte jemand drüber schauen

Ich würde mal prüfen, ob Du überhaupt die beabsichtigte Melodie ausliest 
und nicht irgendwelchen Datenmüll.

Ich als Arduino-Programmierer verhaspele mich per default regelmäßig 
dabei, auf ein Array of PROGMEM-Konstanten über ein Array von 
PROGMEM-Pointern zuzugreifen und brauche dann stets serielles Debugging, 
um mir das auszubaldowern, wie die Zugriffe mit Pointern und pgm_read... 
in sich stimmig sind.

So auf Anhieb würde ich erstmal sagen, dass Deine Melodieanfänge im 
Programm nicht "array of char" sein sollen:

const char ma[] PROGMEM = "m4,  m1,  m2,  m3";

sondern dass da ein "array of char pointer" definiert werden sollte, und 
das nicht als String, sondern als Array of Pointer:

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

[Achim (Gast)]

Danke Jürgen, werde es probieren

[Achim S. (achims)]

Habe die Zeile noch mal kontrolliert. War fehlerhaft übertragen. Habe es 
jetzt geändert und bekomme ein Fehlermeldung:

Error  1  variable 'ma' must be const in order to be put into read-only 
section by means of '__attribute__((progmem))'

Sorry, versteh nicht was ich machen soll.
achim

[Achim S. (achims)]

Sorry, habe die Zeile und die übersetzung vergessen. Kommt sofort

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

/*
\  Fehler 1 Variable 'ma' muss const sein, um mit Hilfe von '__attribute __ ((progmem))' 
E in Nur-Lese-Abschnitt gesetzt werden .c 63 13 Sound_V1_1
*/

Was sagt mir diese Zeile?
achim

[Jürgen S. (jurs)]

Achim Seeger schrieb:
> Sorry, habe die Zeile und die übersetzung vergessen. Kommt sofort
>
>

> const char *ma [] PROGMEM = {m4,  m1,  m2,  m3};
> 
> /*
> \  Fehler 1 Variable 'ma' muss const sein, um mit Hilfe von '__attribute 
> __ ((progmem))'
> E in Nur-Lese-Abschnitt gesetzt werden .c 63 13 Sound_V1_1
> */
>

>
> Was sagt mir diese Zeile?


Die Fehlermeldung besagt, dass der Compiler den Code nicht fressen 
möchte.
Das ist ja gediegen!

Ich habe es selbst gerade mal mit der Arduino-IDE getestet:

Mit einer alten AVR-GCC Compilerversion (Arduino 1.0.5) wird der Code 
fehlerfrei compiliert.

Mit einer neuen AVR-GCC Compilerversion (Arduino 1.5.7) erzeugt der Code 
beim Compilieren die Fehlermeldung.

Mit ist bekannt, dass am AVR-GCC etwas an der PROGMEM-Verarbeitung von 
Flash-Konstanten geändert wurde, so dass es nun zwingend erforderlich 
ist, PROGMEM-Konstanten als "const" zu deklarieren.

Aber dass sich auf die altbekannte Art überhaupt keine Stringtabellen 
mehr vollständig im Flash-Speicher anlegen lassen, war mir neu. Ich 
konnte auch nicht über Google herausfinden, was da die neue Alternative 
sein soll. Mit ein bisschen Tüfteln bin ich auf diese Zeile gekommen, 
die der Compiler akzeptiert:

const int ma[] PROGMEM= {(int)m4, (int)m1, (int)m2, (int)m3};

Da String-Pointer auf 8-Bit AVRs ja im Endeffekt Integers sind, sollte 
es damit funktionieren. Ich habe allerdings nur getestet, dass sich der 
Code damit COMPILIEREN läßt. Das Funktionieren habe ich mangels Hardware 
NICHT getestet.

[Achim S. (achims)]

Hallo Jürgen
habe es sofort versucht. Es lässt sich ohne Fehler compilieren. Leider 
keine Funktion
Sorry, wenn du schon gediegen nimmst, was bleibt mir noch zu sagen.
Vermute das einiges Profis hier mitlesen. Vielleicht gibt es ein 
klärendes wort dazu? Hallo ...
achim

[Jürgen S. (jurs)]

Achim Seeger schrieb:
> Hallo Jürgen
> habe es sofort versucht. Es lässt sich ohne Fehler compilieren. Leider
> keine Funktion

Also ich habe das Programm mit meiner Änderung mal in die Arduino-IDE 
geladen und lasse mir in der Play-Funktion die zu spielenden Noten auf 
dem "Seriellen Monitor" ausgeben.

Debug-Code der dekodierten Noten auf Arduino:

          if (note != 63) 
            {
              Serial.print(note);Serial.print('\t');
              Serial.print(oktave);Serial.print('\t');
              Serial.print(f(note, oktave));Serial.print('\t');
              Serial.println(dauer_ms);
              /*
              OCR0A = f(note, oktave);     // Tonfrequenz einstellen
              OCR0B = f(note, oktave);
              ctc_on();              // Ton einschalten
              my_delay_ms(dauer_ms);      // Ton fuer berechnete Dauer halten
              ctc_off();              // Ton ausschalten      
              */
            }

Serielle Ausgabe der dekodierten Noten und der zu spielenden Frequenz 
beim Song "Yesterday":

Note  Oktave  Freq.  Dauer
7  5  2550  480
5  5  2864  240
5  5  2864  480
9  5  2271  240
11  5  2023  240
1  6  1804  240
2  6  1702  240
4  6  1516  480
5  6  1431  240
4  6  1516  480
2  6  1702  240
2  6  1702  480
2  6  1702  240
2  6  1702  240
0  6  1911  240
10  5  2144  240
9  5  2271  240
7  5  2550  240
10  5  2144  240
9  5  2271  240
9  5  2271  240
9  5  2271  480
7  5  2550  480
5  5  2864  480
9  5  2271  240
7  5  2550  240
7  5  2550  480
2  5  3400  240
5  5  2864  480

Also wenn Du mit der Hardware diese Noten/Frequenzen mit den 
Abspieldauern in Millisekunden ausgibst, sollte eigentlich etwas zu 
hören sein.

Wenn nicht, dann dürfte entweder etwas mit der eigentlichen 
Tongenerierung in Deinem Programm nicht stimmen. Oder es stimmt etwas 
nicht mit der Hardwareschaltung für die Tonausgabe.

[Achim S. (achims)]

Hallo Jürgen
es könnte sein das der verwendete PC7 gar nicht für sowas geht. Mal 
sehen was ich an der Hardware schnell machen kann.
achim

[Jürgen S. (jurs)]

Achim Seeger schrieb:
> Hallo Jürgen
> es könnte sein das der verwendete PC7 gar nicht für sowas geht. Mal
> sehen was ich an der Hardware schnell machen kann.

Ich muß mal sehen, ob ich irgendwo noch einen alten PC zur Entsorgung 
abgestellt rumstehen habe, wo ich mir schnell mal einen 
Kleinstlautsprecher zum Testen ausbauen kann. Dann könnte ich mal mit 
einem Atmega328 probieren, ob mit Deinem Code Töne ausgegeben werden.

Aber mal eine andere Frage:
So wie ich im Thread Beitrag "Einfache Tonerzeugung" sehe, 
spielst Du schon seit über zwei Jahren mit einfacher Piepstonausgabe auf 
8-Bit AVR Controllern herum. Hast Du in den zwei Jahren noch keine 
verlässliche Möglichkeit gefunden, "Sinustöne" bestimmter Piepsfrequenz 
an einem Pin auszugeben?

In dem Fall wäre mein Rat, sich mal "Arduino" näher anzusehen. Da gibt 
es für diverse Standardaufgaben entweder Funktionen in der Arduino 
Core-Library, oder in mitgelieferten Libraries, oder von Leuten aus der 
Arduino-Community, die eigene Libraries als Open Source anbieten. Zur 
Tonerzeugung ist sogar direkt im Arduino-Core eine Funktion dabei:
http://arduino.cc/en/pmwiki.php?n=Reference/Tone
Damit zauberst Du quasi mit Null Aufwand und ohne irgendwelche Register 
"zu Fuß" programmieren zu müssen, eine Audio-Tonfrequenz auf einen 
Ausgabepin.

Mit direkter Registerprogrammierung der AVR-Controller kenne ich mich 
selbst nur schlecht aus. Ich muß mal sehen, ob ich das in Deinem Sketch 
nachvollziehen kann, zumindest auf Atmega328. Aber vorher benötige ich 
erstmal einen Lautsprecher zum Testen.

Du müßtest auch darauf achten, dass die erzeugten Frequenzen wirklich 
genau erzeugt werden. Wenn Du beispielsweise statt 1804 oder 1702 Hertz 
andere Frequenzen erzeugst, die acht- oder sechzehnmal so hoch sind, 
dürftest Du wohl kein hörbares Audiosignal mehr erhalten.

[Achim S. (achims)]

Hallo Jürgen
ist eigentlich eine einfache Sache. Im Jahre 2012 habe ich noch viel mit 
dem Nibo 2 gemacht. Dieser hat den Ausgang mit dem OPV drauf. Habe 
versucht was in Hardware und Bus dazu zu bauen und Erweiterungen zu 
machen. Der Hersteller nutzt seine eigenen Libs usw. und gibt keine oder 
sehr wenig Info. Dann noch alles open source. Irgendwann hatte ich keine 
Lust mehr, blöde Fragen zu stellen und keine Antworten zubekommen. Habe 
dann an dem I2C Bus weiter gemacht und einiges dazu gebaut und 
programmiert. Verwende jetzt den AT1284p auf einem eigenen Board und ca. 
20 zusätzliche Platinen. Alles in einem einheitlichen System mit 
gleichen Anschlüssen. Dadurch kann ich alles zusammenstellen wie ich 
möchte und ständig erweitern und umbauen und umstecken. Dazu zählen 
Netzteile, Anzeigen, Relais, Triax, Fernbedienung, 8 und 16 Bit Ein- und 
Ausgänge, die Kombinationen zwischen Bus und Port, Übertragung des Bus 
auf Entfernung bis hin zum Multitasking und der Kombination aus beiden 
Sachen. Zufällig habe ich auf dem PC7 einen Piezo Lautsprecher 
eingebaut. Diesen wollte ich zur Ausgabe eines Tones nutzen. Mit einer 
einfachen Art (delay) klappt es sehr gut. Vom Nibo kannte ich noch das 
RTTTL und woltte es auch so machen. Das klappt leider nicht. Dietr hat 
schon geschrieben, das der PC7 nicht da für geht. Da kein PWM. Wustte 
ich nicht. Muss mir wohlwas anderes überlegen.
achim

[bt (Gast)]

Vielleicht erklärt hier mal jemand, wie sich das mit den PWM Ausgängen 
der Timer verhält..
Wenn der Timer 0 benutzt wird, dann kommt der Pieps an einem Pin raus, 
der auch als OC0 bezeichnet ist, wenn's der Timer1B ist, piepst's nur 
wenn der Speaker an einem Pin mit der Zusatzbezeichnung OC1B hängt.
In "doc2467.pdf" (von Atmel Seite downloadbar) ab Seite 82 geht's los..
oder etwas auf deutsch:
[[http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR]]

und das mit den Titeladressarray geht bei mir so (im Studio 6)

/*****************************************************  TITEL STARTADRESSE

  ->  nr = Titelindex (Titelnummer-1) in der songs[] Liste

  <-  Startadresse des RTTTL Notenstrings im Flash
    Der Zeiger wird zur Titelanzeige mit show_titel() verwendet 
    und / oder an den RTTL Parser play_song() übergeben

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

const char * PROGMEM const songs[] = {song0,song1,song2,song3,song4,song5,song6,\
          song7,song8,song9,songA,songB,songC,songD,songE,songF};

PGM_P audio_start_titel_P(uint8_t nr){
  if (nr >= (sizeof(songs)/sizeof(songs[0]))) nr =0;
  return (const char*)(pgm_read_word(&(songs[nr])));
}