Attiny2313 - Problem mit PWM

[Dextrose (Gast)]

Gute Tag. Ich verwende einen Attiny2313 um die Helligkeit dreier LEDs zu 
steuern. Dazu benutze ich 3 PWM Kanäle.
Nun bin ich auf ein Problem gestoßen, bei dem ich nicht weiter komme.
Ich gehe davon aus, dass mein Programm in Ordnung ist, denn auf dem 
STK500 klappt alles ohne Probleme. Jeder Kanal lässt sich individuell 
einstellen.

Das ganze habe ich jetzt auf Lochraster übertragen und ein Kanal macht 
Probleme. Habe ich alle drei Kanäle angeschlossen, so ist es immer der 
OC0B Pin (PD5) der nicht richtig funktionieren will. Ich habe ihn mal 
zur Seite gebogen, so dass er keine Kontakt mir dem Sockel hatte und mit 
eine Oszilloskop nachgemessen. Es tut sich nichts an dem Pin. Ich denke, 
dass dieser Pin dann die ganze Zeit hoch impedant ist. Gehe ich mit 
einem Schraubendreher dran so flackert die LED mit auffälligen 50Hz
Das kuriose ist nun, dass dieser PWM Kanal an PD5 bestens funktioniert, 
sobald ich einen anderen PWM Kanal weg biege. Wenn ,in meinem Fall: OC0A 
oder OC1A, keinen Kontakt zum Sockel/Platine haben, funktionieren die 
zwei PWM Kanäle die übrig geblieben sind wunderbar.

Ich habe schon alles mögliche nachgemessen. Die Eingänge der 
Mosfettreiber auf die die PWM Kanäle gehen haben alle keinen 
Kurzschluss. Die Treiber und die Mosfets funktionieren auch. Den Attiny 
habe ich testweise raus genommen und einen Arduino an die Pins 
angeschlossen. Alles funktionierte bestens, auf dem STK500 klappt auch 
alles ohne Probleme.

Die Beschaltung des Attinys sieht wie folgt aus: 4MHz Quarz mit 22pF 
Stützkondensatoren. 100nF Abblockkondensator. Die Spannung beträgt 5V
Die Beschaltung der Gatetreiber und der Mosfets: MCP1407 an 5V. 100nF 
Abblockkondensator. Die Beiden OUT Pins sind zusammengelötet und gehen 
auf das Gate des Mosfets (IRLU023N)

Wo könnte mein Problem liegen?

[Max D. (max_d)]

Was passiert wenn du den Pin in Software als I/O auf (dauer-)high 
schaltest ?

[Thomas E. (thomase)]

Dextrose schrieb:
> Die Beschaltung des Attinys sieht wie folgt aus: 4MHz Quarz mit 22pF
> Stützkondensatoren. 100nF Abblockkondensator. Die Spannung beträgt 5V
> Die Beschaltung der Gatetreiber und der Mosfets: MCP1407 an 5V. 100nF
> Abblockkondensator. Die Beiden OUT Pins sind zusammengelötet und gehen
> auf das Gate des Mosfets (IRLU023N)

Schaltungen beschreibt man nicht in Prosa. Zeichne einen Schaltplan.

mfg.

[Dextrose (Gast)]

Max D. schrieb:
> Was passiert wenn du den Pin in Software als I/O auf (dauer-)high
> schaltest ?

Habe in der Hauptschleife: ,,sbi PORTD, 5" eingefügt.
Wie zu erwarten bleibst der Pin die ganze zeit high.
Habe einen anderen AVR ausprobiert und das selbe Problem.

Hier ein Schaltplan, die anderen zwei Kanäle sind gleich aufgebaut.

Die Übertragung via UART habe ich mit einem Logicanalyzer getestet. Die 
Daten kommen alle über.

[Ich (Gast)]

"T1: Timer/Counter1 External Counter Clock input is enabled by setting 
(one) the bits CS02 and CS01 in the Timer/Counter1 Control Register 
(TCCR1)"

Hast du evtl. da was gesetzt?

Dextrose schrieb:
> Ich gehe davon aus, dass mein Programm in Ordnung ist

Dein Code wäre auch nützlich um das beurteilen zu können ;)

[Dextrose (Gast)]

