Senden und empfangen auf dem UART mit ISR kompatibel zur bisherigen RP6lib

[RolfD]

Ok, da das Thema ISR für dich Neuland zu sein scheint, versuche ich das noch etwas genauer zu erklären.

Prozessoren arbeiten normalerweise einfach ein Programm ab und fragen dabei Zustände ab.
Auch wenn Prozessoren dabei sehr schnell sind, bedeutet das ggf. warten auf ein Ereignis/Zustand.
Wärend des Wartens kann es nun sein das an anderer Stelle etwas passiert, also ein Ereignis statt findet.
Dafür hat man Interrupts erfunden. Der erste, wichtigste und selbstverständlichste "Interrupt"
ist eigentlich das Reset Signal. Es zwingt den Prozessor die Programmstruktur von vorn abzuarbeiten, und
unterbricht die laufende Arbeit.
Es gibt weitere Interrupts, manche hängen mit externen Leitungen zusammen, manche passieren auf Grund
von Änderungen im Prozessor. Der Unterschied von einem Reset zu einem echten Interruprt wie man es im
RP6 nutzt ist, das man nach einem Interrupt an der Stelle weiter arbeiten kann, wo man vom Interrupt
unterbrochen wurde. Wärend einer Warteschleife kann also auf Anforderung eines Interrupts spezieller Code
abgearbeitet werden und nach Beendigung des Spezialcodes kehrt der Prozessor an seine Warteschleife zurück.
Diesen speziellen Code nennt man ISR. Interrupts haben dabei Eigenschaften.

Interrupts kann man per Software einzeln oder alle ab und an schalten.
Interruptquellen gibt es massenhaft... ich meine so um ca. 20 im RP6 und werden durch bestimmte Ereigisse ausgelöst.
Andere Prozessoren kennen bis zu mehrere hundert und sogar per Software auslösbare.
Allerdings muss man eine ISR nur für die Interrupts haben wenn man diesen speziellen Interrupt auch braucht / nutzt.
Interrupts bzw. die Ausführung der passenden ISR können geschachtelt passieren wenn 2 Interrupts dicht aufeinander folgen.
ISR sollten kurz sein damit schnell wieder zum vorherigen Programmteil zurück gesprungen werden kann.
Das Hauptprogramm merkt nicht das es durch ein Interrupt unterbrochen wurde. Da ISR aber Register und Variablen ändern
können, sollten alle diese Variablen als volatile definiert sein.
Der Compiler sorgt durch die Definition ISR dafür, das die Register im Prozessor vor Ausführung der ISR gesichert und bei beenden
der ISR der alte Zustand in den Registern wieder hergestellt werden.

Eine ISR ist also ein kleines Stück Programm, welches unabhängig vom Hauptprogramm bei Eintreten eines Ereignisses
ausgeführt wird. Nehmen wir als Beispiel einen Radencoder aus der RP6RobotBaseLib.c.

ISR (INT0_vect)
{
    mleft_dist++;
    mleft_counter++;    
}

Der Radencoder leitet sein Signal ENC_R oder L laut Schaltplan an PD2 bzw. PD3. Impulse an PD2 und PD3 führen
daher zum auslösen des jeweiligen Interrupts. Eingeschaltet wurden die Interrupts in der Funktion void initRobotBase(void)
unter // Initialize External interrupts:

Rollt der RP6 nun, werden sehr viele Interrupts ausgelöst und wie in der ISR zu sehen 2 Variablen aufaddiert.
Würden wir an der Stelle keinen Interrupt einsetzen, müsste der Prozessor laufend den Eingang auf Veränderungen abfragen.
Gehen würde das auch aber der RP6 könnte kaum noch was anderes machen.
Also nutzt man da besser Interrupts.

