Ansteuerung/Fading von 12 LED mit IR Empfänger durch PIC oder ATTiny

[Daniel B. (daniel_bach)]

Hallo zusammen.

Ich möchte ein Modellauto (Trabant 601) im Maßstab 1:18 beleuchten. Dazu 
möchte ich bedrahtete SMD LED´s der Baugröße 0805 bzw 0603 verwenden. 
Die Verschiedenen Leuchtmodi (Blinker links, Blinker rechts, 
Warnblinker, Standlicht, Abblendlicht, Bremslicht usw.) sollen mittels 
IR Empgänger / IR Fernbedienung umschaltbar sein. Als Spannungsquelle 
sollen 3 oder 4 AA Batterien/Akkus dienen.

Zu meinen Fragen:

Welchen µC würdet ihr empfehlen? Ich habe mir einen PIC18F14K22 
ausgesucht, da ich schonmal mit dsPics zu tun hatte. Um das Modell 
realistischer wirken zu lassen, sollen die Blinker dimmen/faden, da ja 
der Trabant herkömmliche Leuchtmittel verbaut hatte und keine LED. Das 
Soll mittels PWM realisiert werden.
Da 12 LED´s recht viel sind, würde ich einen LED-Treiber dazunehmen, 
zumal ich mir unsicher bin ob ich die LED´s direkt an den µC anschließen 
sollte. Die 20 mA welche die LED´s maximal ziehen sind halt genau die 
Grenze was der µC pro PIN als Output schalten kann. Als LED-Treiber habe 
ich mir den TLC 5940 ausgeschaut.

Das ganze soll auf einen kleinen Platine (ca. 4x6 cm ) im Modell seinen 
Platz finden.

Habt ihr Tipps zur Hardware welche ihr verwenden würdet? Gerne auch 
Alternativen zum LED Treiber z.B. durch Multiplexen.

--> 12 LEDs einzeln/paarweise Ansteuern (dimmbar/fading)
--> Analog in für IR-Empfänger
--> Festpannungsregler auf 5 oder halt 3,3 V je nach µC

Ich hätte auch nix gegen Atmel, nur ist die Entwicklungsumgebung für 
Microchip schon da und ich habe damit schon mal gearbeitet.

Sowas soll realisiert werden:

https://www.youtube.com/watch?v=vivnPwefRlo

Danke für eure Tips und ein paar ruhige Feiertage!

[Falk B. (falk)]

@Daniel Bach (daniel_bach)

>Welchen µC würdet ihr empfehlen?

Da geht fast jeder halbwegs aktuelle Typ.

>Ich habe mir einen PIC18F14K22

Klingt OK.

>der Trabant herkömmliche Leuchtmittel verbaut hatte und keine LED. Das
>Soll mittels PWM realisiert werden.

Normal.

>Da 12 LED´s recht viel sind, würde ich einen LED-Treiber dazunehmen,

Brauchst du nicht, die 20mA/Port können die meisten uCs allein treiben. 
Außerdem braucht man bei ultrahellen LEDs keine 20mA, da wird man eher 
blind! Da reichen 2-5mA locker!

>Grenze was der µC pro PIN als Output schalten kann. Als LED-Treiber habe
>ich mir den TLC 5940 ausgeschaut.

Overkill.

>Das ganze soll auf einen kleinen Platine (ca. 4x6 cm ) im Modell seinen
>Platz finden.

Kriegt man hin.

>Habt ihr Tipps zur Hardware welche ihr verwenden würdet? Gerne auch
>Alternativen zum LED Treiber z.B. durch Multiplexen.

Kein Treiber, kein Multiplexen. Einfach Soft-PWM + IRMP.

>Microchip schon da und ich habe damit schon mal gearbeitet.

Dann bleib dabei.

[Thomas E. (thomase)]

Daniel B. schrieb:
> Da 12 LED´s recht viel sind, würde ich einen LED-Treiber dazunehmen,
> zumal ich mir unsicher bin ob ich die LED´s direkt an den µC anschließen
> sollte. Die 20 mA welche die LED´s maximal ziehen sind halt genau die
> Grenze was der µC pro PIN als Output schalten kann. Als LED-Treiber habe
> ich mir den TLC 5940 ausgeschaut.

