LED Matrix (AtMega2560)

[Lehner P. (gruffi)]

Hallo µC.net Gemeinde,
nach Jahren des mitlesens und ausmärzen meiner Fehler in meinen 
Schaltungen, mithilfe der Posts in eurem Forum, habe ich mich nun 
dennoch angemeldet, da ich bei meinem aktuellen Projekt, einer 3x5 LED 
Matrix im Multiplexbetrieb, wohl einen Fehler drinnen habe, welchen ich 
nicht,... finde?

Trotzdem ich einige der Themen mir durchgelesen habe, auf welche auch 
öfters verwiesen wird bei diesem LED Matrix Thema, kann ich meinen 
Fehler einfach nicht finden.
Nun zu meinem Projekt / Problem:

Ich arbeite mit einem Arduino Mega2560 r3 Bord(µC ist natürlich der 
AtMega2560).
Als Programmierumgebung benutze ich das AVR Studio (Atmel Studio 6.1).

Ich habe mir meine Schaltung nach dem Berechnen der Vorwiderstände der 
LED, Basistransistorwid,... in Eagle gezeichnet und sie anschließend mal 
gelötet, as usual.
(siehe Anhang LED Matrix Eagle sch)

Als SRG nutze ich einen normalen 8bit Zähler (weil ich den zuhause 
hatte)
Die Reihen schalte ich mit PNP (Q1 bis Q5).
Die Spalten mit NPN (T1 bis T3).
T4 dient als Schalter um beim Hochzählen des Zählers die LED ausschalten 
zu können.

Das Bord sowie die Schaltung versorge ich beim Programmieren über USB.
Beim Normalen Betrieb, um mir um die Versorgungsleistung keine Gedanken 
machen zu müssen, über mein Netzgerät und die Strombuchse am Bord.

Die Schaltung funktioniert soweit.
Meines erachtens, ist der Hund wohl in meinem C-Code begraben...

Bevor ich hier lang und breit meinen Code poste wollte ich fragen wie es 
üblich bzw sinnvoll ist, ein Hauptprogramm (LED_Matrix) und eine eigene 
Header+Source Datei (LED_Matrix_MUX.c & .h) hier im Forum zu posten? 
(jeweils ca 150 bis 200 Zeilen)

Zum Code:
Zum Testen der Matrix habe ich anfangs einige "Muster" definiert, welche 
im ca 5 Sekundentakt durchlaufen sollten. Dies hat mit meinem Code zum 
Multiplexen auch funktioniert, allerdings nur mit einem "_delay_ms(1)".

Es ist mir klar, dass in den meisten Fällen ein "delay" eine schlechte 
Art zu programmieren ist, ist zum ausprobieren aber recht praktisch. 
Darum wollte ich anschließend das "delay" durch eine Interrupt Routine 
ersetzen.
Gesagt getan. Timer initialisiert, ISR usw angelegt.

Doch nun funktioniert der Teil mit dem Multiplexen nicht mehr, der Code 
wurde natürlich mit dem Umstellen vom "delay" auf den Timer/ISR 
angepasst.
Ich vermute, dass hier der Fehler in meinem Programm ist.
Bisher hatte ich noch nichts mit Timern zu tun, vlt liegt also das 
Problem in dessen Config oder daran wie ich die ISR verwende.

Mit meiner ISR setze ich meine eigene Interrupt Variable und zähle eine 
Variable zum "Musterwechsel" hoch.
Meine eigene Interrupt Variable nutze ich in meinem Hauptprogramm 
(Globale Variable) und in meiner "LED_Matrix_MUX".
Hier eine Frage:
Kann ich eine Varibale, welche im Hauptprogramm als Globale Variable 
angelegt ist, in meiner LED_Matrix_MUX.c / .h mittels "extern" ebenfalls 
verwenden?

Hierzu sei noch gesagt, dass ich den Timer (genauergesagt die ISR) auch 
zum bestimmen der Zeit nutze, wann das Muster gewechselt werden sollte 
und das funktioniert.


Als Info noch, was beim Multiplexen passieren sollte und was bei "delay" 
und "timer/ISR" wirklich passiert.

Meine Matrix:
LED's
A | B | C
D | E | F
G | H | I
J | K | L
M | N | O