Guckst du dir nun das UART file an, wirst du sehen das zum Empfangen von Zeichen schon eine ISR genutzt wird.
Beim senden wird in der Originaldatei das Senderegister durch eine Warteschleife mit while (!(UCSRA & (1<<UDRE)));
abgefragt. Das bedeutet, der Prozessor wartet mit dem versenden von Zeichen IM HAUPTPROGRAMM bis jeweils das Senderegister leer ist um ein weiteres Zeichen zu versenden.
In der Zeit passieren zwar Interrupts aber er macht eben nichts anderes.
Meine Änderung ist in der Hauptsache der Umbau der Sendefunktion auf ISR, so das das nächste Zeichen aus einem Ringbuffer (32 Byte) "automatisch" bzw. per ISR ins Senderegister kopiert wird sobald das Register frei ist. "Senderegister frei" ist dabei eine der vielen Interrupt quellen. Das Hauptprogramm füllt also den Buffer und die ISR arbeitet das ab.
Es gibt 2 Situationen, die eine Ausnahme erfordern. Buffer voll.... dann muss eben doch gewartet werden bis wieder Platz
im Buffer ist.. oder Buffer leer.. ist nichts zum senden da ...dann muss man den Interrupt abschalten.
Daraus folgt, das man in der Sendefunktion den Interrupt zunächst anschalten muss damit die ISR dann die weitere Arbeit
machen kann... Das ist auch der Unterschied zwischen Radencoder- und UART-ISR ..Die ISR für die Radencoder läuft
immer, die SendeISR nur dann wenn Zeichen zu übertragen sind. Damit wartet aber nicht mehr das Hauptprogramm auf "Senderegister frei". Das verändert natürlich das Laufzeit Timing des Hauptprogramms so lange der Buffer nicht voll ist.
Ein komplexes Betriebssystem könnte nun z.B. auch noch den Buffer vergrößern wenn es auf "Buffer voll" trifft. Für den RP6 ist das aber zu komplex bzw. zu viel Aufwand.

ISR sind also kleine Progrämmchen, die auf ein Event (IRQ oder Interruptrequest) hin unabhängig vom Hauptprogramm
vom Prozessor angesprungen werden. Das ist ein sehr vielseitiges Konzept und kann sogar dafür genutzt werden,
eine Form von Multitasking (Timeslicing) zu nutzen indem per ISR und Timerinterrupt zwischen mehreren Hauptprogrammen
umgeschaltet wird. Beim RP6 wird dies so nicht genutzt, dort laufen aber viele Reaktionen auf Sensoren über ISR.

So.. das war eine kurze Einführung zum Thema ISR aus dem Ärmel geschüttelt. Vielleicht hilft dir das weiter.

Weitere Änderungen von mir betreffen eigentlich nur einen etwas anderen (einfacherem) Ringbuffer Algorithmus, die Erkennung des Zeichen 0x00, welches vorher nicht erkannt werde konnte weil 0x00 als returnwert für "kein char empfangen" stand und ein wenig Kosmetik.
Gruß

[inka]

Ok, da das Thema ISR für dich Neuland zu sein scheint, versuche ich das noch etwas genauer zu erklären.

danke für diese hilfreiche erklärung. Werde ich sicher noch paarmal lesen...

Rollt der RP6 nun, werden sehr viele Interrupts ausgelöst und wie in der ISR zu sehen 2 Variablen aufaddiert.
Würden wir an der Stelle keinen Interrupt einsetzen, müsste der Prozessor laufend den Eingang auf Veränderungen abfragen.
Gehen würde das auch aber der RP6 könnte kaum noch was anderes machen.
Also nutzt man da besser Interrupts.

was mich sehr reizen würde wäre eine kommunikation mit dem RP6, wenn er etwas weiter entfernt ist. Kabellos kann ich ja jetzt kontakt halten, ich möchte z.b dass er es mitteilt, wenn bestimmte ereignisse eintreten und auch auf anweisungen reagiert. Nicht als RC-auto oder steuerung über die fernbedienung - verstehst Du was ich meine? Ich habe jetzt aber erstmal noch keinen plan wie ich es anfange, nur völlig nebelhafte ideen...

Interrupts kann man per Software einzeln oder alle ab und an schalten.
Interruptquellen gibt es massenhaft... ich meine so um ca. 20 im RP6 und werden durch bestimmte Ereigisse ausgelöst.
Andere Prozessoren kennen bis zu mehrere hundert und sogar per Software auslösbare.

ist z.b. der MRESET (ist ja auch ein interrupt) per software auslösbar?

[RolfD]