Du brauchst keinen Treiber. Die 20mA sind viel zu viel. Allerdings weder 
für die Leds noch für den Controller, sondern für deine Augen. Geh mal 
davon aus, daß maximal 5mA ausreichen. Die roten Leds(Rück-, Bremslicht) 
könntest du bei Vcc=5V zudem in Reihe schalten. Bei den gelben Blinkern 
(jeweils links/rechts) sollte das auch noch klappen. Nur die weißen 
müssen einzeln angesteuert werden.

[Daniel B. (daniel_bach)]

Hallo zusammen,

da Projekt existiert noch und hat fortschrittte gemacht.
Ich habe mich für einen PIC18F45k22 entschieden, als IR-Receiver 
verwende ich einen TSOP4838. Das Verfahren zum decodieren gibt´s ja im 
Netz nachzulesen, ich verwende eine Arduino-Fernbedienung welche mit dem 
NEC Protokoll arbeitet. LED ansteuern funktioniert also schonmal.

Nun hänge ich an einer wahrscheinlich banalen Stelle. Das Verfahren zum 
Decodieren setzt bei erfolgreicher Dekodierung eine Variable auf TRUE 
welche dann als Bedingung einer Weilschleife dient. Im Hauptprogramm 
kann ich dann je nach gedrückter Taste verschiedene Ports anschalten 
usw.

Ich möchte jedoch das so realisieren, dass eine Unterfunktion, z.B. 
Led-Fading solange ausgeführt wird bis ich die Taste erneut drücke.

Wenn ich die Codierung mit if abfrage, rollt er einmal durch die 
Fading-Funktion und das wars.

Wenn ich Taste a drücke soll er praktisch solange etwas machen bzw 
starten bis ich die Taste nochmal drücke.

Ich hänge mal meinen Code hier an, vllt ist die Lösung ja so simpel als 
das ich nicht drauf komme.

Hauptprogramm:

void main(void)
{
  Pmd_Init();
  Ports_Init();
  Config_Init();
  Timer_Init();
  Irq_Init();
 
  __delay_ms(1000);   // wait 1 second
 
  while(1)
  {
    while (!remote_decoder_g_decode_ok);   // wait until NEC code receiver
 
    remote_decoder_g_decode_ok = 0;   // reset decoding process
    remote_decoder_g_decode_status = 0;
    T1CONbits.TMR1ON    = 0;   // disable Timer1
    
    U8_T empfang_code = 0u;
 
    empfang_code = remote_decoder_g_remote_code;    
   
    if(empfang_code == 0x3f)
    {
        Led_Control_Fade_On();
        Led_Control_Fade_Off();
        
        empfang_code = 0;
    }
   
    INTCONbits.RBIE = 1;    // enable PORTB change interrupt
 
  }
 
}

Decodierroutine:

