Vor der Benutzung eines Ports ist für die einzelnen Portanschlüsse die Datenrichtung festzulegen:

Transkript

1 AVR-Mikrocontroller ATmaga32 in AVR-GCC Programmieren Ein-Ausgabe-Ports Der Mikrocontroller ATmage32 hat 4 8Bit-Ports zum Datenaustausch mit der Peripherie: PORT A, PORT B, PORT C und Port D. Die einzelnen Bits dieser Ports können unabhängig von einander als Eingänge oder Ausgänge benutzt werden. Die Programmierung erfolgt jeweils über 3 8Bit-Register: Port Port A Port B Port C Port D BitNr (A) Datenrichtungsregister DDRA DDRB DDRC DDRD DDAx Datenausgaberegister PORTA PORTB PORTC PORTD PAx Pin-Leseregister PINA PINB PINC PIND PINAx Vor der Benutzung eines Ports ist für die einzelnen Portanschlüsse die Datenrichtung festzulegen: Beispiel für Port A: Bits 4-7 Ausgänge, Bits 0 bis 3 Eingänge, DDRA = 0xf0; // entspricht binär Ausgänge werden mit 1, Eingänge mit 0 programmiert. Mit dem Datenausgaberegister PORTA (kein Leerzeichen!) können nun an den Port A Daten ausgegeben werden: Beispiel: Es soll ausgegeben werden: PA7=1, PA6=1, PA5=0, PA4=1 PA0 bis PA7 sind die Bezeichnungen der Bits. PORTA=0xD0; // binär Der in der AVR-Gemeinde bevorzugte Programmierstil arbeitet mit den Shift- Operator: PORTA = (1<<PA7) (1<<PA6) (1<<PA4); Erklärung: PA7 steht für 7, PA6 für 6 und PA4 für 4. (1<<PA7) Verschiebt die 1 im Byte um 7 Stellen nach links:

2 Aus wird Das heißt (1<<PA7) berechnet den Gewichtungsfaktor von Bit7 (128). Die einzelnen Gewichtungsfaktoren für zu programmierende Einsen werden dann oder-verknüpft: oder oder entspricht 0xD0 Durch Setzen einer 1 im Register PORTA können bei den programmierten Eingängen interne PULL-UP-Widerstände programmiert werden, zum Beispiel, um Schalter gegen Masse anzuschließen. Ein einzelnes Portbit setzen: sbi(porta, PA5); // mit #include "bit.h" oder PORTA =(1<<PA5); Mehrere einzelne Portbits setzen: PORTA =(1<<PA5) (1<<PA6); oder PORTA= PORTA 0x60; Ein einzelnes Portbit zurücksetzen: cbi(porta, PA5); // mit #include "bit.h" oder PORTA &= ~(1<<PA5); PORTA &= ~((1<<PA5) (1<<PA6)) oder PORTA= PORTA & (~0x60);

3 Mit dem Pin-Leseregister können nun die als Eingänge definierten Anschlüsse gelesen werden: Den ganzen Port lesen: unsigned char ein; // besser: uint8_t ein; ein=pina; Ein einzelnes Bit testen: if(bit_is_set(pina, PINA2)) //Wenn Bit 2 Eins ist, oder if(bit_is_clear(pina, PINA2) //Wenn Bit 2 Null ist, oder if(pina&(1<<pina2)) //Wenn Bit 2 Eins ist, oder if(!(pina&(1<<pina2)) //Wenn Bit 2 Null ist

4 Bitverarbeitung mit Hilfe einer Union mit Bitfeld Header-Datei bbbk.h #ifndef _bbbk_ #define _bbbk_ typedef union { uint8_t byte; struct { uint8_t b0 : 1; uint8_t b1 : 1; uint8_t b2 : 1; uint8_t b3 : 1; uint8_t b4 : 1; uint8_t b5 : 1; uint8_t b6 : 1; uint8_t b7 : 1; bit; bbbk; Diese Typdefinition ermöglicht den direkten Zugriff ein Byte und auf die einzelnen Bits dieses Bytes: Man kann nun "Hybrid"-Variablen anlegen, die als Byte oder auch in ihren einzelnen Bits angesprochen werden können: bbbk a; #endif Ansprechen als Byte(lesen + schreiben): a.byte = 0xab; // a.byte < Ansprechen eines Bits (lesen + schreiben) a.bit.b6 = 1; // Bit 6=1 => a.byte <