Also so weit ich weiss, ist die Reset Leitung /RESET eine Input Schaltung am Prozessor.
Seite 34 im PDF zur CPU unter "System Control and Reset" beschreibt aber schon allein 5 Quellen, u.a. auch ein Watchdog,
also eine Art Timer der ein Reset auslösen kann. JTAG Adapter und auch der RS232 Adapter von AREXX können die CPU
ebenfalls von extern aus resetten. Technisch ist resetten aber nur das zwangsweise setzen der CPU auf ein definierten Zustand...
Ich kann mir vorstellen das es in Assembler einen Reset Befehl gibt, ich weis aber nicht ob dieser dazu führt,
das auch das externe /Reset Signal bedient wird. Im simpelsten Fall kann man per Software ein Reset bewirken indem man den Reset Vektor anspringt.
In Normalfall verwendet man sowas aber nicht, da man auch jedes mal die CPU initialisieren müsste. Da kann man aber statt dessen auch gleich die CPU in den State bringen, den sie haben soll.
Es geschehen ja nicht irgend welche wunderlichen Dinge beim resetten - wenn man mal von so Dingen wie dem Bootloader absieht.
Da würde ich dich aber thematisch gern an Slyd verweisen weil der Bootloader nach wie vor nicht open source und auch kaum dokumentiert ist.
Man kann sich aber durchaus auch freie Bootloader angucken und lernen... allerdings ist das glaube ich zu speziell für RP6 Anwender und nicht essentiell für das allgemeine Verständnis von Interrupts relevant. Ich hatte den Reset auch nur angeführt um zu zeigen das die aktuelle Programmausführung durch ein externes Signal unterbrochen wird ohne das das Hauptprogramm das mitbekommt. Von einem Reset aus wird nicht zurück ins Programm gesprungen, von einem INT aus durch reti ja. reti = assemblerbefehl am Schluß einer ISR vergleichbar mit "return from interrupt".

Gruß

[RolfD]

Ich versuche hier mal laut zu denken...
Es gibt ja die stdio Funktionen, welche man evtl. aus anderen Projekten kennt. Leider führen diese Funktionen zu einer doch recht relevanten code Vergrößerung von ca. üblichen 40 byte RAM und 1400 byte Code, allerdings bieten die auch genormte, erprobte, einheitliche Schnittstellen. Wenn man um jedes Byte Platz in der CPU kämpft, sollte man sie vielleicht vermeiden. Klar! Als einfache "Hallo Welt" Write Funktionen reichen die internen aus der RP6 Lib allemal.
Entschlackt man aber die Programme und wirft die RP6 Funktionen raus, spart man auch wieder Platz. Die reale Codegröße im Projekt ist also kleiner als die stdio Funktionen auf den ersten Blick brauchen. Ich schätze mal vielleicht 1000 Byte. Nimmt man noch mal den vorhandenen Aufwand für bisher extra schreib/lese Funktionen bei TWI, LCD und File_IO auf SD und EEPROM in der RP6 lib, verkleinert sich der Platzbedarf letztlich noch mal gegenüber der bisher genutzten Write Geschichten. Man braucht ja letztlich nur eine lese/schreib funktion per "device" und den rest erledigt printf/scanf. Allerdings ist man dann an die Möglichkeiten dieser Funktionen auch zunächst gebunden. Viele größere Projekte bauen allerdings auf die stdio auf.

Eine Ausgabe auf RS232 und alternativ TWI sähe dann so aus:

// Filehandle erstellen
    static FILE uart_io = FDEV_SETUP_STREAM (uart_putchar, uart_getchar, _FDEV_SETUP_RW);
    static FILE twi_io = FDEV_SETUP_STREAM (twi_putchar, twi_getchar, _FDEV_SETUP_RW);

//Zuweisung von Standardkanälen, kann alles mögliche an devices sein
    stdin = stdout = &uart_io;
//Ausgabe auf Standardkanal
    printf     ("Hello, world!\n");
//Ausgabe auf TWI-Kanal
    fprintf (twi_io,"Hello, world!\n");
//jetzt wird TWI-Kanal als Standard Kanal getauscht
    stdin = stdout = &twi_io;
//Ausgabe auf UART-Kanal
    fprintf (uart_io,"Hello, world!\n");
//Ausgabe auf twi als Standardkanal
    printf     ("Hello, world!\n");

Das würde natürllich auch mit scanf, also formatierter Eingabe gehen... und es ständen eben alle Funktionen aus der stdio zur Verfügung.
Das Ganze hat neben dem Platzbedarf einen großen Nachteil für Anfänger und die Demo-Programme.
Man müsste entweder die Write Funktionen auf das stio umschreiben was wieder Platz kostet...
oder man müsste die Demos auf stdio umschreiben was viel Arbeit ist.
Die stdio Funktionen bieten auch die Formatierungen der rp6 Write Funktionen und mehr... incl. WriteLong und WriteFloat und ähnlichem Krempel.

Der Nutzen von stdio wächst mit der Komplexität von Ein/Ausgaben, ein Projekt was jedoch nur ab und zu eine debug Meldung absetzt und ansonsten nur als Statemachine Sensoren abfragt, profitiert weniger davon. Aber wenn es auf geregelte Kommunikation ankommt... also bei Funkmodulen, diverse UARTs, I2C zwischen Prozessorboards, Filesystemen usw., ist sie von Vorteil.

Ich hab ein bischen versucht, die Vor und Nachteile abzuwägen.. nun meine Fragen an euch: Würdet ihr auf stdio umsteigen? Besteht Bedarf für eine angepasste Lib? Wie seht ihr das?

Gruß

[Dirk]

Hi RolfD,

prinzipiell finde ich deinen Vorschlag gut, allerdings habe ich Verständnis-Fragen dazu:

1. Der Hauptzweck mobiler Roboter besteht ja sicher eher nicht darin, Messwerte und Daten in großer Menge ANZUZEIGEN, sondern ihr Verhalten daran auszurichten. Das heißt nicht, dass das Anzeigen von Daten nicht wichtig wäre: Im Gegenteil kann man das gut zur Kontrolle der eigenen Programmierung nutzen. Frage: Braucht man also optimierte Ausgabefunktionen unter der genannten Einschränkung?

2. Durch die Aufteilung der Prozessoren im RP6-System (Base, M32, M128, M256 WiFi) auf jeweils eigene autonome Systeme müßte man ja im Prinzip die printf/scanf Funktionen für jede dieser Plattformen zur Verfügung stellen (das ist ja bei den jetzigen Funktionen auch so). Macht das Sinn?

3. Die printf/scanf Funktionen haben ja ihre Hauptvorteile neben den standardisierten Formatierungen in der einfachen Wählbarkeit des Ein-/Ausgabekanals. Das finde ich natürlich auch reizvoll. Aber: Nicht alle "Kanäle" (I2C, UART, SPI, Filezugriff auf SD, int./ext. EEPROM ...) sind auf allen Plattformen verfügbar. D.h. man würde nicht den Zugriff auf alle Kanäle auf jeder Plattform brauchen. Einverstanden?

4. Reizvoll wäre auch, wenn die verschiedenen Kanäle über das komplette RP6-System von allen Plattformen hinweg angesprochen werden könnten. Das scheitert allerdings daran, dass als alleinige Verbindung zwischen den Plattformen der I2C-Bus vorgesehen ist. Dazu kommen dann nur noch je nach Hardwareausstattung wenige Ein-Ausgabekanäle auf der jeweiligen Plattform. Und: Zur kabelgebundenen Verbindung zum PC wird ausschließlich der UART verwendet, eine Kommunikation ist aber davon abhängig, ob das Interface gerade an die jeweilige Plattform angeschlossen ist. Welche Vorteile könnten printf/scanf Funktionen bei dieser vorliegenden Hardware bringen?

5. Was meinst du mit "Entschlackt man aber die Programme und wirft die RP6 Funktionen raus, spart man auch wieder Platz."? Die meisten Funktionen in den RP6 Libs sind ja nicht Ein-/Ausgabefunktionen. Was sollte man da rauswerfen (ok, die bisherigen Ein-/Ausgabefunktionen ja auf jeden Fall,- die würden ja durch neue Funktionen ersetzt...), ohne dass Funktionalität fehlt?

6. Was schätzt du, wie hoch der Aufwand ist, die Ein-/Ausgabefunktionen und ggf. die Demos neu zu schreiben? Würdest du das unter best. Bedingungen angehen?

7. Würdest du mal eine "Musterfunktion" oder Demo zum Testen hier zeigen?

[SlyD]

Nett wäre es auf jeden Fall als Alternative. Wirklich vermisst habe ichs aber bislang auch nicht
Ich hatte das damals absichtlich nicht verwendet - hast ja auch schon gesagt warum (Speicherplatz).

Alle Beispielprogramme umändern halte ich für nicht sinnvoll.
Einfach ein zwei neue besser dazu passende (wo man die Vorteile sieht) würde doch reichen.
Wenn Du das tatsächlich umsetzt, mach evtl. #defines in den Code damit man zwischen beiden Varianten
wählen kann - oder beides verwenden kann - auf der M256 hat man ja z.B. eh Platz ohne Ende da ist das egal.


MfG,
SlyD

[RolfD]

Hallo Dirk & Slyd
zunächst auf Dirks Fragen bezogen:

Der Hauptzweck...

Also das muss jeder für sich entscheiden... was Hauptzweck ist. Ich glaube aber, das man mit dem RP6 mehr unternehmen kann als Linienfolger oder Bumpergesteuerte Rempelbots zu bauen. Je mehr Vernetzung, um so komplexer die Kommunikation.

Durch die Aufteilung der Prozessoren...