void __interrupt() EXT(void)
{
/*************** start external interrupt ISR ***************/
  if (INTCONbits.RBIF && (PORTBbits.RB4 || !PORTBbits.RB4))   // PORTB change ISR (& clear mismatch condition)
  {
    INTCONbits.RBIF = 0;   // clear PORTB interrupt flag bit
    if(remote_decoder_g_decode_status != 0)
    {
      remote_decoder_g_timer_val = (TMR1H << 8) | TMR1L;  // store Timer1 value
      TMR1H = TMR1L = 0;     // reset Timer1
    }
 
    switch(remote_decoder_g_decode_status)
    {
     case 0 :              // start receiving IR data (we're at the beginning of 9ms pulse)
       TMR1H = TMR1L = 0;  // reset Timer1
       T1CONbits.TMR1ON = 1;         // enable Timer1
       remote_decoder_g_decode_status = 1;      // next state: end of 9ms pulse (start of 4.5ms space)
       remote_decoder_g_fill_up_bits = 0;
       break;
 
     case 1 :                                       // End of 9ms pulse
       if((remote_decoder_g_timer_val > 19000) || (remote_decoder_g_timer_val < 17000))
       { // invalid interval ==> stop decoding and reset
         remote_decoder_g_decode_status = 0;  // reset decoding process
         T1CONbits.TMR1ON = 0;     // disable Timer1
       }
       else
         remote_decoder_g_decode_status = 2;  // next state: end of 4.5ms space (start of 562µs pulse)
       break;
 
     case 2 :                                       // End of 4.5ms space
       if((remote_decoder_g_timer_val > 10000) || (remote_decoder_g_timer_val < 8000))
       { // invalid interval ==> stop decoding and reset
         remote_decoder_g_decode_status = 0;  // reset decoding process
         T1CONbits.TMR1ON = 0;     // disable Timer1
       }
       else
         remote_decoder_g_decode_status = 3; // next state: end of 562µs pulse (start of 562µs or 1687µs space)
       break;
 
     case 3 :    // End of 562µs pulse
       if((remote_decoder_g_timer_val > 1400) || (remote_decoder_g_timer_val < 800))
       { // invalid interval ==> stop decoding and reset
         T1CONbits.TMR1ON = 0;     // disable Timer1
         remote_decoder_g_decode_status = 0;  // reset decoding process
       }
       else
         remote_decoder_g_decode_status = 4;  // next state: end of 562µs or 1687µs space
       break;
 
       case 4 :
       if((remote_decoder_g_timer_val > 3600) || (remote_decoder_g_timer_val < 800))
       { // invalid interval ==> stop decoding and reset
         T1CONbits.TMR1ON = 0;     // disable Timer1
         remote_decoder_g_decode_status = 0;  // reset decoding process
       }
 
       else
       {
         if( remote_decoder_g_timer_val > 2000)  // if space width > 1ms (short space)
           remote_decoder_g_remote_code |=   (U32_T)1 << (31 - remote_decoder_g_fill_up_bits);   // write 1 to bit (31 - remote_decoder_g_fill_up_bits)
 
         else    // if space width < 1ms (long space)
           remote_decoder_g_remote_code &= ~((U32_T)1 << (31 - remote_decoder_g_fill_up_bits));  // write 0 to bit (31 - remote_decoder_g_fill_up_bits)
         remote_decoder_g_fill_up_bits++;
 
         if(remote_decoder_g_fill_up_bits > 31)
         {
           remote_decoder_g_decode_ok = 1;   // decoding process OK
           INTCONbits.RBIE = 0;     // disable PORTB change interrupt 
         }
 
         else
           remote_decoder_g_decode_status = 3;  // next state: end of 562µs pulse (start of 562µs or 1687µs space)
         
         break;
       }  // end " else "
       
    }  // end " switch(remote_decoder_g_decode_status) "
 
  }  // end " if (RBIF && (RB0 || !RB0)) "
/*************** end external interrupt ISR ***************/
 
/*************** start Timer1 ISR ***************/
  if (PIR1bits.TMR1IF)         // Timer1 ISR
  {
    PIR1bits.TMR1IF    = 0;   // clear Timer1 overflow flag bit
    remote_decoder_g_decode_status = 0;   // reset decoding process
    T1CONbits.TMR1ON    = 0;   // disable Timer1
  }
}/* end function */

/* EOF */

[Daniel B. (daniel_bach)]

Hallo, eine LED mit pwm zu betreiben funktioniert soweit, und zwar mit 
Timer Interrupt und dem Timer 0. Der Chip läuft mit 16 MHz, der Timer 
ist so eingestellt dass alle 30 µs ein Überlauf und somit ein 
Timer-Interrupt ausgelöst wird. In der ISR wird nun eine Variable 
hochgezählt(time), und mit einem voreingestellten Wert pwm_val 
verglichen. Ist der Zählerwert kleiner als der PWM-Wert (time<pwm_val) 
wird der Pin an dem die LEd angeschlossen isr auf 1 gestellt, ansosnten 
0. Somit kann ich mit unterschiedlichen Werten von pwm_val die 
Helligkeit der LED einstellen.