Hier die "Matrix", welche ein "X" darstellen sollte
(Led welche nicht leuchten sollten entfallen)

A | - | C
D | - | F
- | H | -
J | - | L
M | - | O

Matrix mit "delay"
(alter Code)

A | - | C
D | - | F
- | H | -
J | - | L
M | - | O

Matrix mit "Timer/ISR"
(angepasster Code)

A | B | C
D | E | F
- | - | -
J | K | L
M | N | O

Den C Code poste ich, sobald ich die Gepflogenheiten diesbezüglich hier 
im Forum erfahren habe ;-)

Danke schonmal für die Mühe, mir helfen zu wollen ;-)

Beste Grüße Phil

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Lehner P. schrieb:
> ausmärzen
ausmerzen.
Auch wenn es evtl tatsächlich vom März kommt, in den die schlechtesten 
Lämmer zu Lammbraten umfunktioniert wurden...

Lehner P. schrieb:
> (siehe Anhang LED Matrix Eagle sch)
Bei den Q1...5 ist C und E vertauscht

Lehner P. schrieb:
> Kann ich eine Varibale, welche im Hauptprogramm als Globale Variable
> angelegt ist, in meiner LED_Matrix_MUX.c / .h mittels "extern" ebenfalls
> verwenden?
Wo "im Hauptprogramm"?
BTW: wenn dein Programm nicht funktioniert dann solltest das mal 
anhängen.

[Marc V. (Firma: Vescomp) (logarithmus)]

Lehner P. schrieb:
> Matrix mit "Timer/ISR"
> (angepasster Code)
>
> A | B | C
> D | E | F
> - | - | -
> J | K | L
> M | N | O

> Den C Code poste ich, sobald ich die Gepflogenheiten diesbezüglich hier
> im Forum erfahren habe ;-)

 Nicht nötig, der Zeiger für Reihen wird richtig angesteuert, aber der
 Zeiger für Spalten wahrscheinlich nicht.

[Lehner P. (gruffi)]

@ Lothar Miller
Wer Rechtschreibfehler findet, darf sie behalten, aber Danke Lothar 
Miller ;-)

Ja hatte bei den PNP schon so meine zweifel, aber da die Matrix erst 
funktionierte, dachte ich wirds schon passen. Werde das ansonsten 
ändern.

Ich habe in meinem Main.c die Variable "short InterruptT0var" global 
angelegt.
In meiner Matrix.c wollte ich diese Variable ebenso verwenden. Dort habe 
ich sie mit "extern short InterruptT0var" angelegt (ebenso im 
zugehörigen .h File).
Kann ich so auf den Wert dieser Variable auch in einem Sourcefile 
zugreifen?

Oder würde dies nur funktionieren wenn ich diesen Wert übergebe (Bspw 
mit einem Pointer)?

@Marc Vesely

Hab mich bei meinem ersten Post vertan, es handelt sich um ein H nicht 
um ein X... sry
werde das noch editieren.

Das Problem der Matrix liegt meines erachtens daran, dass in meinem 
Aufruf für das Multiplexen, nur der erste Wert angenommen wird.

---------

Ich schreib hier mal meinen Code rein, sollte es nicht passen den Code 
so anzufügen, so sagt mir bitte wie es hier im Forum richtig gemacht 
wird.

In meinem Source File verwende ich in der switch-case einmal ein 
weiteres switch-case und anschließend eine if-else if.
Begründung:
Um auszuschließen, dass es sich hierbei um den Fehler handelt, jedoch 
habe ich bei beiden das gleiche Problem, dass eben in der "inneren 
switch-case(casecount)" immer nur der erste Aufruf ausgeführt wird...
Liegt dies daran, das meine Variable "InterruptT0var" von mir falsch 
verwendet / angelegt wird?


Hier der Großteil des Codes
(die USART Befehle müsst ihr nicht beachten, die hauen hin ;-) )

Hauptprogramm (main)

#include <avr/io.h>      //für PORT,...
#include <util/delay.h>    //für delay (sollte ersetzt werden)
#include <avr/interrupt.h>  //für interruptfunktionen
#include "usart.h"      //für send & recive //für eine ausgabe über putty
#include "LED_Matrix_3x5_MUX.h"  //für eigene MUX Funktionen


