Mikrocontroller und Robotik

Transkript

1 Mikrocontroller und Robotik Dipl-Inform. Dr. Merten Joost Universität Koblenz Institut für integrierte Naturwissenschaften Abteilung Physik Mikrocontroller und Robotik (von der CPU zum Computer)

2 2 Mikrocontroller und Robotik Messtechnik TTL Schaltkreisfamilie Treiber, Gleichstrom/Schritt/Servomotoren Prozessorentwicklung CISC/RISC Mikrocontroller Assembler und C I/O Unterprogramme Interrupts DA/AD Wandler serielle Schnittstellen Einchipcomputer VGA PS2 IDE Ethernet

3 3 Messung von Strom und Spannung Spannungsmessung: I = U I L R L V I V R iv Strommessung: I A R ia = U R L Strom(a)- und Spannungsfehlerschaltung(b): A I I A I R I V I R = R x U R V = V U A R x U R a) b)

4 4 einfacher Inverter U B I C R C I B R B U E U BE U A Ausgangsspannung in Abhängigkeit zur Eingangsspannung Übertragungskennlinie U A U E

5 5 TTL Ubertragungskennlinien U Q (Ausgang) Ausgang Eingang U H U QHmin 45 o H-Pegel U QHmin H-Pegel U IHmin U u U u U QLmax U L 45 o 45 o U QLmax L-Pegel UILmax L-Pegel U L UILmax U u U IHmin U H (Eingang) a) Übertragungskennlinie b) graphische Darstellung der Pegelbereiche

6 6 TTL Schaltkreise U B R 1 R 2 R 4 T1 E U 2 T 3 4 E 2 3 T 2 T 4 D 5 A U 1 U 3 R 3 U A Multi-Emitter (T 1 ) Normal-, Inversbetrieb (T 1 ) Gegentaktendstufe Hubdiode

7 Datasheet

8 8 Signallaufzeit U H I 50% L t U H Q 50% L t PHL t PLH t Schaltzeit eines Gatters (hier NOT-Gatter) Bezugspunkt: 50% des max. Pegels T PHL : propagation delay H L T PLH : propagation delay L H

9 9 Signalübergangszeit UI H L t a) idealer Rechteckimpuls am Eingang U Q H 90% L 10% t d tf ts tr t b) verformter Rechteckimpuls am Ausgang U Q H L tthl ttlh c) linearisierter Ausgangsimpuls Dauer eines Pegelwechsels Bezugspunkte: 10% und 90% des max. Pegels t d : delay time t f : fall time t s : storage time t r : rise time t THL : transition time H L t TLH : transition time L H

10 10 Fan in / Fan out Fan in Gatter einer Schaltkreisfamilie erzeugen an den vorgeschalteten Gattern eine definierte Last (Stromfluss) Gatter 1 Gatter 2 HIGH Pegel 40uA LOW Pegel -1,6mA Standard TTL: bei LOW Pegel: 1,6mA bei HIGH Pegel: 40µA Gatter die genau diese Last erzeugen, haben einen Fan in von 1 Fan out Gatter können mehrere weitere Gatter ansteuern Ein Fan out von 10 bedeutet, dass 10 Schaltglieder gleichzeitig angesteuert werden können, die einen Fan in von 1 haben (oder 5 mit einem Fan in von 2 usw.) Bei Überschreitung des Fan out, werden die Pegel nicht mehr garantiert

11 11 TTL Schaltkreisfamilien Standard TTL 74xx 10mW, 10ns LowPower TTL 74Lxx 1mW, 33ns High Speed TTL 74Fxx 8mW, 5ns LowPower Schottky TTL 74LSxx 2mW, 7ns High Speed CMOS TTL 74HCxx/74HCTxx 0, 0025mW, 8ns

12 12 Treiber Schalten einer externen Spannung V y prinzipieller Aufbau: V y E 1 Y E Y 0 0V 1 V y Blockschaltbild V y E Y

13 13 Treiber Treiberbaustein L 293 D V s 4A 4Y GND GND 3Y 3A EN EN1 1A 1Y GND GND 2Y 2A V y

14 14

15 15

16 16

17 Gleichstrom-Motor 17

18 18 H-Brückenschaltung Motorsteuerung Rechts-Links-Stop Aufbau aus zwei Treiberbausteinen V y V y V y E 0 E 1 1 M 1 E 0 M E 1 E 0 E 1 M 0 0 Stop 0 1 Rechts 1 0 Links 1 1 Stop Brückenschaltung mit Power-MOSFETs R1 1K8 Q7 IRF9540 Q8 IRF9540 R7 1K8 R2 Q4 BC R3 1K2 R4 2K2 Q3 BC Q1 MOTOR Q2 BC BC R10 2K2 R5 Q5 IRF540 Q6 IRF540 R6 5K6 R8 5K6 R9 1K2 1 V1/1 7402N V1/2 5 6 /EN D R12 R11 5K6 1K2 7402N 5K6 1K2

19 19 Schrittmotor prinzipieller Ablauf: Schritt 1 Schritt Schritt 3 Schritt Ansteuerung für eine Drehrichtung A B C D Schritt 1 L H L H Schritt 2 H L L H Schritt 3 H L H L Schritt 4 L H H L

20 20 Halbschritt Betrieb prinzipieller Ablauf: Schritt 1 Schritt 2 Schritt 3 Schritt Schritt 5 Schritt 6 Schritt 7 Schritt Ansteuerung für eine Drehrichtung A B C D Schritt 1 L H L L Schritt 2 L H L H Schritt 3 L L L H Schritt 4 H L L H Schritt 5 H L L L Schritt 6 H L H L Schritt 7 L L H L Schritt 8 L H H L

21 21 Servomotoren Verbindung aus Gleichstrommotor und Regelkreis fährt vorgebbare Positionen an Automatisches Halten dieser Position beliebt im Roboterbau: Servos aus dem Modellbaubereich Preiswert schnell hohes Drehmoment Positionsvorgabe über Pulsweite eines Rechtecksignals alle 20 ms ein Impuls zwischen 1ms und 2ms 1.5 ms entspricht der Mittelstellung

22 22 CISC Prozessoren Motivation für CICS Prozessoren langsamer, kleiner und teurer Hauptspeicher leistungsfähige Assemblerprogrammierung gefordert Ziel: Prozessor mit einem Befehl lange beschäftigen Eigenschaften der CISC Prozessoren umfangreicher Befehlssatz (Complex Instruction Set Computer) mächtige Befehle umfangreiche Adressierung Spezialregister (Accu, Indexregister,...) Microprogrammiert komplexes Steuerwerk, viel Chipfläche gegenläufige Bewegung Hochsprachen setzten sich durch Compiler nutzen nur eine Bruchteil aller Befehle Compiler nutzen Register intensiv Intel Untersuchung: 10 Befehle für 96% Code

23 23 RISC Prozessoren Ziel: durch vereinfachte Architektur preiswert Eigenschaften einfache Maschinenbefehle wenige Maschinenbefehle (Reduced Instruction Set Computer) möglichst einen Befehl pro Takt einfaches Steuerwerk, diskret aufgebaut einheitliche Befehlslänge z.b. 32 o. 64 Bit große Zahl allgemeiner Register (32 64) Zugriff auf Speicher nur über LOAD/STORE Befehle Load/Store Architektur sonst sind Operanden ausschließlich Register Befehls Pipelining optimierende Compiler nötig

24 24 RISC Prozessoren Ziel: durchschnittlich ein Befehl pro Takt abarbeiten nur durch parallele Bearbeitung mehrere Befehle möglich Prinzip: Fließband Pipelining Zerlegung eines Befehls in kleine Teilschritte Bearbeitung in hintereinander geschalteten Verarbeitungseinheiten Verarbeitungseinheiten taktsynchron Jede Einheit bearbeitet einen Teilschritt unterschiedlicher Befehle Verarbeitungseinheiten taktsynchron Zwischenspeicher (Latches) zwischen Verarbeitungseinheiten einheitliche Befehlslänge z.b. 32 o. 64 Bit Aufbau einer Pipeline Takt Eingabe Register VE 1 Register VE 2 Register VE n Ausgabe

25 25 Zerlegung eines Maschinenbefehls Zerlegung eines Machinenbefehls in 5 Mikroschritte IF Phase Instruction Fetch Befehl aus Speicher laden Increment PC ID Phase Instruction Decode übernahme ins Instruction Register Decodierung des Opcodes Operanden aus Registern holen EX Phase Execute/AdressCalculation Operanden zur ALU ALU berechnet Ergebniss bei Sprung Befehlen PC schreiben MEM-Phase Ergebniss aus ALU in Zwischenregister Nur für LOAD/STORE Befehle Speicherzugriff WB Phase Write Back Ergebnis ins Register schreiben

26 26 von EX Takt +4 PC IF ID EX MEM WB Opcode Adreßfeld A A Opcode- Dekoder D D EX MEM WB Daten D D Steuersignale ALU =0? D zu IF A D Schreibports des Registerblocks Befehlsspeicher Datenspeicher A D Leseports des Registerblocks Aufbau einer 5-stufigen Pipeline

27 27 Ausführung eines Maschinenbefehls Seriell: IF ID EX MEM WB IF ID EX MEM WB Pipeline: IF ID EX MEM WB IF ID EX MEM WB IF ID EX MEM WB IF ID EX MEM WB IF ID EX MEM WB Benötigte Takte für n Befehle mit je k Mikroschritten seriell: n k Takte Pipeline: k +n 1 Takte Speedup: S = n k k+n 1 = k k n +1 1 n Für n = k SCALARE Architektur

28 28 Pipelinekonflikte Pipeline Mikroschritte können voneinander abhängen Vier Arten von Pipelinekonflikten: Struktureller Konflikt zb. Gleichzeitiger Zugriff auf Speicher Datenflußkonflikt zb. warten auf Ergebniss einer vorherigen Operation Laufzeitkonflikt zb. warten auf vorherigen Speicherzugriff Steuerflußkonflikt zb. bei einer Verzweigung Behebung der Konflikte Pipeline Verarbeitung aussetzen Pipelinestufen nicht optimal ausgelastet Beseitigung der Konflikte zusätzliche Hardware optimierende Software

29 29 Strukturelle Konflikte Datenpfad oder Funktionseinheit werden von zwei Befehlen gleichzeitig benötigt LOAD IF ID EX MEM WB IF ID EX MEM WB IF ID EX MEM WB (NOP) NOP NOP NOP NOP NOP ADD IF ID EX MEM WB Gemeinsamer Daten /Befehlsspeicher MEM Phase und IF Phase eines nachfolgenden Befehls Behebung Aussetzen der Pipelineverarbeitung Getrennter Befehls und Daten Cache

30 30 Datenfluß und Laufzeitkonflikte Datenabhängigkeiten Read After Write (RAW) oder echte Datenabhängigkeit Write After Write (WAW) oder Ausgabe Datenabhängigkeit Write After Read (WAR) oder unechte Datenabhängigkeit Wert R3 gueltig Wert liegt an R3 an ADD R3,R2,R1 IF ID EX MEM WB Wert in R3 gespeichert (NOP) NOP NOP NOP NOP NOP (NOP) NOP NOP NOP NOP NOP (NOP) NOP NOP NOP NOP NOP ADD R5,R4,R3 IF ID EX MEM WB Wert aus R3 gelesen Behebung eines RAW Datenflußkonflikts Einfügen von NOPs Bypass Hardware (Rückkopplung des EX Segments) Laufzeitkonflikt bei Hauptspeicherzugriff MEM-Phase Dauer unbestimmt (Cache Miss) Takt sperren für Teile der Pipeline, bis Datum gültig