5 bit.h Weiter zusätzliche Header-Dateien #ifndef cbi #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) //Löschen eines Bits in einem Register //Beispiel cbi(portc,pc5) oder cbi(portc,5) löscht Bit5. //Alle anderen Bits werden nicht verändert. #endif #ifndef sbi #define sbi(sfr, bit) (_SFR_BYTE(sfr) = _BV(bit)) //Setzen eines Bits in einem Register //Beispiel sbi(portc,pc5) oder cbi(portc,5) setzt Bit5 auf 1. //Alle anderen Bits werden nicht verändert. #endif #ifndef bit_is_set #define bit_is_set(sfr, bit) (_SFR_BYTE(sfr) & _BV(bit)) //Prüft, ob ein Bit in einem Register gesetzt (1) ist. //Beispiel if(bit_is_set(pinc,pinc0))... // oder if(bit-is_set(pinc,0))... #endif #ifndef bit_is_clear #define bit_is_clear(sfr, bit)!(_sfr_byte(sfr) & _BV(bit)) //Prüft, ob ein Bit in einem Register gelöscht (0) ist. //Beispiel if(bit_is_clear(pinc,pinc0))... // oder if(bit-is_clear(pinc,0))... #endif

6 warten.h #include <avr/delay.h> void warten1s(void){ uint8_t n; for(n=0;n<50;n++) _delay_ms(160);//50*(160/8) ms = 1 Sekunde bei 8MHz void warten1ms(void){ _delay_ms(8);//(8/8) ms = 1 ms bei 8MHz void warten10ms(void){ _delay_ms(80);//(80/8) ms = 10 ms bei 8MHz void warten100ms(void){ uint8_t n; for(n=0; n<5;n++) _delay_ms(160);//5*(160/8) ms = 100 ms bei 8MHz void warten_ns(unit8_t n){ uint8_t k; for(k=0;k< n ; k++) warten1s();

7 Aufgaben: Port C wird mit der Erweiterungskarte verbunden: PORT C --- SV4. Die Jumper 5V und Pull-Down sind gesteckt. Damit liegt folgende Beschaltung von Port C vor: +5V PC0 S9 PC1 S10 PC2 S11 PC3 S12 PC4 PC5 PC6 PC7 LED 1 LED 2 LED 3 LED 4 0V A1) Im Grundzustand sind alle LEDs aus. Bei gedrücktem Taster S9 leuchtet LED1. Nach Loslassen von S9 geht das LED 1 wieder aus. A2) Im Grundzustand sind alle LEDs aus. Bei Betätigung von S9 werden alle LEDs eingeschaltet und bei Betätigung von S10 wieder ausgeschaltet. A3) Erweitern Sie das Programm A1) so, dass auch die Taster S10 bis S13 die entsprechenden LEDs LED 2 bis LED 4 einzeln schalten! A4) Nach Betätigen des entsprechenden Tasters soll der Leuchtzustand des zugeordneten LED umgeschaltet (getoggelt) werden und bis zur nächsten Betätigung des zugeordneten Tasters erhalten bleiben.

8 A5) Es soll die folgende logische Schaltung simuliert werden: PC0 = PC4 PC0 >1 = PC6 PC3 PC1 PC1 = PC5 PC2 & PC7 PC2 PC3 A6) Die logische Schaltung der Aufgabe 5 liegt extern vor. Erstellen Sie ein Programm, das eine Qualitätskontrolle der Schaltung vornimmt!

9 Lösungen: zu A1 Version 1) int main(void) { DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen while (1) { if((pinc&(1<<pinc0))==1) PORTC =(1<<PC4); //Wenn Taste gedrückt, Led ein, else PORTC&=~(1<<PC4); // sonst Led aus zu A1 Version 2) #include "bit.h" int main(void) { DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen while (1) { if(bit_is_set(pinc,pinc0)) sbi(portc,pc4); else cbi(portc,pc4);

10 zu A1 Version 3) include <avr/io.h> #include "bbbk.h" int main(void) { bbbk PinC, PortC; //Hybrid-Variablen vereinbaren DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen PortC.byte=0; //Byte der Variablen PortC auf 0 setzen while (1) { PinC.byte = PINC; //Pin-Byte lesen if(pinc.bit.b0==1) PortC.bit.b4=1; else PortC.bit.b4=0; PORTC=PortC.byte; //Port-Byte schreiben zu A2 Version 1) int main(void){ DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen do { if(pinc&(1<<pinc0)) PORTC =(1<<PC4) (1<<PC5) (1<<PC6) (1<<PC7); // oder PORTC =0xf0; if(pinc&(1<<pinc1) PORTC&=~((1<<PC4) (1<<PC5) (1<<PC6) (1<<PC7)); // oder PORTC&=0x0f; while(1);

11 zu A2 Version 2) #define Taster1_gedrueckt PINC&(1<<PINC0) #define Taster2_gedrueckt PINC&(1<<PINC1) #define AlleLedsEinschalten PORTC =(1<<PC4) (1<<PC5) (1<<PC6) (1<<PC7) #define AlleLedsAusschalten PORTC&=~((1<<PC4) (1<<PC5) (1<<PC6) (1<<PC7)) int main(void) { DDRC=0xf0; do { if(taster1_gedrueckt) AlleLedsEinschalten; if(taster2_gedrueckt) AlleLedsAusschalten; while(1); Hinweis: Der Compiler ersetzt vor der Compilierung die in den "#Defines" definierten Texte durch die rechts stehenden Ausdrücke. So kann man ein Programm besser lesbar machen. zu A3) int main(void){ DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen do{ if(pinc&(1<<pinc0)) PORTC =(1<<PC4); else PORTC&=~(1<<PC4); if(pinc&(1<<pinc1)) PORTC =(1<<PC5); else PORTC&=~(1<<PC5); if(pinc&(1<<pinc2)) PORTC =(1<<PC6); else PORTC&=~(1<<PC6); if(pinc&(1<<pinc3)) PORTC =(1<<PC7); else PORTC&=~(1<<PC7); while(1);