//Für Interrupskonfig
#ifndef TIMER0_OVF_vect // Für ältere WinAVR Versionen z.B. WinAVR-20071221
#define TIMER0_OVF_vect TIMER0_OVF0_vect
#endif

//Globale Variablen
short interruptT0var=0, autocount=0;

/*
*  Der Overflow Interrupt Handler wird aufgerufen, wenn TCNT0 von 255 auf 0 wechselt (256 Schritte),
*  Interrupt Aktion alle   (16000000/64)/256 Hz = 976,6 Hz   bzw.   1/976,6 s = 1,024 ms     
*/
ISR (TIMER0_OVF_vect)
{
  interruptT0var=1;    //Setzen einer eigenen Iterrupvariable
  autocount++;      //Autocount für Musterwechsel
  TCNT0 &= 0b00000000;  //Rücksetzen des Timer Zählregisters
  TIFR0 = (1<<TOV0);    //Löschen des Interrupt Flag Overflow Timer 0
}

/* 
*  getkey gibt folgendes zurück:
*  0, wenn keine Taste gedrückt ist
*  1, wenn die Taste gedrückt ist
*/
int getkey(void)
{
  if (PINC & (1<<0) )
  {
    return 0;
  }
  else
  {
    return 1;
  }
}


int main(void)
{
  // Timer 0 konfigurieren
  TCCR0B |= 0b00000011;  // Prescaler none(001), 8(010), 64(011), 256(100), 1024(101)
              // 16MHz/Prescaler/256= 7813Hz => 0,13ms
  
  // Overflow Interrupt erlauben
  TIMSK0 |= (1<<TOIE0);
  
  // Global Interrupts aktivieren
  sei();
  
  //Taster auf PORTC
  DDRC=0x00;    //PortC als Eingang
  PORTC=0x01;    //PullUp von Pin 0 eingeschaltet
  
  //Leds auf PORTA
  DDRA=0xFF;  //PORTA als Ausgang definieren
  
  /*
  *  Zähler Info
  *  PORTA0 = Reset ->  a high voltage level on the MR
  *            line resets all counters to their zero state
  *  
  *  PORTA1 = Count ->  All counter stages are master-slave flip-flops. The
  *            state of the stage advances one count on the negative
  *            transition of each clock pulse;
  */
  
  //Rücksetzen des Zählers
  PORTA=0b00000001;
  PORTA=0b00000000;
  
  //Definition der Variablen
  
  char eingabemuster [10] = {0};
  int short zahlmuster=0, taster=0, progwechsel=0;
  long entprellt=0;
    
  //Initialisierung der seriellen Ausgabe
  usart0Init(USART_BAUDRATE_9600,USART_NO_PARITY,USART_1_STOP_BIT);
  
  //fertigen eines string um ihn mit sendstring ausgeben zu können
  //snprintf(text, 50,"\n\rUmgewandeltes Zeichen: (ASCII CODE) %d \n\r", zahl7s)
  
  //Beginn des eig Programs  
  while(1)  //Ausgabeinfo
  {
    
    //Ausgabe welche Muster im Sourcefile hinterlegt sind
    VorhandeneMuster();
    
    //Abfrage des gewünschten Musters
    /*
    *do
    *{
    *usart0ReceiveStringBlocking(eingabemuster,10);
    *zahlmuster=atoi(eingabemuster);
    *} while ((zahlmuster<0||zahlmuster>8));
    */
  
    //Ausgabe Info
    usart0SendStringBlocking("\n\rMit jedem Tastendruck, wird ein neues Muster gezeigt\n\r");
    
    //Hauptprogram
    while(1)
    {
      //Aufruf der LEDMatrix Ansteuerung
      MatrixMux(zahlmuster);
      
      //nach Programmwechsel Entprellt und progwechsel rücksetzten 
      if (progwechsel>0)
      {
        entprellt=0;  //Für gleiche Tasterzeiten
        progwechsel=0;
      }
      
      //Abfrage des Taster (mit nachfolgender Entprellung)
      taster=getkey();
      if (taster==1)
      {
        entprellt++;
      }
      
      //Wenn Taster eine gewisse Zeit (entprellt mal) gedrückt ist == entprellt
      if (entprellt>=40000)  //2,5ms+Prellen
      {
        zahlmuster++;  //Muster hochzählen
        entprellt=0;  //Entprellen rücksetzen
        progwechsel++;  //Programmwechsel vorgeben
      } 
      
      //Autocount zum automatischen wechseln des Musters
      if (autocount==5000)  //Bei ISR alle 1,024ms = ca 5 Sekunden
      {
        zahlmuster++;
        autocount=0;
      }
      
      //Mustercounter nach Durchlauf wieder zurücksetzen
      if (zahlmuster>8)
      {
        zahlmuster=0;
      }
      
    }  //while Hauptprogam
            
  }  //while AusgabeInfo  

}  //main