31 31 Steuerflußkonflikt Berechnung der Verzweigung bewirkt Verzögerung Neuer PC gueltig 1000: JNZ 1020 IF ID EX MEM WB 1004: (NOP) NOP NOP 1008: (NOP) NOP NOP 1020: ADD R5,R4,R3 IF ID EX MEM WB Behebung eines Steuerflusskonflikts Einfügen von NOPs branch prediction parallele Auswertung der möglichen Verzweigungen

32 32 optimierende Compiler Maschinenprogrammierung nicht sinnvoll Codegenerierung durch Compiler NOP durch konfliktfreie Befehle ersetzen Ziel: optimale Füllung der Pipeline Beispiel: Datenflusskonflikt vorher: 100: SUB R6,R2,R1 104: AND R5,R2,R1 108: ADD R3,R1,R2 10C: NOP 110: NOP 114: NOP 118: ADD R4,R1,R3 11C: XOR R6,R7,R8 nachher: 100: ADD R3,R1,R2 104: SUB R6,R2,R1 108: AND R5,R2,R1 10C: XOR R6,R7,R8 110: ADD R4,R1,R3

33 33 RISC Zusammenfassung Leistungssteigerung durch Pipelining Feinkörnige Parallelität ist für den Programmierer transparent Hardware kann besser ausgelastet werden höhere Taktraten möglich Compiler behebt Pipelinekonflikte Optimierende Compiler eliminieren NOPs Weiterentwicklung zu Superskalaren Prozessoren Paralleles Pipelining Dynamisches Befehlsscheduling Arithmetische-, Logische- und Gleitkomma Pipelines mehrere Verzweigungseinheiten mehrere LOAD/STORE Einheiten

34 34 Aufbau eines Mainboards: Mikrocontroller Peripherie Prozessor Speicher Integration der Baugruppen in einen Chip

35 35 v. Neumann vs. Harvard Von Neumann Architektur Harvard Architektur

36 36 AVR Controller 8-Bit RISC-Prozessor 2-stufige Pipeline 32 Register 1 Takt pro Maschinenbefehl bis zu 133 Maschinenbefehle Takt: 0-20 MHz Speicher Flash EPROM (Programm) EEPROM (nichtflüchtige Daten) statisches RAM Digitale Ports sonstige Peripherie interner Oszilator Analogkomparator und AD-Wandler asynchrone/synchrone serielle Interfaces (UART,SPI,TWI) 8/16 Bit Timer/Counter mit Pulsweitenmodulation (PWM) Watchdog Idle/Powerdown Mode (Stromsparprogramme) ausgezeichnete Dokumentation: kostenlose Entwicklungs/Simulationsumgebung Assembler und GNU-C unendliches Weiten des Webs

37 AVR Übersicht 37

38 38

39 39

40 40

41 41 ALU Alle Befehle 16Bit arithm. log. Operationen 1 Takt Speicherzugriffe 2-3 Takte (Speicherabhängig) Sprünge 2 Takte (selten 3 Takte) ISR und UP 4 Takte

42 42 Register 7 0 R0 R1 : : General Pupose Working Register R13 R14 R15 R16 R17 : : R26 R27 R28 R29 R30 R31 X-register Low Byte X-register High Byte Y-register Low Byte Y-register High Byte Z-Register Low Byte Z-register High Byte 15 XH XL 0 X-register 7 R R YH YL 0 Y-register 7 R R ZH ZL 0 Z-register 7 R R Arbeitsregister R0 R31 mit je 8 Bit R26 bis R31 bilden zudem drei 16 Bit Register (X,Y,Z) little endian format (Lowest Byte First) einige Befehle sind nicht auf die Register R0 R15 anwendbar RISC: alle Operationen über diese Register ADD R1,R2 ; Addition von R1 und R2, Ergebnis in R1

43 43 Spezialregister Statusregister 8-Bit Register Informationen zu vorhergegangen arithmetisch/logischen Operationen bedingte Sprünge Rechnen mit großen Zahlen temporäres Speichern eines Bits globale Interruptfreigabe/sperrung Stackpointer 16-Bit Register Pointer ins RAM Aufbau des Statusregister: 7 I Global Interrupt Enable 6 T Bit Copy Storage 5 H Half Carry Flag 4 S Sign Bit 3 V Two s Complement Overflow Flag 2 N Negative Flag 1 Z Zero Flag 0 C Carry Flag Programmcounter 13 Bit Register Pointer ins FLASH-Memory

44 44 Speicher und Speicherzugriff FLASH 16 KByte Flash Speicher Programme und Konstanten Zugriff mit LPM und SPM garantierte Schreib/Löschvorgänge SRAM 1024 Byte statisches RAM Variablen Zugriff mit LD und ST (LOAD and STORE) EEPROM 512 Byte EEPROM nichtflüchtige Daten Zugriff über spezielle EEPROM Register garantierte Schreib/Löschvorgänge Peripherie Register 60 8-Bit Register Kontrolle und Status der Peripherie Zugriff über IN und OUT Alternativ über RAM (LD/ST)

45 45 Memory Adressierung alle vier Speicher haben getrennte Adressräume möglich durch unterschiedliche Zugriffsbefehle Besonderheit: Adressierung des RAM Beginn des eigentlichen Speichers erst an Adresse 0x60

46 46 Mnemonics Operands Description Operation Flags #C Arithmetische Operatoren ADD Rd, Rr Add two Registers Rd Rd+Rr Z,C,N,V,H 1 ADC Rd, Rr Add with Carry two Registers Rd Rd+Rr+C Z,C,N,V,H 1 ADIW Rdl,K Add Immediate to Word Rdh:Rdl Rdh:Rdl+K Z,C,N,V,S 2 SUB Rd, Rr Subtract two Registers Rd Rd - Rr Z,C,N,V,H 1 SUBI Rd, K Subtract Constant from Register Rd Rd - K Z,C,N,V,H 1 SBC Rd, Rr Subtract with Carry two Registers Rd Rd - Rr - C Z,C,N,V,H 1 SBCI Rd, K Subtract with Carry Constant from Reg. Rd Rd - K - C Z,C,N,V,H 1 SBIW Rdl,K Subtract Immediate from Word Rdh:Rdl Rdh:Rdl - K Z,C,N,V,S 2 AND Rd, Rr Logical AND Registers Rd Rd Rr Z,N,V 1 ANDI Rd, K Logical AND Register and Constant Rd Rd K Z,N,V 1 OR Rd, Rr Logical OR Registers Rd Rd Rr Z,N,V 1 ORI Rd, K Logical OR Register and Constant Rd Rd K Z,N,V 1 EOR Rd, Rr Exclusive OR Registers Rd Rd Rr Z,N,V 1 COM Rd One s Complement Rd 0xFF - Rd Z,C,N,V 1 NEG Rd Two s Complement Rd 0x00 - Rd Z,C,N,V,H 1 SBR Rd,K Set Bit(s) in Register Rd Rd K Z,N,V 1 CBR Rd,K Clear Bit(s) in Register Rd Rd (0xFF - K) Z,N,V 1 INC Rd Increment Rd Rd+1 Z,N,V 1 DEC Rd Decrement Rd Rd - 1 Z,N,V 1 TST Rd Test for Zero or Minus Rd Rd Rd Z,N,V 1 CLR Rd Clear Register Rd Rd Rd Z,N,V 1 SER Rd Set Register Rd 0xFF None 1 MUL Rd, Rr Multiply Unsigned R1:R0 Rd x Rr Z,C 2 MULS Rd, Rr Multiply Signed R1:R0 Rd x Rr Z,C 2 MULSU Rd, Rr Multiply Signed with Unsigned R1:R0 Rd x Rr Z,C 2 FMUL Rd, Rr Fractional Multiply Unsigned R1:R0 (Rd x Rr) << 1 Z,C 2 FMULS Rd, Rr Fractional Multiply Signed R1:R0 (Rd x Rr) << 1 Z,C 2 FMULSU Rd, Rr Fractional Multiply Signed with Unsigned R1:R0 (Rd x Rr) << 1 Z,C 2 BRANCH INSTRUCTIONS RJMP k Relative Jump PC PC+k+1 None 2 IJMP Indirect Jump to (Z) PC Z None 2 JMP k Direct Jump PC k None 3 RCALL k Relative Subroutine Call PC PC+k+1 None 3 ICALL Indirect Call to (Z) PC Z None 3 CALL k Direct Subroutine Call PC k None 4 RET Subroutine Return PC STACK None 4 RETI Interrupt Return PC STACK I 4 CPSE Rd,Rr Compare, Skip if Equal if (Rd = Rr) PC PC+2 or 3 None 1,2,3 CP Rd,Rr Compare Rd - Rr Z,N,V,C,H 1 CPC Rd,Rr Compare with Carry Rd - Rr - C Z,N,V,C,H 1 CPI Rd,K Compare Register with Immediate Rd - K Z,N,V,C,H 1 SBRC Rr, b Skip if Bit in Register Cleared if(rr(b)=0) PC PC+2 or 3 None 1,2,3 SBRS Rr, b Skip if Bit in Register is Set if(rr(b)=1) PC PC+2 or 3 None 1,2,3 SBIC P, b Skip if Bit in I/O Register Cleared if(p(b)=0) PC PC+2 or 3 None 1,2,3 SBIS P, b Skip if Bit in I/O Register is Set if(p(b)=1) PC PC+2 or 3 None 1,2,3 BRBS s, k Branch if Status Flag Set if(sreg(s)=1) PC PC+k+1 None 1,2 BRBC s, k Branch if Status Flag Cleared if(sreg(s)=0) PC PC+k+1 None 1,2 BREQ k Branch if Equal if(z=1) PC PC+k+1 None 1,2 BRNE k Branch if Not Equal if(z=0) PC PC+k+1 None 1,2 BRCS k Branch if Carry Set if(c=1) PC PC+k+1 None 1,2 BRCC k Branch if Carry Cleared if(c=0) PC PC+k+1 None 1,2 BRSH k Branch if Same or Higher if(c=0) PC PC+k+1 None 1,2 BRLO k Branch if Lower if(c=1) PC PC+k+1 None 1,2 BRMI k Branch if Minus if(n=1) PC PC+k+1 None 1,2 BRPL k Branch if Plus if(n=0) PC PC+k+1 None 1,2 BRGE k Branch if Greater or Equal, Signed if(n V=0) PC PC+k+1 None 1,2 BRLT k Branch if Less Than Zero, Signed if(n V=1) PC PC+k+1 None 1,2 BRHS k Branch if Half Carry Flag Set if(h=1) PC PC+k+1 None 1,2 BRHC k Branch if Half Carry Flag Cleared if(h=0) PC PC+k+1 None 1,2 BRTS k Branch if T Flag Set if(t=1) PC PC+k+1 None 1,2 BRTC k Branch if T Flag Cleared if(t=0) PC PC+k+1 None 1,2 BRVS k Branch if Overflow Flag is Set if(v=1) PC PC+k+1 None 1,2 BRVC k Branch if Overflow Flag is Cleared if(v=0) PC PC+k+1 None 1,2 BRIE k Branch if Interrupt Enabled if(i=1) PC PC+k+1 None 1,2 BRID k Branch if Interrupt Disabled if(i=0) PC PC+k+1 None 1,2

