Ik ben sinds kort een beetje aant experimeteren met de UART op een ATTiny2313, in de hoop dat ik op deze manier een simpel menutje richting mijn pc kan brengen.

Maar nu heb ik het volgende probleem:
De onderstaande code lijkt in de AVR Studio 4 simulator gewoon te werken, en ik heb ook sterke aanwijzingen dat de receive kant het goed doet, echter ...

In deze form produceert het verzenden van een string alleen maar onzin .. De linefeed komt er vaak nog wel door, de carriage return soms en daarna krijg ik 1 of 2 onzin bytejes door en dan niets meer..

Door te experimeteren met delays heb ik wel strings in de vorm van "USART Tes$~" terug gekregen, maar in princiepe zouden delays op deze manier niet nodig zijn toch ?

verder loopt de schakeling op 5 volt en gebruik ik een ST3232 met 4X 1uF elco's - de ATTiny2313 draait op de interne klok (1Mhz)..


.include "tn2313def.inc"

.def    aux1            = r16
.def    aux2            = r17

.def    arg1            = r25
.def    arg2            = r24

;   yh:yl - current command jump location


;------------------------------------------------------------------------------
; interrupt table
;
rjmp    main                    ; reset interrupt
reti                            ; external interrupt request 0
reti                            ; external interrupt request 1
reti                            ; timer/Counter1 capture event
reti                            ; timer/Counter1 compare match A
reti                            ; timer/Counter1 overflow
reti                            ; timer/Counter0 overflow
rjmp    uart_rxc                ; USART0, Rx complete
reti                            ; USART0, data register empty
reti                            ; USART0, Tx complete
reti                            ; analog comparator
reti                            ; pin change interrupt
reti                            ; timer/counter1 compare match B
reti                            ; timer/counter0 compare match A
reti                            ; timer/counter0 compare match B
reti                            ; USI Start
reti                            ; USI Overflow
reti                            ; timer/Counter1 overflow
reti                            ; timer/Counter0 overflow
reti                            ; EEPROM Ready
reti                            ; watchdog timer overflow

;------------------------------------------------------------------------------
; data

version:
.db 0x0a, 0x0d, "USART Test v.01", 0x0a, 0x0d, 0

help:
.db 0x0a, 0x0d, "(h)elp,(v)ersion,(s)tart,(x)stop,([r|g|b|][nn])",0x0a, 0x0d, 0

error:
.db 0x0a, 0x0d, "?",0x0a, 0x0d, 0

; menu options with corresponding command pointers
command_pointers:
.db 'h', HIGH(cmd_help), LOW(cmd_help), \
    'v', HIGH(cmd_version), LOW(cmd_version), \
    's', HIGH(cmd_start), LOW(cmd_start), \
    'x', HIGH(cmd_stop), LOW(cmd_stop), \
    'r', HIGH(cmd_r), LOW(cmd_r), \
    'g', HIGH(cmd_g), LOW(cmd_g), \
    'b', HIGH(cmd_b), LOW(cmd_b), \
    0    

;------------------------------------------------------------------------------
; includes
;
.include "delay.inc"

;------------------------------------------------------------------------------
; USART Receive complete interrupt
;
uart_rxc:
    push    aux1
    push    aux2 
    push    zh
    push    zl

    in      aux1, SREG
    push    aux1    

    ; ignore err state.. - but if it's zero - break..
    in      aux2, UDR               ; make sure byte is read
    tst     aux2
    breq    uart_rxc_finished

    ; (yh:yl > 0) ? newstate : jump yh:yl
    mov     aux1, yl
    or      aux1, yh
    breq    uart_rxc_new_state
    movw    zh:zl, yh:yl            ; jumpt to active command
    ijmp

    ; find command pointer
    uart_rxc_new_state:
    ldi     zl, LOW(command_pointers << 1)    
    ldi     zh, HIGH(command_pointers << 1)
    uart_rxc_find_state:
        lpm     aux1, z+
        cp      aux1, aux2
        breq    uart_rxc_set_state
        tst     aux1
        breq    cmd_err             ; command pointer not found
        adiw    zh:zl, 2
    rjmp    uart_rxc_find_state

    ; jump to command pointer
    uart_rxc_set_state:
    lpm     yh, z+
    lpm     yl, z
    movw    zh:zl, yh:yl
    ijmp
    
    uart_rxc_finished:
    pop     aux1
    out     SREG, aux1

    pop     zl
    pop     zh
    pop     aux2
    pop     aux1
reti 