Hier mein Sourcefile LED_Matrix_3x5_MUX
***Header***

#ifndef LED_MATRIX_3X5_MUX_H_
#define LED_MATRIX_3X5_MUX_H_

//defines der Zähler für bestimmte Muster
#define LED12 91
#define LEDX 164
#define LEDI0I 160
#define LEDECKEN 174
#define LEDFLAGGE1 160
#define LEDFLAGGE2 228
#define LEDSTREIFENLAENGS 234
etc...
 


void MatrixMux(int MusterNr);
void VorhandeneMuster(void);

extern short interruptT0var;

#endif /* LED_MATRIX_3X5_MUX_H_ */

***Sourcefile***

#include <avr/io.h>        //Für PORT,...
#include <avr/interrupt.h>    //Für Interrupfunkltionen
#include "LED_Matrix_3x5_MUX.h"  //für eigene MUX Funktionen
#include "usart.h"        //für ein ausgabe über putty
#include <util/delay.h>      //Für delay (eliminieren)

//Für Interruptkonfig
#ifndef TIMER0_OVF_vect 
#define TIMER0_OVF_vect TIMER0_OVF0_vect // Für ältere WinAVR Versionen z.B. WinAVR-20071221
#endif



//Globale Variable zum richtigen Ablauf der "Count" im switch case
short casecount =0;
extern short interruptT0var;

//Ausgabeder vorhandenen Muster
void VorhandeneMuster(void)
{
  usart0SendStringBlocking("\n\r\n\rEs sind folgende Muster verfuegbar:");
  usart0SendStringBlocking("\n\rEckpunkte = 1\n\r");
  usart0SendStringBlocking("\n\rein H = 2\n\r");
  usart0SendStringBlocking("\n\rein X = 3\n\r");
  usart0SendStringBlocking("\n\rFlagge 1 = 4\n\r");
  usart0SendStringBlocking("\n\rFlagge 1 = 5\n\r");
  usart0SendStringBlocking("\n\rStreifen Laengs = 6\n\r");
  usart0SendStringBlocking("\n\rStreifen quer = 7\n\r");
}

//Reset des Zählers
void ResetCount(void)
{
  PORTA=0b00000001;
  PORTA=0b00000000;
}

//Funktion zum Setzten des Zählers für auszugebende Muster
void Count (int count)
{  
  cli();  //Interrupt off
  
  if (interruptT0var==1)
  {
    //Ausschalten der LED um die Matrix beim Hochzählen nicht 
    //dauernd alle LED zu beleuchten
    PORTA=0b00000000;
    
    //Rücksetzen des Zählers
    ResetCount();
    
    //Hochzählen auf den neuen "LED_M" Wert
    int i=0;
    for (i=0;i<count;i++)
    {
      PORTA=0b00000010;
      PORTA=0b00000000;
    }
    //Wiedereinschalten der LED Matrix
    PORTA=0b00000100;
    
    casecount++;    //Hochzählen der Variable für die case(MusterNr)
    interruptT0var=0;  //eigene Interruptvariable rücksetzen
  }
  
  sei();  //Interrupt on
  
}


