FM-Radio mit Arduino Pro Mini und Si4703 - Programm hängt sich auf!

Zitat:

---

Zitat von basteluwe

Das "Anpingen" würde ich ja gern probieren, nur wie macht man das? Unwissenheit kann nerven, ich weiß!
Gibt es einen Befehl in der Wire-Library (keinen gefunden), oder muß man das jeweils handisch coden, ähnlich wie im I2C-Scanner Code?

Gruß Uwe

---

habe ich doch oben geschrieben!

vor jedem einzelnen Geräte-Zugriff (Radio, OLED, was auch immer) IMMER zwischendurch diesen Code einfügen:

Code:

---

Wire.beginTransmission(addr); // transmit to device I2C addr
int ioerr=Wire.endTransmission();
if(ioerr) {  // Ausgabe eines Fehlers samt i2c-addr.
  Serial.print("Fehler bei addr 0x");
  if (addr<16) { Serial.print("0"); }
  Serial.print(addr,HEX);
  Serial.print(" ioerr="); 
  Serial.println(ioerr);
}

---

am besten sogar noch mit Debug-Zusätzen wie
Serial.println("vor Lautstärke:");
...
Serial.println("vor Sender:");
...
Serial.println("vor RDS:");
...
Serial.println("vor OLED print:");
...
usw usf

Für addr musst du ntl dort jeweils die exakte i2c-Geräteadresse einsetzen (z.B. wenn OLED die Adresse 0x3c hat, dann jeweils vor OLED-Zugriff):

Code:

---

int addr=0x3c; // für OLED
Wire.beginTransmission(addr); // transmit to device I2C addr
int ioerr=Wire.endTransmission();
if(ioerr) {  // Ausgabe eines Fehlers samt i2c-addr.
  Serial.println("vor OLED print:");
  Serial.print("Fehler bei addr 0x");
  if (addr<16) { Serial.print("0"); }
  Serial.print(addr,HEX);
  Serial.print(" ioerr="); 
  Serial.println(ioerr);
}

---

PS:
für diesen Code-Block kannst du ntl auch eine eigene Debug-Funktion spendieren

Code:

---

void i2c_debug(int addr, char * message) {
  Wire.beginTransmission(addr); // transmit to device I2C addr
  int ioerr=Wire.endTransmission();
  if(ioerr) {  // Ausgabe eines Fehlers samt i2c-addr.
    Serial.println(message);
    Serial.print("Fehler bei addr 0x");
    if (addr<16) { Serial.print("0"); }
    Serial.print(addr,HEX);
    Serial.print(" ioerr="); 
    Serial.println(ioerr);
  }
}

---

Aufruf dieser Funktion ist dann ja wohl trivial ;)

Zitat:

---

Zitat von HaWe

habe ich doch oben geschrieben!

---

Mist! Wer lesen kann hat tatsächlich Vorteile!
Tut mir leid, das hab ich im ganzen Frust irgendwie ausgeblendet, werde ich aber natürlich nun versuchen.

Seit ich die Anzeigeroutine aus der main-loop nur noch alle 5 Sekunden aufrufe oder auch nach Änderungen durch Tastendruck, hat das Script sich bisher noch nicht wieder aufgehängt!
Ist aber sicher noch zu früh, sich zu freuen.

Gruß und einen schönen Restsonntag,
Uwe

Zitat:

---

Zitat von basteluwe

Ist aber sicher noch zu früh, sich zu freuen.

---

Wenn man es beschreit!!! :mad:
Na klar blockiert er immer noch! Subjektiv ist es zwar seltener geworden aber er spinnt nach wie vor von Zeit zu Zeit.
Den I2C-check hab ich jetzt wie vorgeschlagen eingebaut aber auch der hat nichts angezeigt. Der Hänger passiert ja immer aus heiterem Himmel OHNE irgendwelche Interaktion. Am I2C zum Si4703 bringt der wahrscheinlich in der Form sowieso nichts, der Bus wird dort aktuell nur zum Schreiben benutzt. Das heisst, beim Tastendruck wird zwar Volume oder Frequenz geändert. Ich lese aber vom Radio-Chip nichts aus! Also passiert dort I2C-mäßig nichts, wenn keine Taste gedrückt wird, richtig? Deshalb zeigt der Checker dort auch keinen Fehler.
Auch am Beginn der OLED-Printfunktion habe ich den I2C-Checker drin, ohne Erfolg! Keine Fehlermeldung trotz Hänger!

Langsam fange ich an, an einen Hardware-Bug des Si4703 zu glauben. Komisch ist nämlich, das der Hänger mehrfach aufgetreten ist, wenn ich mich in der unmittelbaren Nähe des Geräts bewegt habe. Andererseits lässt sich auch DAS nicht reproduzieren. Vielleicht bestelle ich mir doch noch einen Ersatz und tausche noch mal.