Nun zu meinem Anliegen: wie kann ich damit ein sanftes ein/aus faden 
machen? Es soll damit einmal ein Blinken mit ein/ausfaden von 4 LEDs 
verwirklicht werden.
Ansatz: Ich würde einen 2. Timer nehmen (ca. alle 50ms ein Interrupt, 
und da bei jedem Interrupt die Variable pwm_val ändern welche wiederum 
die Helligkeit der LED beeinflusst.

Ich würde gerne das hier auf der Seite gezeigte Verfahren mit Soft-PWM 
benutzen, leider bekomme ich es einfach nicht hin das für den Atmega32 
gedachte Beispiel auf meine PIC18F45K22 umzumünzen.

Init:

  
  /* Timer 0 */
  T0CON  = 0x88;
  TMR0H = 0xFF;
  TMR0L = 0x88;
  INTCONbits.GIE = 1;
  T0CONbits.TMR0ON = 1;

PWM Funktion:

U16_T time = 0;
const U8_T pwm_val = 1;
 /*************************** main function *********************/
void main(void)
{
  Pmd_Init();
  Ports_Init();
  Config_Init();
  Timer_Init();
  Irq_Init();
 
  __delay_ms(1000);   // wait 1 second
 
    while(1)
    {
        if (INTCONbits.T0IF)
        { 
            INTCONbits.T0IF = 0;
            TMR0H   = 0xFF;
            TMR0L   = 0x88;
            
            time++;
            
            if (time>20) 
            {
                time=0;
            }

            if (time<pwm_val)
            {
                 LATCbits.LATC7 = 1;
            }
            else
            {
                 LATCbits.LATC7 = 0;
            }
        }
    
 
    }
}
/*************************** end main function ********************************/

[Frank M. (ukw) (Moderator)]

Daniel B. schrieb:
> Nun zu meinem Anliegen: wie kann ich damit ein sanftes ein/aus faden
> machen?

Artikel LED-Fading

[Daniel (Gast)]

Danke, das Beispiel habe ich mir natürlich mehrfach durchgelesen vorher, 
sosnt hätte ich nicht die Frage geschrieben.
Das das Beispiel hier für den AVR war, war die Umsetzung mit einem PIC 
nicht ganz trivial.
Das Problem wurde jedoch gelöst und ich habe mittels Timer-Interrupt 
welcher einen PWM-Multiplexer erstellt. Sanftes an/ausfaden 
funktioniert.

Mein Problem ist nun dass ich den Dekodiervorgang (max. ca. 100ms) der 
Fernbedienung und die Soft-PWM vereinen muss. Da der Timer Interrupt für 
das PWM ca. alle 500 µs kommt, müsste ich den Dekodiervorgang der 
Fernbedienung mit NEC Protokoll so anpassen / aufsplitten dass die neuen 
Werte für die PWM trotzdem alle 500 µs erstellt werden und nicht ca. 
100ms gewartet wird bis der dekodiervorgang abgeschlossen ist.

Der Code zum dekodieren steht schon weiter oben (Post vom 23.11.2018).
Meine Idee wäre nach jedem Timer Interrupt (evtl. mit einem 2. Timer) am 
Portpin an dem der IR Empfänger angeschlossen ist zu schauen ob sich der 
Pegel geändert hat.

Hat jemand eine Idee wie man den Dekodiervorgang sinnvoll aufsplitten 
kann ohne 100ms warten zu müssen?

[Axel S. (a-za-z0-9)]

Daniel schrieb:
> Das Problem wurde ... gelöst und ich habe mittels Timer-Interrupt
> welcher einen PWM-Multiplexer erstellt. Sanftes an/ausfaden
> funktioniert.

Schön. Und Soft-PWM nimmst du, weil dein PIC keine Hardware-PWM kann? 
Also ich hätte ja lieber nach einem µC Ausschau gehalten, der das hat.

> Mein Problem ist nun dass ich den Dekodiervorgang (max. ca. 100ms) der
> Fernbedienung und die Soft-PWM vereinen muss. Da der Timer Interrupt für
> das PWM ca. alle 500 µs kommt, müsste ich den Dekodiervorgang der
> Fernbedienung mit NEC Protokoll so anpassen / aufsplitten dass die neuen
> Werte für die PWM trotzdem alle 500 µs erstellt werden und nicht ca.
> 100ms gewartet wird bis der dekodiervorgang abgeschlossen ist.

Aka "verschachtelte Interrupts". Das englische Wort wäre "nested"

> Hat jemand eine Idee wie man den Dekodiervorgang sinnvoll aufsplitten
> kann ohne 100ms warten zu müssen?

Das einzige, was an der IR-Empfangs ISR zeitkritisch ist, ist das 
Abtasten des Pins, an dem der IR-Empfänger hängt. Der Rest danach darf 
verzögert werden (aber natürlich nicht länger als bis kurz vor dem 
nächsten Interrupt).

Auf einem AVR wird das I-Flag beim Eintritt in eine ISR gelöscht, was 
weitere Interrupts blockiert. Hier würde man das so lösen, daß man in 
der IR-Empfangs ISR direkt nach dem Abtasten des Pins ein sei() 
unterbringt, was Interrupts (die jetzt die ISR unterbrechen) erlaubt. 
Beim PIC sollte etwas ähnliches gehen. Ich erinnere mich dunkel, gelesen 
zu haben, daß es da ohnehin zwei Interrupt-Level gibt. Da würde es dann 
reichen, das so zu konfigurieren, daß der PWM-Interrupt die IR-Empfangs 
ISR unterbrechen kann.

[Michael B. (hardwarepunktbas)]

Auch ich denke, dass Low-Power-LEDs für
dieses Modell gehen, um Treiber zu vermeiden.
Meine Empfehlung für den Chip wäre allerdings
ein AVR, programmiet in BASCOM, denn einen halben
Roman für ein entsprechendes kompliziertes
Programm zu schreiben, erachte ich als unnötige
Zeitverschwendung
VG Micha

[Daniel (Gast)]

Der PIC würde bewusst gewählt, da ich damit schon mal zu tun hatte und 
mir so die Entwicklungsumgebung und Einstellungen bekannt waren. 
Weiterhin habe ich schon einen Prgrammer für den PIC hier liegen. Warum 
keine Hardware PWM?  Weil es keinen Mikrocontroller mit 13 unabhängigen 
PWM-Kanälen gibt und man durch Soft PWM flexibler ist.
Für mich wäre es Zeit (und Geld) Verschwendung wenn ich mir erst einen 
neuen Chip kaufen muss inkl. Programmer und ihn in einer mir unbekannten 
Sprache programmieren muss (BASCOM)
wahrscheinlich ist meine Frage im Microchip Forum besser aufgehoben.

[Harald A. (embedded)]

Bevor du dich mit PWM quälst, sei es nun HW oder SW PWM, nehme doch 
einfach WS2812 LEDs. Die kannst du schön von Ort zu Ort durchverbinden 
und hast die gewünschte Farbe und Helligkeit. Sicher, Du brauchst nicht 
an jedem Ort alle Farben, aber das ist bei dem Preis egal. Am Ende 
einfach ein Arduino Nano, da gibt es fertige LIBSs und die Anwendung ist 
in einem Tag komplett fertig, auch für weniger Geübte.

Die WS2812 gibt es als Strip (schneiden und mit Litze verlängern), auf 
Einzelplatine, als SMD und auch bedrahtet.

Verdrahtung ist gegenüber klassischen LEDs vermutlich eleganter.

Noch besser finde ich persönlich APA102 LEDs, die haben ein fast 
klassisches SPI Interface und sind absolut zeitunkritisch in der 
Ansteuerung. Ist dann ein Draht mehr von LED zu LED.

[Harald A. (embedded)]

Die APA102 gibt es auch superklein im 2020 Gehäuse, falls es mal 
irgendwo eng wird.