/*
*  Beim MUX ist darauf zu achten, dass so wenige Schritte wie möglich
*  abgearbeitet werden müssen, damit die Zahlen möglichst hell sind 
*  nach meinem try and error
*/
void MatrixMux(int MusterNr)
{
  
  switch (MusterNr)
  {
    case 0:
      Count(LED12);
      casecount=0;  //Rücksetzten der casecount Variable
    break;
    case 1: //Muster Eckpunkte
      Count(LEDECKEN);
      casecount=0;
    break;
    case 2:  //Muster H
      switch (casecount)
      {
        case 0:
          Count(LEDI0I);
        break;
        case 1:
          Count(LED12);
          casecount=0;
        break;
      }
    break;
    case 3:  //Muster X
      if (casecount==0)
      {
        Count(LEDX);
      }
      else if (casecount==1)
      {
        Count(LED12);
      }
      casecount=0;
    break;
    case 4:  //Muster Flagge 1
      Count(LEDFLAGGE1);
      casecount=0;
      
    break;
    case 5: //Muster Flagge 2 
      Count(LEDFLAGGE2);
      casecount=0;
      
    break;
    case 6: //Muster Streifen laengs
      Count(LEDSTREIFENLAENGS);
      casecount=0;
    break;
    case 7: //Muster Streifen quer
      if (casecount==0)
      {
        Count(LED00);
      }
      else if (casecount==1)
      {
        Count(LED02);
      }
      else if (casecount==2)
      {
        Count(LED11);
      }
      else if (casecount==3)
      {
        Count(LED20);
      }
      else if (casecount==4)
      {
        Count(LED04);
      }
      else if (casecount==5)
      {
        Count(LED13);
      } 
      else if (casecount==6)
      {
        Count(LED22);
      }
      else if (casecount==7)
      {
        Count(LED24);
      }
      casecount=0;
    break;
    
    case 8: //Muster aus
      ResetCount();
      casecount=0;
      interruptT0var=0;  //eigene Interruptvariable rücksetzen
    break;
      
  }  //switch (MusterNr)
  
}  //void MatrixMux

[Karl M. (Gast)]

Hallo,

auf die Schnelle was mir aufgefallen ist:
Der Datentype zu |interruptT0var| ist nicht vollständig und die Timer 
ISR kann den Wert nicht ändern.

Stichwort: volatile

Warum wird das Multiplexen der LED nicht in der Timer ISR durchgeführt ?
volantile

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Lehner P. schrieb:
> @ Lothar Miller Wer Rechtschreibfehler findet, darf sie behalten
Das war kein Rechtschreibfehler, sondern ein Verständnisproblem (so wie 
z.B. anderswo "Standart"). Deshalb hatte ich das kurz mal erwähnt...

> Danke Lothar Miller ;-)
Keine Ursache,  man lernt nie aus.

> Ja hatte bei den PNP schon so meine zweifel, aber da die Matrix erst
> funktionierte, dachte ich wirds schon passen. Werde das ansonsten
> ändern.
Ja, denn du betreibst die Transistoren im Inversbetrieb. Das bringt 
insbesondere einen Nachteil mit sich, dass die Stromverstärkung nur noch 
ca. 10 statt 300 ist. Deine Vorwiderstände sind dafür falsch 
berechnet...


BTW:

Antwort schreiben
Wichtige Regeln - erst lesen, dann posten!
.... 
    * Längeren Sourcecode nicht im Text einfügen,
      sondern als Dateianhang

[Marc V. (Firma: Vescomp) (logarithmus)]

Lehner P. schrieb:
> Das Problem der Matrix liegt meines erachtens daran, dass in meinem
> Aufruf für das Multiplexen, nur der erste Wert angenommen wird.

 Sage ich doch.
 Ohne mich durch deinen Code zu wühlen:
 Spalten werden richtig umgeschaltet aber der zugehörige Wert wird
 nicht übernommen bzw. aktualisiert.

[Lehner P. (gruffi)]

Zu meinem vorherigen Post:
ich kann ihn leider nicht mehr editieren...

Karl M. schrieb:
> Der Datentype zu |interruptT0var| ist nicht vollständig und die Timer
> ISR kann den Wert nicht ändern.
>
> Stichwort: volatile

Was heißt "nicht vollständig"?
Und warum kann eine ISR den Wert einer Variable nicht ändern?

Das "Problem" mit "volatile" sollte ich umgehen können wenn ich in den 
Projekt Properties in der Toolchain unter AVE/GNU C Compiler Optimation 
den Optimation Level auf "none" setzte oder? Hab ich nämlich dafür so 
eingestellt.
Wenn ich in meinem Code "volatile" verwende, ändert sich nichts.


Karl M. schrieb:
> Warum wird das Multiplexen der LED nicht in der Timer ISR durchgeführt ?

Wäre meine ISR dann nicht relativ lange? Und sollte man dies nicht 
vermeiden?


Lothar M. schrieb:
> Ja, denn du betreibst die Transistoren im Inversbetrieb. Das bringt
> insbesondere einen Nachteil mit sich, dass die Stromverstärkung nur noch
> ca. 10 statt 300 ist. Deine Vorwiderstände sind dafür falsch
> berechnet...

Stimmt, die hab ich kervehrt eingebaut... die LED leuchten jetzt auch 
generell etwas heller, Danke für den Tipp.


Lothar M. schrieb:
> BTW:Antwort schreiben
> Wichtige Regeln - erst lesen, dann posten!
> ....
>     * Längeren Sourcecode nicht im Text einfügen,
>       sondern als Dateianhang

Wird in Zukunft berücksichtigt!


Nun wieder zum Problem:

Die Variable "InterruptT0var", wird in meinem Programm, so wie ich es 
wollte, in der ISR geändert.
Das sehe ich, wenn ich mir die Speicherstelle ansehe und daran, dass 
wenn ich sie in der ISR auf "0" setze, keine LED mehr leuchten.
Wohl eben, weil ich die Optimation ausgeschaltet habe.

-> main

/*
*  Der Overflow Interrupt Handler wird aufgerufen, wenn TCNT0 von 255 auf 0 wechselt (256 Schritte),
*  Interrupt Aktion alle   (16000000/64)/256 Hz = 976,6 Hz   bzw.   1/976,6 s = 1,024 ms     
*/
ISR (TIMER0_OVF_vect)
{
  interruptT0var=1;    //Setzen einer eigenen Iterrupvariable
  autocount++;      //Autocount für Musterwechsel
  TCNT0 &= 0b00000000;  //Rücksetzen des Timer Zählregisters
  TIFR0 = (1<<TOV0);    //Löschen des Interrupt Flag Overflow Timer 0
}

-> header

extern short interruptT0var;

-> source

//Globale Variable zum richtigen Ablauf der "Count" im switch case
short casecount =0;
extern short interruptT0var;

Mein Problem dürfte also im folgenden liegen:
Mit "casecount", zähle ich eine Variable hoch, welche aussagen sollte, 
welche LED im aktuellen Muster eingeschaltet werden sollte.
Was aber nicht passiert...

--> MatrixMux ist die Funktion, welche das "übergebene" Muster an LED 
ansteuern sollte, jedoch wird immer nur der erste "Count" 
Funktionsaufruf ausgeführt.
Bei Muster H eben die beiden äußeren Spalten, nicht jedoch der zweite 
case, die mittlere LED.