47 47 Mnemonics Operands Description Operation Flags #C DATA TRANSFER INSTRUCTIONS MOV Rd, Rr Move Between Registers Rd Rr None 1 MOVW Rd, Rr Copy Register Word Rd+1:Rd Rr+1:Rr None 1 LDI Rd, K Load Immediate Rd K None 1 LD Rd, X Load Indirect Rd (X) None 2 LD Rd, X+ Load Indirect and Post-Inc. Rd (X), X X + 1 None 2 LD Rd, - X Load Indirect and Pre-Dec. X X - 1, Rd (X) None 2 LD Rd, Y Load Indirect Rd (Y) None 2 LD Rd, Y+ Load Indirect and Post-Inc. Rd (Y), Y Y + 1 None 2 LD Rd, - Y Load Indirect and Pre-Dec. Y Y - 1, Rd (Y) None 2 LDD Rd,Y+q Load Indirect with Displacement Rd (Y + q) None 2 LD Rd, Z Load Indirect Rd (Z) None 2 LD Rd, Z+ Load Indirect and Post-Inc. Rd (Z), Z Z+1 None 2 LD Rd, -Z Load Indirect and Pre-Dec. Z Z - 1, Rd (Z) None 2 LDD Rd, Z+q Load Indirect with Displacement Rd (Z + q) None 2 LDS Rd, k Load Direct from SRAM Rd (k) None 2 ST X, Rr Store Indirect (X) Rr None 2 ST X+, Rr Store Indirect and Post-Inc. (X) Rr, X X + 1 None 2 ST - X, Rr Store Indirect and Pre-Dec. X X - 1, (X) Rr None 2 ST Y, Rr Store Indirect (Y) Rr None 2 ST Y+, Rr Store Indirect and Post-Inc. (Y) Rr, Y Y + 1 None 2 ST - Y, Rr Store Indirect and Pre-Dec. Y Y - 1, (Y) Rr None 2 STD Y+q,Rr Store Indirect with Displacement (Y + q) Rr None 2 ST Z, Rr Store Indirect (Z) Rr None 2 ST Z+, Rr Store Indirect and Post-Inc. (Z) Rr, Z Z + 1 None 2 ST -Z, Rr Store Indirect and Pre-Dec. Z Z - 1, (Z) Rr None 2 STD Z+q,Rr Store Indirect with Displacement (Z + q) Rr None 2 STS k, Rr Store Direct to SRAM (k) Rr None 2 LPM Load Program Memory R0 (Z) None 3 LPM Rd, Z Load Program Memory Rd (Z) None 3 LPM Rd, Z+ Load Program Mem. and Post-Inc Rd (Z), Z Z+1 None 3 SPM Store Program Memory (Z) R1:R0 None - IN Rd, P In Port Rd P None 1 OUT P, Rr Out Port P Rr None 1 PUSH Rr Push Register on Stack STACK Rr None 2 POP Rd Pop Register from Stack Rd STACK None 2 BIT AND BIT-TEST INSTRUCTIONS SBI P,b Set Bit in I/O Register I/O(P,b) 1 None 2 CBI P,b Clear Bit in I/O Register I/O(P,b) 0 None 2 LSL Rd Logical Shift Left Rd(n+1) Rd(n), Rd(0) 0 Z,C,N,V 1 LSR Rd Logical Shift Right Rd(n) Rd(n+1), Rd(7) 0 Z,C,N,V 1 ROL Rd Rotate Left Through Carry Rd(0) C,Rd(n+1) Rd(n),C Rd(7) Z,C,N,V 1 ROR Rd Rotate Right Through Carry Rd(7) C,Rd(n) Rd(n+1),C Rd(0) Z,C,N,V 1 ASR Rd Arithmetic Shift Right Rd(n) Rd(n+1), n=0..6 Z,C,N,V 1 SWAP Rd Swap Nibbles Rd(3..0) Rd(7..4),Rd(7..4) Rd(3..0) None 1 BSET s Flag Set SREG(s) 1 SREG(s) 1 BCLR s Flag Clear SREG(s) 0 SREG(s) 1 BST Rr, b Bit Store from Register to T T Rr(b) T 1 BLD Rd, b Bit load from T to Register Rd(b) T None 1 SEC Set Carry C 1 C 1 CLC Clear Carry C 0 C 1 SEN Set Negative Flag N 1 N 1 CLN Clear Negative Flag N 0 N 1 SEZ Set Zero Flag Z 1 Z 1 CLZ Clear Zero Flag Z 0 Z 1 SEI Global Interrupt Enable I 1 I 1 CLI Global Interrupt Disable I 0 I 1 SES Set Signed Test Flag S 1 S 1 CLS Clear Signed Test Flag S 0 S 1 SEV Set Twos Complement Overflow. V 1 V 1 CLV Clear Twos Complement Overflow V 0 V 1 SET Set T in SREG T 1 T 1 CLT Clear T in SREG T 0 T 1 SEH Set Half Carry Flag in SREG H 1 H 1 CLH Clear Half Carry Flag in SREG H 0 H 1 MCU CONTROL INSTRUCTIONS NOP No Operation None 1 SLEEP Sleep (see specific descr. for Sleep function) None 1 WDR Watchdog Reset (see specific descr. for WDR/timer) None 1 BREAK Break For On-Chip Debug Only None N/A

48 48 Maschinencode RISC alle Befehle sind gleich lang (AVR: 16 Bit) ADD Rd, Rr rd dddd rrrr EOR Rd, Rr rd dddd rrrr ADIW Rd+1:Rd,K KKdd KKKK d {24,26,28,30},0 K Bit Operation, 2 Takte RJMP k 1100 kkkk kkkk kkkk 2K k 2K 16 Bit Operation, 2 Takte JMP k k kkkk 110k kkkk kkkk kkkk kkkk 0 k 4M 32 Bit Befehl, 16 Bit Operation, 3 Takte CLR Rd dd dddd dddd vgl. EOR BRBC (BRBS) s, k sind die grundlegenden bedingten Sprungbefehle BSET (BCLR) s, sind die grundlegenden Bitmanipulationen im Statusregister 133 Maschinenbefehle sind glatt gelogen!

49 49 I/O I/O Logik an jedem digitalen Pin jeder I/O Pin kann individuell konfiguriert werden DDRx, PORTx, Pinx sind je 8 Bit breit(x=a,b,c,d) Steuern zusammen je 8 I/O Pins des AVR

50 50 I/O 3 Register: Data Direction, Port, Pin Data Direction Register DDRx 1: Output 0: Input Port Register PORTx Output: Schreiben ins PORT Register setzt Pegel am Ausgang Pin Register PINx anliegender Pegel kann im Pin Register gelesen werden Sonderfunktion des Port Register bei Input schreiben einer 1 schaltet Pullups hinzu ohne Pullups: Tristate DDR Port Pin 0 0 Input (Tristate) 0 1 Input mit Pullup 1 0 Output Output 1

51 51 8 Bit Inverter in Assembler I/O Beispiel ; die folgende Zeile sollen immer in einem Asssembler ; programm vorhanden sein. Sie definiert die ; IO-Port-Adressen zu lesbaren Namen.include "m16def.inc" ; wir wollen an PortA das ; Komplement von PortB ausgeben ; Port A: Ausgabe ldi r16,0xff out DDRA,r16 ; Port B: Eingabe ldi r16,0x00 out DDRB,r16 ldi r16,0xff out PORTB,r16 ; alle Pins an Port A ; als Output konfigurieren ; alle Pins an Port B ; als Input konfigurieren ; und die Pullup Widerstaende ; dazuschalten loop: in r16,pinb ; Eingabe in Register R16 einlesen com r16 ; R16 Einerkomplementbildung out PORTA,r16 ; Ausgabe auf PortA rjmp loop ; und Endlosschleife 8 Bit Inverter in C #include <avr/io.h> int main() { DDRA = 0xFF; DDRB = 0x00; PORTB = 0xFF; } while(1) PORTA = ~(PINB);

52 52 Tabellen in C Version A: Tabelle im RAM #include <avr/io.h> unsigned char TABELLE[16] = {0x7E,0x30,0x6D,0x79,0x33,0x5B,0x5F,0x70, 0x7F,0x7B,0x77,0x1F,0x4E,0x3D,0x4F,0x47}; int main() { DDRA = 0xFF; DDRC = 0x00; PORTC = 0xFF; } while(1) PORTA=TABELLE[PINC & 0x0F]; Version B: Tabelle im FLASH #include <avr/io.h> #include <avr/pgmspace.h> prog_uchar TABELLE[16] = {0x7E,0x30,0x6D,0x79,0x33,0x5B,0x5F,0x70, 0x7F,0x7B,0x77,0x1F,0x4E,0x3D,0x4F,0x47}; int main() { DDRA = 0xFF; DDRC = 0x00; PORTC = 0xFF; } while(1) PORTA=pgm_read_byte(TABELLE+(PINC & 0x0F));

53 53 Unterprogramme Eigenschaften abgeschlossene Befehlsfolge beliebig aufrufbar korrekter Rücksprung Parameter und Rückgabewerte Stackpointer 16 Bit Adressregister Initialisierung Aufruf des UP: CALL < adr > (SP ) = ++PC;PC = adr Rückkehr ins Hauptprogramm: RET PC = (++SP)

54 54 AVR-Stackpointer 16 Bit Register Zeiger in einen LIFO speichert Rücksprungadressen bei Unterprogrammen und Interruptroutinen temp. Datenspeicher muss initialisiert werden Pointer in das statische RAM idealerweise ans RAM-Ende, da der Stack nach unten wächst Stackoperatoren PUSH <reg> Inhalt des Registers auf den Stack Stackpointer decrementieren POP <reg> Stackpointer incrementieren Akt. Inhalt des Stack ins Register ldi r16,low(ramend) out SPL,r16 ldi r16,high(ramend) out SPH,r16 ldi r20,0x0f push r20 pop r21 ; Stackpointer initialisieren ; Register fuellen ; Inhalt auf den Stack ; r21 ist nun 0x0F

55 55 Registerinhalte keine Restaurierung disjunkte Registernutzung Vom Hauptprogramm Kenntniss über das UP wenig Aufwand Vom UP alle im UP benutzten Register transparent im HP Beispiel: UP benutzt r16,r24,r25 UP: ret push r16 push r24 push r25 : UP Code : pop r25 pop r24 pop r16

56 56 Parameter u. Rückgabe in Registern schnell laden der Register entfällt beschränkte Anzahl Hauptspeicher (feste Adresse) langsam unbeschränkte Anzahl konstante (und bekannte) Adresse keine Rekursion Stack langsam unbeschränkte Anzahl aufwändige Programmierung Parameter hinter Rücksprungadresse verborgen Stack muss aufgeräumt werden

57 57 Beispiel: Zeitschleife Unterprogramm zur Zeitverzögerung: delay: push r16 push r24 push r25 loop2: ; äussere Schleife ueber Parameter r16 ldi r24,0xd0 ; innere 16 Bit Schleife ldi r25,0x07 ; über r25:r24 loop1: ; benoetigt sbiw r25:r24,1 ; ziemlich genau 1 ms brne loop1 ; aber nur ziemlich ;-) dec r16 ; wieviele ms? brne loop2 ; genug gewartet? dann zurück pop r25 pop r24 pop r16 ret innere Schleife r25:r24 ca. 1msec äußere Schleife r16 Parameterübergabe r16 Aufruf im Hauptprogramm: ldi r16,high(ramend) out SPH,r16 ldi r16,low(ramend) out SPL,r16 : ldi r16,0x0a rcall delay ; Stack initialisieren ; 10 ms ; delay

58 58 Parameter in C Compilerabhängig GCC: Parameter und Rückgabe in Registern default 16Bit, daher Registerpaare Parameter ab R24:R25 abwärts Rückgabe immer in R24:R25 int sum (int x, int y) { return(x+y); } main() { int erg,x,y; } x=43; y=127; erg = sum(x,y); in Maschinensprache int sum (int x, int y) { return(x+y); ADD R24,R22 in R22,23 ist x, in R24,25 y ADC R25,R23 Ergebniss in R24:25 RET } main() { x=43; } y=127; LDI R22,0x2B 16 Bit Zahlen mit Konstanten LDI R23,0x00 fuellen, erst X LDI R24,0x7F dann y LDI R25,0x00 dabei R22-25 nutzen als Parameter erg = sum(x,y); CALL 0x004F Unterprogrammaufruf Adresse 0x004F erg= R24,25

59 59 Einführung in C Anfang der 70er Jahre (Dennis Ritchie) Hardwarenahe Sprache kaum Compilerunterstützung kein Speicherschutz kein Garbage Collector Kann chaotisch programmiert werden International Obfuscated C Code Contest 1990 winner: Basic Interpreter #define O(b,f,u,s,c,a)b(){int o=f();switch(*p++){x u:_ o s b();x c:_ o a b();\ default:p--;_ o;}} #define t(e,d,_,c)x e:f=fopen(b+d,_);c;fclose(f) #define U(y,z)while(p=Q(s,y))*p++=z,*p= #define N for(i=0;i<11*r;i++)m[i]&& #define I "%d %s\n",i,m[i] #define X ;break;case #define _ return #define R 999 typedef char*a;int*c,e[r],l[r],m[r],p[r],l,i,j;char B[R],F[2];A m[12*r],malloc (),p,q,x,y,z,s,d,f,fopen();a Q(s,o)A s,o;{for(x=s;*x;x++){for(y=x,z=o;*z&&*y== *z;y++)z++;if(z>o&&!*z)_ x;}_ 0;}main(){m[11*R]="E";while(puts("Ok"),gets(B) )switch(*b){x R :C=E;l=1;for(i=0;i<R;P[i++]=0);while(l){while(!(s=m[l]))l++;if (!Q(s,"\"")){U("<>", # );U("<=", $ );U(">=",! );}d=b;while(*f=*s){*s== " &&j ++;if(j&1!q(" \t",f))*d++=*s;s++;}*d--=j=0;if(b[1]!= = )switch(*b){x E :l=-1 X R :B[2]!= M &&(l=*--c)x I :B[1]== N?gets(p=B),P[*d]=S():(*(q=Q(B,"TH"))=0,p =B+2,S()&&(p=q+4,l=S()-1))X P :B[5]== "?*d=0,puts(b+6):(p=b+5,printf("%d\n",s ()))X G :p=b+4,b[2]== S &&(*C++=l,p++),l=S()-1 X F :*(q=q(b,"to"))=0;p=b+5;p[i =B[3]]=S();p=q+2;M[i]=S();L[i]=l X N :++P[*d]<=M[*d]&&(l=L[*d]);}else p=b+2,p[ *B]=S();l++;}X L :N printf(i)x N :N free(m[i]),m[i]=0 X B :_ 0 t( S,5,"w",N fprintf(f,i))t( O,4,"r",while(fgets(B,R,f))(*Q(B,"\n")=0,G()))X 0:default:G() ;}_ 0;}G(){l=atoi(B);m[l]&&free(m[l]);(p=Q(B," "))?strcpy(m[l]=malloc(strlen(p )),p+1):(m[l]=0,0);}o(s,j, =,==, #,!=)O(J,K, <,<, >,>)O(K,V, $,<=,!,>=) O(V,W, +,+, -,-)O(W,Y, *,*, /,/)Y(){int o;_*p== -?p++,-y():*p>= 0 &&*p<= 9?strtol(p,&p,0):*p== (?p++,o=s(),p++,o:p[*p++];}

60 60 Einführung in C eine der häufigst verwendeten Sprachen Syntax wurde von JAVA weitestgehend übernommen nicht Objektorientiert(!) Objektkonzepte in C++ Ein erstes Programm: /**************************************** * Ein erstes Programm: Hello, World! *****************************************/ #include <stdio.h> int main () { printf ("Hello, World!\n"); return (0); } Schlüsselworte in C: auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while

61 61 Datentypen arithmetische Datentypen Typ Größe (unsigned) char 1 Byte (unsigned) short 2 Byte (unsigned) int 2 oder 4 Byte (unsigned) long 4 Byte float 4 Byte double 8 Byte long double 8,10 oder 16 Byte boole sche Datentyp keinen gesonderten booleschen Typ ganzzahliger Wert == 0 FALSE ganzzahliger Wert!= 0 TRUE Endlosschleife while(1); Zeichen char: 1 Zeichen char[n]: n-1 Zeichen in C ist ein String immer null-terminiert x : 1 Byte x : 2 Byte Arrays mit allen Datentypen möglich Bsp: int d[n] n-stelliges Integerarray d[0] - d[n-1]

62 62 Operatoren Unterscheidung: Bitweise vs. Logische Operation Operation Bitweise Logisch UND & && ODER NOT! XOR ˆ LEFT SHIFT << RIGHT SHIFT >> Beispiele char a = 0xE4; /* */ char b = 0xAA; /* */ Bitweise UND char r = a & b; /* */ Bitweise ODER char r = a b; /* */ Bitweise NOT char r = a; /* */ Bitweise XOR char r = a ˆ b; /* */ LEFT SHIFT char r = a << 1; /* */ RIGHT SHIFT char r = a >> 1; /* */ Logisches UND char r = a && b; /* */ Logisches ODER char r = a b; /* */ Logisches NOT char r =!a; /* */

63 63 Kontrollstrukturen syntaktisch mit JAVA identisch if-, if-else-anweisung switch-anweisung while-anweisung for-anweisung do-while-anweisung spezielle Anweisungen break-, continue-anweisung break: Abbruch einer Schleife continue: Sprung zum Schleifenbeginn goto-anweisung unbedingter Sprung

64 64 Zeiger (Pointer) int n; Speicherbereich für eine Integervariable n n = 10; weist n den Wert 10 zu int *ptr Speicherbereich für einen Zeiger in den Speicher ptr = 10 ptr zeigt nun auf Speicheradresse 10 ptr = &n; Zeiger zeigt nun auf die Variable n &n liefert die Adresse der Variablen n (Referenzierung) *ptr = 20; weist n den Wert 20 zu *ptr liefert die Variable des Zeigers zurück (Dereferenzierung) int k[10]; Zeiger auf einen Speicherbereich von 10 Integervariablen *k=15 weist dem ersten Element des Arrays den Wert 15 zu identisch mit: k[0]=15; main() { char str[]="hello World"; char *ptr=str; } while(*ptr) puts(*ptr++); // puts: zeichenweise Ausgabe

65 65 Funktionen Funktionen Methoden in JAVA nicht an ein Objekt gebunden Parameter call by value call by reference call by value Wert einer Variablen wird übergeben (Kopie) im aufrufenden Programm bleibt Variable unverändert swap(int a, int b) { int tmp; tmp=a; a=b; b=tmp } sinnlos, da a,b im aufrufenden Programm unverändert bleiben call by reference Adresse der Variablen wird übergeben (keine Kopie) Folge: Überschreiben der Variable global gültig Seiteneffekt RICHTIG: swap(int *a, int *b) { int tmp; } tmp=*a; *a=*b; *b=tmp

66 66 Variablen statische Speicherverwaltung: globale Variablen werden ausserhalb von main() definiert belegen immer Platz im Hauptspeicher durch schreibenden Zugriff: Seiteneffekt lokale Variablen Belegen (soweit möglich) nur Register bei rekursiver Nutzung: Speicherung alter Werte auf dem Stack bei Registermangel: Hauptspeicher statische Variablen lokale Variablen mit statischen Werten belegen immer Platz im Hauptspeicher werden zu Programmstart initialisiert unsigned char itertiefe; // globale variable unsigned char sum(unsigned char start, unsigned char end) { // start,end: lokale Variablen(rekursiv) static unsigned char cnt=0; // lokale statische Variable itertiefe = ++cnt; } if (start==end) return end; else return(start + sum(start+1,end)); int main() { unsigned char start=1,end=5;// lokale variablen } printf("sum %d bis %d = %d Iterartionstiefe = %d\n", start, end, sum(start,end), itertiefe);

67 67 dynamische Speicherverwaltung relevante Funktionen: char* malloc(int size) liefert einen Pointer auf einen reservierten Speicherbereich der Grösse size (in Byte) char* realloc(void *ptr, int size) verändert die Größe eines reservierten Speicherbereichs void free(void* ptr) gibt Speicherbereich wieder frei statische vs. dynamische Speicherreservierung statische Reservierung char x[k]; x: K reserviert K Byte im RAM (.bss segment) Größe fix Zugriff: x[i], 0 i < K dynamische Reservierung char *x; x=(char*)malloc(k); x: K reserviert K Byte im RAM (heap) Größe variabel (realloc) Zugriff: x[i], 0 i < K

68 68 dynamische Speicherverwaltung Datentypen > 1 Byte statisch short x[k]; Zugriff: x[i], 0 i < K K (2K Byte) x: dynamisch short *x; x=(short*)malloc(k * sizeof(short)); Zugriff: x[i], 0 i < K x: K (2K Byte)

69 69 zweidimensionale Arrays statische Reservierung char x[n][k]; K x: : : N reserviert N*K Byte im.bss segment Größe fix in beiden Dimensionen Zugriff: x[i][j], 0 i < N,0 j < K teildynamische Reservierung char *x[n]; for(i=0;i<n;i++) x[i]=(char*)malloc(k); K x: N : : : : reserviert N*sizeof(char*) Byte im.bss Segment reserviert N*K Byte im heap 1. Dimension fix 2. Dimension variabel Zugriff: x[i][j], 0 i < N,0 j < K

70 70 zweidimensionale Arrays dynamische Reservierung char **x; x=(char**)malloc(n*sizeof(char*)); for(i=0;i<n;i++) x[i]=(char*)malloc(k); x: K N : : : : reserviert N*sizeof(char*)+N*K Byte im heap Größe in beide Dimensionen variabel (realloc) Zugriff: x[i][j], 0 i < N,0 j < K Freigabe Achtung: free(x); genügt nicht! es müssen vorher alle x[i] freigegeben werden mehrdimensionale Array analog statisch und dynamisch möglich Mischformen möglich

71 71 Speicherverwaltung im AVR sehr kleiner Hauptspeicher (RAM) Variablen Stack Rest für dynamische Größen (Heap) RAM.data.bss heap stack (Variablen).data segment beinhaltet initialisierte Variablen benötigt denselben Platz im Flash für die initialen Werte int i=0;.bss Segment beinhaltet nicht initialisierte Variablen int i; Stack Rücksprungadressen Parameter und Sicherungskopien der Register lokale Variablen Heap Rest für dynamische Speicheranforderungen Kollisionsgefahr Heap Stack Speicheranforderung gefährdet nie den Stack aber: Stack kann den Heap überschreiben

72 72 Speicherverwaltung reservierte und freie Speicherblöcke müssen verwaltet werden Anfang und Länge eines Speicherblocks müssen bekannt sein Anfang wird durch den Returnwert von malloc repräsentiert Länge steht im Speicher vor dem reservierten Block (+2 Byte) char *ptr=malloc(10); ptr: 0 A 2 10 Freie Speicherblöcke werden in einer freelist verwaltet keine eigene Struktur freelist innerhalb der Blöcke realisiert ersten zwei Byte: Pointer auf den nächsten freien Block a = malloc(5); b = malloc(5); c = malloc(5); a: b: c: freelist = free(a); free(c); b: freelist RAM Adressen A 1B 1C 1D 1E 1F 20 21

73 73 serielle Schnittstelle UART-Universal Asynchronous serial Receiver and Transmitter serielle Kommunikationsstrecke ohne Takt (asynchron) Zeichenorientiert, jedes Zeichen in einem Frame: 1 Startbit 5-9 Datenbits optionales Paritätsbit 1-2 Stopbits Übertragungsraten bis 2MBit/s bidirektional, gleichzeitiges Senden und Empfangen 3 Leitungen TXD, RXD, GND TTL-Pegel log. 1=5V, log. 0=0V RS-232 (UART des PCs) dieselben Konfigurationen möglich Hardware Handshake möglich (2 weitere Leitungen) bis max Bit/s Achtung: andere Pegel log. 1=-12V, log 0=12V

74 74 UART Timingbeispiel für: 8 Datenbit Paritätsbit odd 1 Stopbit Pegel: obere Kurve MCU untere Kurve PC Pegelanpassung durch MAX Konverter: 0V auf 12 V bzw. 5V auf -12 V interne Spannungserzeugung

75 75 Register der UART UDR Register Doppelregister zum Senden und Empfangen Schreiben ins UDR löst eine Übertragung aus UCSRA (USART Control and Status Register A) Bit: Name: RXC TXC UDRE FE DOR PE U2X MPCM RXC (USART Receive Complete) Zeigt an, dass ein Zeichen empfangen wurde TXC (USART Transmit Complete) Zeigt an, dass ein Sendevorgang abgeschlossen wurde. UDRE (USART Data Register Empty) Zeigt an, dass UDR-Register leer ist. FE (Framing Error) Frame-Fehler beim Datenempfang. DOR (Data OverRun) Ein Datenüberlauf ist eingetreten PE (Parity Error) ein Parity Fehler ist aufgetreten U2X (Double the USART Transmission Speed) doppelte Übertragungsgeschwindigkeit einschalten MPCM (Multiprocessor Communication Mode) im synchronen Mode, mehrere Empfänger

76 76 Register der UART UCSRB (USART Control and Status Register B) Bit: Name: RXCIE TXCIE UDRIE RXEN TXEN UCSZ2 RXB8 TXB8 RXCIE (RX Complete Interrupt Enable) Interrupt bei abgeschlossenem Empfang einschalten TXCIE (TX Complete Interrupt Enable) Interrupt bei abgeschlossenem Sendevorgang einschalten UDRIE (USART Data Register Empty Interrupt Enable) Interrupt bei leerem UDR einschalten RXEN (Receiver Enable) Empfangseinheit der UART einschalten TXEN (Transmitter Enable) Sendeeinheit der UART einschalten UCSZ2 (9 Bit Characters) 9-Bit Transfer einschalten RXB8 (Receive Data Bit 8) enthält das 9-te Empfangsbit TXB8 (Transmit Data Bit 8) enthält das 9-te Sendebit

77 77 Register der UART UCSRC (USART Control and Status Register C) Bit: Name: URSEL UMSEL UPM1 UPM0 USBS UCSZ1 UCSZ0 UCPOL URSEL (Register Select) sollte 1 sein, wenn in UCSRC geschrieben wird UMSEL (USART Mode Select) schaltet den synchronen Modus ein UPM1/0 (Parity Mode) USBS (Stop Bit Select) UPM1 UPM0 Parity Mode 0 0 Disabled 0 1 Reserved 1 0 Even Parity 1 1 Odd Parity Anzahl Stopbits (0=1,1=2) UCSZ1/0 (Charakter Size) UCSZ2 UCSZ1 UCSZ0 Character Size Bit Bit Bit Bit 1 x x Reserved Bit UCPOL (Clock Polarity) Datum bei fallender Taktflanke (synchroner Modus)

78 78 Register der UART UBRRL, UBRRH (USART Baud Rate Register) Bit: UBRRH URSEL USRR11 UBRR10 UBRR9 UBRR8 UBRRL UBRR7 UBRR6 UBRR5 UBRR4 UBRR3 UBRR2 UBRR1 UBRR0 Achtung Das UCSRC teilt sich intern mit dem UBRRH Register dieselbe Adresse. Ist URSEL=0 wird das UBRRH Register angesprochen, bei URSEL=1 das UCSRC Register. URSEL (Register Select) sollte 0 sein, wenn in UBRRH geschrieben wird UBRRx USART Baud Rate Register Taktteiler, die die Baudrate festlegt BAUD = F CPU 16(UBRR+1) typische Baudraten bei 8 MHz: UBRR = F CPU 16BAUD 1 U2X=0 bps UBRR Error ,2% ,2% ,2% 19,2K 25 0,2% 38,4K 12 0,2% 57,6K 8-3,5% 115,2K 3 8,5% 230,4K 1 8,5%

79 79 ASM Programmierung der UART.include "m16def.inc".equ F_CPU = equ BAUD = equ UBRR = F_CPU/16/BAUD-1 jmp main uart_init: push r16 ldi r16,(1<<rxen) (1<<TXEN) out UCSRB,r16 ldi r16,(1<<ursel) (3<<UCSZ0) out UCSRC,r16 ldi r16,high(ubrr) out UBRRH,r16 ldi r16,low(ubrr) out UBRRL,r16 pop r16 ret uart_send: sbis UCSRA,UDRE jmp uart_send out UDR,r16 ret uart_recv: sbis UCSRA,RXC jmp uart_recv in r16, UDR ret main: ldi r16,high(ramend) out SPH, r16 ldi r16,low(ramend) out SPL,r16 ; save regs ; enable tx and rx ; 8Bit character size, 1 stopbit ; Baudrate at 8 MHz ; restore regs ; send r16 ; wait for UDR empty ; send ; returns val in r16 ; wait for revieve complete ; save to r16 ; dont forget stack;-) L1: call uart_init call uart_recv L2: call uart_send dec r16 brne L2 rjmp L1

80 80 C Programmierung der UART lese n von UART sende n, n-1,..,1 über UART #include <avr/io.h> #define F_CPU #define BAUD #define UBRR F_CPU/16/BAUD-1 void UART_Init( unsigned int ubrr ) { UCSRB = (1<<RXEN) (1<<TXEN); // enable RXD,TXD UCSRC = (1<<URSEL) (1<<UCSZ1) (1<<UCSZ0); // 8Bit, 1Stopbit UBRRH = (unsigned char)(ubrr>>8); // set UART Clock UBRRL = (unsigned char)ubrr; } void UART_Send(char data) { while (!( UCSRA & (1<<UDRE))); UDR = data; } unsigned char UART_Recv() { while (!(UCSRA & (1<<RXC))); return UDR; } // wait for sendbuffer // send // wait for recieve int main() { unsigned char i; } UART_Init(UBRR); while(1) { i=uart_recv(); while(i) UART_Send(i--); }

81 81 printf in C printf kann an eigene Ausgaberoutinen gebunden werden Funktion: fdevopen(outroutine,inroutine) Ein- Ausgabe muss byteweise erfolgen Ausgabehardware ist beliebig Ports, TWI, SPI, UART, usw. Beispiel: Bindung von printf an die UART: #include <avr/io.h> #define F_CPU #define BAUD #define UBRR F_CPU/16/BAUD-1 void UART_Send(char data) { while (!( UCSRA & (1<<UDRE))); UDR = data; } unsigned char UART_Recv() { while (!(UCSRA & (1<<RXC))); return UDR; } void UART_Init( unsigned int ubrr ) { UBRRH = (unsigned char)(ubrr>>8); UBRRL = (unsigned char)ubrr; UCSRB = (1<<RXEN) (1<<TXEN); UCSRC = (1<<URSEL) (1<<UCSZ1) (1<<UCSZ0); fdevopen (UART_Send, UART_Recv); } int main() { UART_Init(UBRR); printf("hello World"); }

82 82 Interrupts Benachrichtigungsmechanismus der Hardware Ein bestimmtes Ereigniss ist eingetreten Alternative: Warten auf ein Ereignis Polling: permanente Abfrage Nachteil: CPU ist nur mit Abfragen beschäftigt Interrupts treten unabhängig vom Programm auf Programm wird unterbrochen Interrupt Sevice Routine (ISR) wird ausgeführt Programm wird fortgesetzt Int Prog ISR PC auf Stack, CLI PUSH SGRE PC vom Stack, SEI POP SGRE RETI Interrupt Verarbeitung (HW=Hardware) Interrupts tritt ein (HW) Sperrung weiterer Interrupts (HW) aktuelle Befehl der CPU wird abgearbeitet (HW) PC auf den Stack (HW) Sprung zur ISR (HW) Sichern des Statusregister Ausführung der ISR Statusregister restaurieren Return from Interrupt RETI PC wird restauriert (HW) Interrupt Freigabe (HW) Programm wird fortgeführt (HW) Unterprogramm mit Hardwareaufruf

83 83 Interrupt Woher weiss die CPU wo die entsprechende ISR liegt ISR haben feste Einsprungadressen Interrupt-Vektor-Tabelle des ATmega16: Vector No. Speicheradresse Quelle Auslöser 0 0x00 RESET External Pin, Power-On Reset, Brown-out Reset, Watchdog Reset, 1 0x02 INT0 External Interrupt Request 0 2 0x04 INT1 External Interrupt Request 1 3 0x06 TIMER2 COMP Timer/Counter2 Compare Match 4 0x08 TIMER2 OVF Timer/Counter2 Overflow 5 0x0A TIMER1 CAPT Timer/Counter1 Capture Event 6 0x0C TIMER1 COMPA Timer/Counter1 Compare Match A 7 0x0E TIMER1 COMPB Timer/Counter1 Compare Match B 8 0x10 TIMER1 OVF Timer/Counter1 Overflow 9 0x12 TIMER0 OVF Timer/Counter0 Overflow 10 0x14 SPI STC Serial Transfer Complete 11 0x16 USART RXC USART, Rx Complete 12 0x18 USART UDRE USART Data Register Empty 13 0x1A USART TXC USART, Tx Complete 14 0x1C ADC ADC Conversion Complete 15 0x1E EE RDY EEPROM Ready 16 0x20 ANA COMP Analog Comparator 17 0x22 TWI Two-Wire Serial Interface 18 0x24 INT2 External Interrupt Request x26 TIMER0 COMP Timer/Counter0 Compare Match 20 0x28 SPM RDY Store Program Memory Ready Platz zwischen zwei Einsprungadressen ist 4 Byte (2Worte) reicht für einen JMP <ISR> oder ein RETI, falls keine ISR ausgeführt werden soll Interrupts müssen global freigegeben werden I-Bit im Statusregister Spezielle Befehle SEI und CLI Interrupt müssen lokal freigegeben werden Enable Bit in Steuerregister der jeweiligen Hardware

84 84 ISR typischer Programmkopf:.org 0x000 jmp MAIN.org 0x002 jmp EXT_INT0.org 0x004 jmp EXT_INT1.org 0x006 jmp TIM2_COMP.org 0x008 jmp TIM2_OVF.org 0x00A jmp TIM1_CAPT.org 0x00C jmp TIM1_COMPA.org 0x00E jmp TIM1_COMPB.org 0x010 jmp TIM1_OVF.org 0x012 jmp TIM0_OVF.org 0x014 jmp SPI_STC.org 0x016 jmp USART_RXC.org 0x018 jmp USART_UDRE.org 0x01A jmp USART_TXC.org 0x01C jmp ADC.org 0x01E jmp EE_RDY.org 0x020 jmp ANA_COMP.org 0x022 jmp TWI.org 0x024 jmp EXT_INT2.org 0x026 jmp TIM0_COMP.org 0x028 jmp SPM_RDY ; Reset Handler ; IRQ0 Handler ; IRQ1 Handler ; Timer2 Compare Handler ; Timer2 Overflow Handler ; Timer1 Capture Handler ; Timer1 CompareA Handler ; Timer1 CompareB Handler ; Timer1 Overflow Handler ; Timer0 Overflow Handler ; SPI Transfer Complete Handler ; USART RX Complete Handler ; UDR Empty Handler ; USART TX Complete Handler ; ADC Conversion Complete Handler ; EEPROM Ready Handler ; Analog Comparator Handler ; Two-wireSerialInterface Handler ; IRQ2 Handler ; Timer0 Compare Handler ; Store Program Memory Ready Handler nichtbenötigte Sprünge sollten durch RETI ersetzt werden Beispiel der UART, (nächste Seite) Interruptgesteuert Interrupt: UART RX complete wird aufgerufen, sobald ein Datum komplett empfangen wurde Sendeschleife wandert in die ISR UART Init, UART Send und UART Recv indentisch mit UART Beispiel

