RN-Wissen.de - Benutzerbeiträge [de]

Interrupt

2008-09-04T18:30:43Z

Xyt0nite: /* Unterschiede zum Polling */

===Interrupt Request===

"Ein Interrupt ist ein Signal, meist von einem externen Gerät, mit dem der Prozessor aufgefordert wird, den aktuellen Programmablauf anzuhalten (zu unterbrechen) und eine sog. Unterbrechungsroutine ([[ISR]]) aufzurufen." (Zitat aus der Wikipedia [http://de.wikipedia.org/wiki/Interrupt_Request Interrupt Request])

Man unterscheidet zwischen maskierbaren (d.h. Interrupts, die man unterdrücken kann) und nicht maskierbaren Interrupts.

Sind die Interrupts nicht unterdrückt, wird der normale Programmfluss unterbrochen, sobald ein externes Signal an einer von mehreren Interrupt-Eingängen anliegt. Es wird eine spezielle Unterroutine abgearbeitet ([[ISR]]), die auf das externe Signal reagieren und es ggf. abschalten muss (um erneute Interrupt Requests und damit Endlosschleifen zu vermeiden).

Nicht maskierbare Interrupts werden vor allem für besonders schwerwiegende Ereignisse (z.B. zu hohe Umgebungstemperatur) verwendet, da hier das Steuerprogramm immer unmittelbar reagieren muss, um Schaden vom System abwenden zu können (z.B. indem es eine Kühlung aktiviert).

Da die Anzahl der Interrupt-Leitungen bei Microprozessoren meist begrenzt sind, werden oft Interrupt-Controller vorgeschaltet, die auch kaskadiert (in Serie geschaltet) werden können. Um in solch einem System die Interrupt-Quelle eindeutig identifizieren zu können, muss diese dem Microcontroller über den normalen Datenbus z.B. eine Kennung übermitteln können. Die dazu nötige Kommunikation zwischen Microcontroller und Interrupt-Quelle findet in der Interrupt Service Routine statt.

===Unterschiede zum Polling===

Alternativ zur Verwendung von Interrupts lässt sich das Auftreten eines externes Ereignisses auch durch das regelmäßige Abfragen des externen Gerätes erkennen. Diese Technik nennt sich Polling (der Prozessor ''frägt'' das externe Gerät).

'''Vorteile des Pollings gegenüber der Verwendung von Interrupts:'''
* Es ist einfacher zu implementieren, da die Abfrage des Geräts im Hauptprogramm erfolgen kann.
* Es reagiert meist schneller auf das externe Ereignis. Bei Interrupts wird der aktuelle Befehl des Hauptprogramms noch fertig ausgeführt, dann wird die Rücksprungadresse gesichert und in die [[ISR]] verzweigt. Diese wiederrum muss die zu benutzenden Register auf dem Stack sichern, bevor sie mit der eigentlichen Reaktion auf das externe Ereignis beginnen kann. Beim Polling kann nach Erkennung des Ereignisses sofort reagiert werden.
* Es ist weniger Hardwareaufwand bei den Geräten notwendig, da diese nicht in der Lage sein müssen, auf das Auftreten eines Ereignisses mit einer Interrupt-Anfrage zu reagieren. So braucht z.B. ein Temperatursensor für Polling im einfachsten Fall nur einen [[ADC|A/D-Wandler]]. Bei der Verwendung von Interrupts muss er jedoch neben der Möglichkeit, die Temperatur zu messen, zusätzlich auf die Änderung der Temperatur mit einer Interruptanfrage reagieren können.

'''Vorteile von Interrupts gegenüber Polling:'''
* Das Hauptprogramm wird u.U deutlich einfacher und besser verständlich, weil es sich auf das Wesentliche konzentriert, ohne ständig oder von unterschiedlichen Codestellen aus Ereignisse abzufragen zu müssen.
* Das Auftreten des externen Ereignisses wird immer überwacht. Beim Polling geschieht dies nur zu den Zeiten, zu denen das Hauptprogramm danach frägt.
* Das Hauptprogramm kann andere Aufgaben übernehmen als das externe Gerät zu überwachen. Beim Polling wird häufig sämtliche Rechenleistung für die Abfrage der Geräte aufgewendet.
* Die Kommunikationsleitungen, Datenbusse und externen Geräte werden entlastet. Im Gegensatz zum Polling wird nur mit dem Gerät kommuniziert, wenn tatsächlich ein externes Ereigniss stattfindet.
* Es ist oft stromsparender. Hat das Hauptprogramm keine Aufgaben mehr zu erledigen, so kann es Teile der CPU bis zum nächsten Auftreten eines Interrupts in einen stromsparenden Sleep-Mode versetzen. In diesem Modus wird die CPU angehalten und beim nächsten Interrupt wieder aktiviert. Fast alle modernen, interruptfähigen Prozessoren unterstützen einen solchen Modus.

<div style="border:2px solid #ffd700; margin-left:auto; margin-right:auto; padding:0.3em; text-align:left; ">
In den allermeisten Fällen überwiegen die Vorteile der Verwendung von Interrupts deutlich!
</div>

===Interrupt-Sharing===
Stehen auf dem Controller weniger Interruptleitungen zur Verfügung, als interruptfähige Geräte angeschlossen werden sollen, so ist es notwendig, dass sich mehrere Geräte eine Interruptleitung teilen (Interrupt-Sharing). Bei einfachen Controllern kann es sogar vorkommen, dass nur eine einzige [[ISR]] definiert werden kann, die bei '''jeder Art''' von Ereignis aufgerufen wird.
In diesem Fall muss die durch den Interrupt aufgerufene [[ISR|Interrupt Service Routine]] prüfen, bei welchem Gerät das Ereignis aufgetreten ist. Das geschieht wiederrum durch Abfrage jedes in Frage kommenden Geräts (also Polling).
==Siehe auch==
* [[ISR]]

[[Kategorie:Microcontroller]]

Maussensor

2008-06-10T22:05:43Z

Xyt0nite: /* Weblinks */

== Grundsätzliches ==
Computermäuse bieten sich als Entfernungs- und Geschwindigkeitsmesser in autonomen Robotern geradezu an. Die Entwicklung weg von den "Kugelmäusen" hin zu optischen Sensoren hat viele Probleme beseitigt, welche diese Bausteine jetzt hochinterressant erscheinen lassen:
* berührungslos
* billig
* hochintegriert und einfach zu beschalten

Die optischen Mäuse verfügen über eine kleine CCD-"Kamera" von 16x16 bis 30x30 Pixeln. Damit wird ein mikroskopisches Bild des Untergrundes aufgenommen. Über den Vergleich zweier aufeinander folgender Bilder mittels eines integrierten DSPs wird eine Bewegungs-Information errechnet, welche die Bewegungsrichtung (2 Achsen) und Entfernung beinhaltet. Viele dieser Sensorchips haben noch einen "Kompatibilitätsmodus", welcher Quadratur-Signale wie eine Kugelmaus zur Verfügung stellt. Die neueren Chips verzichten darauf immer häufiger.

In einer Maus findet man in aller Regel den Sensorchip selber und einen Controller, der das Sensorsignal auswertet und in ein PS/2 oder USB-Signal umwandelt.

Sehr verbreitet in der Anfangszeit der optischen Mäuse waren die Sensoren von Agilent ADNS2051. Die Chips in vielen Billigmäusen sind dazu kompatibel, auch wenn die Bezeichnungen abweichen.
In den meisten Billigmäusen (< 7€) finden sich der PAN101 oder der kleine Bruder PAN3101 von Pixart.

Häufig kann über den SDIO-Anschluss auch das Sensorbild ausgelesen werden, was praktisch zur Anpassung einer geänderten Optik ist.

== Datenblätter ==
Hilfreich und informativ ist auf jeden Fall das Studium von entsprechenden Datenblättern. Es finden sich sowohl Beispiele für die elektrischen Beschaltung (die häufig sogar 1:1 von den Mausherstellern übernommen wurden) als auch eine exacte Beschreibung der Protokolle. Dabei ist häufig die genaue Taktung wichtig. Auch wenn man "seinen" Maussensor nicht findet, kann einem das Studium vergleichbarer Typen wichtige Hinweise geben, taiwanische und chinesische Chips sind häufig kompatibel zu den "großen" Markenherstellern.

* [[http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=349 ADNS 2610]]
* [[http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=348 ADNS 2051]]
* [[http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=347 PAN 301]]

== Anschluss (elektrisch) ==

Der Anschluss über SDIO ist relativ simpel. Man muss zwei PINS dazu identifizieren, Clock und SDIO.
Der Takt wird vom Controller vorgegeben, damit kann dann Bitweise gelesen oder geschrieben werden.
Die Sensorchips haben in aller Regel auch ein paar Konfigurations-Register, in denen Betriebsmodus und Auflösung eingestellt werden können.

Für die Quadratur-Ausgänge muss man 4 Leitungen am Chip identifizieren.

=== seriell über SDIO ===

Um einen Maussensor an einen Mikrocontroller anzuschliesen braucht man eigentlich nur 2 Leitungen.
* Der SCLK Eingang vom Maussensor wird an einen Output-Pin des Controller angeschlossen.
* Der SDIO oder SDA Aus/Eingang des Maussensors wird an an einen IO Pin des Controllers angeschlossen.
Falls man den Chip aus einer optischen Maus verwenden möchte und sich keinen neuen Chip gekauft hat, muss man die Verbindung der zwei Pins SCLK und SDIO/SDA am Maussensor Chip noch mit einem Teppichmesser oder einer Trennscheibe abtrennen von den Pins des anderen ICs, der die Daten eigentlich an den PC schicken sollte, nun aber überflüssig ist.<br/><br/>
Ansonsten muss man halt noch für die 5V Spannungsversorgung des Maussensors sorgen. Dazu kann man gleich die Anschlüsse (normalerweise Schwarz=GND Rot=+5V) für das Kabel zum PC verwenden. Und wenn man grad dabei ist, kann man auch noch die anderen zwei Leitungen(andersfarbig z.B. Grün und Weiß) die eigentlich mal die Daten zum Pc gebracht haben, rauslöten und an unsere zwei Pins (SCLK und SDIO/SDA) am Maussensorchip löten. So hat man gleich noch das Mauskabel wiederverwertet ;) und hat zum testen erst mal eine schöne Reichweite mit der Maus. Manchmal ist es auch noch hilfreich, den PD-Pin (Power Down) herauszuführen, da man damit den Seriellen Anschluss wieder zurücksetzen kann, wenn man mal aus dem Takt gekommen ist.

=== Über Quadratur-Ausgänge ===

Für die Quadratur-Ausgänge muss man 4 Pins (XA, XB, YA, YB) identifizieren. Wenn man kein Datenblatt des Sensorchips zur Verfügung hat, kann man sie meistens daran erkennen das 4 Leitungen direkt nebeneinander vom Sensorchip zum Controller-Chip laufen.

== Auswertung (Software) ==
Hier bitte Codebeispiele einfügen, anhand derer man einen Einstieg finden kann.
=== seriell über SDIO ===

Der hier vorgestellte Code ist in C geschrieben. Er ermöglicht es einen PAN3101 oder,
nach kleinen Änderungen bei den Registern, einen PAN101 (großer Bruder des PAN3101)
zu beschreiben und auszulesen.<br/><br/>
Das Main Programm liest immer wieder die DeltaXund DeltaY Register ein, wobei auch
eventuelle Überläufe überprüft werden und addiert diese zu den Positionsvariablen
posx und posy. Diese können dann ausgegeben werden.<br/><br/><br/>

<pre>

#define DDR_SCK DDRB /*!< DDR fuer Maus-SCLK */
#define DDR_SDA DDRA /*!< DDR fuer Maus-SDA */

#define PORT_SCK PORTB /*!< PORT fuer Maus-SCK */
#define PORT_SDA PORTA /*!< PORT fuer Maus-SDA */
#define PIN_SDA PINA /*!< PIN fuer Maus-SDA */

#define SCK_PIN (1<<PB0) /*!< PIN nummer fuer Maus-SCK */
#define SDA_PIN (1<<PA0) /*!< PIN nummer fuer Maus-SDA */

/*!
* Uebertraegt ein Byte an den Sensor
* @param data das Byte
*/
void pan_writeByte(unsigned char data){
signed char i;

DDR_SDA|= SDA_PIN; // SDA auf Output

for (i=7; i>=0; i--){

PORT_SCK &= ~SCK_PIN; //SCK auf Low, Daten vorbereiten

if(data&(1<<i)){ //Bit rausschieben
PORT_SDA|=SDA_PIN;
}else{
PORT_SDA&=~SDA_PIN;
}

PORT_SCK |= SCK_PIN; // SCK =1 Sensor uebernimmt auf steigender Flanke

_delay_us(1); //Sensor Zeit lassen um Bit zu holen
}

DDR_SDA &=~ SDA_PIN; //HI-Z state
PORT_SDA &=~ SDA_PIN;

}

/*!
* Liest ein Byte vom Sensor
* @return das Byte
*/
unsigned char pan_readByte(void){
signed char i;
unsigned char data=0;

_delay_us(3); //Sensor Zeit lassen um die Daten aus dem Register zu holen

for (i=7; i>-1; i--){
PORT_SCK &= ~SCK_PIN; // SCK =0 Sensor bereitet Daten auf fallender Flanke vor !

_delay_us(1); //Sensor kurz zeit lassen

PORT_SCK |= SCK_PIN; // SCK =1 Daten lesen auf steigender Flanke

if(PIN_SDA&SDA_PIN){ //BIT einlesen
data |= (1<<i);
}else{
data &=~ (1<<i);
}

}
return data;
}

/*!
* Uebertraegt ein write-Kommando an den Sensor
* @param adr Adresse
* @param data zu schreibendes byte
*/
void pan_write(unsigned char adr, unsigned char data){
adr|=(1<<7);
pan_writeByte(adr); //rl MSB muss 1 sein für Write Operation
pan_writeByte(data);
}

/*!
* Schickt ein Lesekommando an den Sensor
* und liest ein Byte zurueck
* @param adr die Adresse
* @return der registerwert
*/
unsigned char pan_read(unsigned char adr){

pan_writeByte(adr);
return pan_readByte();
}

/*!
* Initialisiere PAN3101

!! Muss unbedingt ganz am ANFANG von main stehen, sonst gibts FEHLER !!
(wenn der PAN3101 sich initialisiert hat, bevor der Controler SCK und
SDA auf Output gestellt hat)
Deshalb kann es auch sinnvoll sein die Powerup Zeit in den Config Bits
auf 4ms zu stellen oder noch besser mit Boden zu arbeiten.

*/
void pan_init(void){

DDR_SCK |= SCK_PIN; // SCK auf Output
DDR_SDA |= SDA_PIN; //SDA auf Output

PORT_SCK |= SCK_PIN; // SCK auf high
PORT_SDA|= SDA_PIN; //SDA auf high

// hier müssen bei Umstellung auf PAN101 die entsprechenden Register gesetzt werden
//Reset PAN3101
pan_write(0x00,0x80);
// kein Sleep modus
pan_write(0x00,0x01);
}

int main(void){

unsigned char ino;
signed char x,y;
signed short posx=0,posy=0;

//ganz an den Anfang damit der Controller schneller asl der PAN ist um Fehler zu vermeiden
pan_init();
//Individuelle Port Configuration und Initialisierung
initialisierung();

lcd_init(LCD_DISP_ON);
lcd_clrscr();

while(1){

//Endlosschleife

ino=pan_read(0x16);

//wenn 7tes bit vom Register 0x16 gesetzt ist wurde die Maus bewegt => Bewegungsdaten abfragen
if(ino&(1<<7)){
//Deltax Register auslesen
x=pan_read(0x17);
//und zu der Positionvariable addieren
posx=posx+x;

/* Nachschaun ob das Überlauf-Bit im Register 0x16 gesetzt ist
wenn das der Fall ist muss je nach Vorzeichen der Deltax Variable x
noch 128 (überlauf nach oben) dazugezählt oder eben 128 abgezogen werden
*/
if(ino&(1<<3)){
if(x<0){
posx-=128;
}else{
posx+=128;
}
}

//ab hier nochmal das Gleiche für die yRichtung

y=pan_read(0x18);
posy=posy+y;

if(ino&(1<<4)){
if(y<0){
posy-=128;
}else{
posy+=128;
}
}

}

//hier kann jeder seine Ausgabevariante selber wählen ;)

lcd_ausgabe_int(0,3,posx);
lcd_ausgabe_int(7,3,posy);

}

return 0;
}

</pre>
<br/>
Das Programm wurde mit einem PAN3101 auf einem ATMega32 mit 14,7456 Mhz getestet und lief problemlos.

=== über Quadratur-Ausgänge ===

==Autor/en==
* Reinald
* Javik

==Siehe auch==
*[[Sensorarten]]

==Weblinks==
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=6782 Thread im RN-Forum] 6782 Fragen zum optischen Maussensor von Agilent
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=6894 Thread im RN-Forum] 6894 Optische Maus: geänderte Fokus-Distanz
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=11548 Thread im RN-Forum] 11548 GeneralKeys Lasermaus als Sensor für die Odometrie
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=12579 Thread im RN-Forum] 12579 Sensor einer Optischen Maus zur Streckenmessung
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=13271 Thread im RN-Forum] 13271 Programmierung des ADNS 3060
*[http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=22353 Thread im RN-Forum] 22353 Schnittstelle für PAN101(Sensor einer optischen Maus)

*[http://www.pixart.com.tw/ Pixart] Hersteller diverser Maussensoren hat u.a. Datenblätter zum PAN3101

*[http://www.mstarmetro.net/~rlowens/OpticalMouse/ guter Internetseite über diverse Maussensoren]
[[Kategorie:Sensoren]]