Richtig. Für die M256 sehe ich da auf Grund von ausreichendem Platz auch kein Problem, bei M32 und Base wirds etwas enger aber auch da nutzt das Slave Programm noch nicht 100% des Platzes, folglich ist auch da noch Platz für solche Änderungen vorhanden. Einzig mit der M128 und ihrem InterpreterC wirds kompliziert aber auch da denke ich, wäre sowas machbar. Ich hab zumindest selbst eine M128 und würde mich dann auch mal daran setzen wollen.

Einverstanden?

Richtig. Aber: Man braucht z.B. auf der M32 kein stdio Kanal für die Motorkontrolle aber trotzdem kann man mit Slave und Master von einer m32 aus die Motorgeschwindigkeit regeln.. woran liegt das? Abstrahiere das mal... weil ein Hardware Protokol (i2c) zur Übertragung von Informationen zwischen m32 und Base vorhanden ist! Dazu gehört weiterhin ein Treiberendstück welches auf der Base liegt.. also quasi der i2c-slave .. und der Master.. also quasi der Treiberkopf... betrachtet man nun slave, I2C und master als eine Einheit, so steuert die m32 durchaus den Motor. Ok, Jetzt noch mal zur Frage ob die m32 ein stdio kanal für die Motorsteuerung braucht... die Frage ist eher.. muss es unbedingt so kompliziert laufen wie bisher wenn man was von einem Board aufs andere kriegen will!

Reizvoll wäre auch

Habe ich mit dem vorherigen Punkt eigentlich schon angesprochen. Ja es wäre möglich, in einer 2.ten Ausbaustufe Datenströme als * File auch über die Boardgrenzen hinweg bereitstellen zu können weil es die Printf Funktion nicht interessiert ob da einfach nur "while (!(UCSRA & (1<<UDRE))); UDR = (uint8_t)ch;" oder ein ganzes i2c-master/slave System hinter der "putchar" steckt.

Was meinst du mit ...

Du hast dir ein Teil des Punktes bereits selbst beantwortet. Überleg aber mal wie eine Ausgabe von Infos als Tabelle bisher ausschaut:

* writeString_P("Toggle Bit:");
* writeChar(rc5data.toggle_bit + '0');
* writeString_P(" | Device Address:");
* writeInteger(rc5data.device, DEC);
* writeString_P(" | Key Code:");
* writeInteger(rc5data.key_code, DEC);
* writeChar('\n');


7 Writes... das lässt sich mit printf in einer einzigen Zeile ausgeben! Das meine ich mit entschlacken.

Was schätzt du...

Also ich baue grade für mich die UART Lib dementsprechend um. Die UART Lib ist ja zumindest für die Base und M32 gleich.
Ich werde die Demos sicher nicht anpassen aber ich bin auch dabei, die bisherigen Writes über Kapselfunktionen an printf zu leiten.
Das sieht dann z.B. so aus:

void writeNStringP(const char *pstring)
{
    printf_P(pstring);
}
void writeInteger(int16_t number, uint8_t base)
{
    char str[17];
    printf("%s", itoa(number, str, base));
}

Ich möchte zunächst die UART LIB fertig bekommen bevor ich mich dann an die M32 LCD Funktionen setze.
Weitere Ein/Ausgabe Ziele habe ich für mich noch nicht geplant, ich denke aber das es mit der Zeit auch mehr wird. Großes Fernziel ist tatsächlich aber auch die angesprochene Nutzung von Geräten anderer Boards per io Stream. Dazu muss ich aber auch noch mal den I2C Treiber überarbeiten und von registerbasierter Übertragung auf Stream umstellen.
Für mich stellt sich eigentlich nur die Frage... mach ich das im stillen Kämmerlein so wie meine freeRTOS Geschichten (die übrigends klasse laufen) oder gibts da Interesse auch von anderen die IO Funktionen bezüglich.

Übrigends ist die SendeISR aus dem Quellcode oben noch verbesserbar.
Sie wird nach Ende der Übertragung noch ein mal angesprungen nur um die ISR abzuschalten.
Ich hab sie jetzt so umgebaut, das mit dem letzten Zeichen im Buffer auch direkt die ISR abgeschaltet wird.

ISR(USART_UDRE_vect, ISR_BLOCK) { // wir werden angesprungen, also ist ein char im buffer
	UDR = tx_buff.ring[tx_buff.tail]; // char aus buffer auf UDR schreiben
	tx_buff.tail = (tx_buff.tail + 1) % UART_SEND_BUFFER_SIZE; // tail um eins hochzählen
	if (tx_buff.head == tx_buff.tail) UCSRB &= ~(1 << UDRIE); // sendebuffer leer, isr aus schalten
}

Ein paar Kommentare sind auch noch hinzu gekommen.

Gruß