-         

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: Interrupts fur Anfanger

  1. #1
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    08.08.2004
    Ort
    Zwolle
    Alter
    61
    Beiträge
    531

    Interrupts fur Anfanger

    Anzeige

    Hallo Robotiker,

    Ich habe immer schwierigkeiten wenn's um Interrupts geht.
    Dann mahl ist dies und dann mahl ist dass wieder nicht in ordnung und lauft nichts.

    Ich hab timer/counter0 benutzt um die grune Led jede Sekunde ein und aus zu schalten. Da gibts zwei programme in eine Datei.

    Dass 1e Teil benutzt die timer/counter0 'overflow' Fahne und dass 2e Teil benutzt die timer/counter0 Interrupt. Beide machen die Led ein und aus.

    Hab viel kommentar im Program beigeschrieben.

    Hoffne mahl dass jemand etwas daraus lernen kann.

    Gruss

    Henk
    Angehängte Dateien Angehängte Dateien

  2. #2
    Benutzer Stammmitglied
    Registriert seit
    05.03.2005
    Beiträge
    36

    Interrupts => timer

    Hallo Leutz,

    der Code oben ist mir völlig fremd (und ich dachte, ich kann C).
    Mein größtes Problem ist, das bei z.B. ASURO.C manche Dinge irgendwie nirgends definiert werden und von Datenblättern bzw. Schaltplänen habe ich soviel Ahnung, wie ein Hund vom eierlegen.

    Meine Frage ist, wie man eine Funktion im ASURO aktivieren/ programmieren/ irgendwiereinbringen kann, die einen 'Tick'-Wert in millisekunden zurückliefert, seit der Robbie eingeschaltet wurde. Da die Register, so vermute ich mal, keine 64Bit-Superlong sind, wäre der Wert vielleicht ein 2-Byte int(?). Wäre schön, so eine Funktion in die asuro.c mit zu übernehmen und vielleicht hat jemand in diesem Forum sich darüber schon Gedanken gemacht und diese Interrupt-Beispiel scheint ja irgendwie damit zu tun zu haben.

    Greets


    Banzai

  3. #3
    Benutzer Stammmitglied
    Registriert seit
    01.12.2004
    Ort
    Buxtehude
    Beiträge
    70
    Siehe auch :
    http://www.roboternetz.de/phpBB2/viewtopic.php?t=7571
    erweiterte ASURO Bibliothek.
    Weja

  4. #4
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    08.08.2004
    Ort
    Zwolle
    Alter
    61
    Beiträge
    531
    Hallo Banzai (und andere die's nicht verstehen)

    der Code oben ist mir völlig fremd (und ich dachte, ich kann C).
    na ja, dass ist auch ein bisschen Schade...
    aber dass kann ich mich vorstellen.

    z.B. 'abracadabra, sim sala bim...'

    ========================================
    TCCR2 &= ~ ( (1<<CS22) | ( 1<<CS21) | (1<<CS20) )

    TCCR2 ist ein register im Atmega8L chip, ein Timer/counter2 control register.
    ========================================
    CS22 ist nicht anderes als 2 (wieso denn?)

    in test.c steht irgendwo #include "asuro.h"
    dass heisst an dieser stelle sollte mann eigentlich die Datei asuro.h zwischenfugen, aber da wird die test.c Datei so gross und unubersichtlich und es ist einfacher um hier asuro.c zu includen statt complet zu kopieren.

    aber, aber...

    in asuro.h steht auch wieder #include <avr/io.h>, #include <avr/interrupt.h> und #include <avr/signal.h>

    ai, ai....und wass sehe ich irgendwo in avr/io.h? nah,
    #elif defined (__AVR_ATmega8__)
    # include <avr/iom8.h>


    und wenn wir in <avr/iom8.h> gucken, dort steht irgendwo
    #define CS22 2
    #define CS21 1
    #define CS20 0

    so fur CS22 kann man auch '2' lesen

    ich hab nicht gesagt dasses einfach ist

    <avr/iom8.h> ist die datei C:\WinAVR\avr\include\avr\iom8.h, ja, ja

    ========================================
    TCCR2 &= ~ ( (1<<CS22) | ( 1<<CS21) | (1<<CS20) )

    anders geschrieben
    TCCR2 &= ~ ( (1<<2) | ( 1<<1) | (1<<0) )

    aufmerkung zwischendurch: binair heist so wass wie 'bitweis'.

    1<<2 heist, die 1 wird zweimahl nach links geschoben, oder
    binair: aus 0000 0001 wird 0000 0100
    oder
    hex: aus 0x01 wird 0x04

    anders geschrieben
    TCCR2 &= ~ ( (0x04) | (0x02) | (0x01) )

    die '|' damit is ODER gemeint

    (0x04) oder (0x02) oder (0x01) ist dass gleiche wie
    binair: 0000 0100 = hex: 0x04
    binair: 0000 0010 = hex: 0x02
    binair: 0000 0001 = hex: 0x01
    ------------------------------ oder, oder, macht zusammen
    binair: 0000 0111 = hex: 0x07

    seuche, seuche...

    ========================================
    TCCR2 &= ~ ( (1<<CS22) | ( 1<<CS21) | (1<<CS20) )
    ist gleich wie
    TCCR2 &= ~ ( 0x07 )

    '~' heisst 'invertiere mahl'

    so ~( 0x07 ) ist gleich
    ~ (binair: 0000 0111) = (binair: 1111 1000) = hex: 0xF8

    ========================================
    TCCR2 &= ~ ( (1<<CS22) | ( 1<<CS21) | (1<<CS20) )
    ist gleich wie
    TCCR2 &= 0xF8
    ist gleich wie
    TCCR2 = TCCR2 & 0xF8
    ist gleich wie
    TCCR2 = TCCR2 UND 0xF8

    anders gesagt

    binair: 0110 0011 = TCCR2, mit ein beispiel inhalt, VOR der anderung
    binair: 1111 1000 = hex: 0xF8
    ----------------------------- jetzt ein UND function bitweise durchfuhren
    binair: 0110 1000 = hex: 0x68 = resultat dass wieder zuruck geschrieben wird nach TCCR2

    jetzt kan mann sehen dass die rechter 3 bits in TCCR2 jetzt '0' sind unabhagig wass vorher in die rechter 3 bits von TCCR2 war
    und dass die linker 5 bits in TCCR2 sich NICHT geanderd haben

    so, sosososo,

    ========================================
    TCCR2 &= ~ ( (1<<CS22) | ( 1<<CS21) | (1<<CS20) )
    ist nicht anderes als mache die 3 rechter bits in TCCR2 mahl alle drei '0' und lass die ubrigen bits ungeandert.

    Bis soweit diese Sendung,

    ich wunsche ihnen einen gute nacht

    gruss,

    Henkes

  5. #5
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    08.08.2004
    Ort
    Zwolle
    Alter
    61
    Beiträge
    531
    kleine fehler...

    ai, auwah!

    binair: 0110 0011 = TCCR2, mit ein beispiel inhalt, VOR der anderung
    binair: 1111 1000 = hex: 0xF8
    ----------------------------- jetzt ein UND function bitweise durchfuhren
    binair: 0110 1000 = hex: 0x68 = resultat dass wieder zuruck geschrieben wird nach TCCR2 IST FALSCH

    binair: 0110 0000 = hex: 0x60 = resultat dass wieder zuruck geschrieben wird nach TCCR2 IST GUT

    gruss

    Henk

  6. #6
    Neuer Benutzer Öfters hier
    Registriert seit
    16.02.2005
    Ort
    Berlin
    Alter
    37
    Beiträge
    17
    hi,
    versuch heute schon den ganzen tag die motoren mittels C anzusprechen ohne asuro.h einzubinden
    bekomm das einfach nicht hin ,
    wie macht ihr das???
    könntet ihr da vielleicht ein Codeschnipsel posten, wie gesagt aber ohen einbindung der asuro.h

    müsste dann irgendwie so ähnlich aussehen:

    DDRB |= (1 << PB1) | (1 << PB2);
    PORTB |= (1 << PB5);
    PORTD |= (1 << PD5);
    OCR1A = 0xFF;
    OCR1B = 0xFF;

    mfg der Grave

  7. #7
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    08.08.2004
    Ort
    Zwolle
    Alter
    61
    Beiträge
    531
    Hallo Grave80

    ich hab mahl was zusammen gebastelt.

    Code:
    //NICHT VERGESSEN DIE asuro.c DATEI LEER ZU MACHEN!
    
    //denn die MAKEFILE will asuro.c auch compilieren, und
    //weil 'asuro.h' nicht 'included' ist entstehen compilerfehler
    //wenn 'asuro.c' leer ist gibts kein fehler und daurt das flashen mahl ganz kurz!
    
    #include <avr/io.h>
    
    int main(void){
    
    	//linker motor forwarts/ruckwarts signalen als ausgang schalten
    	DDRD|=(1<<PD5)|(1<<PD4);
    
    	//linker motor forwarts/ruckwarts signalen hoch schalten (inaktief)
    	PORTD|=(1<<PD5)|(1<<PD4);
    
    	//rechter motor forwarts/ruckwarts signalen als ausgang schalten
    	DDRB|=(1<<PB5)|(1<<PB4);
    
    	//rechter motor forwarts/ruckwarts signalen hoch schalten (inactief)
    	PORTB|=(1<<PB5)|(1<<PB4);
    
    	//geschwindigkeits kontrol beider motoren als ausgang schalten
    	DDRB|=(1<<PB2)|(1<<PB1);
    
    	//timer/counter1 prescaler faktor 64 einstellen (nur fur die deutlichkeit bit fur bit programmiert)
    	TCCR1B&=~(1<<CS12);	//CS12 niedrich
    	TCCR1B|= (1<<CS11);	//CS11 hoch
    	TCCR1B|= (1<<CS10);	//CS10 hoch
    
    	//ausgang OC1A hoch/niedrich schalten (wie die ausgang auf timer1 reagieren soll)
    	TCCR1A|=(1<<COM1A1)|(1<<COM1A0);
    
    	//ausgang OC1B hoch/niedrich schalten (wie die ausgang auf timer1 reagieren soll)
    	TCCR1A|=(1<<COM1B1)|(1<<COM1B0);
    
    	//timer1 mode 5 selektieren (nur fur die deutlichkeit bit fur bit programmiert)
    	TCCR1B&=~(1<<WGM13);	//WGM13 niedrich
    	TCCR1B|= (1<<WGM12);	//WGM12 hoch
    	TCCR1A&=~(1<<WGM11);	//WGM11 niedrich
    	TCCR1A|= (1<<WGM10);	//WGM10 hoch
    
    	//linker motor forwarts
    	PORTD&=~(1<<PD4);
    
    	//rechter motor forwarts
    	PORTB&=~(1<<PB4);
    
    	//linker moter  ungefahr ein drittel von maximale geschwindigkeit (0x00 = full speed, 0xFE = am langsahmsten)
    	OCR1A=0xA0;
    
    	//rechter motor ungefahr ein drittel von maximale geschwindigkeit (0x00 = full speed, 0xFE = am langsahmsten)
    	OCR1B=0xA0;
    
    	//UND LOS GEHT'S!!!
    
    	//warte hier
    	while(1);
    	
    	//verlasse die function (wird niemahl ausgefurt, sonst kompilierer warnung)
    	return 0;
    	
    }
    
    
    /*
    
    	Einige bemerkungen:
    
    	- allein bits hoch programmieren ist ganz gefahrlich weil mann nicht da von ausgehen sollte
    	  dass bits die niedrich sein sollten dass schon vorher sind!
    		Mann weiss nie wie das boot-programm die bits hinterlasst.
    		Hat mich schon mache stunde gekostet!
    		
    	- timer1 kent 15 verschiedene modes (mode 5 is gewahlt)
    
    		mode 5 lass timer1 hochzahlen von 0 bis 255 und wieder zurck zahlen nach 0 und wieder hoch zahlen, usw.
    		
    		mode 5:
    		
    		COM1A0/COM1A1 beide hoch heisst: (OC1A = linker motor geschwindigkeits reglung)
    			- wenn timer1 hoch   zahlt und gleich OCR1A ist wird ausgang OC1A hoch
    			- wenn timer1 zuruck zahlt und gleich OCR1A ist wird ausgang OC1A niedrich
    			
    		COM1B0/COM1B1 beide hoch heisst: (OC1B = rechter motor geschwindigkeits reglung)
    			- wenn timer1 hoch   zahlt und gleich OCR1B ist wird ausgang OC1B hoch
    			- wenn timer1 zuruck zahlt und gleich OCR1B ist wird ausgang OC1B niedrich
    		
    		Wie hoher die OC1A/OC1B wert je kurzer ist die ausgang OC1A/OC1B hoch und lauft die motor langsamer
    
    		Die prescaler ist auf 64 gewahlt dass macht die taktfrequenz vom timer1 gleich:
    		8MHz (externen oszillator) geteilt durch 64 macht 488Hz aber weil die timer1 hochzahl und zuruck zahlt
    		bleiben 488Hz/2 = 244Hz ubrich, dass ist die frequenz womit die IC1A/OC1B pinnen pulsieren.
    
    
    		PORTD		PD5				PD4
    						hoch			hoch			= linker motor beide anschliessungen hochohmig/unterbrochen
    						hoch			niedrich	=	linker motor vorwarts 
    						niedrich	hoch			=	linker motor zuruckwarts
    						niedrich	niedrich	=	linker motor beide anschliessungen mit plus verbunden
    
    		PORTB		PB5				PB4
    						hoch			hoch			= rechter motor beide anschliessungen hochohmig/unterbrochen
    						hoch			niedrich	=	rechter motor vorwarts 
    						niedrich	hoch			=	rechter motor zuruckwarts
    						niedrich	niedrich	=	rechter motor beide anschliessungen mit plus verbunden
    
    
    	gruss
    	
    	Arexx-Henk
    	
    
    */
    gruss

    Henk

  8. #8
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    07.03.2005
    Ort
    Essenrode bei Braunschweig
    Beiträge
    182
    //linker motor forwarts/ruckwarts signalen als ausgang schalten
    DDRD|=(1<<PD5)|(1<<PD4);
    Hallo Henk,

    ich gehe mal davon aus, daß PD5 = 5 ist etc.

    Ist
    DDRD|=0x30;
    dann nicht kürzer und übersichtlicher ?
    Wo ist der Vorteil bei der Bitschieberei ?
    Gruß
    Ulli

  9. #9
    Erfahrener Benutzer Roboter Experte
    Registriert seit
    08.08.2004
    Ort
    Zwolle
    Alter
    61
    Beiträge
    531
    Hallo UlliC

    Da hast Du recht.

    DDRD|=(1<<PD5)|(1<<PD4);
    ist gleich wie
    DDRD|=0x30;

    ich gehe mal davon aus, daß PD5 = 5 ist etc.
    in die 'included' Datei avr/io.h wird Datei iom8.h angerufen und darin steht zum Beispiel:
    #define PD5 5
    io.h und iom8.h sind die Dateien:
    C:\WinAVR\Avr\include\avr\io.h
    C:\WinAVR\Avr\include\avr\iom8.h


    Dass ganze Program kann mann auch so schreiben:

    DDRB = 0x33;
    PORTB = 0x20;
    DDRD = 0x30;
    PORTD = 0x20;
    TCCR1A = 0xF1;
    TCCR1B = 0x0D;
    OCR1A = 0xA0;
    OCR1B = 0xA0;


    Aber hier werden alle 8 bits pro byte geschrieben.
    Da sollte mann sich genau bedenken wie die ubrige bits (die nicht fur
    die Motorsteurung benotigt sind) zu schalten sind so dass keine unerwunsten effekte auftreten.

    Wo ist der Vorteil bei der Bitschieberei ?
    Dass Vorteil ist dass mann nur die bits zur sache andert und die ubrige bits nicht andert.

    Die schreibeweise (1<<PD5) wird in Atmega datasheets genutzt und die Asuro entwickler haben dass so ubernommen.
    Deshalb hab ich dass beispiel auch so geschrieben und alles etwas ausfuhrig notiert, nur zum besseren verstandnis.

    Persohnlich finde ich die schreibweise (1<<PD5) ein bischen unschon und unubersichtlich, wenn mann ein bichen die bits kent ist DDRD|=0x20 besser zu lesen als DDRD|=(1<<PD5), aber vielleicht ist dass gesmacksache und sollte mann sich daran gewohnen.

    gruss

    Henk

  10. #10
    Erfahrener Benutzer Fleißiges Mitglied
    Registriert seit
    07.03.2005
    Ort
    Essenrode bei Braunschweig
    Beiträge
    182
    Dass Vorteil ist dass mann nur die bits zur sache andert und die ubrige bits nicht andert.
    Hallo Henk,

    danke für die guten Erklärungen.
    Allerding: Mit der zusammengesetzten Zuweisung |= (bitweises ODER) werden doch immer nur die gesetzten Bits des rechten Operanden dem linken zugewiesen und der linke ansonsten nicht beeinflußt, oder ?

    Ich glaube jetzt werde ich mir auch mal so einen Asuro zulegen....
    Vielleicht krieg ich ihn ja zum Balancieren.

    MfG
    Ulli

Seite 1 von 2 12 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •