Forum: Mikrocontroller und Digitale Elektronik C8051F020DK SiLab LED's an mehreren Port's ansteuern


C8051F020DK SiLab LED's an mehreren Port's ansteuern
von batty m. (battyman)

Lesenswert?
• ▲
▼ 
Ein fröhliches Hallo an die Geimeinde,

Seit einigen Wochen beschäftige ich mit dem o.g. µC und werde nur so 
langsam Schlau aus der Materie.

Vorbildung:
leider nur VB - gesmate Befehlsgewalt in C ist mir i-wie befremdlich

Thematik:
Für meinen Pkw-Kofferraum möchte ich gerne einzelne LED-Reihen 
unterschiedlich ansteuern. Die LED's sind schon fest verdrahtet und 
verbaut, was ein Ändern der Hardware schwierig gestalltet.
Da im Kofferraum sitzend das Programmieren unbequem ist habe ich mir 
noch eine kleine Laboranwendung aufgebaut.

Materialien:
- selbstgebautes Netzteil (Trafo, Graetzbrücke, Kondensator, 
Festspannungsregler 5V)
- 4 x IC's mit 7 belegbaren Pins je rein/raus
- 4 x 10er-Pin-Port's (wobei 8 Pins für eig. Signal - 7 werden pro Port 
nur genutzt)
- 28 LED's mit entsprechenden Vorwiderständen und Verdrahtung
     LED-Farbe   -   LED-Anzahl
       BLAU              10
        ROT               8
       Gruen             10

...die unterschiedliche Anzahl von LED's ist auf den Widerständen 
zurückzuführen, da für Rot mehrere LED's zusammfassbar waren. Demnach 
sind bei zwei Reihen für Blau und Gruen je 2 LED's vorhanden.

Hardware-LED-Aufbau:
- 3 Linien (Farben Blau-Rot-Gruen)
- 8 Reihen (LED's)

      [Reihe]
__1_2_3_4_5_6_7_8
G           x   x   3
G x x x x x x x x___3______
R x x x x x x x x___2______ [Linien]
B x x x x x x x x   1
B           x   x   1

...in Port-Pin Schreibweise folgend so (ist so komplett fertig gelötet - 
auch wenn sehr kompliziert und umständlich) ---

Bsp.:Port0^Pin0 = 0^0

           [Reihe]
____1____2____3____4____5____6____7____8
G                           2^5       3^6      3
G  0^2  0^5  1^1  1^4  2^0  2^4  3^1  3^5 ____3_____
R  0^1  0^4  1^0  1^3  1^6  2^3  3^0  3^4 ____2_____ [Linien]
B  0^0  0^3  0^6  1^2  1^5  2^2  2^6  3^3      1
B                           2^1       3^2      1


Bisheriger Stand:
- Timer vom Blinky-Bsp. (SiLabs) mit 10Hz Ein-/Ausschalten übernommen
- Timer mit Zaehler (t1=0; t1>10; t1++) auf 1Hz runter gebrochen, da ein 
Uumschalten im Sekundentakt eher mein Wunsch entspricht

Step by Step herantasten:
- da ich nicht weiß wie ich in C jede einzelne LED ansprechen kann habe 
ich erstmal mit einer Block-Matrix angefangen, wobei ich mir hier 
Port-Weise (O-3) die Hex-Werte zur Hilfe nahm...

für alle 4 Ports habe ich:

void PORT_Init(void)
 {
 XBR1    = 0x40;
 P0MDOUT = 0xff;     // analog P1; P2; P3
 }

Zaehler: n = 0;
         n = n +1
         if ( n > 8) n = 0;

...Lauflicht Blau...
unsigned char Blau0[8] = {0x01; 0x08; 0x40; 0x00; 0x00; 0x00; 0x00; 
0x00}
unsigned char Blau1[8] = {0x00; 0x00; 0x00; 0x04; 0x20; 0x00; 0x00; 
0x00}
unsigned char Blau2[8] = {0x00; 0x00; 0x00; 0x00; 0x00; 0x06; 0x40; 
0x00}
unsigned char Blau3[8] = {0x00; 0x00; 0x00; 0x00; 0x00; 0x00; 0x00; 
0x0C}

...analoges Vorgehen für jede einzelne Farbe und deren Mischvariation. 
So konnte ich mit jeder einzelnen Matrix die Farben 
Bl-R-Gr-Cy-Ma-Ge-Weiß erstellen und in "Abfolge" mit 1Hz laufen 
lassen...

...nun wollte ich aus dem Lauflicht ein ansteigenden Balken machen, was 
ich wieder durch die elendigen Tabellen realisierte, indem ich die 
entsprechenden Hex-Werte addierte - auch für jede mögliche 
Kombination!!!

""Problem""  (und sehr viel Schreibarbeit!!!):

dabei war, das ich nicht alle Kombinationen (Lauflicht - Balken - 
Farbenkombi) hintereinander laufen lassen konnte (immer nur einen, den 
Rest auskommentiert), da es aus Deklarationssicht Konflikte gibt. Des 
Weiteren konnte ich nicht einfach ein 4er Block mit x-beliebig vielen 
auf einanderfolgenden Hex-Werten erstellen, da die übergebende 
Datenmenge zu groß ist (Max: 4x32 = reicht nicht für alle Kombos).

Also musste ein anderer Ansatz her!
neue Deklaration der einzelnen LED's mit Prot und Pin - Zuweisung für 
Blau als Bsp., analog dazu entsprechend auch für Rot und Gruen

sbit B0 = P0^0;
sbit B1 = P0^3;
sbit B2 = P0^6;
sbit B3 = P1^2;
sbit B4 = P1^5;
sbit B5 = P2^1; // + P2^2  , da die beiden immer gleich sein sollen
sbit B6 = P2^6;
sbit B7 = P3^2; // + P3^3  , da die beiden immer gleich sein sollen ...

..Problem dabei ist, dass er das so nicht nimmt - WAS/Wie TUN?????

...bisher habe ich das nun immer einzelnd von B0-B9 gemacht, aber i-wie 
nicht so schön, da man an die zwei immer mit denken muss, obwohl sie 
immer und zu jeder Zeit mit der eigentlichen Reihe-Linie angehen bzw. 
ausgehen soll. Zu Ein-/Ausschalten benutz ich nun folgende Logik:

Zaehler: m = 0;
         m = m +1
         if ( m > 1) m = 0;

 B0 = ... = B9 = m     // alle LED's für blau EIN/AUS

// ist eine bescheidene Lösung, da hier die einzelnen Farben nur als 
gesmates blinken, also kein Lauflicht noch Balken ist realisierbar (für 
mich)
Weiteres Problem ich kann B0-B9 nicht mit einem Zaehler versehen:
 B[k] = m;
  for (k = 0; k > 9; k++)    // ist wohl nicht korrekt dekl.?!?!?!
___________________________________________________________________----- 
-

FRAGE?????????????????:

Für mich als Anfänger ist das alles schon recht komplex und meine 
Gehirnzellen zerfallen in alle Einzelteile. Ein anderer Ansatz war/ist 
für mich eigentlich noch logischer, jedoch weiß ich leider nicht ob und 
wenn ja wie ich das umsetzen kann - und zwar:
- Bau und Deklaration einer Port-Pin-Matrix um dann nur noch mit 0/1 zu 
schalten

siehe dann so aus:

        Port0        Port1       Port2      Port3

Pin0      0            0           1          1

Pin1      1            0           0          1       //etc. für alle

Pin2

Pin3

Pin4

Pin5

Pin6      0            0            1          1


...über diese Matrix lässt sich doch jede einzelne LED ansteuern und 
über Zahler und Schleifen dann auch Lauflicht - Balken erzeugen.


GEHT DAS SO WIE ICH ES MIR DENKE???????
Kann man auch mit den Block-Varianten Schleifen und Zähler so bauen, das 
ich die {HEX-WERTE} benutzen kann??? - ist nur sehr viel Schreibarbeit 
und nicht zu 100% elegant gelöst

Für Verbesserungen, Vorschläge, Anregungen bin ich vollstens zu haben.


Vielen Dank für eure Unterstürzung und Hilfe

Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
von Wilhelm F. (Gast)

Lesenswert?
• ▲
▼ 
Nimms leicht. Einen oder zwei Tage wirst du schon brauchen, für lästige 
Schreibarbeit.

Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
von Jim M. (turboj)

Lesenswert?
• ▲
▼ 
Marcel M. schrieb:
> leider nur VB - gesmate Befehlsgewalt in C ist mir i-wie befremdlich

Dann lies erstmal ein C-Buch. Dann noch eins über 8051 und C, denn wegen 
der Mehrfach- Havard- Architektur braucht der noch ein paar 
Erweiterungen, siehe DATA, IDATA, PDATA und XDATA.

Siehe übrigens auch Bitmanipulation.

Aber wieso sich Stress machen:

1
#define ANZAHL_LED_PORTS 4

2
#define ANZAHL_MUSTER 2

3
4
unsigned char code Muster[ANZAHL_MUSTER *  ANZAHL_LED_PORTS ] = 

5
  {0x00; 0x00; 0x00; 0x00; 

6
   0xFF; 0xFF; 0xFF; 0xFF };

7
8
9
void main (void) 

10
{

11
  unsigned char i;

12
  Init_Device(); // siehe Config2 tool

13
  while (1) {

14
    for (i = 0; i < ANZAHL_MUSTER; i++) {

15
      P0 = Muster[i*ANZAHL_LED_PORTS + 0];      

16
      // ...

17
      P3 = Muster[i*ANZAHL_LED_PORTS + 3];

18
19
     // hier warten

20
    }

21
22
  }

23
}


Durch die Verwendung von "code" packt der Compiler das Array ins Flash. 
Dadurch darf das Array ziemlich groß werden, der C8051F020 hat 64 kB 
Flash.
Wenn Du beim Berechnen des Musters Probleme hast, ein Tipp: Mit dem 
Debugger kann man auch die Portpins direkt setzten, ein Muster also 
direkt ausprobieren.

> Festspannungsregler 5V

Schau nochmal ins Datenblatt: Der C8051F020 braucht 3,3 Volt als 
Betriebsspannung.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
  


  

    

      von
      
        batty m.
        (battyman)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Erstmal vielen Dank für die schnellen Antworten.

Also um die Schreibarbeit gehts mir an sich ja nicht, alles was sein 
muss soll auch geschrieben werden. Nur ich habe das Gefühl das ich sehr 
komplizierte Wege beschreite und dadurch zu viel schreibe, was die 
Übersichtlichkeit und Einfachheit entgegen steht.

Nachdem ich nun wiedermals mein Geschriebenes hier durchlesen habe fasse 
ich meine im Gedanken befindlichen Ziele zusammen.

4 Licht-Varianten:
- Erzeugen jeder möglichen Farbe (Bl,R,Gr,Cy,Ma,Ge und Weiß) - 
Standlicht
- Erzeugen eines Lauflichts jeglicher Farbe
- Erzeugen eines aufbauenden Balken
- Erzeugen von 1Hz Blinklicht jeder Farbe

- Varianten-Steuerung durch Auswahlschalter/-Taster (bzs. 
Programmnummer) oder Zufallsgenerator

- Ein-/Ausschalten erfolgt durch den Kofferraumschalter (Masseschalter 
für Licht), für Laboranwendung durch einstecken des Netzteils

@Jim Meba
Der Festspannungsregler von 5V ist nicht für das Kontrollerboard 
zuständig.
Also ich habe ein Trafo der die Netzwechselspannung von 230V auf 9V 
heruntertransformiert. Danach kommt ein Diodengleichrichter zum Einsatz 
um eine pulsierende Gleichspannung zuerzeugen, die dann durch zwei 1mF 
Kondensatoren geglättet wird. Die ausgehenden Gleichspannung liegt somit 
bei ca 11,8V und kommt damit der Autobetriebsspannung sehr nahe - Die im 
Kofferraum verarbeiteten LED's sind in Reihe mit dazugehörigen 
Vorwiderstand an die 12V angepasst. - Da mein Laboraufbau in klein 
gehalten wurde, regel ich die 11,8V Gleichspannung mittels 
Festspannungsregler runter. Somit benutze ich bloß 5V und dann 
entsprechende Vorwiderstände für die LED's.
Die LED's bekommen somit die entsprechenden Arbeitsspannungen, der 
Minuspol ist mit dem IC angebunden, da der IC die Masse schaltet. Der µC 
hat seine eigene Stromversorgung durch das eigene Netzteil (ist das 
ganze Entwicklerboard, nicht nur der Chip). Die dort anliegenden 3,3V 
reichen als ausgehende Signalstärke (high) aus, um die IC (Arbeitsweise 
auf TTL-Standard) zum Durchschalten zu bewegen.
Die Signal-Schaltung mit den Ports und LED's habe ich oben ja schon 
ausfürhlich (so hoffe ich doch) beschrieben.


Folgend mein derzeitiger kompletter Programmcode:

- in diesem sind die Matrix-Werte enthalten die ich immer einzelnd Ein- 
und Auskommentieren müsste, um das Lauflicht oder die Balken zu 
generieren
(27.04.2013)
- Ansteuerung mit Block-Matrix und Logik (29.04.2013) wobei nur 
Lauflicht für Weiß gerade möglich ist
- 15.05.2013 Versuch eines neuen Logik-Ansatzes mittels 
Port-Pin-Direktanwahl
_____________________________________________________________________

#include <c8051f020.h>                    // SFR declarations

//---------------------------------------------------------------------
// 16-bit SFR Definitions for 'F02x
//---------------------------------------------------------------------
sfr16 DP       = 0x82;                    // data pointer
sfr16 TMR3RL   = 0x92;                    // Timer3 reload value
sfr16 TMR3     = 0x94;                    // Timer3 counter
sfr16 ADC0     = 0xbe;                    // ADC0 data
sfr16 ADC0GT   = 0xc4;                    // ADC0 greater than window
sfr16 ADC0LT   = 0xc6;                    // ADC0 less than window
sfr16 RCAP2    = 0xca;                    // Timer2 capture/reload
sfr16 T2       = 0xcc;                    // Timer2
sfr16 RCAP4    = 0xe4;                    // Timer4 capture/reload
sfr16 T4       = 0xf4;                    // Timer4
sfr16 DAC0     = 0xd2;                    // DAC0 data
sfr16 DAC1     = 0xd5;                    // DAC1 data
//----------------------------------------------------------------------
// Global CONSTANTS
//----------------------------------------------------------------------
#define SYSCLK 2000000        // approximate SYSCLK frequency in Hz

// Deklaration von B0-B9 analog R & G mit direkter Port-Pin-Zuweisung
// 15.05.2013 neuer Ansatz für bessere Logik-Steuerung der LED's
sbit B0 = P0^0;
sbit B1 = P0^3;
sbit B2 = P0^6;
sbit B3  = P1^2;
sbit B4  = P1^5;
sbit B5  = P2^1;
sbit B6 = P2^2;    //Blau doppelt aussen
sbit B7  = P2^6;
sbit B8  = P3^2;
sbit B9 = P3^3;    // Blau doppelt aussen

sbit R0 = P0^1;
sbit R1 = P0^4;
sbit R2 = P1^0;
sbit R3 = P1^3;
sbit R4  = P1^6;
sbit R5  = P2^3;
sbit R6  = P3^0;
sbit R7  = P3^4;

sbit G0  = P0^2;
sbit G1  = P0^5;
sbit G2  = P1^1;
sbit G3  = P1^4;
sbit G4  = P2^0;
sbit G5  = P2^4;
sbit G6 = P2^5;    //Gruen doppelt aussen
sbit G7  = P3^1;
sbit G8  = P3^5;
sbit G9 = P3^6;    //Gruen doppelt aussen


// globale zaehlvariable
unsigned char n = 0;   // dezimal
unsigned char t1 = 0;
unsigned char m = 0;

//---------------------------------------------------------------------- 
-
// Projekt - LED_Kofferraumbeleuchtung - Laborversuch in Kleinmaßstab

//------ Hex-Werte für jede einzelne LED auf dem Board - 29.04.2013 ----
/* Logik-Ansteuerung siehe unten ("Lauflicht Weiß  mit Block-Benutzung")
//LED Blau
unsigned char LED_Blau0[9] = { 0x00, 0x01, 0x08, 0x40, 0x00, 0x00, 0x00, 
0x00, 0x00 };
unsigned char LED_Blau1[9] = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 
0x00, 0x00 };
unsigned char LED_Blau2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 
0x40, 0x00 };
unsigned char LED_Blau3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x0C };

//LED Rot
unsigned char LED_Rot0[9] = { 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00 };
unsigned char LED_Rot1[9] = { 0x00, 0x00, 0x00, 0x01, 0x08, 0x40, 0x00, 
0x00, 0x00 };
unsigned char LED_Rot2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 
0x00, 0x00 };
unsigned char LED_Rot3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x01, 0x10 };

//LED Grün
unsigned char LED_Gruen0[9] = { 0x00, 0x04, 0x20, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Gruen1[9] = { 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Gruen2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x30, 0x00, 0x00 };
unsigned char LED_Gruen3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x02, 0x60 };
*/

//---------------------------------------------------------------------- 
---
// Hex-Werte-Matrix für jede mögliche Farbe (B,R,Gr,M,Ge,C,W) bei 
Lauflicht oder Balken - 27.04.2013 - ohne Logik nur Zaehler [n] s.u.
// Lauflicht: 
------------------------------------------------------------------------
/*
//LED Blau-Lauflicht
unsigned char LED_Block0[9] = { 0x00, 0x01, 0x08, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x06, 0x40, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x0C };

//LED Rot-Lauflicht
unsigned char LED_Block0[9] = { 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x01, 0x08, 0x40, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x08, 0x00, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x10 };

//LED Grün-Lauflicht
unsigned char LED_Block0[9] = { 0x00, 0x04, 0x20, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x30, 0x00, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x02, 0x60 };

//LED Durchlauf1-Lauflicht ---Blau---Rot---Grün---
unsigned char LED_Block0[27] = { 0x00, 0x01, 0x08, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x04, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char LED_Block1[27] = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x40, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00 };
unsigned char LED_Block2[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x06, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00 };
unsigned char LED_Block3[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x60 };

//LED Blau-Rot-Lauflicht (Magenta)
unsigned char LED_Block0[9] = { 0x00, 0x03, 0x18, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x01, 0x0C, 0x60, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x0E, 0x40, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x1C };

//LED Rot-Grün-Lauflicht (Gelb)
unsigned char LED_Block0[9] = { 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x03, 0x18, 0x40, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x38, 0x00, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x03, 0x70 };

//LED Grün-Blau-Lauflicht (Cyan)
unsigned char LED_Block0[9] = { 0x00, 0x05, 0x28, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x02, 0x14, 0x20, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x36, 0x40, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x02, 0x6C };

//LED Durchlauf2-Lauflicht ---Magenta 9---Gelb 18---Cyan 27---
unsigned char LED_Block0[27] = { 0x00, 0x03, 0x18, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x05, 0x28, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00 };
unsigned char LED_Block1[27] = { 0x00, 0x00, 0x00, 0x01, 0x0C, 0x60, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x18, 0x40, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x02, 0x14, 0x20, 0x00, 0x00, 0x00 };
unsigned char LED_Block2[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x0E, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x38, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x36, 0x40, 0x00 };
unsigned char LED_Block3[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x70, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x6C };

//LED Blau-Rot-Grün-Lauflicht (Weiß)
unsigned char LED_Block0[9] = { 0x00, 0x07, 0x38, 0x40, 0x00, 0x00, 
0x00, 0x00, 0x00 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x03, 0x1C, 0x60, 
0x00, 0x00, 0x00 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x3E, 0x40, 0x00 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x03, 0x7C };
*/

//---------------------------------------------------------------------
// Balken:
//---------------------------------------------------------------------
/*
//LED Blau-Balken
unsigned char LED_Block0[9] = { 0x00, 0x01, 0x09, 0x49, 0x49, 0x49, 
0x49, 0x49, 0x49 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x24, 
0x24, 0x24, 0x24 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x06, 0x46, 0x46 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x0C };

//LED Rot-Balken
unsigned char LED_Block0[9] = { 0x00, 0x02, 0x12, 0x12, 0x12, 0x12, 
0x12, 0x12, 0x12 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x01, 0x09, 0x49, 
0x49, 0x49, 0x49 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x08, 0x08, 0x08 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x11 };

//LED Grün-Balken
unsigned char LED_Block0[9] = { 0x00, 0x04, 0x24, 0x24, 0x24, 0x24, 
0x24, 0x24, 0x24 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x02, 0x12, 0x12, 
0x12, 0x12, 0x12 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x31, 0x31, 0x31 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x02, 0x62 };

//LED Durchlauf3-Balken (Blau -> Rot -> Grün)
unsigned char LED_Block0[27] = { 0x00, 0x01, 0x09, 0x49, 0x49, 0x49, 
0x49, 0x49, 0x49, 0x00, 0x02, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 
0x00, 0x04, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24 };
unsigned char LED_Block1[27] = { 0x00, 0x00, 0x00, 0x00, 0x04, 0x24, 
0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x01, 0x09, 0x49, 0x49, 0x49, 0x49, 
0x00, 0x00, 0x00, 0x02, 0x12, 0x12, 0x12, 0x12, 0x12 };
unsigned char LED_Block2[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x06, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x31, 0x31, 0x31 };
unsigned char LED_Block3[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x62 };

//LED Blau-Rot-Balken (Magenta)
unsigned char LED_Block0[9] = { 0x00, 0x03, 0x1B, 0x5B, 0x5B, 0x5B, 
0x5B, 0x5B, 0x5B };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x01, 0x0D, 0x6D, 
0x6D, 0x6D, 0x6D };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x0E, 0x4E, 0x4E };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x1D };

//LED Rot-Grün-Balken (Gelb)
unsigned char LED_Block0[9] = { 0x00, 0x06, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36 };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x03, 0x1B, 0x5B, 
0x5B, 0x5B, 0x5B };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x39, 0x39, 0x39 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x03, 0x73 };

//LED Grün-Blau-Balken (Cyan)
unsigned char LED_Block0[9] = { 0x00, 0x05, 0x2D, 0x6D, 0x6D, 0x6D, 
0x6D, 0x6D, 0x6D };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x02, 0x16, 0x36, 
0x36, 0x36, 0x36 };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x37, 0x77, 0x77 };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x02, 0x6E };

//LED Durchlauf4-Balken (Magenta -> Gelb -> Cyan)
unsigned char LED_Block0[27] = { 0x00, 0x03, 0x1B, 0x5B, 0x5B, 0x5B, 
0x5B, 0x5B, 0x5B, 0x00, 0x06, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x00, 0x05, 0x2D, 0x6D, 0x6D, 0x6D, 0x6D, 0x6D, 0x6D };
unsigned char LED_Block1[27] = { 0x00, 0x00, 0x00, 0x01, 0x0D, 0x6D, 
0x6D, 0x6D, 0x6D, 0x00, 0x00, 0x00, 0x03, 0x1B, 0x5B, 0x5B, 0x5B, 0x5B, 
0x00, 0x00, 0x00, 0x02, 0x16, 0x36, 0x36, 0x36, 0x36 };
unsigned char LED_Block2[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x0E, 0x4E, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x39, 0x39, 0x39, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x37, 0x77, 0x77 };
unsigned char LED_Block3[27] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x01, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x73, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x6E };

//LED Blau-Rot-Grün-Balken (Weiß)
unsigned char LED_Block0[9] = { 0x00, 0x07, 0x3F, 0x7F, 0x7F, 0x7F, 
0x7F, 0x7F, 0x7F };
unsigned char LED_Block1[9] = { 0x00, 0x00, 0x00, 0x03, 0x1F, 0x7F, 
0x7F, 0x7F, 0x7F };
unsigned char LED_Block2[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
0x3F, 0x7F, 0x7F };
unsigned char LED_Block3[9] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x03, 0x7F };
*/

//---------------------------------------------------------------------
// Function PROTOTYPES
//---------------------------------------------------------------------
void PORT0_Init (void);
void PORT1_Init (void);
void PORT2_Init (void);
void PORT3_Init (void);
void Timer3_Init (int counts);
void Timer3_ISR (void);

//---------------------------------------------------------------------
// MAIN Routine
//---------------------------------------------------------------------
void main (void) {

   // disable watchdog timer
   WDTCN = 0xde;
   WDTCN = 0xad;

   PORT0_Init ();
   PORT1_Init ();
   PORT2_Init ();
   PORT3_Init ();
   Timer3_Init (SYSCLK  12  10);   // Init Timer3 to generate 
interrupts
                          // at a 10Hz rate.

   EA =1;

   while (1) {                       // spin forever
   }
}
//---------------------------------------------------------------------
// PORT_Init
//---------------------------------------------------------------------
//
// Configure the Crossbar and GPIO ports

void PORT0_Init (void)
{
   XBR2    = 0x40;                 // Enable crossbar and weak pull-ups
   P0MDOUT |= 0xff;                // enable Port0 as push-pull output
}
void PORT1_Init (void)
{
   XBR2    = 0x40;                 // Enable crossbar and weak pull-ups
   P1MDOUT |= 0xff;                // enable Port1 as push-pull output
}
void PORT2_Init (void)
{
   XBR2    = 0x40;                 // Enable crossbar and weak pull-ups
   P2MDOUT |= 0xff;                // enable Port2 as push-pull output
}
void PORT3_Init (void)
{
   XBR2    = 0x40;                 // Enable crossbar and weak pull-ups
   P3MDOUT |= 0xff;                // enable Port3 as push-pull output
}
//----------------------------------------------------------------------
// Timer3_Init
//----------------------------------------------------------------------
//
// Configure Timer3 to auto-reload and generate an interrupt at interval
// specified by <counts> using SYSCLK/12 as its time base.
//
void Timer3_Init (int counts)
{
   TMR3CN = 0x00;                      // Stop Timer3; Clear TF3;
                                       // use SYSCLK/12 as timebase
   TMR3RL  = 0xffff -counts;           // Init reload values
   TMR3    = 0xffff;                   // set to reload immediately
   EIE2   |= 0x01;                     // enable Timer3 interrupts
   TMR3CN |= 0x04;                     // start Timer3
}
//----------------------------------------------------------------------
// Interrupt Service Routines
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Timer3_ISR
//----------------------------------------------------------------------
// This routine changes the state of the LED whenever Timer3 overflows.
//
void Timer3_ISR (void) interrupt 14
{
   TMR3CN &= ~(0x80);                       // clear TF3

/* ---------------------------------------------------------------------
// Lauflicht Weiß  mit Block-Benutzung s.o. - 29.04.2013
   P0 = LED_Blau0[n] | LED_Rot0[n] | LED_Gruen0[n];
   P1 = LED_Blau1[n] | LED_Rot1[n] | LED_Gruen1[n];
   P2 = LED_Blau2[n] | LED_Rot2[n] | LED_Gruen2[n];
   P3 = LED_Blau3[n] | LED_Rot3[n] | LED_Gruen3[n];
 ------------------------------------------------------------------------
*/
//-----derzeitige Anwendung = Blinklicht im Sekundentakt und Farbwechsel

   t1 = t1 + 1;
   if(t1>10)
   {
  B0 = B1 = B2 = B3 = B4 = B5 = B6 = B7 = B8 = B9 = m;

  m = m+1;
  if(m>2) m=0;      //1sek aus, 2sek an

  R0 = R1 = R2 = R3 = R4 = R5 = R6 = R7 = n;
  n = n+1;
  if(n>1) n=0;

  G0 = G1 = G2 = G3 = G4 = G5 = G6 = G7 = G8 = G9 = m;
/*---------------------------------------------------------------------
      //n = n + 1;
      //if(n>8) n = 0;    // Lauflicht oder Balken für ein Durchlauf
-----------------------------------------------------------------------* 
/

       t1 = 0;
   }
}
//----------------------------------------------------------------------
______________________________________________________________________ 
_


Hoffe doch das ich meine Gedanken und vorhandene Hardware besser 
verdeutlicht habe.
Die einzelnen Licht-Varianten würde ich in Programmodule (1,2,3,4) 
verpacken und per Taster durchschalten wollen. Mittels einer vorhandenen 
7-Segmentanzeige könnte man das gewählte Programm anzeigen lassen, aber 
das ist/wäre das i-Tüpfelchen. Wichtig ist wirklich ein guter 
Lösungsansatz, womit man die Licht-Varianten richtig ansteuern kann, 
also Port-Pin-Zusweisung mit logischen Verknüpfungen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
  


  

    

      von
      
        Battyman (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
ist der Code zu überladen?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
  


  

    

      von
      
        battyman (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
up

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: C8051F020DK SiLab LED's an mehreren Port's ansteuern
  


  

    

      von
      
        batty m.
        (battyman)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
So Tach auch, hab mal wieder geforscht und rum probiert.

Vielen Dank - das mit dem "code" hat super geklappt. Bin nun von 126byte 
auf 16byte wieder runter gerutsch.

Des Weiteren habe ich nun für die einzelnen drei Farben je ein 
Einzel-LED Array erstellt und arbeite in der Timer3_ISR mit logischen 
Operationen.
Damit habe ich jetzt das Lauflicht und den ansteigenden Balken für jede 
Farbkombi erstellt (Case 9 - 22).

Hier mal der derzeitige ganze Code:

1
#include <c8051f020.h>                    // SFR declarations

2
3
// Global CONSTANTS-------------------------------------------

4
#define SYSCLK 2000000          // approximate SYSCLK frequency in Hz

5
6
int rand(void);

7
void srand (unsigned int seed);

8
unsigned char n = 0;

9
unsigned char t1 = 0;

10
unsigned char t2 = 1;

11
sbit SW2 = P3^7;

12
13
//Hex-Werte für jede einzelne LED auf dem Board - 29.04.2013-----

14
//LED Blau-Lauflicht

15
unsigned char code L_LED_Blau0[9] = {0x00,0x01,0x08,0x40,0x00,...,0x00};

16
unsigned char code L_LED_Blau1[9] = {0x00,...,0x04,0x20,0x00,0x00,0x00};

17
unsigned char code L_LED_Blau2[9] = {0x00,...,0x06,0x40,0x00};

18
unsigned char code L_LED_Blau3[9] = {0x00,...,0x0C};

19
20
//LED Rot-Lauflicht analog Blau mit eintsprechenden Hex-Werten

21
unsigned char code L_LED_Rot0[9] = {0x00,0x02,0x10,0x00,..., 0x00};  

22
...

23
24
//LED Grün-Lauflicht analog Blau mit eintsprechenden Hex-Werten

25
unsigned char code L_LED_Gruen0[9] = {0x00,0x04,0x20,...,0x00};  

26
...

27
28
//Port-"Puffer"-Variablen wird später als Algor.-Zaehlvar. benutz

29
unsigned char B_LED_P0 = 0;

30
unsigned char B_LED_P1 = 0;

31
unsigned char B_LED_P2 = 0;

32
unsigned char B_LED_P3 = 0;

33
34
// Function PROTOTYPES------------------------------------------

35
void PORT0_Init (void);  

36
void PORT1_Init (void);

37
void PORT2_Init (void);

38
void PORT3_Init (void);

39
40
void Timer3_Init (int counts);  

41
void Timer3_ISR (void);   

42
43
// MAIN Routine------------------------------------------------

44
void main (void)

45
{

46
   // disable watchdog timer

47
   WDTCN = 0xde;

48
   WDTCN = 0xad;

49
50
   PORT0_Init ();

51
   PORT1_Init ();

52
   PORT2_Init ();

53
   PORT3_Init ();

54
   Timer3_Init (SYSCLK / 12 / 10);   // Init Timer3 to generate interrupts

55
                    // at a 10Hz rate.

56
   EA =1;

57
   while (1) {                            // spin forever

58
   }

59
}

60
61
// PORT_Init - Configure the Crossbar and GPIO ports--------------

62
void PORT0_Init (void)

63
{

64
   XBR2    = 0x40;         // Enable crossbar and weak pull-ups

65
   P0MDOUT |= 0xff;        // enable Port0 as push-pull output  

66
}   

67
// Port1 /-2 analog zu Port0

68
69
void PORT3_Init (void)

70
{

71
   XBR2    = 0x40;         // Enable crossbar and weak pull-ups

72
   P3MDOUT = 0x7f;         // enable Port3 Pin1-7 as push-pull output  

73
                           // Pin8 ist der Taster dran SW2 = P3^7

74
}

75
76
// Timer3_Init----------------------------------------------

77
void Timer3_Init (int counts)

78
{

79
   TMR3CN = 0x00;                      // Stop Timer3; Clear TF3;

80
                                       // use SYSCLK/12 as timebase

81
   TMR3RL  = 0xffff -counts;           // Init reload values

82
   TMR3    = 0xffff;                   // set to reload immediately

83
   EIE2   |= 0x01;                     // enable Timer3 interrupts

84
   TMR3CN |= 0x04;                     // start Timer3

85
}

86
87
// Timer3_ISR-----------------------------------------------

88
void Timer3_ISR (void) interrupt 14

89
{

90
   TMR3CN &= ~(0x80);     // clear TF3

91
              

92
   t1 = t1 + 1;            //generieren von 1Hz-Taktrate

93
   if(t1>10)

94
   {

95
      n = n + 1;          //Zaehlvariablen n für Hex-Array-Stellen

96
      if(n>8)              

97
      {

98
    n = 0;      //n NULL setzen = Neustart Zaehlvariable

99
    if (SW2 == 1)

100
   {

101
      t2= rand()%22+2;  //Zufallszahlen von 2 bis 22 für Case's

102
   }

103
   else

104
   {

105
      t2= t2+1;  //Durchlauf der Case's nacheinander

106
      if(t2>=23) t2 = 1;    

107
   }

108
109
   B_LED_P0 = 0;  //Variable "B_LED_P*" nach 9 Runden loeschen

110
   B_LED_P1 = 0;

111
   B_LED_P2 = 0;

112
   B_LED_P3 = 0;

113
      }

114
115
      if (t2<23)        //für "switch"-Anweisung (Case-Nummer)

116
      {

117
   switch ( t2 )

118
   {           

119
     case 1 : //jede nullte Stelle der Arrays B,R,G ist 0x00 = AUS

120
121
     B_LED_P0 = L_LED_Blau0[0] | L_LED_Rot0[0] | L_LED_Gruen0[0];

122
      B_LED_P1 = L_LED_Blau1[0] | L_LED_Rot1[0] | L_LED_Gruen1[0];

123
     B_LED_P2 = L_LED_Blau2[0] | L_LED_Rot2[0] | L_LED_Gruen2[0];

124
      B_LED_P3 = L_LED_Blau3[0] | L_LED_Rot3[0] | L_LED_Gruen3[0];

125
          

126
           P0 = B_LED_P0;    

127
     P1 = B_LED_P1;

128
     P2 = B_LED_P2;

129
     P3 = B_LED_P3;

130
     break;

131
132
      case 2 : //Weiß-An

133
      B_LED_P0 = L_LED_Blau0[0] | L_LED_Rot0[0] | L_LED_Gruen0[0];

134
     B_LED_P1 = L_LED_Blau1[0] | L_LED_Rot1[0] | L_LED_Gruen1[0];

135
     B_LED_P2 = L_LED_Blau2[0] | L_LED_Rot2[0] | L_LED_Gruen2[0];

136
     B_LED_P3 = L_LED_Blau3[0] | L_LED_Rot3[0] | L_LED_Gruen3[0];

137
138
        //Port's negierte Variable übergeben, AUS wird zu EIN

139
                 P0 = ~B_LED_P0;

140
     P1 = ~B_LED_P1;

141
     P2 = ~B_LED_P2;

142
     P3 = ~B_LED_P3;

143
     break;

144
145
      case 3 : //Blau-An - Hex-Wert der Arrays mit ODER verknüpft

146
  B_LED_P0 = L_LED_Blau0[1] | L_LED_Blau0[2] | L_LED_Blau0[3];  

147
      B_LED_P1 = L_LED_Blau1[4] | L_LED_Blau1[5];

148
      B_LED_P2 = L_LED_Blau2[6] | L_LED_Blau2[7];

149
      B_LED_P3 = L_LED_Blau3[8];

150
          

151
     P0 = B_LED_P0;  

152
     P1 = B_LED_P1;

153
     P2 = B_LED_P2;

154
      P3 = B_LED_P3;

155
     break;

156
           

157
  //case 4 - 8 analoge herangehensweise: 

158
159
            case 9 : //Blau-Lauflicht - "n" zaehlt von 0-8 

160
                 P0 = L_LED_Blau0[n];  

161
                 P1 = L_LED_Blau1[n];

162
                 P2 = L_LED_Blau2[n];

163
                 P3 = L_LED_Blau3[n];

164
                 break;

165
166
     //case 10 - 11 analog 

167
 

168
            case 12 : //Magenta-Lauflicht

169
                 P0 = L_LED_Blau0[n] | L_LED_Rot0[n];  

170
                 P1 = L_LED_Blau1[n] | L_LED_Rot1[n];

171
                 P2 = L_LED_Blau2[n] | L_LED_Rot2[n];

172
                 P3 = L_LED_Blau3[n] | L_LED_Rot3[n];

173
                 break;

174
175
        //case 13 - 15 analog: 

176
177
            case 16 : //Blau-Balken - "n" von 0-8 

178
                 B_LED_P0 = B_LED_P0 | L_LED_Blau0[n];  

179
                 B_LED_P1 = B_LED_P1 | L_LED_Blau1[n];

180
                 B_LED_P2 = B_LED_P2 | L_LED_Blau2[n];

181
                 B_LED_P3 = B_LED_P3 | L_LED_Blau3[n];

182
183
                 P0 = B_LED_P0;  //aufaddierte Variable 

184
           P1 = B_LED_P1;

185
           P2 = B_LED_P2;

186
           P3 = B_LED_P3;

187
           break;

188
  

189
   //case 17 - 22 analog: 

190
191
       }

192
  }

193
  t1 = 0;    //t1 = NULL setzen, für Zaehlerneustart  

194
   } 

195
}



Problem:
Da in diesem Switch alle Case-Varianten enthalten sind, leuchten die 
ersten 8 Case durch "n" dauerhaft für 8 Sekunden. Dazu:
a.) für die n-te Zaehldauer würde ich gerne ein blinken generieren. z.B. 
im halben Sekundentakt - nur wie???

b.) kein  8s-Intervall-Dauerleuchten, sondern direkt mit meinem Taster 
"SW2" anwählen und so lange anlassen, bis ich durch erneutes drücken von 
"SW2" zum nächsten möchte.
-> Das mit dem Taster ist derzeitig leider ohne richtige Logik und 
funktioniert nicht so wie ich es mir dachte. Bitte um hilfe???

Ab Case 9 soll dann alles wie jetzt schon gehabt auch bleiben.

Der Zufallsgeneartor ist derzeitig nun auch nur ein Pseudozufall, nur 
leider kennt mein µC keine "#include <timer.h>", wodurch ich den 
Startwert des zufallgenerators nicht variabel geändert bekomme. Wie kann 
ich das noch realisieren???


Für die weitere Unterstützung dabk ich euch im Voraus

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.