;------------------------------------------------------------------------------
; Send a zero-terminated string located at zh:zl
uart_send_string:
    push    aux1
    push    zh
    push    zl

    uart_send_string_loop:
    lpm     aux1, z+
    tst     aux1
    breq    uart_send_string_finished
    out     UDR, aux1
        uart_wait_loop:
        sbis    UCSRA, UDRE
        rjmp    uart_wait_loop
    rjmp    uart_send_string_loop

    uart_send_string_finished:

    pop     zl
    pop     zh
    pop     aux1
ret

;------------------------------------------------------------------------------
; reset command state - clear current command pointer
;
reset_cmd_state:
    clr     yl
    clr     yh
ret

;------------------------------------------------------------------------------
; commands
;
cmd_r:
    ; ..
    rjmp    cmd_rgb

cmd_g:
    ; ..
    rjmp    cmd_rgb

cmd_b:
    ; ..    

cmd_rgb:
    ; ...
    rcall   reset_cmd_state
rjmp uart_rxc_finished

; yh:yl contians pointer to response txt, reset by dre interrupt when done
cmd_help:    
    ldi     zh, HIGH(help << 1)
    ldi     zl, LOW(help << 1)
    rcall   uart_send_string
    rcall   reset_cmd_state
rjmp uart_rxc_finished

cmd_version:
    ldi     zh, HIGH(version << 1)
    ldi     zl, LOW(version << 1)
    rcall   uart_send_string    
    rcall   reset_cmd_state
rjmp uart_rxc_finished

cmd_start:
    ; ..
    rcall   reset_cmd_state
rjmp uart_rxc_finished

cmd_stop:
    ; ..
    rcall   reset_cmd_state
rjmp uart_rxc_finished

cmd_err:
    ldi     zh, HIGH(error << 1)
    ldi     zl, LOW(error << 1)
    rcall   uart_send_string    
    rcall   reset_cmd_state
rjmp uart_rxc_finished

uart_init:
    cli     ; clear interrupt flags

    ; clear flags and set normal speed
    clr     aux1
    out     UCSRA, aux1     

    ; enable receive interrupt and receive and transmit ports
    ldi     aux1, (1 << RXCIE) | (1 << RXEN) | (1 << TXEN)
    out     UCSRB, aux1

    ; enable async, no parity, 1 stop bit, 8 char bits
    ldi     aux1, (1 << UCSZ1) | (1 << UCSZ0)
    out     UCSRC, aux1

    ; enable 2400 baud
    ldi     aux1, 25
    out     UBRRL, aux1
    clr     aux1
    out     UBRRH, aux1

    sei     ; set interrupt flags
RET

;------------------------------------------------------------------------------
; main
;
main:
    ; init stack
    ldi     aux1, RAMEND
    out     SPL,r16    

    ; clear registers
    clr     yh
    clr     yl

    rcall   uart_init

l: rjmp l 

Allereerst complimenten voor de strakke code layout, als je ziet wat hier af en toe voor onleesbaars langskomt is dit een verademing :)

Ik zie niet echt iets wat fout is, behalve dat het volgens mij beter is de UDRE flag te testen voordat je een byte stuurt, in plaats van erna om te zien of de byte verzonden is. Zo geeft de datasheet het namelijk ook:


USART_Transmit:
  ; Wait for empty transmit buffer
  sbis UCSRA,UDRE
  rjmp USART_Transmit

; Put data (r16) into buffer, sends the data
out UDR,r16

Het erna checken zou denk ik ook wel lukken (behalve bij de eerste byte, maar als het goed is is er daarvoor niets verzonden), maar dit is wel iets wat me opviel, zeker ook omdat je zegt dat het met delays beter werkt.

Verder nog een kleine tip, voor de interrupt vector bestaan ook constanten in de includes (behalve voor reset, 0). Je kunt dus ook dit schrijven:

.org 0x0
    rjmp main
.org URXCaddr	
    rjmp uart_rxc

Op zich is het wel goed iret's te hebben op de ongebruikte adressen maar zo is het wel minder fout gevoelig omdat je niet hoeft te tellen.

Ik zie niet waar het em in zit, maar ik denk dat er teveel code in de ISR routine zit en ik zie een rjmp erin zitten...
Altijd voor zorgen dat dat zo min mogelijk code is.

Dat is ook een goed punt, maar als je niet tegelijk zend en ontvangt, in combinatie met een loop als main programma moet het wel kunnen. Maar zolang je karakters stuurt in de ISR kun je geen karakters ontvangen.

Ook zou ik zoals RES zegt het jumpen tussen verschillende routines vermijden, het maakt het lastiger de code te volgen. En foutgevoeliger ook.

Een betrouwbare RS232-verbinding opzetten met de interne 1MHz-klok, is zoiets wel mogelijk?

Op 8 september 2007 14:44:01 schreef pros:
Een betrouwbare RS232-verbinding opzetten met de interne 1MHz-klok, is zoiets wel mogelijk?