void MatrixMux(int MusterNr)
{
  
  switch (MusterNr)
  {
    case 0:
      Count(LED12);
      casecount=0;  //Rücksetzten der casecount Variable
    break;
    case 1: //Muster Eckpunkte
      Count(LEDECKEN);
      casecount=0;
    break;
    case 2:  //Muster H
      switch (casecount)
      {
        case 0:
          Count(LEDI0I);
        break;
        case 1:
          Count(LED12);
          casecount=0;
        break;
      }
    break;
    case 3:  //Muster X

In meiner Count Funktion, würde ich diese Variable, nach einem 
Durchlauf, aber immer um Eins erhöhen...?

//Funktion zum Setzten des Zählers für auszugebende Muster
void Count (int count)
{  
  cli();  //Interrupt off
  
  if (interruptT0var==1)
  {
    //Ausschalten der LED um die Matrix beim Hochzählen nicht 
    //dauernd alle LED zu beleuchten
    PORTA=0b00000000;
    
    //Rücksetzen des Zählers
    ResetCount();
    
    //Hochzählen auf den neuen "LED_M" Wert
    int i=0;
    for (i=0;i<count;i++)
    {
      PORTA=0b00000010;
      PORTA=0b00000000;
    }
    //Wiedereinschalten der LED Matrix
    PORTA=0b00000100;
    
    casecount++;    //Hochzählen der Variable für die case(MusterNr)
    interruptT0var=0;  //eigene Interruptvariable rücksetzen
  }
  
  sei();  //Interrupt on
  
}

Da müsste der Wurm drinnen sein, aber ich sehe ihn nicht  ;-)

Danke für die bisherigen schnellen und hilfreichen Antworten.

[Jan L. (ranzcopter)]

Lehner P. schrieb:
>> Stichwort: volatile
>
> Was heißt "nicht vollständig"?
> Und warum kann eine ISR den Wert einer Variable nicht ändern?

ich glaube, er meint

"A variable should be declared volatile whenever its value can be 
changed by something beyond the control of the code section in which it 
appears, such as a concurrently executing thread."

[Lehner P. (gruffi)]

Info @ all:

Mein Programm läuft jetzt, Danke nochmal an die hilfreichen Antworten!

Mein Fehler lag hier:

In meiner inneren Switch hatte ich die Variable "casecount" nullgesetzt, 
natürlich ist das immer passiert, sobald case "0" abgearbeitet worden 
war.

case 2:  //Muster H
      switch (casecount)
      {
        case 0:
          Count(LEDI0I, interruptT0var);
        break;
        case 1:
          Count(LED12, interruptT0var);
        break;
                                casecount=0; <-- Fehler!
      }
    break;

Richtiggestellt sieht der Code so aus:
Nun wird die "casecount" Variable erst nach der letzten inneren switch 
case Anweisung nullgesetzt.

case 2:  //Muster H
      switch (casecount)
      {
        case 0:
          Count(LEDI0I, interruptT0var);
        break;
        case 1:
          Count(LED12, interruptT0var);
          casecount=0; <-- Richtig
        break;
      }
    break;

Ich sollte meine Augen eben aufmachen beim lesen und schreiben :-D

Einen gemütlichen "Abend" noch an alle.


PS: Eine Frage hätte ich noch, wie löst man es sauber in der ISR den 
neuen Zählerstand auszugeben? Tipps? :-)

[Karl M. (Gast)]

Danke Jan,

Jan L. schrieb:
> ich glaube, er meint
>
> "A variable should be declared volatile whenever its value can be
> changed by something beyond the control of the code section in which it
> appears, such as a concurrently executing thread."

ich dachte er (TE) würde sich mehr mit den MC und C beschäftigen und 
diesen Fehler in seinem Programm finden. Er ist nun immer noch 
vorhanden.


>Karl M. schrieb:
>> Warum wird das Multiplexen der LED nicht in der Timer ISR durchgeführt ?

>Wäre meine ISR dann nicht relativ lange? Und sollte man dies nicht
>vermeiden?

Ja und ich will ja auch nicht, dass die LED flackern, sondern die LED 
mit einer definierten Umschaltzeit "bedient" werden.

Wenn man für die Ausgabe zwei LED Framepuffer verwendet, dauert dise 
auch nicht lange. Im Hauptprogramm wird das Muster berechnet und in den 
nicht benutzen LED Framepuffer geschrieben, ist das Muster vollständig, 
wird der LED Framepuffer umgeschaltet.
Dein gesamtes Programm wird durch diese Maßnahmen strukturierter, besser 
lesbar und besser wartbar.

[Lehner P. (gruffi)]

Karl M. schrieb:
> Ja und ich will ja auch nicht, dass die LED flackern, sondern die LED
> mit einer definierten Umschaltzeit "bedient" werden.
>
> Wenn man für die Ausgabe zwei LED Framepuffer verwendet, dauert dise
> auch nicht lange. Im Hauptprogramm wird das Muster berechnet und in den
> nicht benutzen LED Framepuffer geschrieben, ist das Muster vollständig,
> wird der LED Framepuffer umgeschaltet.
> Dein gesamtes Programm wird durch diese Maßnahmen strukturierter, besser
> lesbar und besser wartbar.

Alles klar, dann werde ich meinen Code noch etwas umstrukturieren.



Habt ihr auch Tipps oÄ welchen Normen oder vlt auch Vorschriften oder 
Richtlinien solche Codes in der Industrie bzw in Firmen folgen?
Worauf muss man in der Softwareentwicklung bzw Hard&Software Engineering 
oder im Bereich der Embedded Software auf soetwas achten?