85 85 ISR in Assembler.org 0x00 rjmp main.org 0x02 reti.org 0x04 reti.org 0x06 reti.org 0x08 reti.org 0x0A reti.org 0x0C reti.org 0x0E reti.org 0x10 reti.org 0x12 reti.org 0x14 reti.org 0x16 jmp USART_RXC.org 0x18 reti.org 0x1A reti.org 0x1C reti.org 0x1E reti.org 0x20 reti.org 0x22 reti.org 0x24 reti.org 0x26 reti.org 0x28 reti ; ISR: USART recieve complete USART_RXC: push r16 in r16,sreg push r16 call uart_recv L0: call uart_send dec r16 brne L0 pop r16 out SREG,r16 pop r16 reti main: ldi r16,high(ramend) out SPH, r16 ldi r16,low(ramend) out SPL,r16 call uart_init sbi UCSRB,RXCIE ; dont forget stack;-) ; enable rx interrupt sei L1: rjmp L1 ; enable global interrupts

86 86 #include <stdio.h> #include <avr/io.h> #include <avr/interrupt.h> #define F_CPU #define BAUD #define UBRR F_CPU/16/BAUD-1 ISR in C void UART_Send(char data) { while (!( UCSRA & (1<<UDRE))); UDR = data; } unsigned char UART_Recv() { while (!(UCSRA & (1<<RXC))); return UDR; } void UART_Init( unsigned int ubrr ) { UCSRB = (1<<RXEN) (1<<TXEN); UCSRC = (1<<URSEL) (1<<UCSZ1) (1<<UCSZ0); UBRRH = (unsigned char)(ubrr>>8); UBRRL = (unsigned char)ubrr; fdevopen (UART_Send, UART_Recv); } ISR(USART_RXC_vect) { unsigned char i=uart_recv(); while(i) UART_Send(i--); } int main() { UART_Init(UBRR); sei(); UCSRB = (1<<RXCIE); while(1); }

87 87 Fuses Fuses dienen der Grundkonfiguration der MCU sind extern zugängliche Register regeln Takt, Programmierung, Startup-Verhalten, Speicherzugriff werden programmiert durch Schreiben von Nullen sind Device abhängig AtMega16: 3 Fuses lock Bits, High Fuse, Low Fuse Lock Bits (6 Bits) Bit: BLB12 BLB12 BLB02 BLB01 LB2 LB1 def: Regeln den Zugriff auf Flash und Eeprom default: unbegrenzter Zugriff mögliche Einschränkungen: Verbot des Auslesens Verbot des Überschreibens Absichern des Bootloader Bereiches Beschränkung des Bootloaderzugriffs

88 88 High Fuse Bit: OCDEN JTAGEN SPIEN CKOPT EESAVE BOOTSZ1 BOOTSZ0 BOOTRST def: OCDEN (On Chip Debug Enable) Ermöglicht Debugging zur Laufzeit (JTAG Interface) JTAGEN (JTAG Enable) Schaltet JTAG Interface ein (belegt 4 Pins PortC) SPIEN (SPI Enable) ermöglicht serielles Programmieren über SPI CKOPT (Clock Options) nötig bei > 8MHz Clock EESAVE (EEPROM preserved through Chip erase) verhindert Löschen des EEPROMS beim Programmieren BOOTSZ1, BOOTSZ0 (BOOT Size) reserviert Speicher für einen Bootloader (128, 256, 512, 1024 Words) BOOTRST (BOOT Reset Vektor) verbiegt Reset Vektor auf den Bootloader Bereich

89 89 LOW Fuse Bit: BODLEVEL BODEN SUT1 SUT0 CKSEL3 CKSEL2 CKSEL1 CKSEL0 def: BODLEVEL (Brown-out Detector Trigger Level) Brown-out Pegel: 1=2.7V bzw. 0=4.0V BODEN (Brown-out Detector Enable) Spannungsüberwachung einschalten. Werden die og. Level unterschritten: RESET SUT1, SUT0 (Startup Time) regelt Verbindung mit CKSEL0 das Delay zwischen Spannungsversorgung und Start der CPU 0-63ms plus K Takte CKSEL3,CKSEL2,CKSEL1 (Clock Select) regelt Art und Frequenzbereich des Taktes Quartz, keramischer Oszillator, RC-Oszillator, interner Oszillator, externer Takt Default Einstellung: 1MHz interner Oszillator mit 65ms startup Time ECB16 8MHz intern mit 65ms startup Time 512 Words Bootloader kein JTAG High Fuse = 0xDA, Low Fuse = 0xE4

90 90 Speicheraufteilung AtMega 16 Bootloader Pagesize = Flash 8K Word Bootloader Bereich Reset Vektor (BOOTRST=1) Reset Vektor (BOOTRST=0) Flash kann nur Seitenweise beschrieben bzw. gelöscht werden Funktionen zum Schreiben und Lesen des Flashes und der UART UART ReadPage() liefert Index der Seite als Rückgabewert andere Seite der UART: flash.exe while(1) { if(uart_datain) c=uart_recv(); if(c==writepage) { if(uart_readpage(&page,pagebuf)<(bootpage/pagesize)) FLASH_WritePage(page,pagebuf); } if(c==readpage) { page = USART_Recv()<<8; page += USART_Recv(); FLASH_ReadPage(page,pagebuf); UART_WritePage(pagebuf); } } if(yel_but_press) asm("jmp 0");

91 91 DA/AD Wandler Meßsignale meist in analoger Form Temperatur, Zeit, Geschwindigkeit zur rechnergestützten Verarbeitung digitalisieren Analog/Digital Wandler (AD Wandler) Digital/Analog Wandler (DA Wandler) Abtastung Umwandlung in diskreten Zeitabständen Aliasing, Shannon sches Abtasttheorem Signal Quantisierung Umwandlung analoger Messgrößen in Binärworte Quantisierungsfehler Umwandlung stets Fehlerbehaftet

92 92 AD Wandlung Beispiel: 3 Bit AD Wandler t t t t t t t T t t t t t t t T

93 93 DA Wandlung Beispiel: 3 Bit DA Wandler t t t t t t t T Glättung durch ein RC-Glied 8 7 orginal t t t t t t t T

94 94 DA Wandler (RnR) mit abgestuften Widerständen Widerstände (umgekehrt) proportional zum Stellengewicht U a (D) = R a U ref R a + R D mit D = d d d 1 2+d 0 falls R a R D folgt U a (D) D Ra R U ref

95 95 DA Wandler (RnR) Abhängig vom Lastwiderstand R a R a < R (links) ideale Form (linear) geringe Ausgangsspannung R a > R (rechts) nichtlinear höhere Ausgangsspannungen Lösung: Operationsverstärker

96 96 DA Wandler (R2R) Widerstandsnetzwerk mit nur 2 Werten (R/2R) regelmäßige Struktur (CMOS) AusgangsspannungU a weitestgehendunabhängigvomlastwiderstand R a U a (D) = U ref ( d d d d 3 2 ) = U ref 2 4 (d 0 +2d 1 +4d 2 +8d 3 ) = U ref 2 4 D

97 97 Beispiel 2 Bit R2R R 2R 2R 2R U A d 0 d 1 U ref d 1 = 0,d 0 = 0 U a = 0 d 1 = 0,d 0 = 1 U a = 1 4 U ref d 1 = 1,d 0 = 0 U a = 2 4 U ref d 1 = 1,d 0 = 1 U a = 3 4 U ref Ersatzschaltbild für d 1 = 0,d 0 = 1 (links) und d 1 = 1,d 0 = 1 (rechts) U ref U ref U A R 2R 2R 3 8 2R U A 1 8 2R R R 2R

98 98 Beispiel: Funktionsgenerator 4 Bit DA Wandler Frequenz über Eingabeport regelbar Sägezahn Signal (über einen Zähler) Digitalausgabe an R2R DA-Wandler main: ldi r16,high(ramend) out SPH,r16 ldi r16,low(ramend) out SPL,r16 ldi r16,0xff out DDRA,r16 ; Stack initialisieren ; kompletten Port A ; als Output konfigurieren ldi r16,0x00 ; kompletten PortC als out DDRC,r16 ; als Input ldi r16,0xff ; dabei die Pullups out PORTC,r16 ; nicht vergessen ;-) loop: ldi r17,0x0f ; Saegezahn beginnt mit 16 L0: out PORTA,r17 ; den Wert ausgeben in r16,pinc ; Delayparameter einlesen call delay ; und delay UP aufrufen dec r17 ; neuen Ausgabewert erzeugen brpl L0 ; solange Wert >=0 zur Ausgabe springen jmp loop ; danach wieder mit 16 beginnen

99 99 Beispiel: Funktionsgenerator in C #include <avr/io.h> #include <util/delay.h> void delay5us(unsigned int time) { while(time--) { asm("nop"); asm("nop"); : : asm("nop"); asm("nop"); } } int main() { unsigned char i; DDRA = 0xFF; DDRC = 0x00; PORTC = 0xFF; // PortA Output // PortC Input // with pullups } while(1) { for(i=0;i<0x0f;i++) { PORTA=i; delay5us(pinc); } }

100 100 Frequenzen und Töne Ton Intervall Frequenz Perioden absolute verhältniss verhältniss Delay Werte Hex c Prime B4 d Sekunde 9/8 8/9 160 A0 e Große Terz 5/4 4/ f Quarte 4/3 3/ g Quinte 3/2 2/ a Große Sexte 5/3 3/ C h Große Septime 15/8 8/ c Oktave 2 1/2 90 5A ldi r16,0xff out DDRA,r16 ; kompletten Port A ; als Output konfigurieren ldi r16,0x00 ; kompletten PortC als out DDRC,r16 ; als Input ldi r16,0xff ; dabei die Pullups out PORTC,r16 ; nicht vergessen ;-) clr r0 ; 0 Konstante fuer 16Bit Addition loop: L2: ldi ZH,high(NOTEN<<1) ; Basisaddresse der Delaywerte ldi ZL,low(NOTEN<<1) ; in den Z-Pointer in r16,pinc ; Offset (Note) einlesen add ZL,r16 ; diesen Wert auf die Basisadc ZH,r0 ; adresse addieren lpm r16,z ; Notendelay aus Tabelle holen ldi r17,0x0f ; Mit dem Saegezahn beginnen out PORTA,r17 ; Ausgabe an den DA Wandler call delay ; fuer diese Note Delay erzeugen dec r17 ; neuer Wert des Saegezahns brne L2 ; Ausgabe solange Wert >=0 jmp loop ; sonst neue Note einlesen NOTEN:.db 0xB4,0xA0,0x90,0x87,0x78,0x6C,0x60,0x5A

