Kategorien
Arduino

Arduino – MCP42010 mehrere digitale Potentiometer kaskadiert steuern

Arduino – MCP42010 – Beispiel Ansteuerung mehrerer digitaler Potentiometer

Nach dem Beispiel Arduino – steuern und Test Digital Potentiometer MCP42010 auf Steckbrett und der grafischen Variante Node Red – Arduino – digitales Potentiometer MCP42010 steuern habe ich die Ansteuerung von 2 digitalen Potentiometern MCP42010 kaskadiert getestet.

Schaltung

 

Ansteuerung der beiden MCP42010

Die Ansteuerung des primären MCP42010 ist ausführlich in Arduino – steuern und Test Digital Potentiometer MCP42010 auf Steckbrett beschrieben.
Schreiben in Potentiometer 1 -> B00010001 und in Potentiometer 2 -> B00010010
Als zweites Byte wird der Wert übertragen, den das ausgewählte Potentiometer annehmen soll.

Um den zweiten MCP42010 zu erreichen müssen 4 Bytes, statt bisher 2 gesendet werden. Beim dritten MCP42010 wären es dann 6, beim vierten 8 und so weiter.
Um ein Potentiometer des 2. MCP42010 direkt anzusteuern ohne die Inhalte des ersten Chips zu verändern, werden zwei weitere Bytes mit dem Wert 0 gesendet.
Siehe auch Bild links aus dem Datenblatt.

Schreiben in Potentiometer 3 -> B00010001 WERT B00000000 B00000000
Schreiben in Potentiometer 4 -> B00010010 WERT B00000000 B00000000

Das ganze ist von rechts nach links zu lesen.
Es werden 4 Bytes geschrieben oder besser hinein geschoben. Die ersten beiden Bytes (von links) werden von den folgenden beiden Bytes in den zweiten MCP42010 geschoben.
Im ersten MCP42010 kommen zwei mal Null an, also keine Änderungen an den Werten im 1. Chip.

Anbei ein Minimal Beispiel, wie in das Potentiometer 1 (Pot0) des zweiten MCP42010 der Wert 127 geladen wird.

Kategorien
Node Red

Arduino – Node Red – MCP42010 – Steuerung des digitalen Potentiometers

Arduino – Node Red – MCP42010 – Beispiel Steuerung des digitalen Potentiometers

Im Beitrag Arduino – steuern und Test Digital Potentiometer MCP42010 auf Steckbrett habe ich dargestellt wie der MCP42010 über den seriellen Monitor der Arduino IDE gesteuert werden kann.
Jetzt will ich dieses etwas komfortabler zu tun.
Die Bedienung sollte aus dem Browser heraus erfolgen, optisch sehr ansprechend aussehen und auch mit dem Smartphone möglich sein.

Warum mit Node Red?

Node Red ist in der Standard Installation der Raspberry Pi enthalten, kostenlos und intuitiv bedienbar.
Durch die Möglichkeit den Programm Flow per drag and drop zusammen zu stellen, kommt man sehr schnell zu einem guten Ergebnis.
Für Prototypen und auch IOT Anwendungen eine echt tolle Sache.
Wo Licht ist, ist auch Schatten: Es verbraucht recht viel Ressourcen.
Dennoch kommt die Raspberry Pi 2 spielend damit zurecht und die Pi 3 logischerweise noch viel besser.

benötigte Funktionen des Flows

Der Flow soll die Eingaben, die ich im Experiment Arduino – steuern und Test Digital Potentiometer MCP42010 auf Steckbrett per Hand gemacht habe übernehmen.
Der Flow soll die Rückgabe – Werte in einem Gauge Chart darstellen.

Eingabe:
1:Wert von 0-255 -> setzt Potentiometer1 auf den Wert und gibt die Spannung an A0 zurück
2:Wert von 0-255 -> setzt Potentiometer2 auf den Wert und gibt die Spannung an A1 zurück

Der Flow

  • einfach den folgenden Flow kopieren und unter Menü (rechts oben) -> Import – Clipboard einfügen
[{"id":"ebf0e947.110038","type":"ui_slider","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Slider","topic":"","group":"Pot1","order":1,"min":0,"max":"255","x":225.5,"y":125,"wires":[["25bd2695.9acaf2"]]},{"id":"b755b484.2bd75","type":"ui_text","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Wert","group":"Pot1","order":1,"format":"{{msg.payload}}","x":636.5,"y":102,"wires":[]},{"id":"ed9f01b2.dfae38","type":"ui_gauge","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Spannung in V an A0","group":"Pot1","order":1,"format":"{{value}}","min":0,"max":"5","x":681.5,"y":322,"wires":[]},{"id":"25bd2695.9acaf2","type":"function","z":"8ec3bd3.cce4dc","name":"Value to Command","func":"var msg1 = { payload:\"1:\" + msg.payload +\"\\n\"};\nreturn [msg, msg1];","outputs":"2","noerr":0,"x":440.5,"y":125,"wires":[["b755b484.2bd75"],["134514.6c0042ed"]]},{"id":"134514.6c0042ed","type":"serial out","z":"8ec3bd3.cce4dc","name":"/dev/ttyUSB0","serial":"d535ccdc.123838","x":658.5,"y":148,"wires":[]},{"id":"13db30d1.da3c67","type":"serial in","z":"8ec3bd3.cce4dc","name":"/dev/ttyUSB0","serial":"43aa993f.185738","x":186.5,"y":345,"wires":[["f39416bc.0495"]]},{"id":"f39416bc.0495","type":"function","z":"8ec3bd3.cce4dc","name":"Response to value","func":"//find A0 or A1\nvar value;\nif (msg.payload.indexOf(\"A0\") != -1) {\n    value = msg.payload.split(\"A0: \");\n    value = value[1].replace(\" Volt\", \"\");\n    msg.payload = value;\n    return [msg, null];\n} else {\n    value = msg.payload.split(\"A1: \");\n    value = value[1].replace(\" Volt\", \"\");\n    msg.payload = value;\n    return [null , msg];\n}","outputs":"2","noerr":0,"x":431.5,"y":345,"wires":[["ed9f01b2.dfae38"],["ddbfff6.2bdb3"]]},{"id":"8a48ef7d.33ba9","type":"ui_slider","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Slider","topic":"","group":"Pot2","order":1,"min":0,"max":"255","x":224,"y":227,"wires":[["127d632d.c0419d"]]},{"id":"5a58be54.e6b8d8","type":"ui_text","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Wert","group":"Pot2","order":1,"format":"{{msg.payload}}","x":635,"y":204,"wires":[]},{"id":"127d632d.c0419d","type":"function","z":"8ec3bd3.cce4dc","name":"Value to Command","func":"var msg1 = { payload:\"2:\" + msg.payload +\"\\n\"};\nreturn [msg, msg1];","outputs":"2","noerr":0,"x":439,"y":227,"wires":[["5a58be54.e6b8d8"],["ee1b0407.9fbca"]]},{"id":"ee1b0407.9fbca","type":"serial out","z":"8ec3bd3.cce4dc","name":"/dev/ttyUSB0","serial":"43aa993f.185738","x":657,"y":250,"wires":[]},{"id":"ddbfff6.2bdb3","type":"ui_gauge","z":"8ec3bd3.cce4dc","tab":"147200e2.b8e19f","name":"Spannung in V an A1","group":"Pot2","order":1,"format":"{{value}}","min":0,"max":"5","x":681,"y":370,"wires":[]},{"id":"147200e2.b8e19f","type":"ui_tab","z":"","name":"Test MCP42010","icon":"dashboard","order":"1"},{"id":"d535ccdc.123838","type":"serial-port","z":"","serialport":"/dev/ttyUSB0","serialbaud":"9600","databits":"8","parity":"none","stopbits":"1","newline":"\\n","bin":"false","out":"char","addchar":false},{"id":"43aa993f.185738","type":"serial-port","z":"","serialport":"/dev/ttyUSB0","serialbaud":"9600","databits":"8","parity":"none","stopbits":"1","newline":"\\n","bin":"false","out":"char","addchar":false}]

Video Ansteuerung MCP42010 mit Node Red

Kategorien
Raspberry Pi

Raspberry Pi – Eigenbau Pegelwandler für serielle Kommunikation RS232 3,3Volt zu 5Volt TTL für AVR Mikrocontroller

Da mir der unter Raspberry Pi – Serielle Schnittstelle (RS232) nutzen vorgestellte Aufbau zu sperrig war, habe ich ein wenig gesucht, ob sich nicht ein Pegelwandler zusammen löten lässt, der direkt zwischen GPIO der Pi und RX / TX Pins des Mikrocontrollers hängt.

Unter http://www.elektronik-kompendium.de/sites/praxis/bausatz_pegelwandler-mit-transistoren.htm fand ich eine brauchbare Schaltung mit Transistoren und Widerständen, die ich so ähnlich in der Werkzeugkiste hatte.

Die folgenden Bilder zeigen meinen Schaltplan und den Testaufbau.

Der erste Test funktionierte einwandfrei sowohl in die Richtung Pi als auch in Richtung AVR Mikrocontroller.

Eigenbau_Pegelwandler_2Eigenbau_PegelwandlerSchaltplan_Pegelwandler_Raspberry_Pi_TTLEigenbau_Pegelwandler_3

Das dritte Bild zeigt den verwendeten Schaltplan und das vierte Bild den Aufbau auf Lochrasterplatine.

Jetzt kann ich mein Testboard und die Pi über normale Jumper Kabel verbinden, ohne diverse Zusatzplatinen herum hängen zu haben.

Kategorien
Raspberry Pi

Raspberry Pi – Serielle Schnittstelle (RS232) nutzen

Die Raspberry Pi ist mit vielen Schnittstellen ausgestattet.
Mit dem USB Port lassen sich die Möglichkeiten diesbezüglich mehr als potenzieren.
Um mit meinen AVR Mikrocontrollern zu kommunizieren ist am besten eine serielle Schnittstelle geeignet.

Natürlich hat die Raspberry Pi Eine, aber leider nur als Pins auf der GPIO Steckerleiste.
Die benötigten Pins könnten theoretisch direkt mit dem Mikrocontroller z.B. ATMega8 verbunden werden.
Das würde aber voraussetzen, dass der Mikrocontroller mit 3,3 Volt arbeitet.
Mein Pollin Evaluationsboard arbeitet aber mit 5 Volt, bringt aber eine fertige RS232 Schnittstelle zur Kommunikation mit PC’s oder sonstigen Gerätschaften mit.
Am einfachsten wäre es, die Pi hätte ebenso eine RS232 Schnittstelle.
Beim Googlen habe ich dann die Seite Serial Port Add On gefunden.
Das dort beschriebene Serial Port to TTL Digital Converter Module, habe ich mir bei Ebay gekauft.

GPIO Header Pins
RaspberryPI_GPIO_serielle_Schnittstelle
2 4 6 8 10 12 14 16 18 20 22 24 26
1 3 5 7 9 11 13 15 17 19 21 23 25
1= 3.3V, 9= GND, 8= TX, 10= RX

Die Jumper Kabel zum Anschluss an die Raspberry Pi wurden mitgeliefert.
Ich habe das Modul, wie im Bild dargestellt mit der Pi verbunden.

Um die serielle Schnittstelle ans Laufen zu bekommen müssen noch die /etc/inittab und die /boot/cmdline.txt angepasst werden.

/etc/inittab

  • Auskommentieren der Zeile ‘T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100’
#Spawn a getty on Raspberry Pi serial line
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

/boot/cmdline.txt

  • Löschen von: dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Bilder meiner PI inklusive ‘serieller Schnittstelle’

RaspberryPI_mit_serieller_Schnittstelle_VS RaspberryPI_GPIO_serielle_Schnittstelle1_VS RaspberryPI_GPIO_serielle_Schnittstelle2_VS RaspberryPI_GPIO_serielle_Schnittstelle3_VS RaspberryPI_GPIO_serielle_Schnittstelle4_VS

Video, zur Demonstration

Das Video kommt bereits bei meinem ‘Hello World Beispiel’ im ATMega8 Bereich meiner Webseite zum Einsatz.
Ich habe dafür ein kleines Perl Script geschrieben.
Sicherlich wäre es auch mit Programmen wie minicom gegangen, aber da hätte ich mich auch erst mal wieder einarbeiten müssen.
Das Script ging schneller und ist am Ende des Tages flexibler.

Kategorien
ATMega8

ATMega8 – Registerinhalte auf dem Mikrocontroller über serielle Schnittstelle steuern

Pollin_Board_klein
Wie im Beispiel Hello World über serielle Schnittstelle senden und im Beispiel LED’s des Pollin Evaluationboards über die serielle Schnittstelle steuern dargestellt, ist es recht einfach möglich Buchstaben oder Bytes zu einem PC zu übertragen und auch anders herum vom PC aus Schaltzustände zu verändern.
Die neue Herausforderung ist es nun Registerinhalte via serieller Schnittstelle zu füllen und Diese wieder auszulesen.

Gedacht ist die Übung als Vorbereitung für eine interne Systemuhr auf dem ATMega8, die von einem PC oder z.B. auch der Raspberry Pi gestellt und abgelesen werden kann.

PollinBoard_ATMega8_Registerinhalte_per_UART_steuern_und_ausgeben_Ablaufplan_VSWie im Ablaufplan (Bild links) dargestellt, habe ich das Programm so strukturiert, dass

  • im Hauptprogramm die Variablen initialisiert werden und der Interrupt sobald ein Byte über RX/UART empfangen wird, aktiviert ist
  • Das Unterprogramm IncommingByte entscheidet, ob es sich um ein Aktives, oder Neues Unterprogramm handelt und ruft ein weiteres Unterprogramm FunctionCall auf, was an das aktive oder gewählte Unterprogramm weiterleitet.
  • Das Unterprogramm StelleUhr, wird durch das Senden eines Bytes mit dem Inhalt 1 aufgerufen und erwartet das danach 3 weitere Bytes als Inhalt für die Register Stunde, Minute und Sekunde via RX/UART übergeben werden. Diese werden in den Registern gespeichert.
  • Das Unterprogramm Sende Uhrzeit, wird mit einem Byte mit Inhalt 2 aufgerufen und sendet 3 Byte mit den Inhalten Stunde, Minute und Sekunde zurück an den PC.

Der hier abgebildete Assemblercode ist mit vielen Kommentaren versehen.

Quellcode des Assemblerprogramms:

; avrdude -p m8 -c stk500v2 -P /dev/ttyACM0 -U flash:w:Registerinhalte_via_UART_steuern_und_ausgeben.hex
; 13.9.2013 Das Programm soll Registerinhalte per serielle Datenübertragung manipulieren können und diese auch wieder ausgeben
.NOLIST
;.INCLUDE "/home/henry/Dokumente/Mikrocontroller/AVR-Assembler/AVR_Definitionsfiles/m8def.inc"
.INCLUDE "m8def.inc"
.LIST
;
.def Sekunde                = R2
.def Minute                 = R3
.def Stunde                 = R4
;--------------------------------
.def temp                   = R16               ; Register 16 der Variable temp zuweisen 
.def ByteNummer             = R17               ; Enthält die Nummer des aktuell übertragenen Bytes innerhalb eine Unterprogramms
.def aktivesUnterprogramm   = R19               ; Enthält die numerische ID des aktuell aktiven Unterprogamms
.def EmpfRXByte             = R20               ; Enthält das zuletzt via. UART empfangene Byte 
 
.equ F_CPU = 16000000                           ; Systemtakt in Hz
.equ BAUD  = 9600                               ; Baudrate
 
; Berechnungen
.equ UBRR_VAL   = ((F_CPU+BAUD*8)/(BAUD*16)-1)  ; clever runden
.equ BAUD_REAL  = (F_CPU/(16*(UBRR_VAL+1)))     ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000)  ; Fehler in Promille
 
.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))       ; max. +/-10 Promille Fehler
  .error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif
 
; Startvektoren 
.org 0x00
    rjmp main
.org URXCaddr                                   ; Interruptvektor für UART-Empfang
    rjmp IncommingByte
 
; --------------------------------Hauptprogramm--------------------------------------
main:
 
    ; Stackpointer initialisieren
    ldi     temp, HIGH(RAMEND)
    out     SPH, temp
    ldi     temp, LOW(RAMEND)
    out     SPL, temp
 
    ; Baudrate einstellen
    ldi     temp, HIGH(UBRR_VAL)
    out     UBRRH, temp
    ldi     temp, LOW(UBRR_VAL)
    out     UBRRL, temp
 
    ; Frame-Format: 8 Bit
    ldi     temp, (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0)     out     UCSRC, temp     sbi     UCSRB, RXCIE                        ; Interrupt bei Empfang     sbi     UCSRB, RXEN                         ; RX (Empfang) aktivieren          sei                                         ; Interrupts global aktivieren loop:     rjmp    loop                                ; Endlosschleife / idle mode ; ---------------------------ENDE Hauptprogramm-------------------------------------- ; ---------------------------IncommingByte------------------------------------------- ; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde IncommingByte:     in      EmpfRXByte, UDR                     ; empfangenes Byte lesen,                                                 ; dadurch wird auch der Interrupt gelöscht     cpi     aktivesUnterprogramm, 1             ; vergleich aktivesUnterprogramm mit 1     brge    UPAufruf                            ; ist aktivesUnterprogramm > 0, springe zu UPAufruf
    mov     aktivesUnterprogramm, EmpfRXByte    ; kopiere EmpfRXByte in aktivesUnterprogramm
    clr     ByteNummer                          ; setze ByteNummer aud 0
 
UPAufruf:
    rcall   FunctionCall                        ; rufe Unterprogramm FunctionCall auf
EndIncommingByte:
    reti                                        ; Interrupt beenden
; ----------------------Ende-IncommingByte-------------------------------------------
 
; ---------------------------FunctionCall--------------------------------------------
; Abfrage aktivesUnterprogramm und Aufruf der entsprechenden Unterprogramme
FunctionCall:
    cpi     aktivesUnterprogramm, 1
    breq    Byte1                               ; Wenn eine 1 übertragen wurde zu Byte1 springen 
    cpi     aktivesUnterprogramm, 2
    breq    Byte2                               ; Wenn eine 2 übertragen wurde zu Byte2 springen 
    rjmp    EndFunctionCall                     ; zum Unterprogramm - Ende (Es wurde kein Wert der einem gültigem Unterprogarmm entspricht übertragen.)
 
Byte1:
    rcall   StelleUhr                           ; StelleUhr aufrufen
    rjmp    EndFunctionCall                     ; zum Unterprogramm - Ende
Byte2:
    rcall   SendeUhrzeit                        ; SendeUhrzeit aufrufen
    rjmp    EndFunctionCall                     ; zum Unterprogramm - Ende
EndFunctionCall:
    ret                                         ; Ende - zurück springen
; ----------------------Ende-FunctionCall--------------------------------------------
 
; ---------------------------StelleUhr-----------------------------------------------
StelleUhr:
    cpi     ByteNummer, 1                       ; vergleich ByteNummer mit 1
    breq    StelleSekunde                       ; ist ByteNummer = 1, springe zu StelleSekunde
 
    cpi     ByteNummer, 2                       ; vergleich ByteNummer mit 2
    breq    StelleMinute                        ; ist ByteNummer = 2, springe zu StelleMinute
 
    cpi     ByteNummer, 3                       ; vergleich ByteNummer mit 3
    breq    StelleStunde                        ; ist ByteNummer = 3, springe zu StelleStunde
 
    rjmp    ErhoeheByteNummer                   ; springe zu ErhoeheByteNummer
 
StelleSekunde:
    mov     Sekunde, EmpfRXByte                 ; Kopiere EmpfRXByte in Sekunde
    rjmp    ErhoeheByteNummer                   ; spinge zu ErhoeheByteNummer
 
StelleMinute:
    mov     Minute, EmpfRXByte                  ; Kopiere EmpfRXByte in Minute
    rjmp    ErhoeheByteNummer                   ; spinge zu ErhoeheByteNummer
 
StelleStunde:
    mov     Stunde, EmpfRXByte                  ; Kopiere EmpfRXByte in Stunde
    clr     aktivesUnterprogramm                ; setze aktivesUnterprogramm auf Null, wir sind fertig mit Uhr stellen :-)
    rjmp    EndStelleUhr                        ; spinge zu EndStelleUhr
 
ErhoeheByteNummer:
    inc     ByteNummer                          ; erhöhe ByteNummer um 1
EndStelleUhr:
    ret                                         ; Ende - zurück springen
; ----------------------Ende-StelleUhr-----------------------------------------------
 
; ---------------------------SendeUhrzeit--------------------------------------------
SendeUhrzeit:
    cbi     UCSRB, RXEN                         ; RX (Empfang) deaktivieren
    sbi     UCSRB, TXEN                         ; TX (Senden) aktivieren
 
Sekunde_wait:
    sbis    UCSRA,UDRE                          ; Warten bis UDR für das nächste Byte bereit ist
    rjmp    Sekunde_wait                        ; Springe zurück zu Sekunde_wait, solange UDR noch nicht bereit ist
    out     UDR, Sekunde                        ; sende das Byte Sekunde via UART
 
Minute_wait:
    sbis    UCSRA,UDRE                          ; Warten bis UDR für das nächste Byte bereit ist
    rjmp    Minute_wait                         ; Springe zurück zu Minute_wait, solange UDR noch nicht bereit ist
    out     UDR, Minute                         ; sende das Byte Minute via UART
 
Stunde_wait:
    sbis    UCSRA,UDRE                          ; Warten bis UDR für das nächste Byte bereit ist
    rjmp    Stunde_wait                         ; Springe zurück zu Stunde_wait, solange UDR noch nicht bereit ist
    out     UDR, Stunde                         ; sebnde das Byte Stunde via UART
 
    cbi     UCSRB, TXEN                         ; TX (Senden) deaktivieren
    sbi     UCSRB, RXEN                         ; RX (Empfang) aktivieren
    clr     aktivesUnterprogramm                ; setze aktivesUnterprogramm auf Null, wir sind fertig mit Uhrzeit ausgeben :-)
EndSendeUhrzeit:
    ret                                         ; Ende - zurück springen
; ----------------------Ende-SendeUhrzeit--------------------------------------------

 

Video, zur Demonstration

 

Kategorien
ATMega8

ATMega8 – LED’s des Pollin Evaluationboards über die serielle Schnittstelle steuern

Pollin_Board_kleinRS232_VS
Das Prinzip der seriellen Schnittstelle (RS232), wie Sie früher an nahezu jedem PC zu finden war ist nach wie vor aktuell.
Für den PC sind RS232 zu USB Adapter verfügbar und auf der Mikrocontroller – Seite lässt sich z.B. ein Bluetooth zu Serial Adapter einsetzen, womit ganz auf die Kabel verzichtet werden kann und die Kommunikation auch jedes Smartphone übernehmen kann.

In diesem Beispiel soll ein Byte vom PC an das Evaluationboard gesendet werden.
Sobald Dieses über UART empfangen wird, beginnt die Prüfung des übertragenen Bytes.
Ist der Wert = 1, soll die LED1 eingeschaltet werden, bei 2 soll die LED1 ausgeschaltet werden.
Bei 3 soll die LED2 eingeschaltet werden und bei 4 soll die LED2 ausgeschaltet werden.
Werden andere Inhalte empfangen, sollen keine Aktionen ausgelöst werden.
Um Bytes über die serielle Schnittstelle zu übertragen, gibt es mehrere Möglichkeiten.
Unter Linux nutze ich Cutecom, unter Windows geht Putty.
Es gibt aber auch noch viele andere Programme. Auch ein entsprechendes Script ist für diesen Zweck schnell geschrieben.

PollinBoard_ATMega8_LEDS_per_UART_steuern_Ablaufplan_VSWie im Ablaufplan Links zu erkennen, ist dieses Beispiel ein wenig komplexer als die vorherigen beiden Posts zum Evaluationsboard (LED 1 und 2 über Taster T1 und T2 schalten und Hello World über serielle Schnittstelle senden).
Dennoch lässt sich der Code sehr gut in Assembler abbilden.
Kein Grund hier C einsetzen zu müssen oder gar ein Embedded Linux System o.ä.

Der hier abgebildete Assemblercode ist mit vielen Kommentaren versehen.

Quellcode des Assemblerprogramms:

; avrdude -p m8 -c stk500v2 -P /dev/ttyACM0 -U flash:w:LEDs_via_UART_schalten.hex
; 31.8.2013 Das Programm soll über UART empfangene Bytes auswerten und wenn ein Zahlenwert 
; zwischen 1 und 4 empfangen wurde die LED1/2 folgendermßen schalten
; 1 - LED1 an
; 2 - LED1 aus
; 3 - LED2 an
; 4 - LED2 aus
; Der UART Receive Teil des Programms ist in Teilen aus 
; http://www.mikrocontroller.net/articles/AVR-Tutorial:_UART#Empfangen_von_Zeichen_per_Interrupt
; übernommen. Dort gibt es noch viel weitere Infos und Tipps
.NOLIST
;.INCLUDE "/home/henry/Dokumente/Mikrocontroller/AVR-Assembler/AVR_Definitionsfiles/m8def.inc"
.INCLUDE "m8def.inc"
.LIST
;
.def temp   = R16                               ; Register 16 der Variable temp zuweisen 
.def RXByte = R17                               ; Register 17 der Variable RXByte zuweisen
 
.equ F_CPU = 16000000                           ; Systemtakt in Hz
.equ BAUD  = 9600                               ; Baudrate
 
.equ LED1       = PD5                           ; Pin LED1
.equ LED2       = PD6                           ; Pin LED2
 
 
; Berechnungen
.equ UBRR_VAL   = ((F_CPU+BAUD*8)/(BAUD*16)-1)  ; clever runden
.equ BAUD_REAL  = (F_CPU/(16*(UBRR_VAL+1)))     ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000)  ; Fehler in Promille
 
.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))       ; max. +/-10 Promille Fehler
  .error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif
 
; Startvektoren 
.org 0x00
    rjmp main
.org URXCaddr                                   ; Interruptvektor für UART-Empfang
    rjmp IncommingByte
 
; --------------------------------Hauptprogramm--------------------------------------
main:
 
    ; Stackpointer initialisieren
    ldi     temp, HIGH(RAMEND)
    out     SPH, temp
    ldi     temp, LOW(RAMEND)
    out     SPL, temp
 
    ; Baudrate einstellen
    ldi     temp, HIGH(UBRR_VAL)
    out     UBRRH, temp
    ldi     temp, LOW(UBRR_VAL)
    out     UBRRL, temp
 
    ldi     temp, (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0)
    out     UCSRC, temp
 
    sbi     UCSRB, RXCIE                    ; Interrupt bei Empfang
    sbi     UCSRB, RXEN                     ; RX (Empfang) aktivieren
 
    ; Port D, LED Pins auf Ausgang und Taster Pins auf Eingang schalten
    ldi     temp, (1<<LED1) | (1<<LED2)                         
    out     DDRD, temp                      ; LED1/2 Pollin Evaluationsboard ,, PD5/6 auf Ausgang schalten  
 
    sei                                     ; Interrupts global aktivieren    
 
loop:
    rjmp    loop                            ; Endlosschleife / idle mode
 
; ---------------------------ENDE Hauptprogramm--------------------------------------
 
; ---------------------------IncommingByte-------------------------------------------
; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde
IncommingByte:
    in      RXByte, UDR                     ; empfangenes Byte lesen,
                                            ; dadurch wird auch der Interrupt gelöscht
; Abfrage des Byte Inhaltes und aufruf der entsprechenden Unterprogramme zum schalten der LED's
    cpi     RXByte, 1
    breq    Byte1                           ; Wenn eine 1 übertragen wurde zu Byte1 springen 
    cpi     RXByte, 2
    breq    Byte2                           ; Wenn eine 2 übertragen wurde zu Byte2 springen 
    cpi     RXByte, 3
    breq    Byte3                           ; Wenn eine 3 übertragen wurde zu Byte3 springen 
    cpi     RXByte, 4
    breq    Byte4                           ; Wenn eine 4 übertragen wurde zu Byte4 springen 
    rjmp    EndIncommingByte                ; zum Unterprogramm - Ende (Es wurde kein Wert zwischen 1 und 4 übertragen.)
 
Byte1:
    rcall   LED1Ein                         ; LED1Ein aufrufen
    rjmp    EndIncommingByte                ; zum Unterprogramm - Ende
Byte2:
    rcall   LED1Aus                         ; LED1Aus aufrufen
    rjmp    EndIncommingByte                ; zum Unterprogramm - Ende
Byte3:
    rcall   LED2Ein                         ; LED2Ein aufrufen
    rjmp    EndIncommingByte                ; zum Unterprogramm - Ende
Byte4:
    rcall   LED2Aus                         ; LED2Aus aufrufen
    rjmp    EndIncommingByte                ; zum Unterprogramm - Ende
 
EndIncommingByte:
    reti                                    ; Interrupt beenden
; ----------------------Ende-IncommingByte-------------------------------------------
; ----------------------Die 4 Unterprogramme zum LED's schalten----------------------
LED1Ein:
    sbi     PORTD, LED1                     ; Setze das LED1 Bit in PORTD
    ret
 
LED1Aus:
    cbi     PORTD, LED1                     ; Lösche das LED1 Bit in PORTD
    ret
 
LED2Ein:
    sbi     PORTD, LED2                     ; Setze das LED2 Bit in PORTD
    ret
 
LED2Aus:
    cbi     PORTD, LED2                     ; Lösche das LED2 Bit in PORTD
    ret
; -----------------Ende-Die 4 Unterprogramme zum LED's schalten----------------------

 

Video, zur Demonstration

 

Kategorien
ATMega8

ATMega8 – Hello World über serielle Schnittstelle senden


Pollin_Board_kleinDas Pollin Evaluations – Board ist mit einer seriellen RS232 Schnittstelle ausgestattet, was einen einfachen zum Datenaustausch mit einem PC ermöglicht.

