PIC: Schleife für Matrixausgabe mit MAX7219 wird abgebrochen

[Marcel L. (switch)]

Hallo an alle,

seit einiger Zeit beschäftige ich mich nun mit dem Mikrocontroller 
PIC12F675 und möchte mit dem MAX7219 eine Laufschrift programmieren.

Derzeit habe ich zwei 8x8 Matrix mit je einem MAX7219 an den PIC 
angeschlossen. Einen Standtext anzuzeigen habe ich bereits geschafft. 
Nun soll dieser Text auch von rechts nach links laufen. Dazu habe ich 
als Anfang diesen Code geschrieben. Er soll erst mal nur einen Balken 
von links beginnend nach rechts ziehen (Später dann Buchstaben).

/****************** Portbelegung *******************************************************/
#define MAX7219DIN              GPIO.F5
#define MAX7219LOAD             GPIO.F2
#define MAX7219CLK              GPIO.F4

/****************** Funktionsprototypen ************************************************/
// Zwei MAX7219 hintereinander (kaskadiert)
void MAX7219_INIT2(char Scanlimit, char ShutdownFormat, char DecodeMode, char Intensity);
void MAX7219_KOMMANDO2(char Adr1, char Data1, char Adr2, char Data2);

// Hilfsunterprogramm
void MAX7219_SENDBYTE(char Byte);

/****************** Controller initialisieren ******************************************/
void INIT(void)
{
    OSCCAL = 0b11111100;

// Port konfigurieren
    TRISIO = 0b00000000;             // Richtungsregister Port (0: Ausgang, 1: Eingang)
/*             ++------------------- Bit 7-6 Reserve
                 +------------------ Bit 5 Port GP5: hier Ausgang (Takt CLK)
                  +----------------- Bit 4 Port GP4: hier Ausgang (Data DIN)
                   +---------------- Bit 3 Port GP3: hier unbenutzt
                    +--------------- Bit 2 Port GP2: hier Ausgang (LOAD)
                     +-------------- Bit 1 Port GP1: hier unbenutzt
                      +------------- Bit 0 Port GP0: hier unbenutzt
*/
}

//****************** Unterprogramm Daten ********************

void DATEN(void)
{
     char D1_W1 = 0;
     char D1_W2 = 0;
     char D1_W3 = 0;
     char D1_W4 = 0;
     char D1_W5 = 0;
     char D1_W6 = 0;
     char D1_W7 = 0;
     char D1_W8 = 0;

     char D2_W1 = 0;
     char D2_W2 = 0;
     char D2_W3 = 0;
     char D2_W4 = 0;
     char D2_W5 = 0;
     char D2_W6 = 0;
     char D2_W7 = 0;
     char D2_W8 = 0;

    char SZ;
    for (SZ=17; SZ>0; SZ--)
    {

    // Adressen und Daten an den MAX7219 schicken
    MAX7219_KOMMANDO2(0x01, D1_W1, 0x01, D2_W1);
    MAX7219_KOMMANDO2(0x02, D1_W2, 0x02, D2_W2);
    MAX7219_KOMMANDO2(0x03, D1_W3, 0x03, D2_W3);
    MAX7219_KOMMANDO2(0x04, D1_W4, 0x04, D2_W4);
    MAX7219_KOMMANDO2(0x05, D1_W5, 0x05, D2_W5);
    MAX7219_KOMMANDO2(0x06, D1_W6, 0x06, D2_W6);
    MAX7219_KOMMANDO2(0x07, D1_W7, 0x07, D2_W7);
    MAX7219_KOMMANDO2(0x08, D1_W8, 0x08, D2_W8);

    // Kurz warten
    Delay_ms(200);

    // Den Wert 255 eine Spalte weiter nach vorne kopieren.
    D2_W1 = D2_W2;
    D2_W2 = D2_W3;
    D2_W3 = D2_W4;
    D2_W4 = D2_W5;
    D2_W5 = D2_W6;
    D2_W6 = D2_W7;
    D2_W7 = D2_W8;
    D2_W8 = D1_W1;
    D1_W1 = D1_W2;
    D1_W2 = D1_W3;
    D1_W3 = D1_W4;
    D1_W4 = D1_W5;
    D1_W5 = D1_W6;
    D1_W6 = D1_W7;
    D1_W7 = D1_W8;
    D1_W8 = 255;
    }
}

//***************** Hauptprogramm **************************
void main(void)
{
    INIT();                            // Controller initialisieren

    MAX7219_INIT2(0x07, 0x01, 0x00, 0x0F); // MAX7219 initialisieren
/*                 +------------------------ Scanlimit: 8 Digits
             +------------------ Shutdown-Format: Normal Operation
             +------------ Decode-Mode: No Decode
             +------ Intensity: Volle Helligkeit
*/
    DATEN();

    while (1)
    {
    }
}

/****************** Unterprogramme fuer zwei MAX7219 (Kaskadiert) **********************/