101 101 Frequenzen und Töne Ton Intervall Frequenz Perioden absolute verhältniss verhältniss Delay Werte Hex c Prime B4 d Sekunde 9/8 8/9 160 A0 e Große Terz 5/4 4/ f Quarte 4/3 3/ g Quinte 3/2 2/ a Große Sexte 5/3 3/ C h Große Septime 15/8 8/ c Oktave 2 1/2 90 5A int main() { unsigned char Noten[]={0xB4,0xA0,0x90,0x87,0x78,0x6C,0x60,0x5A}; unsigned char i; DDRA = 0xFF; DDRC = 0x00; PORTC = 0xFF; // PortA Output // PortC Input // with pullups } while(1) { for(i=0;i<0x0f;i++) { PORTA=i; delay5us(noten[pinc]); } }

102 102 programmierbarer Synthesizer Paar Tonlänge/Tonhöhe im Speicher Priodendauer beachten loop: ldi ZH,high(NOTEN<<1) ; Tabelle fuer Tonhoehe und ldi ZL,low(NOTEN<<1) ; Tonlaenge in Z-Pointer L0: ldi r16,0xa0 ; kleine Pause zwischen call delay ; allen Noten erzeugen lpm r18,z+ ; Tonlaenge laden, Z-Pointer++ cpi r18,0xff ; wenn Tonlaenge=FF Tabellenende breq loop ; fang von vorne an lpm r16,z+ ; Note laden, Z-Pointer weitersetzen L2: ldi r17,0x0f ; Saegezahn starten L1: out PORTA,r17 ; Ausgabe call delay ; Noten Delay erzeugen dec r17 ; neuer Saegezahnwert brpl L1 ; solange dieser >= 0 zur Ausgabe dec r18 ; Note lange genug gespielt brne L2 ; nein, dann naechster Saegezahn rjmp L0 ; ja, dann naechste Note laden ; wie heisst die Komposition? ; wer hats erfunden? (Nein, es waren nicht die Schweizer!) ; wer hat den Text geschrieben? NOTEN:.db 0x1E,0x90,0x1E,0x90,0x20,0x87,0x24,0x78.db 0x24,0x78,0x20,0x87,0x1E,0x90,0x1B,0xA0.db 0x18,0xB4,0x18,0xB4,0x1B,0xA0,0x1E,0x90.db 0x2D,0x90,0x0D,0xA0,0x36,0xA0.db 0x1E,0x90,0x1E,0x90,0x20,0x87,0x24,0x78.db 0x24,0x78,0x20,0x87,0x1E,0x90,0x1B,0xA0.db 0x18,0xB4,0x18,0xB4,0x1B,0xA0,0x1E,0x90.db 0x28,0xA0,0x0C,0xB4,0x30,0xB4.db 0x1B,0xA0,0x1B,0xA0,0x1E,0x90,0x18,0xB4.db 0x1B,0xA0,0x0f,0x90,0x10,0x87,0x1E,0x90,0x18,0xB4.db 0x1B,0xA0,0x0f,0x90,0x10,0x87,0x1E,0x90,0x1B,0xA0.db 0x18,0xB4,0x1B,0xA0,0x18,0xF0.db 0x3C,0x90,0x1E,0x90,0x20,0x87,0x24,0x78.db 0x24,0x78,0x20,0x87,0x1E,0x90,0x1B,0xA0.db 0x18,0xB4,0x18,0xB4,0x1B,0xA0,0x1E,0x90.db 0x28,0xA0,0x0C,0xB4,0x30,0xB4.db 0xFF,0xFF

103 103 programmierbarer Synthesizer Paar Tonlänge/Tonhöhe im Speicher Priodendauer beachten #include <avr/io.h> #include <avr/pgmspace.h> prog_uchar SONG[]={ 0x12,0xF0,0x18,0xB4,0xC,0xB4,0xD,0xA0,0x1E,0x90,0x18,0xB4, 0x48,0x78,0x2D,0x90,0xF,0x90, 0x20,0x87,0x12,0x78,0x10,0x87,0xF,0x90,0x10,0x87,0x24,0x78, 0xD,0xA0,0xC,0xB4,0xD,0xA0,0xF,0x90,0x1B,0xA0,0x12,0xF0, 0x18,0xB4,0xC,0xB4,0xD,0xA0,0x1E,0x90,0x18,0xB4, 0x48,0x78,0x2D,0x90,0xF,0x90, 0x10,0x87,0x12,0x78,0xF,0x90,0x10,0x87,0x28,0xA0,0xC,0xB4, 0x3C,0xB4,0xFF,0xFF, }; int main() { unsigned char i,k,ton,dauer; const prog_uchar* ptr; DDRA = 0xFF; // PortA Output ptr = SONG; dauer = pgm_read_byte(ptr++); ton = pgm_read_byte(ptr++); while(ton!= 0xFF) { while(dauer--) for(i=0;i<0x0f;i++) { PORTA=i; delay5us(ton); } PORTA=0; delay5us(100); } } dauer = pgm_read_byte(ptr++); ton = pgm_read_byte(ptr++);

104 104 AD Wandler analoge Signale digitalisieren Signal muss während des Umsetzvorgangs stabil bleiben Sample and Hold Stufe Vergleich mit einem einem Referenz Signal Komparator

105 105 AD Wandler Schaltungen parallel seriell Zählverfahren (einfacher) Sukzessive Approximation (schneller)

106 106 Beispiel: AD Wandler 4 Bit AD Wandler Digitalausgabe an externen R2R DA-Wandler externer Komparator Einfaches Zählverfahren #include <avr/io.h> void delay5us(unsigned int time) { while(time--) { asm("nop"); : asm("nop"); } } int main() { DDRA = 0xFF; // PortA Output DDRC = 0xFE; // PortC Pin0 Input PORTC = 0x01; // PortC Pin0 Pullup } while(1) { for(porta=0x00;porta<0x10; PORTA++) { delay5us(10); // wait for comparator } if(pinc) break; } delay5us(20); // break, if signal strong enough // show result;

107 107 Analog Komparator Vergleicht die Spannungen an AIN0 und AIN1 Ergebniss liegt im ACSR-Register (Bit ACO) AIN0 > AIN1 ACO=1 AIN1 > AIN0 ACO=0 ACSR Register Bit: Name: ACD ACBG ACO ACI ACIE ACIC ACIS1 ACIS0 ACD Analog Comparator Disable schaltet den Komparator aus ACBG Bandgap select ersetzt AIN0 durch eine feste Referenzspannung ACO Analog Comparator Output wird 1 wenn AIN0 > AIN1, sonst 0 ACI Interrupt Flag Ereigniss eingetreten, ggf. ISP aufrufen ACIE Interrupt Enable ermöglicht die Ausführung einer ISR ACIC Input Capture Enable verbindet ACO mit Timer1 ACIS1/0 Mode Select Interrupt Ereigniss ACIS1 ACIS0 Interruptmodus 0 0 Interrupt bei jeder Änderung des ACO 0 1 Reserviert (keine Funktion) 1 0 Interrupt bei fallender Flanke 1 1 Interrupt bei ansteigender Flanke

108 108 ADC des AVR Eigenschaften 10 Bit Wandler integrierte Sample and Hold Stufe sukzessive Approximation 13 Takte pro Wandlung bis 15 ksmpl/s auf 8 Kanäle umschaltbar Referenzspannungen: extern (bis 5V) intern VCC intern kalibriert 2.56V Taktung der ADC ADC-Clock von CPU Clock abgeleitet über Prescaler erzeugt bei 13 Tiks/Smpl: 15 ksmpl s 13 Tiks Spml = 195kTiks s 200kHz Samplezeiten bei 8MHz: ADPS2/1/0 Prescaler ADC-Clock ksmpl/s MHz MHz MHz MHz ,5 MHz 38, khz khz 9, ,5 khz 4,8 Bei 8 MHz CPU Clock Prescaler=64

109 109 Kontrollregister ADCSRA: ADCSRA Register Bit: Name: ADEN ADSC ADATE ADIF ADIE ADPS2 ADPS1 ADPS0 ADEN: Enable ADC Schaltet den AD-Wandler ein ADSC: Start Conversion Startet eine Wandlung ADATE: Trigger enable Start einer Wandlung nach einem Triggerimpuls ADIF: Interupt Flag Wandlung beendet, ggf. ISR aufrufen ADIE: Interupt Enable Interrupt einschalten ADPS0-2: Prescaler Takteinstellung für AD-Converter s.o.

110 110 ADMUX Register ADMUX Register Bit: Name: REFS1 REFS0 ADLAR MUX4 MUX3 MUX2 MUX1 MUX0 REFS1-0: Referenzspannung REFS1 REFS0 Referenzspannungsquelle 0 0 AREF, internes Vref deaktiviert 0 1 AVCC mit externen Kondensator am AREF Pin 1 0 reserviert 1 1 Interne 2,56V Spannungsreferenz ADLAR: left/right Adjust Ergebniss rechts oder linksbündig im Ergebnissregister s.u. MUX4-3: Kanalwahl (0:PA0 7:PA7) für differentielle Spannungen MUX0-2: Kanalwahl (0:PA0 7:PA7) Zuordnung intuitiv MUX2 MUX1 MUX0 Portpin PA PA PA PA PA PA PA PA7

111 Bit Register 10 Bit Ergebniswert Ergebnisregister ADCL/H 6 Bits leer Ergebniss kann links- oder rechtbündig abgelegt werden Siehe ADLAR im ADMUX Register ADLAR=0 Bit: ADCH ADC9 ADC8 ADCL ADC7 ADC6 ADC5 ADC4 ADC3 ADC2 ADC1 ADC0 ADLAR=1 Bit: ADCH ADC9 ADC8 ADC7 ADC6 ADC5 ADC4 ADC3 ADC2 ADCL ADC1 ADC interessant, wenn nur 8 Bit gefordert sind nur ADCH auslesen

112 112 SFIOR Register Bit: Name: ADTS2 ADTS1 ADTS ADTS 2-0 Trigger Source Auswahl der Trigger Quelle ADTS2 ADTS1 ADTS0 Trigger free running Analog Comparator External Interrupt Timer0 Compare Timer0 Overflow Timer1 Compare B Timer1 Overflow Timer1 Capture Codebeispiel einer C-Funktion unsigned int adc(char channel) { ADCSRA = (1<<ADEN) (7<<ADPS0); // AD enable, Prescale=128 ADMUX = (1<<REFS0) channel; // Referenz: VCC, Kanal waehlen ADCSRA = (1<<ADSC); // Wandlung starten while(adcsra & (1<<ADSC)); // warten auf ADSC=0, Ende der Wandlung ADCSRA=0; // ADC ausschalten return(adc); }

113 113 einfaches Oszi ADC des AVR Nur Signale von 0 bis 5V sample Werte in char-array (8 Bit) Ausgabe über grafisches Terminal Einstellung der ADC-Taktrate via UART int main() { unsigned char val[327]; int i; ADCSRA = (1<<ADEN) (7<<ADPS0); // ADC on, Div: 128 ADMUX = (1<<REFS0) (1<<ADLAR); // 5v Ref, 8Bit, Pin0 UART_Init(UBRR); while(1) { while(acsr & (1<<ACO)); while(!(acsr & (1<<ACO))); ADCSRA = (1<<ADSC); for(i=0;i<327;i++) { while(adcsra & (1<<ADSC)); ADCSRA = (1<<ADSC); val[i] = ADCH; } for(i=0;i<327;i++) UART_Send(val[i]); // wait for Trigger // start ADC // wait for result // immidiate start again // save result // send result via // UART if(uart_poll()) // check UATRT ADCSRA = (1<<ADEN) ((UART_Recv() & 0x07)<<ADPS0); // set DIV } }

114 114 PWM PWM: Pulsweitenmodulation Erzeugen eines Pseudo Analog-Signals duch Pulsen einer digitalen Grösse Voraussetzung: Integral über die Zeit muss gleich sein U U Umax c* t k*umax t t t t t t (k*umax)* t = Umax *(c* t) k = c anschauliches Beispiel: Heizung Analog: Durchflussbegrenzung (Thermostat) PWM: Regelung durch Ein- und Ausschalten

115 115 PWM mit Timer Erzeugen einer Pulsweitenmodulation typische Timeraufgabe Timer Zähler an Systemtakt gebunden kann bei Überlauf einen Interrupt erzeugen Overflow Timer Overflow Interrupt ATmega16: 3 Timer 2 * 8Bit Timer0/2, 16Bit Timer1 Taktung durch Vorteilung des Systemtaktes (Register TCRRx) CSx2 CSx1 CSx0 Funktion Timer0/1 Funktion Timer Keine Taktquelle Keine Taktquelle Prozessortakt Prozessortakt Prozessortakt / 8 Prozessortakt / Prozessortakt / 64 Prozessortakt / Prozessortakt / 256 Prozessortakt / Prozessortakt / 1024 Prozessortakt / Takt bei fallender Flanke Prozessortakt / Takt bei steigender Flanke Prozessortakt / 1024 F_CPU F_CPU/8 T= n 2 n 2 *8 F_CPU F_CPU n=8/16

116 116 Timer mögliche Intervalle bei F CPU=8MHz und 8-Bit Timer Precaler F OVFLOW T OVFLOW 1 31,25 khz 32 us 8 3,9 khz 256 us Hz 2,048 ms Hz 8,192 ms ,5 Hz 32,768 ms Finetuning durch Preload direkter Zugriff auf das Zählregister (TCNTx) bei Overflow interrupt Startwert (preload) setzen Zähler beginnt bei preload statt bei 0 Preload gesucht: F=1000 Hz 1ms prescaler=64 8us pro Zählschritt (2048us/256) für 1ms 125 Zählschritte proload = =131=0x83 preload wird später bei VGA benötigt, bei PWM nicht

117 117 einfache Pulsweitenmodulation // Analog nach PWM Umsetzer // Pin A0 -> Pin C0 #include <avr/io.h> #include <avr/interrupt.h> #define PWMDDR DDRC #define PWMPORT PORTC #define PWMPIN PIN0 volatile unsigned char pwmcntr,pwmval; // ISR Overflow Timer 0 (8Bit) ISR(TIMER0_OVF_vect) { if(pwmcntr++ < pwmval) PWMPORT = (1<<PWMPIN); else PWMPORT &= ~(1<<PWMPIN); } unsigned char adc(unsigned char channel) // 8Bit AD-Wandler { ADCSRA = (1<<ADEN) (6<<ADPS0); // prescale = 64, Enable ADMUX = (1<<REFS0) (1<<ADLAR) channel; // 5V REF, left adj, Channel } ADCSRA = (1<<ADSC); while(adcsra & (1<<ADSC)); ADCSRA = 0; return(adch); // start conversion // wait // ADC out // return val int main() { PWMDDR = (1<<PWMPIN): TCCR0 = (1<<CS00); TIMSK = (1<<TOIE0); sei(); // PortC Output // prescaler 1 (FCPU) // enable overflow intr // enable global intr } while(1) pwmval = adc(0);

118 118 Vergleichsregister (OCRx) jeder Timer besitzt ein oder zwei Vergleichsregister (OCRx) vergleicht TCNTx mit OCRx bei Gleichheit Timer-Compare-Interrupt Timer Compare Interrupt COMPARE Timer Overflow Interrupt jedes Vergleichsregister ist an einen Pin gekoppelt (OCx) Zustandänderung am Pin bei COMPARE MATCH möglich Pin muss als Output konfiguriert sein Hardware PWM // Analog nach PWM Umsetzer // Pin A0 -> Pin B3 (OC0) #define PWMDDR DDRB #define PWMPORT PORTB #define PWMPIN PIN3 unsigned char adc(unsigned char channel) {...} // 8Bit AD Wandler s.o. int main() { PWMDDR = (1<<PWMPIN); // OC0 Output TCCR0 = (1<<CS00) // prescaler 1 (FCPU) (1<<WGM01) (1<<WGM00) // Fast PWM (1<<COM01); // clear OCR0 on compare, set at TOP } while(1) OCR0=adc(0);

119 119 Register des Timer0 TCNT0 (Timer Counter Register) 8 Bit jederzeit Zugriff möglich bei Überlauf Overflow Interrupt möglich OCR0 (Output Compare Register) 8 Bit bei Gleichheit mit TCNT0 Compare Match Interrupt möglich TCCR0 (Timer/Counter Control Register) Bit: Name: FOC0 WGM00 COM01 COM00 WGM01 CS02 CS01 CS00 FOC0 (Force Output Compare) erzwingt einen Compare Match (ohne Interrupt) WGM01:00 (Waveform Generation Mode) Timer Funktionen nach folgender Tabelle WGM01 WGM00 Mode 0 0 Normal 0 1 PWM (up/down) 1 0 CTC 1 1 PWM

120 120 Register des Timer0 COM01:00 (Compare Match Output Mode) Reaktionen bei Compare match hängt von der Betriebsart des Timer ab hier für den PWM Mode: COM01 COM00 Mode 0 0 Normal port operation, OC0 disconnected 0 1 reserved 1 0 Clear OC0 on match, set OC0 on TOP 1 1 Set OC0 on match, clear OC0 on TOP andere Modi siehe Handbuch CS02:01:00 (Clock Select) Taktraten Einstellung CS02 CS01 CS00 Mode timer disabled F CPU F CPU/ F CPU/ F CPU/ F CPU/ external clock Source T0 (falling edge) external clock Source T0 (rising edge)

121 121 Register des Timer0 TIMSK (Timer/Counter Interrupt Mask Register) Bit: Name: OCIE0 TOIE0 OCIE0 (Output Compare Interrupt Enable) Compare Match Interrupt einschalten TOIE0 (Timer Overflow Interrupt Enable) Overflow Interrupt einschalten TIFR (Timer/Counter Interrupt Flag Register) Bit: Name: OCF0 TOV0 OCF0 (Output Compare Flag) Compare Match, ggf. Interrupt aufrufen TOV0 (Timer Overflow Flag) Overflow, ggf. Interrupt aufrufen Register der Timer1 und Timer2 analog, teilweise aber 16 Bit

122 122 Audio mit PWM CD: 16 Bit mit Hz 16 Bit = Lautstärkestufen ,9GHz unmöglich bei 20 Mhz F CPU und Hz 20Mhz/44100Hz 453 Takte max 8 Bit Auflösung (256 Stufen) Datenträger SD-Karte mit FAT16 Filesystem unkomprimiertes WAV Format, 8Bit mit Dithering

123 123 Preise : Reichelt, Stand Juni 2008 (Taster: Conrad) Bauteilliste Anzahl Bauteil Schaltplan- Kosten zeichen (Euro) 2 22pF Kondensator C1, C2 0, uF Elko C3, C7 0, nF Kondensator C4 0,04 2 1N4148 Diode D1, D2 0,04 1 ATMega168 IC1 2,85 1 DuoLed 3mm LED1 0, Mhz Quarz Q1 0,24 2 BC337 Transistoren Q2, Q3 0,08 3 1,8KΩ R1, R2, R3 0,06 3 3,3KΩ R4, R5, R6 0,06 2 1KΩ R9, R10 0, Ω R8 0,02 3 Taster S1, S2, S3 1,05 1 Winkelpins SV1 0,12 1 Schalter SV2 0,90 1 3,5mm Stereo Buchse X1 0,18 1 Batteriehalter - 0,41 1 Platine - 0,20 6,67 zudem werden benötigt SD-Karte (ca. 5,00 Euro) 4 Microzellen (ca. 2,00 Euro)

124 124 SD Karten idealer Massenspeicher leicht, billig, robust mit FAT16 Dateisystem PC kompatibel Protokolle 4 Bit Datenbus, oder SPI Interface (MISO, MOSI, SCK, /SS) Achtung: SD Karten sind für 3.3V spezifiziert Anpassung an 5V nötig Doppeldiode in der Spannungsversorgung (2 0, 7V Abfall) Spannungsteiler an den Dateneingängen (1, 8kΩ und 3, 3kΩ) bei Datenausgängen keine Anpassung, 3.3V=HIGH ( )

125 125 SPI Serial Peripheral Interface (SPI) seriell, synchron, voll duplex 1:n Verbindung Arbitrierung: Master-Slave Konzept ATmega: bis 10 MHz Verbindungen: 2 Datenleitungen 1 Taktleitung (0-n) Select-Leitungen Zeichenorientiert (8Bit) LSB-first oder MSB-first einstellbar min. 3 Leitungen SCK: Clock MOSI: Master Out, Slave In MISO: Master In, Slave out (Pro Slave ein Slave Select (/SS)) Datenübertragung immer 8 Bit Master generiert Takt immer duplex

126 126 SPI Register SPDR (SPI Data Register) 8 Bit Lese-, Schreibregister schreiben löst Übertragung aus enthält neues Datum nach Übertragung SPCR (SPI Control Register) Bit: Name: SPIE SPE DORD MSTR CPOL CPHA SPR1 SPR0 SPIE (SPI Interrupt Enable) schaltet End of Transmission Interrupt ein SPE (SPI Enable) schaltet SPI ein, Reservierung der Pins DORD (Data Order) 0: LSB first 1: MSB first MSTR (Master/Slave select) 0: Slave mode 1: Master mode CPOL (Clock Polarity) 0: SCK low when idle 1: SCK high when idle CPHA (Clock Phase) 0: Daten bei erster Flanke lesen, bei zweiter Flanke schreiben 1: Daten bei erster Flanke schreiben, bei zweiter Flanke lesen

127 127 SPI Register SPR01:00 (SPI Clock Rate Select 1 and 0) SPI Taktrateneinstellung nach folgender Tabelle SPR1 SPR0 SCK Frequency (SPI2X=1) 0 0 F CPU/4 (F CPU/2) 0 1 F CPU/16 (F CPU/8) 1 0 F CPU/64 (F CPU/32) 1 1 F CPU/128 (F CPU/64) Takt kann durch SPI2X verdoppelt werden (su.) SPSR (SPI Status Register) Bit: Name: SPIF WCOL SPI2X SPIF (SPI Interrupt Flag) zeigt ein Übertragungsende an (ggf. Interrupt aufrufen) WCOL (Write Collision Flag) SPDR wurde während Datenübertragung geändert SPI2X (Double SPI Speed) verdoppelt den SPI Takt (nur im Master Mode garantiert)

128 128 Monitore Aufbau eines CRT (Röhrenmonitor) Wehneltzy linder Strahlensytem Ablenkplatten Leucht - sc hirm Katode Elektronenstr ahl Bilddarstellung sichtbare Bereich Vertikales Synchronisationssignal VSYNC Horizontales Synchronisationssignal HSYNC Videosignal (analog)

129 129 VGA-Videosignal Eigenschaften seriell assynchron analog unidirektional Synchronisationsimpulse HSYNC (TTL-Pegel) VSYNC (TTL-Pegel) Videosignal analog in Zeit und Grösse 0.7V Spannungsdifferenz zwischen dunkel und hell keine festen Spannungswerte Schwarzschulter definiert dunkel Farbdarstellung: 3 Videosignale R,G,B VESA Standards (alle 60 Hz Vertikalfrequenz) VGA 640 x 480 SVGA 800 x 600 XGA 1024 x 768 SXGA 1280 x 1024

130 130 VGA-Verbindung VGA Buchse Blick von aussen auf die Buchse am Rechner Belegung: Pin Funktion Erweiterung 1 Rot - 2 Grün - 3 Blau ID 2 oder Reserve 5 - digitale Masse 6 Masse für Rot - 7 Masse für Grün - 8 Masse für Blau Masse für Synchronsignale ID0 oder digitale Masse 12 - ID1 oder digitaler Datenaustausch 13 Horizontale Synchronisation - 14 Vertikale Synchronisation Takt für Datenaustausch