Na gut, für das "sauber programmieren" leg ich besser nicht meine Hand in's Feuer. Ich bin ja eher so der "Cut & Paste"-Programmierer. Das fragliche Programm läuft zwar mit Arduino Pro Mini in zwei Versionen bisher problemlos. Trotzdem passierte beim Micro diese Pleite :(
Ich habe einige wenige "char"-Befehle drin und schreibe zwei Variablen in den EEPROM.
Hier ist das komplette Programm:
/************************************************** *******************
* FM-Radio mit RDA5708M, Leonardo Pro Micro 3.3V und OLED 64x32 *
* Steuerung über vier Drucktaster: *
* button 1 - volume down *
* button 2 - volume up *
* button 3 - scan frequency down *
* button 4 - scan frequency up *
* Das OLED-display zeigt drei Zeilen: *
* 1- "Empfangsfrequenz" *
* 2- "RDS Daten" wenn vorhanden, falls nicht dann "No RDS *
* 3- "Volume: 0-15" *
* Die Empfangsfrequenz und der Wert für Volume wird im EEPROM *
* gespeichert, so dass bei jedem Neustart die alten Werte gelten. *
* *
* U.Galepp April 2020 *
************************************************** ******************/
#include <Arduino.h>
#include <Wire.h> // für I2C
#include <radio.h> // für allgemeine Radio-Befehle
#include <RDA5807M.h> // für spezifische RDA5807 Details
#include <RDSParser.h> // für RDS Daten Verarbeitung
#include <EEPROM.h> // für Datenspeicherung wenn Aus
#include "er_oled.h" // für spezielles OLED
#define FIX_BAND RADIO_BAND_FM // ausgewähltes Band ist FM
RDA5807M radio; // create an instance of class for RDA5807M chip
RDSParser rds; // get RDS parser
int button_1 = 4; // Taster für volume down an D4
int button_2 = 5; // Taster für volume up an D5
int button_3 = 6; // Taster für scan down an D6
int button_4 = 7; // Taster für scan up an D7
int buttonState_1 = 0;
int buttonState_2 = 0;
int buttonState_3 = 0;
int buttonState_4 = 0;
int volume; // integer Variable für Lautstärke
int roll = 64; // integer Variable für Laufschrift RDS
int frequency; // integer Variable für Frequenz
byte storeVol; // Speichervariable "Volume" für EEPROM
byte storeFreq; // Speichervariable "Frequenz" für EEPROM
char vol[2]; // Zeichenkette Variable für Lautstärke (0-15)
char* info; // Zeichenkette Variable für RDS-Info
unsigned long previousMillis = 0; // Laufvariable für Zeitmessung EPROM-Speicher
uint8_t oled_buf[WIDTH * HEIGHT / 8]; // Dimension für OLED Puffer
/*** setup ***/
void setup()
{
Serial.begin(57600); // Start seriellen Terminal für Debugging
er_oled_begin(); // OLED starten
radio.init(); // Radio initialisieren
radio.setBand(FIX_BAND); // Radio auf ausgewähltes Band (FM) setzen
storeFreq = EEPROM.read(0); // Speicherwert für Frequenz aus EEPROM holen
frequency = (storeFreq + 825)*10; // Frequenzwert zu int für Radio-Chip wandeln
radio.setFrequency(frequency); // Radio auf gespeicherte Frequenz setzen
storeVol = EEPROM.read(1); // Speicherwert für Volume (byte) aus EEPROM holen
volume = storeVol; // byte zu int (volume) wandeln
radio.setVolume(volume); // Radio auf gespeicherte Lautstärke setzen
radio.attachReceiveRDS(RDS_process); // setup the information chain for RDS data.
rds.attachServicenNameCallback(ServiceName);
pinMode(button_1, INPUT); // Taster-Pins als Eingang definieren
pinMode(button_2, INPUT); // -||-
pinMode(button_3, INPUT); // -||-
pinMode(button_4, INPUT); // -||-
digitalWrite(button_1, HIGH); // Pull-Up Widerstände aktivieren
digitalWrite(button_2, HIGH); // -||-
digitalWrite(button_3, HIGH); // -||-
digitalWrite(button_4, HIGH); // -||-
}
void ServiceName(char *name)
{ info = name; }
void RDS_process(uint16_t block1, uint16_t block2, uint16_t block3, uint16_t block4)
{ rds.processData(block1, block2, block3, block4); }
void loop()
{
// alle 15 Sekunden Abfrage ob Volume oder Frequenz reändert? Wenn ja, dann in EPROM schreiben!
if (millis() - previousMillis > 15000){ // Sind 15 Sekunden um?
previousMillis = millis(); // Zeit zurücksetzen
frequency = (radio.getFrequency()); // Frequenz aus Radio auslesen (int)
storeFreq = (frequency/10)-825; // Frequenz (int) in Speicherwert storeFreq (byte) umrechnen
volume = radio.getVolume(); // Volume aus Radio auslesen (int)
storeVol = volume; // Volume (int) in Speicherwert storeVol (byte) umwandeln
EEPROM.update(1, storeVol); // falls neuer Speicherwert von altem abweicht, dann update EEPROM
EEPROM.update(0, storeFreq); // falls neuer Speicherwert von altem abweicht, dann update EEPROM
}
// Tastenabfrage für Lautstärke und Frequenzänderung
if(!digitalRead(button_1) ) { // wenn Taster 1 gedrückt, Volume einen Schritt runter
while(!digitalRead(button_1) ) // warten auf Taster loslassen == HIGH
{delay(10);}
volume --;
if (volume < 0) volume = 0;
radio.setVolume(volume);
}
if(!digitalRead(button_2) ) { // wenn Taster 2 gedrückt, Volume einen Schritt hoch
while(!digitalRead(button_2) ) // warten auf Taster loslassen == HIGH
{delay(10);}
volume ++;
if (volume >15) volume = 15;
radio.setVolume(volume);
}
if(!digitalRead(button_3) ) { // wenn Taster 3 gedrückt, abwärts scannen
while(!digitalRead(button_3) ) // warten auf Taster loslassen == HIGH
{delay(10);}
radio.seekDown();
info = ""; // RDS-Info löschen
delay(100);
}
if(!digitalRead(button_4) ) { // wenn Taster 4 gedrückt, aufwärts scannen
while(!digitalRead(button_4) ) // warten auf Taster loslassen == HIGH
{delay(10);}
radio.seekUp();
info = ""; // RDS-Info löschen
delay(100);
}
// OLED-Ausgabe der Daten
char s[12]; // Formatierung der Frequenzangabe
radio.formatFrequency(s, sizeof(s)); // -||-
er_oled_clear(oled_buf); // OLED Puffer löschen (Anzeige leeren)
radio.checkRDS(); // RDS Daten abrufen
if (roll == 0)roll = 64; // wenn Laufschrift-Position ganz links, setze wieder auf rechts
if(info == "") // Wenn keine RDS-Info gefunden...
{
er_oled_string(roll, 11, "No RDS", 12, 1, oled_buf); // ...zeige "No RDS"
}
else // ansonsten...
{
er_oled_string(roll, 11, info, 12, 1, oled_buf); // ...zeige RDS-Info
}
roll --; // setze RDS-Position einen Pixel nach links
er_oled_string(0, 0, s, 12, 1, oled_buf); // schreibe Frequenz in erste Zeile OLED Puffer
er_oled_string(6, 22, "Volume: ", 12, 1, oled_buf); // schreibe Zeichenkette "Volume:" in dritte Zeile OLED Puffer
sprintf (vol, "%d", volume); // Umwandlung int "volume" zu char "vol"
er_oled_string(49, 22, vol, 12, 1, oled_buf); // schreibe Zeichenkette vol in dritte Zeile OLED Puffer
er_oled_display(oled_buf); // gesammten Puffer im OLED darstellen
// Ausgabe der Werte für Debugging (Terminal)
Serial.print(" Frequenz: ");
Serial.print(frequency); // Ausgabe der Frequenz
Serial.print(" Volume: ");
Serial.print(volume); // Ausgabe der Lautstärke
Serial.print(" RDS Daten: ");
Serial.println(info); // Ausgabe der RDS-Info
Serial.print("V ");
} // End
Wenn ihr da drinn einen Bug findet, der den USB killed, wäre ich sehr dankbar.
Schönes Wochenende!
was mir als erstes auffiel:
die Zeile
char* info;
alloziert dafür keinen Speicherbereich, du schreibst also Daten ggf irgendwohin ins Speicher-Nirwana - richtiger wäre etwas in der Art wie
char info[30];
auch die Zeilen
void ServiceName(char *name)
{ info = name; }
tun nicht, was sie wschl sollen, denn man kann einem char* oder char[] cstring nicht mit "=" einen char array (einen anderen cstring) zuweisen (außer eine Konstante direkt beim Definieren);
tatsächlich weist du hier nur einem Pointer auf eine Speicheradresse einen anderen Pointer auf eine andere Speicheradresse zu
- richtiger wäre hier
strcpy(info, name); // besser noch: strncpy verwenden!
PS,
auch Zeilen wie
info = "";
oder
if(info == "")
sind aus ähnlichen Gründen syntaktisch nicht korrekt ( das geht mit C++ String und std::string, aber nicht mit ANSI C cstring (char[] arrays).
PPS
wie ServiceName() funktionieren soll (zB. in rds.attachServicenNameCallback(ServiceName) ) verstehe ich allerdings auch nicht, denn du es hast es ja als void definiert, und ich sehe nicht, wo du an ServiceName() überhaupt eine cstring-Variable als Parameter übergibst.
Ob so etwas insgesamt die FW aushebeln kann, kann ich ntl nicht sagen.