Wenn es denn dann sein muss, bitteschön:

 .def temp0 = r16                             ; Definition eines Temporären Registers
 .def temp1 = r19
 .def temp2 = r20
 .def temp3 = r21

 .def data = r17                              ; Data Register, beinhaltet das zu sendende Byte.
 .def durchlauf = r18
 .def data_r = r10
 .def data_g = r11
 .def data_b = r12

 
 .equ baud = 9600                             ; Definiere die baud Rate (HC-05, Standart = 9600 baud)
 .equ f_cpu = 4000000                         ; Definiere die Taktfrequenz des Controllers


 .org 0x000                           
 rjmp main

 main:
 ldi temp0, 0xff
 out DDRB, temp0
 ldi temp0, (1<<PD5)
 out DDRD, temp0


 sei

 ;////////////////////////////////////////////// Stack Pointer setzen //////////////////////////////////////////////////////////////////////
 ldi temp0, (RAMEND)                          ; Lade die niedrigen 8 Bit der letzten Adresse des Rams in temp0
 out SPL, temp0                               ; Setze diese Adresse in die niedrigen 8 Bit des Stackpointers
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



 ;//////////////////////////////////////////////// Timer0 & PWM ////////////////////////////////////////////////////////////////////////////
 ldi temp0, (1<<COM0A1) | (1<<COM0B1) | (1<<WGM01) | (1<<WGM00)   ; COM0A1/B1 = 1 --> Die Pins OC0A/B sind nicht mehr vom PORT Abhängig.
                                                                  ; Ebenfalls wird OC0A/B = 0 gesetzt wenn der Timer OCR0A/B erreicht.
                                  ; Erreicht der Timer TOP (0xFF) dann wird OC0A/B = 1 gesetzt.
 out TCCR0A, temp0
 
 ldi temp0, (1<<CS00)                                             ; Vorteiler des Timer setzen.
 out TCCR0B, temp0

 ldi temp0, 0x00                                                  ; Setzen des Wertes ab wann OC0A = 0 sein soll.
 out OCR0A, temp0
 ldi temp1, 0x00
 out OCR0B, temp1                                                 ; Setzen des Werdes ab wann OC0B = 0 sein soll.
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



 ;//////////////////////////////////////////////// Timer1 & PWM ////////////////////////////////////////////////////////////////////////////
 ldi temp0, (1<<COM1A1) | (1<<WGM10)                              ; Siehe Timer 0
 out TCCR1A, temp0
 
 ldi temp0, (1<<CS10)
 out TCCR1B, temp0

 ldi temp0, 0x00

 out OCR1AL, temp0
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 



 ;////////////////////////////////////////////////// Baud Rate setzen //////////////////////////////////////////////////////////////////////
 .equ UBRRV = ((f_cpu)/(16*baud))-1            ; Errechne den Wert für das UBRR Regsiter (baud Register), Formel aus Datenblatt!
 .equ baudR = (f_cpu/(16*UBRRV+1))             ; Errechne die Reelle baud Rate, Formel aus Datenblatt!                           ; 

 ldi temp0, HIGH(UBRRV)                        ; Lade die 8 höheren Bits des errechneten Wertes ins UBRR Register (UBRRH)
 out UBRRH, temp0
 ldi temp0, LOW(UBRRV)                         ; Lade die 8 niedrigen Bits des errechneten Wertes ins UBRR Register (UBRRL)
 out UBRRL, temp0
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




 ;////////////////////////////////////////////// Frame Format setzen ///////////////////////////////////////////////////////////////////////
 ldi temp0, (1<<UCSZ1) | (1<<UCSZ0)
                                                  ; UCSZ1 & UCSZ0 = 1, somit 8 Datenbits
 out UCSRC, temp0                                 ; Ausgabe der Werte ins UCSRC REgister (HC-05 Standart)
  ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  


 ;////////////////////////////////////////////// Reciver Aktivieren ////////////////////////////////////////////////////////////////////////
 RX1:
 ldi temp0, (0<<TXEN) | (1<<RXEN)               ; Controller für's empfangen bereitstellen
 out UCSRB, temp0
 rjmp empfang0                                  ; Anschließen ind die Empfang schleife springen
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



 ;/////////////////////////////////////////////////// Empfang Schleife /////////////////////////////////////////////////////////////////////
 empfang0:
 ldi durchlauf, 0x09                            ; Anzahl der Durchläufe
 empfang1:
 sbis UCSRA, RXC                                ; Revieve Complete (RXC) Flag prüfen
 rjmp empfang1 
 empfang2:                                      ; Byte angekommen? Hier weitermachen!
 in data, UDR                                   ; RXC Flag Null: Lese die Daten aus UDR in "data" ein
 push data                                      ; Schiebe das Byte auf den RAM
 dec durchlauf                                  ; Reduziere die verbleibenden Durchläufe
 cpi durchlauf, 0x00                            ; Alle Bytes komplett? (=Anzahl der Durchläufe abgearbeitet)
 brne empfang1                                  ; Wenn Durchläufe abgearbeitet weiter. Sonst zurück zu empfang1 und warte auf die nächsten Bytes
 rjmp ausgabe                                   ; Alle Durchläufe abgearbeitet --> zur Ausgabe
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


 ;////////////////////////////////////////////////// Die Eingabe ausgeben //////////////////////////////////////////////////////////////////
 ausgabe:

 ;------------------------------------------------------ BLAU ------------------------------------------------------------------------------
 pop temp1                                     ;nn1   blau
 ldi temp0, 0b00001111
 and temp1, temp0
 

 pop temp3                                     ;n1n
 ldi temp0, 0b00001111
 and temp3, temp0
 mov temp2, temp3
 ldi temp0, 0x09
 bn1n_wtr0:
 add temp2, temp3
 dec temp0
 cpi temp0, 0x00
 breq bn1n_wtr_ende
 rjmp bn1n_wtr0
 bn1n_wtr_ende:
 

 pop temp3                                     ;1nn
 ldi temp0, 0b00001111                         
 and temp3, temp0                              ; Ausmaskierung der oberren 4 Bits da UTF-8 Kodierung

 cpi temp3, 0x00                               ; Eine 0?
 breq b1nn_wtr0
 cpi temp3, 0x01                               ; Eine 1?
 breq b1nn_wtr1
 cpi temp3, 0x02                               ; Eine 2?
 breq b1nn_wtr2
 
 b1nn_wtr0:                                    ; 0 --> 0
 ldi temp3, 0x00
 rjmp b1nn_wtr_end
 b1nn_wtr1:                                    ; 1 --> 100
 ldi temp3, 0x64
 rjmp b1nn_wtr_end
 b1nn_wtr2:                                    ; 2 --> 200
 ldi temp3, 0xC8
 rjmp b1nn_wtr_end
 b1nn_wtr_end:
 
 add temp1, temp2
 add temp1, temp3
 mov data_b ,temp1
 ;---------------------------------------------------- GRÜN --------------------------------------------------------------------------------

 pop temp1                                     ;nn1   grün
 ldi temp0, 0b00001111
 and temp1, temp0
 
 pop temp3                                     ;n1n
 ldi temp0, 0b00001111
 and temp3, temp0
 mov temp2, temp3
 ldi temp0, 0x09
 gn1n_wtr0:
 add temp2, temp3
 dec temp0
 cpi temp0, 0x00
 breq gn1n_wtr_ende
 rjmp gn1n_wtr0
 gn1n_wtr_ende:

 pop temp3                                     ;1nn
 ldi temp0, 0b00001111                         
 and temp3, temp0                              ; Ausmaskierung der oberren 4 Bits da UTF-8 Kodierung

 cpi temp3, 0x00                               ; Eine 0?
 breq g1nn_wtr0
 cpi temp3, 0x01                               ; Eine 1?
 breq g1nn_wtr1
 cpi temp3, 0x02                               ; Eine 2?
 breq g1nn_wtr2
 
 g1nn_wtr0:                                    ; 0 --> 0
 ldi temp3, 0x00
 rjmp g1nn_wtr_end
 g1nn_wtr1:                                    ; 1 --> 100
 ldi temp3, 0x64
 rjmp g1nn_wtr_end
 g1nn_wtr2:                                    ; 2 --> 200
 ldi temp3, 0xC8
 rjmp g1nn_wtr_end
 g1nn_wtr_end:
 
 add temp1, temp2
 add temp1, temp3
 mov data_g ,temp1
 ;------------------------------------------------------- ROT ------------------------------------------------------------------------------

 pop temp1                                     ;nn1   rot 
 ldi temp0, 0b00001111
 and temp1, temp0
 
 pop temp3                                     ;n1n
 ldi temp0, 0b00001111
 and temp3, temp0
 mov temp2, temp3
 ldi temp0, 0x09
 rn1n_wtr0:
 add temp2, temp3
 dec temp0
 cpi temp0, 0x00
 breq rn1n_wtr_ende
 rjmp rn1n_wtr0
 rn1n_wtr_ende:

 pop temp3                                     ;1nn
 ldi temp0, 0b00001111                         
 and temp3, temp0                              ; Ausmaskierung der oberren 4 Bits da UTF-8 Kodierung

 cpi temp3, 0x00                               ; Eine 0?
 breq r1nn_wtr0
 cpi temp3, 0x01                               ; Eine 1?
 breq r1nn_wtr1
 cpi temp3, 0x02                               ; Eine 2?
 breq r1nn_wtr2
 
 r1nn_wtr0:                                    ; 0 --> 0
 ldi temp3, 0x00
 rjmp r1nn_wtr_end
 r1nn_wtr1:                                    ; 1 --> 100
 ldi temp3, 0x64
 rjmp r1nn_wtr_end
 r1nn_wtr2:                                    ; 2 --> 200
 ldi temp3, 0xC8
 rjmp r1nn_wtr_end
 r1nn_wtr_end:
 
 add temp1, temp2
 add temp1, temp3
 mov data_r ,temp1
 ;------------------------------------------------------------------------------------------------------------------------------------------


 out OCR0A, data_r
 out OCR0B, data_g
 out OCR1AL, data_b


 rjmp empfang0                                  ; zurück zum empfang0 und auf Datenübertragung warten.
 ;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[Dextrose (Gast)]

So, habe nun das Problem lösen können. Wie es aussieht habe ich die 
Spannung am AVR nicht genug geglättet, bzw. teilweise Spannungsabfälle 
(brown outs?). Das hat den Controller aus dem Konzept gebracht.
Nun habe ich genug Kondensatoren eingebaut, Elkos sowie Kerkos, und 
alles funktioniert super.