Gruß Uwe

am i2c-check siehst du genau, welcher Zugriff als letzter noch korrekt funktioniert hat und wann ggf. danach ein fehlerhafter Zugriff passiert ist.
Der serielle Monitor muss ntl dabei auch immer ständig mitlaufen, aber das wird ja wohl klar sein ;)

Zitat:

---

Zitat von HaWe

am i2c-check siehst du genau, welcher Zugriff als letzter noch korrekt funktioniert hat und wann ggf. danach ein fehlerhafter Zugriff passiert ist.

---

Genau DAS funktioniert so nicht!
Ich erklärs nochmal am Beispiel des Si4703 (den OLED lass ich jetzt mal aussen vor):
Der I2C zugriff erfolgt NUR wenn ich eine Taste drücke. Und auch nur dann wird der I2C gecheckt. Das Aufhängen tritt aber nie beim Tastendruck auf, sondern IMMER wenn das Ding eigentlich nur einfach so vor sich hin spielt. Genau dann läuft aber ja der Checker NICHT!
Also wird auch nichts angezeigt.
Der Serielle Monitor läuft natürlich immer mit!

Gruß Uwe

ach so, OK.
Läuft denn auch kein OLED und nichts anderes auf dem i2c Bus?
wie könnte ansonsten der i2c Bus blockieren, wenn niemand drauf ist?
Aber was wäre dann im Zweifelsfall, wenn du immer einmal pro loop alle i2c Geräte nacheinander durchpingst, egal ob eine Taste gedrückt wurde?
Oder ist es gar nicht der Bus, der blockiert?

Zitat:

---

Zitat von HaWe

ach so, OK.
Aber was wäre dann im Zweifelsfall, wenn du immer einmal pro loop alle i2c Geräte nacheinander durchpingst...

---

Ach Mensch! Nun hab ich aber richtig in die Ka..e gegriffen! Was ähnliches als das, was du hier oben vorschlägst, hatte ich nämlich gerade schon selbst versucht und es ist gründlich schief gegangen!
Nun hab ich wohl den Arduino zerschossen!
Ich hatte versucht, in die Loop den normalen I2C-Scanner zu integrieren (nicht den Checker von Dir!).
Dabei hab ich wohl im Code gründlich Mist gebaut. Es wurde aber kein Compilerfehler angezeigt. Nach dem Upload lief jedenfalls gar nichts mehr! Egal dachte ich, dann kommt eben erst mal der normale Code wieder drauf = DENKSTE! Geht nicht mehr!!
Ich kann nun gar keinen Sketch mehr hochladen! Bekomme nur noch die berüchtigte Meldung:

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0xb8

Wobei bei jedem Hochladeversuch die Hex-Adresse am Ende der Meldung eine andere ist. Und nein, ich habe nichts an den Einstellungen verändert. Scheint, als wenn der Arduino irgendwie das Hochladen blockiert.
Also hab ich jetzt erst mal ein noch größeres, hausgemachtes Problem zu lösen.

Gruß Uwe

Kurzes Update:
Den Arduino hatte ich wirklich getötet, er lässt sich nicht mehr programmieren. Gestern hab ich einen neuen eingebaut und der Hänger ist immer noch da! Inzwischen kann ich das "Aufhängen" auch provozieren: Beim Druck auf die Tasten "Scan-Up" oder "Scan-Down" hängt er sich nun sicher auf. Manchmal nicht beim ersten Druck aber beim 2. oder 3. passiert das sicher. Darüber hinaus hängt er auch immer wieder völlig ohne dass irgendwelche Aktionen von aussen passieren.
Ich habe in den Code am Anfang der Loop den I2C-Check für beide (OLED und Radio) eingebaut. Der läuft ohne Beanstandungen bis zum Aufhängen durch, dann stoppt die Schleife einfach OHNE irgendeinen I2C-Fehler zu zeigen. Nur zum Test habe ich falsche I2C-Adressen eingegeben, die er sofort als Fehler anzeigt. Der Checker funktioniert also.
Was ich auch nicht verstehe ist, warum der Watchdog nicht reagiert!? Ich hänge mal den kompletten Code in der letzten Variante hier ran. Im Moment warte ich auf zwei neue SI4703-Module aus China.
Was anderes, als auch das Radio-Modul zu wechseln, fällt mir nicht mehr ein, oder gibt es von euch noch Ideen?

P.S.
Eben habe ich mal ALLES was zum OLED gehört aus dem Code auskommentiert. Ich dachte, das vielleicht einfach Radio und OLED sich nicht mögen. Hat aber auch nichts gebracht. Auch wenn das Display praktisch nicht existiert und keine Anzeigeroutinen laufen, hängt sich der Code auf!

Code:

---

#include <Arduino.h>
#include <Wire.h>
#include <radio.h>
#include <si4703.h>
#include "U8glib.h"
#include <avr/wdt.h>                          // only needed for Watchdog

#define FIX_BAND    RADIO_BAND_FM            // the band that will be tuned by this sketch is FM
#define FIX_STATION  8760                    // station at start-up is 87.60 MHz
#define FIX_VOLUME  1                        // volume level at start-up

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);  // define type of display (OLED 0.96" 128x64 pix)

SI4703 radio;                                // create an instance of Class for Si4703 Chip

int volume = FIX_VOLUME;
int button_1 = 3;                            // button volume up at Pin 3
int button_2 = 4;                            // button volume down at Pin 4
int button_3 = 5;                            // button station swap at Pin 5
int button_4 = 6;                            // button scan up at Pin 6
int button_5 = 7;                            // button scan down at Pin 7
int buttonState_1 = 0;
int buttonState_2 = 0;
int buttonState_3 = 0;
int buttonState_4 = 0;
int buttonState_5 = 0;
int flag = 0;                                // used for decission to show "Station Name" or "scan mode"
int stationNr = 0;
int fmFreq[10] = {8760, 8820, 9100, 9350, 9500, 10030, 10080, 10280, 10330, 10480};
char* fmName[10] = {"  NDR 1 MV", "  NDR Kultur", "  NDR 1 MV", "  NDR 2 MV",
                  "    N-JOY", "Deutschlandfunk", "  Antenne MV", "  NDR Info",
                    "Radio Paradiso", "  Ostseewelle"};

unsigned long startMillis;                    // for timing display interval
unsigned long currentMillis;                  // -||-
const unsigned long period = 1000;            // display interval = 1 second

char vol[2];
float volts;
char akku[4];

long readVcc()
  {
  long result;                                // read 1.1V reference against AVcc
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  delay(2);                                  // wait for Vref to settle
  ADCSRA |= _BV(ADSC);                        // convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = 1126400L / result;                // back-calculate AVcc in mV
  return result;
  }

/******************************
 *          Setup            *
 *****************************/
void setup() {

  wdt_enable(WDTO_1S);                        // enable Watchdog, set time to 1 second
 
  radio.init();                              // initialize radio

  Wire.begin();
  Serial.begin(9600);
 
  startMillis = millis();                    // start timer for display interval
 
  radio.setBandFrequency(FIX_BAND, FIX_STATION);
  radio.setVolume(volume);
  radio.setMono(false);
  radio.setMute(false);

  pinMode(button_1, INPUT);                  // define button Pins
  pinMode(button_2, INPUT);                  // -||-
  pinMode(button_3, INPUT);                  // -||-
  pinMode(button_4, INPUT);                  // -||-
  pinMode(button_5, INPUT);                  // -||-
  digitalWrite(button_1, HIGH);              // button-Pin Pull-up
  digitalWrite(button_2, HIGH);              // -||-
  digitalWrite(button_3, HIGH);              // -||-
  digitalWrite(button_4, HIGH);              // -||-
  digitalWrite(button_5, HIGH);              // -||-
}

/******************************
 * Subroutine Display on OLED *
 *****************************/
void displayData()                         
  {
  volts = (float)readVcc()/(float)1000;      // read Vcc and divide by 1000
   
  char s[12];
  radio.formatFrequency(s, sizeof(s));        // format frequency value to output like: "87,60 MHz"

  // begin debugging I2C failure
  int addr=0x3c; // für OLED
  Wire.beginTransmission(addr); // transmit to device I2C addr
  int ioerr=Wire.endTransmission();
  if(ioerr) {  // Ausgabe eines Fehlers samt i2c-addr.
  Serial.println("vor OLED print:");
  Serial.print("Fehler bei addr 0x");
  if (addr<16) { Serial.print("0"); }
  Serial.print(addr,HEX);
  Serial.print(" ioerr="); 
  Serial.println(ioerr);
  }
  // end debugging I2C failure

    u8g.firstPage();
    do {
    u8g.drawFrame(0,0,128,64);                // display frame around screen
    u8g.setFont(u8g_font_timB14);
    u8g.drawStr(15, 22, s);
    u8g.setFont(u8g_font_unifont);
    if(flag==0)
      {
      u8g.drawStr(4, 44, fmName[stationNr]);  // if fequency from array, take name from array too
      }
    if(flag==1)
    {
      u8g.drawStr(25, 44, "scan mode");      // if frequency from scan, show "scan mode"
    }

    if(volts > 3.3)                          // if Vcc > 3.3V display "Volume" & "Volt"     
        {
        u8g.setFont(u8g_font_6x13);
        u8g.drawStr(6, 59,"Volume: ");                         
        sprintf (vol, "%d", volume);          // change int "volume" to char "vol"               
        u8g.drawStr(50, 59, vol);
        u8g.drawStr(68, 59,"Bat:");
        dtostrf(volts, 2, 1, akku);          // change float "volts" to char "akku" 
        u8g.drawStr(94, 59,akku);
        u8g.drawStr(115, 59,"V");
        }
      else                                  // if VCC >= 3.3V display "CHARGE BATTERY"
      {
        u8g.drawStr(6, 59,"CHARGE BATTERY");
      }
      }
    while( u8g.nextPage() );
  }
 
/******************************
 *        Main Loop          *
 *****************************/
void loop()
  {

  // begin debugging I2C failure
  Serial.println("Test läuft:  ");
  int addr=0x10;                      // für SI4703
  Wire.beginTransmission(addr);      // transmit to device I2C addr
  int ioerr=Wire.endTransmission();
  if(ioerr) {                        // Ausgabe eines Fehlers samt i2c-addr.
  Serial.println("für SI4703 print:");
  Serial.print("Fehler bei addr 0x");
  if (addr<16) { Serial.print("0"); }
  Serial.print(addr,HEX);
  Serial.print(" ioerr="); 
  Serial.println(ioerr);
  }
 
  addr=0x3c;                          // für OLED
  Wire.beginTransmission(addr);      // transmit to device I2C addr
  ioerr=Wire.endTransmission();
  if(ioerr) {                        // Ausgabe eines Fehlers samt i2c-addr.
  Serial.println("für OLED print:");
  Serial.print("Fehler bei addr 0x");
  if (addr<16) { Serial.print("0"); }
  Serial.print(addr,HEX);
  Serial.print(" ioerr="); 
  Serial.println(ioerr);
  }
  // end debugging I2C failure
 
  buttonState_1 = digitalRead(button_1);
  buttonState_2 = digitalRead(button_2);
  buttonState_3 = digitalRead(button_3);
  buttonState_4 = digitalRead(button_4);
  buttonState_5 = digitalRead(button_5);
 
  if (buttonState_1 == LOW)
    {
      volume ++;
      if (volume == 16) volume = 15;
      radio.setVolume(volume);
      delay(100);
      displayData();
    }   
  else if (buttonState_2 == LOW)
    {
      volume --;
      if (volume < 0) volume = 0;
      radio.setVolume(volume);
      delay(100);
      displayData();
      }   
  else if (buttonState_3 == LOW)
    {
      stationNr ++;
      if (stationNr == 10) stationNr = 0;
      radio.setFrequency(fmFreq[stationNr]);
      flag = 0;
      delay(500);
      displayData();
      }   
  else if (buttonState_4 == LOW)
    {
      radio.seekUp();
      flag = 1;
      delay(500);
      displayData();
      }
  else if (buttonState_5 == LOW)
    {
      radio.seekDown();
      flag = 1;
      delay(500);
      displayData();
      } 
  else
    {
      currentMillis = millis();                  // get the current "time" (number of milliseconds since the circle started)
      if (currentMillis - startMillis >= period)  // test whether the period has elapsed
        {
        displayData();                          // call display routine
        startMillis = currentMillis;            // save new start time for next display circle
        }
    }
  wdt_reset();                                    // reset Watchdog
 }

---

ich sehe keinen richtigen offensichtlichen Fehler, allerdings kommt mir deine Button-press-Abfrage etwas kritisch vor, was sich u.U. ungünstig während der Laufzeit auswirken könnte:
Denn du liest einen Buttondruck, ohne auf Loslassen zu warten:

Code:

---

if (buttonState_1 == LOW)
    {
      volume ++;
      if (volume == 16) volume = 15;
      radio.setVolume(volume);
      delay(100);
      displayData();
    }   
  else if (buttonState_2 == LOW)
    {
      volume --;
      if (volume < 0) volume = 0;
      radio.setVolume(volume);
      delay(100);
      displayData();
      }

---

ich mache das bei mir in solchen Fällen so:

Code:

---

// digitalRead(buttonPin_1);        // button_pressed == LOW?
if(!digitalRead(buttonPin_1) ) { 
  while(!digitalRead(buttonPin_1) )  // wait for button_up == HIGH
      {delay(10);} 
  //  volume ++;
  //...usw...
}

// digitalRead(buttonPin_2);        // button_pressed == LOW?
if(!digitalRead(buttonPin_2) ) {   
  while(!digitalRead(buttonPin_2) )  // wait for button_up == HIGH
      {delay(10);}
  //  volume --;
  //...usw...
}

---

vlt wäre das ja mal einen Versuch wert....

Zitat:

---

Zitat von HaWe

Denn du liest einen Buttondruck, ohne auf Loslassen zu warten

---

Das ist richtig. Danke für den Hinweis. Das kannte ich so noch nicht, probiere es gleich aus.

Gruß Uwe