void MAX7219_INIT2(char Scanlimit, char ShutdownFormat, char DecodeMode, char Intensity)
{
    // Scanlimit an beide MAX7219 senden
    MAX7219_KOMMANDO2(0x0b, Scanlimit, 0x0b, Scanlimit);

    // Shutdown-Format an beide MAX7219 senden
    MAX7219_KOMMANDO2(0x0c, ShutdownFormat, 0x0c, ShutdownFormat);

      // Decode-Mode an beide MAX7219 senden
    MAX7219_KOMMANDO2(0x09, DecodeMode, 0x09, DecodeMode);

      // Intensity an beide MAX7219 senden
    MAX7219_KOMMANDO2(0x0a, Intensity, 0x0a, Intensity);
}

//-------------------------------------------------------------

void MAX7219_KOMMANDO2(char Adr1, char Data1, char Adr2, char Data2)
{
    // Schritt 1: Steuerleitung LOAD loeschen
       MAX7219LOAD = 0;

  // Schritt 2: Die Adresse des ersten MAX7219 bitweise senden
    MAX7219_SENDBYTE(Adr1);

    // Schritt 3: Die Daten des ersten MAX7219 bitweise senden
    MAX7219_SENDBYTE(Data1);

    // Schritt 4: Die Adresse des zweiten MAX7219 bitweise senden
    MAX7219_SENDBYTE(Adr2);

    // Schritt 5: Die Daten des zweiten MAX7219 bitweise senden
    MAX7219_SENDBYTE(Data2);

    // Schritt 6: Steuerleitung LOAD setzen und ein positive Taktflanke erzeugen
       MAX7219LOAD = 1;
       MAX7219CLK = 1;
}

/****************** Hilfsunterprogramm *************************************************/

void MAX7219_SENDBYTE(char Byte)
{
    char i;


  for (i=8; i>0; i--)
  {
    // MSB ausgeben
        MAX7219DIN = Byte.F7;

    // Takt erzeugen
    MAX7219CLK = 1;
      MAX7219CLK = 0;

      // Bits verschieben (Bit 6 -> Bit 7, Bit 5 -> Bit 6 usw.)
    Byte = Byte << 1;
    }
}

Den Code habe ich dem Programm MicroC geschrieben, deswegen fehlt hier 
auch die __config-Einstellungen, da die direkt im Programm eingestellt 
werden. Ich verwende den internen 4 MHz Oszillator.

Zum Programm:
Nachdem die Einstellungen für den PIC und die MAX7219 (Unterprogramme 
INIT und MAX7219_INIT2) übertragen sind (Zusammen mit den 
Unterprogrammen MAX7219_KOMMANDO2 und MAX7219_SENDBYTE), soll mit dem 
Unterprogramm DATEN der Balken angezeigt werden.
Dazu werden erst alle Variablen auf 0 gesetzt und gesendet. Anschließend 
werden alle Werte um eine Spalte auf der Matrix nach links verschoben. 
Dann wird auch die Variable D1_W8 mit dem Wert 255 (alle 8 LEDs der 
Spalten an) geladen und erneut gesendet. Das soll durch die Schleife 
17mal gehen, bis alle LEDs der beiden Matrix leuchten (Der Wert 255 wird 
immer kopiert.).

Problem ist jetzt, sobald ich als Zeitverzögerung den Wert 300 oder mehr 
eingebe, beginnt der Balken zu laufen und bricht nach der 10. Spalte 
oder schon früher ab und beginnt von vorne. Gebe ich den Wert 200 ein, 
läuft der Balken bis zur letzten Spalte, wird aber dann auch wieder 
gelöscht und beginnt von vorne. Eigentlich sollte er nach den 17mal doch 
die Schleife verlassen und im Hauptprogramm in der Dauerschleife 
bleiben,also alle LEDs eingeschaltet lassen, oder?

Ich hoffe, ihr könnt mir dieses komische Verhalten erklären.
Danke im Vorraus!
switch

[Dieter W. (dds5)]

Das klingt irgendwie nach Reset durch den Watchdog.

[X4U (Gast)]

Marcel L. schrieb:
> Problem ist jetzt, sobald ich als Zeitverzögerung den Wert 300 oder mehr
> eingebe, beginnt der Balken zu laufen und bricht nach der 10. Spalte
> oder schon früher ab und beginnt von vorne.

Das riecht nach overflow. MikroC hat einen sehr guten Simulator. Lass es 
doch erst mal damit laufen und schau die deine chars damit an.

Schlage auch vor aus char SZ unsigned short zu machen da als Zähler 
genutzt.

Den Takt (clock) würde ich dann noch eine Verzögerung spendieren oder 
die LAT Register nehmen (wenn vorhanden). Evtl greift das Read_Modify 
Write Problem (s. Hilfe von MikroC).

[Marcel L. (switch)]

Danke für die schnellen Antworten.

Bei mir war in der config der Watchdogtimer aktiviert und er hat mein 
Programm dauernd unterbrochen. Mit deaktivierten WDT läuft das Programm 
jetzt ohne Probleme durch.

Danke nochmal für diesen guten Hinweis!!!!