12 zu A4) #include "warten.h" int main(void){ DDRC=0xf0; // PC4 - PC7 als Ausgänge einstellen do{ if(pinc&(1<<pinc0)) { PORTC^=(1<<PC4); while(pinc&(1<<pinc0)); warten100ms(); if(pinc&(1<<pinc1)) { PORTC^=(1<<PC5); while(pinc&(1<<pinc1)); warten100ms(); if(pinc&(1<<pinc2)) { PORTC^=(1<<PC6); while(pinc&(1<<pinc2)); warten100ms(); if(pinc&(1<<pinc3)) { PORTC^=(1<<PC7); while(pinc&(1<<pinc3)); warten100ms(); while(1); Erklärung: while(pinc& ) warten100ms() Warten auf Loslassen der gedrückten Taste zum Entprellen der Taster

13 zu A5 Version1 #include "bit.h" int main(void) { uint8_t b0,b1,b2,b3; DDRC=0xf0; do{ if(pinc&(1<<pinc0)) b0=1; else b0=0; if(pinc&(1<<pinc1)) b1=1; else b1=0; if(pinc&(1<<pinc2)) b2=1; else b2=0; if(pinc&(1<<pinc3)) b3=1; else b3=0; if(b0==b3) PORTC =(1<<PC4); if(b1!=b2) PORTC =(1<<PC5); if(!(b0 b1)) PORTC =(1<<PC6); if(!(b2&b3)) PORTC =(1<<PC7); else PORTC&=~(1<<PC4); else PORTC&=~(1<<PC5); else PORTC&=~(1<<PC6); else PORTC&=~(1<<PC7); while(1); /* Beispiel Bit0 und Bit3 sind 1: PINC&(1<<PINC0) == PINC&(1<<PINC3) geht nicht! Diese Bytes werden hier verglichen! Da die Bits an verschiedenen Stellen im Byte liegen, sind die Bytes trotzdem ungleich! */

14 A5 Version 2 #include "bbbk.h" int main(void){ bbbk PinC,PortC; PortC.byte=0; DDRC=0xf0; do{ PinC.byte=PINC; if(pinc.bit.b0==pinc.bit.b3) PortC.bit.b4=1; else PortC.bit.b4=0; if(pinc.bit.b1!=pinc.bit.b2) PortC.bit.b5=1; else PortC.bit.b5=0; if(!(pinc.bit.b0 PinC.bit.b1)) PortC.bit.b6=1; else PortC.bit.b6=0; if(!(pinc.bit.b2 & PinC.bit.b3)) PortC.bit.b7=1; else PortC.bit.b7=0; PORTC=PortC.byte; while(1);

15 A5 Version 3 mit Array const uint8_t aus[16]={0xd0,0x80,0xb0,0xa0,0xf0,0xa0,0x90,0x80, 0xc0,0x90,0xa0,0xb0,0x60,0x30,0x00,0x10; uint8_t ein; int main(void){ DDRC=0xf0; do{ ein=pinc&0x0f; PORTC=aus[ein]; while(1);

16 A6 #include <lcd.h> #include "warten.h" /* Mikrocontrollersystem ATmega32 BBBK: Qualitätskontrolle einer externen logischen Schaltung: Autor: Wolfgang Tschallener Schaltung: bit4=(bit0==bit3) Äquivalenz bit5=(bit1!= Bit2) Antivalenz bit6=nor(bit0,bit1) NOR bit7=nand(bit2,bit3)nand Verbindungen: PortA und Sonderstecker an Prüfschaltung PortD - SV2 für LCD-Display */ uint8_t sollwert[16]={0xd0,0x80,0xb0,0xa0,0xf0,0xa0,0x90,0x80, 0xc0,0x90,0xa0,0xb0,0x60,0x30,0x00,0x10; uint8_t istwert,ein,fehler; int main(void){ lcd_init(0x0c); DDRA=0x0f;//Bit 0-3 Ausgänge (1), Bit 4-7 Eingänge (0) fehler=0; for(ein=0;ein<16;ein++){ PORTA=ein; warten100ms(); istwert = PINA&0xf0; lcd_gotoxy(0,0);lcd_puts("ist "); lcd_puti(istwert,3); lcd_gotoxy(0,1);lcd_puts("soll ");lcd_puti(sollwert[ein],3); warten100ms(); if(istwert!=sollwert[ein]) fehler=1;

17 lcd_clrscr(); lcd_gotoxy(0,0); if(fehler) lcd_puts("fehler!!!"); else lcd_puts("alles OK!"); while(1); //Das ist eine Endlosschleife