Het is wel riskant als de omgevingstemperatuur niet stabiel is of de voedingsspanning. De RC oscillator is daar gevoelig voor. Een xtal is saver, en mooiere deeltallen.

Bedankt voor de snelle feedback !

Net iig even het wachten op UDRE omgedraait naar de suggestie van madwizard maar dat helpt helaas niet ..

Ik zal kijken of ik vanavond ook eens kan testen met een kristal, geen idee hoe stabiel de interne oscilator is.

Het is idd een flink lange interrupt routine - ik had in de eerste instantie ook het senden interrupt gebaseert - werkte achteraf gezien 'iets' beter (kreeg iig een stuk of 3 bytes goed door..). Nu voor de simpele manier gekozen zodat ik zeker weet dat ik tijdens het senden niet onderbroken wordt.

@madwizard: Nog bedankt voor de tip over interrupt vector locatie constante's, wist ik idd niet :) - Maar ik vind zo'n expliciete interrupt tabel ook wel handig ..

Als je een scoop hebt, kan je TXD eens bekijken terwijl de UART in een eindeloze lus 'U' verstuurt. Dan zou je een regelmatige blokgolf moeten zien met een duty-cycle van 50%.

UART op een RC is vragen om problemen (alhoewel het soms ook wel goed gaat hoor...). Hang er een Xtal aan, pas je devisors aan, zet je fuses goed en gaan...

hmm .. - nu probeer ik er een xtal tussen te hangen (de fuse bits aan te passen ..) en heb ik nog maar 2 at2313's over, dus vraag ik 't voor mijn volgende poging ook nog maar even aan jullie ..

Ik heb bij 1 tiny alle cksel bits uitgechecked (in ponyprog) - volgens mij zou dit de "external crystal/ceramic resonator" optie moeten zijn die ik nodig heb. Maar dit chipjes was niet meer te benaderen ..

Bij de volgende heb ik alle cksel bits aangechecked (werd onzeker over de programmed/unprogrammed state) - dit zou dan een externe klok moeten zijn - maar die heb ik natuurlijk niet .. :S

Ik begrijp dat dit best een domme vraag is maar uit de datasheet haal ik 't even niet - zou ik de ckdiv8 fuse ook unprogrammed moeten zetten ?

Met fuses is het altijd oppassen geblazen. Zeker met de H-byte - als je daar bit 0 laag maakt, kan je het serieel programmeren wel vergeten.

Wat de tiny betreft, waar je alle cksel-bits op 0 hebt gezet: dat is de code voor "external clock". Je moet "external crystal" (hebben, wil je een kristal aansluiten. Herstel is mogelijk door op de XTAL1-pin (pin 5) een blokgolf aan te bieden. 1MHz of zo zal wel volstaan.

Waar je alle cksel-bits op 1 hebt gezet, zou het met een kristal moeten werken.

De ckdiv8-fuse heeft uieraard invloed op de snelheid, maar je kan dat ook softwarematig aanpassen indien nodig.

@pros - Precies wat ik dacht :) - Maar nu ik bezig ben met het aansluiten van mijn een-na-laatste tiny2313 (om via CKOUT een klok aan te bieden aan de andere tiny2313) zie ik inneens wat waarschijnlijk het probleem was ...

Het voedings pootje naar mijn ISP is afgebroken - Ik kon helemaal niets meer programmen ...

Maar bedank voor je reactie ! - Het bevestigt dat bijde chips wel weer aan de praat te krijgen moeten zijn .. :)

Weer wat geleert vandaag ! - Na het lezen en toepassen van http://www.seattlerobotics.org/encoder/jun97/basics.html werkte alles ineens :)

Zo'n ST3232 zet blijkbaar, zelfs als ie niet actief aan het zenden of ontvangen is, best wat ruis op de voeding ..

De uart verbinding werkt nu ook vlekkenloos zonder xtal :)

Uiteindelijk 100nF ontkoppel op de Tiny gezet en 1uF op de st3232..

Op 9 september 2007 22:10:26 schreef OGL:
Zo'n ST3232 zet blijkbaar, zelfs als ie niet actief aan het zenden of ontvangen is, best wat ruis op de voeding ..

Uiteraard. Hij zet de hele tijd +5V om in +8V en -8V (of iets dat in de buurt komt). Een spoel met een kleine ohmse weerstand tussen spanningsregelaar en ST3232 of MAX232 doet ook wonderen.

Het moet bijna genant zijn om dit topic te lezen, maar ik ben van beroep en ook geschoold als software engineer, alles wat niet direct met pootjes verbinden te maken heeft is voor mij grootendeels nog steeds "voodoo" om de chipjes heen :)

Maar zo leren we steeds wat bij :) - bedankt voor het advies iig !