RS232_VS
PollinBoard_ATMega8_HelloWorld_per_UART_Beispiel_VS
PollinBoard_ATMega8_HelloWorld_per_UART_Beispiel_Ablaufplan_VS

Die folgenden Ausführungen bauen auf das Beispiel ‘mit Taster T1/2 die LED1/2 ansteuern‘ auf.

Ziel ist es ein ‘Hello World’ an die serielle Schnittstelle zu senden, sobald der Taster T1 gedrückt wurde.
Die im Assemblerprogramm anzusteuernden Ports und Pins sind aus der Grafik auf der rechten Seite ersichtlich.
Auch dieses Beispiel habe ich so ähnlich aus dem AVR Tutorial von Mikrocontroller.net entnommen und auf die Gegebenheiten des Pollin Boards angepasst.

Der hier abgebildete Assemblercode ist mit vielen Kommentaren versehen.

Quellcode des Assemblerprogramms:

; avrdude -p m8 -c stk500v2 -P /dev/ttyACM0 -U flash:w:HelloWorld_via_UART.hex
; 5.8.2013 Das Programm soll die Worte 'Hello World' via. UART ausgeben, sobald der Taster1 gedrückt wurde
; Das Programm ist zum grossen Teil aus 
; http://www.mikrocontroller.net/articles/AVR-Tutorial:_UART#Senden_von_Zeichen
; übernommen. Dort gibt es noch viel weitere Infos und Tipps
.NOLIST
;.INCLUDE "/home/henry/Dokumente/Mikrocontroller/AVR-Assembler/AVR_Definitionsfiles/m8def.inc"
.INCLUDE "m8def.inc"
.LIST
;
.def temp       = R16
 
.equ F_CPU      = 16000000                      ; Systemtakt in Hz
.equ BAUD       = 9600	                        ; Baudrate
 
.equ Taster1 	= PD2
 
; Berechnungen
.equ UBRR_VAL   = ((F_CPU+BAUD*8)/(BAUD*16)-1)  ; clever runden
.equ BAUD_REAL  = (F_CPU/(16*(UBRR_VAL+1)))     ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000)  ; Fehler in Promille
 
.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10))       ; max. +/-10 Promille Fehler
  .error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif
 
.org 0x00
        rjmp main
 
; Hauptprogramm
 
main:
 
; Stackpointer initialisieren
    ldi     temp, HIGH(RAMEND)
    out     SPH, temp
    ldi     temp, LOW(RAMEND)
    out     SPL, temp
 
; Baudrate einstellen
    ldi     temp, HIGH(UBRR_VAL)
    out     UBRRH, temp
    ldi     temp, LOW(UBRR_VAL)
    out     UBRRL, temp
 
; Frame-Format: 8 Bit
    ldi     temp, (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0) 
    out     UCSRC, temp 
    sbi     UCSRB,TXEN                  	; TX aktivieren 
    sei                                         ; Interrupts global aktivieren Tastenabfrage: 
    sbic	PIND, Taster1 
    rcall 	SendHelloWorld			; Wenn Taster1 auf High (gedrückt), dann rufe SendHelloWorld auf 
    rjmp 	Tastenabfrage                   ; Endlosschleife 
SendHelloWorld:
T1entprellen:
    sbic	PIND, Taster1			; loope solange der Taster1 nicht wieder losgelassen wurde 
    rjmp 	T1entprellen 
    ldi		zl,low(my_HelloWorld*2)		; Z Pointer laden 
    ldi		zh,high(my_HelloWorld*2) 
    rcall	serout_string 
    ret   
; Ausgabe eines Strings aus dem Flash  serout_string: 
    lpm						; nächstes Byte aus dem Flash laden 
    and	        r0,r0				; = Null? 	     
    breq	serout_string_ende		; wenn ja, ->; Ende
serout_string_wait:
    sbis	UCSRA,UDRE			; Warten bis UDR für das nächste
						; Byte bereit ist
    rjmp	serout_string_wait
    out		UDR, r0
    adiw	zl:zh,1				; Zeiger erhöhen
    rjmp	serout_string			; nächstes Zeichen bearbeiten
serout_string_ende:
    ret	         				; zurück zum Hauptprogramm
 
my_HelloWorld:			.db "Hello World",10,0

 

Video, zur Demonstration

Im Video wird der serielle Port mittels eines Perl Scripts abgefragt.
Das geht natürlich auch mit Programmen wie Cutecom oder Putty.