![LiFePO4 Speicher Test LiFePO4 Speicher Test](https://www.roboternetz.de/partner/solarspeicher-speicher-akkus-test.jpg)
K (Kategorie) |
|||
(11 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt) | |||
Zeile 3: | Zeile 3: | ||
Ein Erfahrungsbericht: | Ein Erfahrungsbericht: | ||
− | Im folgenden Bericht möchte ich auf die Möglichkeit eingehen, wie man Daten zwischen PC und Roboter via WLAN | + | Im folgenden Bericht möchte ich auf die Möglichkeit eingehen, wie man Daten zwischen PC und Roboter via WLAN austauschen kann. |
− | Meine Wahl | + | Meine Wahl fiel auf das Embedded WLAN Modul der Firma Avisaro. Das Modul kann, je nach Auslieferungszustand via CAN Bus, I2C Bus, SPI oder auch über RS232 Schnittstelle mit dem Roboter kommunizieren. |
Ich habe mich für die Modulversion mit I2C Bus entschieden. | Ich habe mich für die Modulversion mit I2C Bus entschieden. | ||
− | Eingesetzte Software / Hardware | + | ''Eingesetzte Software / Hardware'' |
− | - Roboter RP6 der Firma AREXX | + | - Roboter RP6 der Firma AREXX ( www.arexx.com ) |
− | - Borland C++ Compiler auf dem PC | + | - Borland C++ Compiler auf dem PC ( www.borland.com ) |
− | - PC OS ist Windows XP | + | - PC OS ist Windows XP Home |
− | - Emulations- Software der Firma HWgroup | + | - Emulations- Software der Firma HWgroup ( www.hw-group.com ) |
− | - WLAN Adapter der Firma Avisaro | + | - WLAN Adapter der Firma Avisaro ( www.avisaro.de ) |
- Einfacher WLAN Router von D-Link | - Einfacher WLAN Router von D-Link | ||
Zeile 26: | Zeile 26: | ||
− | ''Beschreibung Komponenten:'' | + | ''Beschreibung der Komponenten:'' |
− | 1) Das WLAN Modul der Firma Avisaro wird über den I2C Bus auf Seiten des Roboters angesprochen, dabei war es mir wichtig, die vorhandenen Routinen zu nutzen, die mit dem RP6 Roboter mit geliefert werden. Das WLAN Modul ist per | + | 1) Das WLAN Modul der Firma Avisaro wird über den I2C Bus auf Seiten des Roboters angesprochen, dabei war es mir wichtig, die vorhandenen Routinen zu nutzen, die mit dem RP6 Roboter mit geliefert werden. Das WLAN Modul ist per default als Slave konfiguriert mit der I2C Adresse 73. Somit müssen die I2C Master Routinen auf dem Roboter benutzt werden. Die Frequenz der I2C Busses habe ich auf 100KHz gelassen. Das WLAN Modul kann auch, via Clock-Stretching, mit höherer Frequenz angesprochen werden |
2) Die Software HW VSP3 „virtual serial port“ der Firma HW-Group wird auf der PC Seite eingesetzt, um die Kommunikation zur PC WLAN Karte zu vereinfachen. | 2) Die Software HW VSP3 „virtual serial port“ der Firma HW-Group wird auf der PC Seite eingesetzt, um die Kommunikation zur PC WLAN Karte zu vereinfachen. | ||
− | 3) Es ist Möglich eine Peer zu Peer Verbindung zwischen PC und WLAN Modul aufzubauen. Ich habe aber die Lösung via WLAN Router gewählt. Das WLAN Modul ist Standardmäßig auf die IP Adresse 192.168.0. | + | 3) Es ist Möglich eine Peer zu Peer Verbindung zwischen PC und WLAN Modul aufzubauen. Ich habe aber die Lösung via WLAN Router gewählt. Das WLAN Modul ist Standardmäßig auf die IP Adresse 192.168.0.73 konfiguriert. Auf die Konfiguration des WLAN Moduls via Weboberfläche möchte ich hier nicht eingehen und verweise hiermit auf die mitgelieferte Dokumentation. |
Wichtig sind nur folgende Parameter: | Wichtig sind nur folgende Parameter: | ||
Zeile 40: | Zeile 40: | ||
- I2C-Bus No ACK | - I2C-Bus No ACK | ||
− | |||
+ | '''Funktionsbeschreibung:''' | ||
+ | ''PC Seite:'' | ||
− | '' | + | ''Serielle Schnittstelle / Emulations-Software'' |
+ | Das PC Programm schreibt / liest Daten von und zu einer seriellen Schnittstelle und nicht direkt auf den PC WLAN Adapter. | ||
+ | Die serielle Schnittstelle wird durch die HW VSP3 Software emuliert und übernimmt Schreiben und Lesen der Daten auf den PC WLAN Adapter. Somit vereinfacht sich die Kommunikation von und zum WLAN Adapter wesentlich, da sich die Kommunikation auf Lesen und Schreiben zur serielle Schnittstelle beschränkt. Hier zu gibt es jede Menge Beispiele im Netz, oder auf der MSDN Webseite bei Microsoft, wie eine serielle Schnittstelle unter Windows XP angesprochen wird. | ||
+ | Ist das WLAN Modul auf dem Roboter im Netzwerk mit seiner IP Nummer erkannt worden, dann kann via der Emulationssoftware ein COM Port zugewiesen werden z.B. COM3. | ||
+ | |||
+ | Die Standardmäßige Einstellung der seriellen Schnittstelle ist, 9600 Baud, 8 Datenbits, 1 Stopbit, No Parity. Es ist an dieser Stelle sehr hilfreich sich das Logfile der Emulations Software anzusehen, da die Parameter der seriellen Schnittestelle herausgeschrieben werden und man sofort erkennt, ob das Modul erfolgreich connected wurde. | ||
− | |||
− | '' | + | ''Programm auf dem PC'' |
− | + | Zur Erstellung der PC seitigen Software habe ich Borland C++ benutzt. Die Routinen im Sourcecode sind wie bereits beschrieben von MSDN kopiert und angepasst worden. | |
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | Programm auf dem PC'' | + | |
− | Zur Erstellung der PC seitigen Software habe ich Borland C++ benutzt. Die Routinen im Sourcecode sind wie bereits beschrieben | + | |
Ich möchte hier nicht so tief auf die Beschreibung des Codes eingehen, dass kann man im angehängten SourceCode viel besser sehen. Das Programm besteht eigentlich nur aus einer lesenden Routine, die Daten aus der seriellen Schnittstelle ausliest und auf dem Bildschirm in einer DOS-Box darstellt. Senden von Daten an den Roboter ist auch möglich und als Funktion hinterlegt. | Ich möchte hier nicht so tief auf die Beschreibung des Codes eingehen, dass kann man im angehängten SourceCode viel besser sehen. Das Programm besteht eigentlich nur aus einer lesenden Routine, die Daten aus der seriellen Schnittstelle ausliest und auf dem Bildschirm in einer DOS-Box darstellt. Senden von Daten an den Roboter ist auch möglich und als Funktion hinterlegt. | ||
Zeile 67: | Zeile 65: | ||
''WLAN:'' | ''WLAN:'' | ||
− | Das WLAN-Netz wurde von mir mit den Standardparametern aufgesetzt. Ich habe nur die IP Adresse, die SSID und den Kanal angepasst. WEP / WAP Verschlüsselung ist möglich und kann via Webpage auf dem WLAN Modul | + | |
+ | Das WLAN-Netz wurde von mir mit den Standardparametern aufgesetzt. Ich habe nur die IP Adresse, die SSID und den Kanal angepasst. WEP / WAP Verschlüsselung ist möglich und kann via Webpage auf dem WLAN Modul eingestellt werden (siehe Dokumentation) | ||
Zeile 74: | Zeile 73: | ||
''WLAN Modul:'' | ''WLAN Modul:'' | ||
+ | |||
Das WLAN Modul wird über den I2C Bus angesprochen, die I2C Adresse habe ich behalten, da die Adresse 73 von keinem anderen I2C Device genutzt wird. | Das WLAN Modul wird über den I2C Bus angesprochen, die I2C Adresse habe ich behalten, da die Adresse 73 von keinem anderen I2C Device genutzt wird. | ||
− | Wichtig war für mich die fertigen Routinen, die mit den RP6 | + | Wichtig war für mich die fertigen Routinen, die mit den RP6 Libraries geliefert werden, zu benutzen. Dadurch musste ich keine extra Funktionen entwickeln die den Lese / Schreibzugriff auf den I2C Bus ausführen. Allerdings ist zu beachten, dass bei schreibenden Zugriffen auf das WLAN Modul die I2C Adresse um ein Bit verschoben werden muss. Das Bit 0 muss mit einer Null gefüllt werden ( Adr<<1 ) |
Schwieriger ist der lesenden Zugriff auf das Modul, dazu muss die Adresse ebenfalls um ein Bit verschoben werden und das Bit 0 auf EINS gesetzt werden ( Adr<<1 | 1 ). | Schwieriger ist der lesenden Zugriff auf das Modul, dazu muss die Adresse ebenfalls um ein Bit verschoben werden und das Bit 0 auf EINS gesetzt werden ( Adr<<1 | 1 ). | ||
Zeile 89: | Zeile 89: | ||
'''Sourcecode für den PC:''' | '''Sourcecode für den PC:''' | ||
− | |||
− | #include <windows.h> | + | #include <windows.h> |
− | #include <string.h> | + | #include <string.h> |
− | #include <stdio.h> | + | #include <stdio.h> |
− | #include <conio.h> | + | #include <conio.h> |
− | #include <commctrl.h> | + | #include <commctrl.h> |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
+ | // ******** Globale Variablen ******** | ||
+ | char *gszPort; | ||
+ | HANDLE hCom = NULL; | ||
+ | DCB dcb; | ||
+ | COMMTIMEOUTS ct; | ||
+ | bool CommFlag; | ||
+ | bool ReadOnly; | ||
+ | char string[100]; | ||
+ | BYTE data_in[100], data_out, buff[100]; | ||
+ | int k, m; | ||
+ | DWORD n; | ||
− | |||
− | int setup_Com_Port () | + | // ************* COM Port initialisieren ************** |
− | { | + | int setup_Com_Port () |
+ | { | ||
gszPort = string; | gszPort = string; | ||
hCom = CreateFile(gszPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); | hCom = CreateFile(gszPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); | ||
Zeile 154: | Zeile 153: | ||
} | } | ||
return 0; | return 0; | ||
− | } | + | } |
+ | |||
Zeile 160: | Zeile 160: | ||
'''Senden von Daten an die serielle Schnittstelle''' | '''Senden von Daten an die serielle Schnittstelle''' | ||
− | /* *********** Senden der Daten an Serielle Schnittstelle ***** */ | + | /* *********** Senden der Daten an Serielle Schnittstelle ***** */ |
− | + | void sende_cmd_start (BYTE cmd[10], int howmuch) // Datenbytes und Anzahl wieviele Bytes gesendet werden sollen | |
− | void sende_cmd_start (BYTE cmd[10], int howmuch) // Datenbytes und Anzahl wieviele Bytes gesendet | + | { |
− | { | + | DWORD n; |
− | + | WriteFile(hCom, &cmd, howmuch, &n, NULL); | |
− | + | } | |
− | } | + | |
Zeile 178: | Zeile 177: | ||
'''Von der serielle Schnittstelle Daten auslesen''' | '''Von der serielle Schnittstelle Daten auslesen''' | ||
− | /* **** Endlos Schleife des Hauptprogramms **** */ | + | /* **** Endlos Schleife des Hauptprogramms **** */ |
− | + | ||
if (hCom != NULL) | if (hCom != NULL) | ||
{ | { | ||
Zeile 209: | Zeile 207: | ||
'''Beim verlassen des Programms serielle Schnittstelle schließen''' | '''Beim verlassen des Programms serielle Schnittstelle schließen''' | ||
− | /* ************ Port schliessen ******* */ | + | /* ************ Port schliessen ******* */ |
Sleep (5); | Sleep (5); | ||
CloseHandle(hCom); | CloseHandle(hCom); | ||
Zeile 229: | Zeile 227: | ||
''Auszug aus dem Hauptprogramm:'' | ''Auszug aus dem Hauptprogramm:'' | ||
− | |||
− | |||
+ | // ISR Handler initialisieren | ||
+ | I2CTWI_initMaster(100); // Initialize the TWI Module for Master operation with 100kHz SCL Frequency | ||
+ | I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); // Register the event hand | ||
− | |||
− | while(true) | + | // *********************** Main loop ************************************ |
− | { | + | while(true) |
+ | { | ||
behaviourController(); // Aufruf der Haupt-Controll-Funktion | behaviourController(); // Aufruf der Haupt-Controll-Funktion | ||
task_RP6System(); // Abfrage des ADC, ACS, IRCOMM usw... | task_RP6System(); // Abfrage des ADC, ACS, IRCOMM usw... | ||
Zeile 245: | Zeile 244: | ||
} | } | ||
task_I2CTWI(); // Call I2C Management routine | task_I2CTWI(); // Call I2C Management routine | ||
− | } | + | } |
− | return 0; | + | return 0; |
Zeile 259: | Zeile 258: | ||
'''Lesen von Daten von der WLAN Karte bereitgestellt über den I2C Bus''' | '''Lesen von Daten von der WLAN Karte bereitgestellt über den I2C Bus''' | ||
− | // **** Comandos von PC über WLAN Karte einlesen | + | // **** Comandos von PC über WLAN Karte einlesen |
− | void task_commandProcessor(void) | + | void task_commandProcessor(void) |
− | { | + | { |
uint16_t size; | uint16_t size; | ||
uint8_t messageBuf [100]; | uint8_t messageBuf [100]; | ||
Zeile 270: | Zeile 269: | ||
size = messageBuf[0]<<8 | messageBuf[1]; // Ermitteln wie viel tatsächlich Byte gesendet wurden | size = messageBuf[0]<<8 | messageBuf[1]; // Ermitteln wie viel tatsächlich Byte gesendet wurden | ||
} // Diese Funktion muss noch optimiert werden | } // Diese Funktion muss noch optimiert werden | ||
− | } | + | } |
+ | // In dem Feld messageBuf [2] bis messageBuf[size] befinden sich die Daten von PC gesendet | ||
Zeile 282: | Zeile 282: | ||
'''Senden von Daten an die WLAN Karte über den I2C Bus''' | '''Senden von Daten an die WLAN Karte über den I2C Bus''' | ||
− | // Mit folgender Routine können eine belibige Anzahl, hier 9 Byte, an die WLAN Karte gesendet werden | + | // Mit folgender Routine können eine belibige Anzahl, hier 9 Byte, an die WLAN Karte gesendet werden |
− | // Daten im Feld „buffer“ zur WLAN Karte senden via I2C Bus | + | // Daten im Feld „buffer“ zur WLAN Karte senden via I2C Bus |
− | + | if (!I2CTWI_isBusy ()) // Daten über I2C an WLAN senden | |
− | if (!I2CTWI_isBusy ()) // Daten über I2C an WLAN senden | + | |
I2CTWI_transmitBytes (73<<1, &buffer[0], 9); | I2CTWI_transmitBytes (73<<1, &buffer[0], 9); | ||
+ | ---- | ||
+ | |||
+ | Author: | ||
+ | Peter Schneider | ||
+ | |||
+ | |||
+ | |||
+ | ---- | ||
+ | --[[Benutzer:Cb2sn43|cb2sn43]] 19:37, 22. Feb 2008 (CET) | ||
− | + | [[Kategorie:Projekte]] | |
− | + | [[Kategorie:Kommunikation]] | |
− | + | ||
− | + |
Aktuelle Version vom 22. Oktober 2009, 08:16 Uhr
Datenaustausch zwischen Roboter und PC via WLAN
Ein Erfahrungsbericht:
Im folgenden Bericht möchte ich auf die Möglichkeit eingehen, wie man Daten zwischen PC und Roboter via WLAN austauschen kann. Meine Wahl fiel auf das Embedded WLAN Modul der Firma Avisaro. Das Modul kann, je nach Auslieferungszustand via CAN Bus, I2C Bus, SPI oder auch über RS232 Schnittstelle mit dem Roboter kommunizieren. Ich habe mich für die Modulversion mit I2C Bus entschieden.
Eingesetzte Software / Hardware
- Roboter RP6 der Firma AREXX ( www.arexx.com )
- Borland C++ Compiler auf dem PC ( www.borland.com )
- PC OS ist Windows XP Home
- Emulations- Software der Firma HWgroup ( www.hw-group.com )
- WLAN Adapter der Firma Avisaro ( www.avisaro.de )
- Einfacher WLAN Router von D-Link
Beschreibung der Komponenten:
1) Das WLAN Modul der Firma Avisaro wird über den I2C Bus auf Seiten des Roboters angesprochen, dabei war es mir wichtig, die vorhandenen Routinen zu nutzen, die mit dem RP6 Roboter mit geliefert werden. Das WLAN Modul ist per default als Slave konfiguriert mit der I2C Adresse 73. Somit müssen die I2C Master Routinen auf dem Roboter benutzt werden. Die Frequenz der I2C Busses habe ich auf 100KHz gelassen. Das WLAN Modul kann auch, via Clock-Stretching, mit höherer Frequenz angesprochen werden
2) Die Software HW VSP3 „virtual serial port“ der Firma HW-Group wird auf der PC Seite eingesetzt, um die Kommunikation zur PC WLAN Karte zu vereinfachen.
3) Es ist Möglich eine Peer zu Peer Verbindung zwischen PC und WLAN Modul aufzubauen. Ich habe aber die Lösung via WLAN Router gewählt. Das WLAN Modul ist Standardmäßig auf die IP Adresse 192.168.0.73 konfiguriert. Auf die Konfiguration des WLAN Moduls via Weboberfläche möchte ich hier nicht eingehen und verweise hiermit auf die mitgelieferte Dokumentation.
Wichtig sind nur folgende Parameter:
- Netzwerksetup als TCP Server
- I2C-Bus No ACK
Funktionsbeschreibung:
PC Seite:
Serielle Schnittstelle / Emulations-Software
Das PC Programm schreibt / liest Daten von und zu einer seriellen Schnittstelle und nicht direkt auf den PC WLAN Adapter. Die serielle Schnittstelle wird durch die HW VSP3 Software emuliert und übernimmt Schreiben und Lesen der Daten auf den PC WLAN Adapter. Somit vereinfacht sich die Kommunikation von und zum WLAN Adapter wesentlich, da sich die Kommunikation auf Lesen und Schreiben zur serielle Schnittstelle beschränkt. Hier zu gibt es jede Menge Beispiele im Netz, oder auf der MSDN Webseite bei Microsoft, wie eine serielle Schnittstelle unter Windows XP angesprochen wird. Ist das WLAN Modul auf dem Roboter im Netzwerk mit seiner IP Nummer erkannt worden, dann kann via der Emulationssoftware ein COM Port zugewiesen werden z.B. COM3.
Die Standardmäßige Einstellung der seriellen Schnittstelle ist, 9600 Baud, 8 Datenbits, 1 Stopbit, No Parity. Es ist an dieser Stelle sehr hilfreich sich das Logfile der Emulations Software anzusehen, da die Parameter der seriellen Schnittestelle herausgeschrieben werden und man sofort erkennt, ob das Modul erfolgreich connected wurde.
Programm auf dem PC
Zur Erstellung der PC seitigen Software habe ich Borland C++ benutzt. Die Routinen im Sourcecode sind wie bereits beschrieben von MSDN kopiert und angepasst worden.
Ich möchte hier nicht so tief auf die Beschreibung des Codes eingehen, dass kann man im angehängten SourceCode viel besser sehen. Das Programm besteht eigentlich nur aus einer lesenden Routine, die Daten aus der seriellen Schnittstelle ausliest und auf dem Bildschirm in einer DOS-Box darstellt. Senden von Daten an den Roboter ist auch möglich und als Funktion hinterlegt.
Netzwerk:
WLAN:
Das WLAN-Netz wurde von mir mit den Standardparametern aufgesetzt. Ich habe nur die IP Adresse, die SSID und den Kanal angepasst. WEP / WAP Verschlüsselung ist möglich und kann via Webpage auf dem WLAN Modul eingestellt werden (siehe Dokumentation)
Roboter Seite:
WLAN Modul:
Das WLAN Modul wird über den I2C Bus angesprochen, die I2C Adresse habe ich behalten, da die Adresse 73 von keinem anderen I2C Device genutzt wird. Wichtig war für mich die fertigen Routinen, die mit den RP6 Libraries geliefert werden, zu benutzen. Dadurch musste ich keine extra Funktionen entwickeln die den Lese / Schreibzugriff auf den I2C Bus ausführen. Allerdings ist zu beachten, dass bei schreibenden Zugriffen auf das WLAN Modul die I2C Adresse um ein Bit verschoben werden muss. Das Bit 0 muss mit einer Null gefüllt werden ( Adr<<1 )
Schwieriger ist der lesenden Zugriff auf das Modul, dazu muss die Adresse ebenfalls um ein Bit verschoben werden und das Bit 0 auf EINS gesetzt werden ( Adr<<1 | 1 ). Wichtig: Im Normalfall adressiert man, als ersten Schritt, ein I2C Device und das zu lesende Register von dem man die Daten abholen möchte. Anschließend greift man lesend auf das zuvor adressierte Register des I2C Devices zu. Will man lesend auf das WLAN Modul zugreifen, so habe ich festgestellt, dass man direkt lesend auf die I2C Adresse zugreifen kann, ohne das Device vorher, durch einen Schreibzugriff , zu adressieren. Die ersten zwei Byte, der abgeholten Daten, sind die Länge / Size der auf dem WLAN Modul bereitgestellten Daten. Somit kann man einfach feststellen wie viele Daten aus dem Device ausgelesen werden müssen. Alle Daten müssen aus dem Device abgeholt werden. Siehe auch SourceCode Beispiele. Die verwendeten Software-Routinen werden mit dem RP6 Roboter mitgeliefert. Ebenso der verwendete AVR Compiler und dessen Libraries.
Sourcecode für den PC:
#include <windows.h> #include <string.h> #include <stdio.h> #include <conio.h> #include <commctrl.h>
// ******** Globale Variablen ******** char *gszPort; HANDLE hCom = NULL; DCB dcb; COMMTIMEOUTS ct; bool CommFlag; bool ReadOnly; char string[100]; BYTE data_in[100], data_out, buff[100]; int k, m; DWORD n;
// ************* COM Port initialisieren ************** int setup_Com_Port () { gszPort = string; hCom = CreateFile(gszPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); if (hCom == INVALID_HANDLE_VALUE) { printf ("\n\n \a Error Initialise Port"); CommFlag = false; return 0; } dcb.DCBlength = sizeof(DCB); GetCommState(hCom, &dcb); if (!BuildCommDCB("baud=9600 parity=N data=8 stop=1", &dcb)) { hCom = NULL; printf ("\n\n \a Error kann Portparameter nicht setzen e.g. 9600 Boud"); CommFlag = false; } if(!SetCommState(hCom, &dcb)) { CloseHandle(hCom); hCom = NULL; printf ("\n\n \a Cannot set comm state BCD.\n"); CommFlag = false; return 0; } ct.ReadIntervalTimeout = MAXDWORD; ct.ReadTotalTimeoutConstant = 0; ct.ReadTotalTimeoutMultiplier = 1; ct.WriteTotalTimeoutConstant = 250; ct.WriteTotalTimeoutMultiplier = 1; if(!SetCommTimeouts(hCom, &ct)) { CloseHandle(hCom); hCom = NULL; printf ("\n \a Cannot set comm timeouts.\n"); CommFlag = false; return 0; } return 0; }
Senden von Daten an die serielle Schnittstelle
/* *********** Senden der Daten an Serielle Schnittstelle ***** */ void sende_cmd_start (BYTE cmd[10], int howmuch) // Datenbytes und Anzahl wieviele Bytes gesendet werden sollen { DWORD n; WriteFile(hCom, &cmd, howmuch, &n, NULL); }
Von der serielle Schnittstelle Daten auslesen
/* **** Endlos Schleife des Hauptprogramms **** */ if (hCom != NULL) { while(CommFlag) // Bearbeiten solange das COM Port offen ist { ReadFile(hCom, &cmd, 9, &n, NULL); // Daten aus der Schnittstelle auslesen, hier 9 Bytes if(n) // Wenn Daten ausgelesen wurden, sichern im Feld data_in { // Daten gesichert für weitere Verarbeitung data_in[0] = cmd[0]; data_in[1] = cmd[1]; data_in[2] = cmd[2]; data_in[3] = cmd[3]; data_in[4] = cmd[4]; data_in[5] = cmd[5]; data_in[6] = cmd[6]; data_in[7] = cmd[7]; data_in[8] = cmd[8]; } } }
Beim verlassen des Programms serielle Schnittstelle schließen
/* ************ Port schliessen ******* */ Sleep (5); CloseHandle(hCom); hCom = NULL; gotoxy (2,32); printf ("\n Port %s geschlossen ", string); printf ("\n\n Programm beendet "); return 0;
Sourcecode für den RP6 Roboter:
Auszug aus dem Hauptprogramm:
// ISR Handler initialisieren I2CTWI_initMaster(100); // Initialize the TWI Module for Master operation with 100kHz SCL Frequency I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); // Register the event hand
// *********************** Main loop ************************************ while(true) { behaviourController(); // Aufruf der Haupt-Controll-Funktion task_RP6System(); // Abfrage des ADC, ACS, IRCOMM usw... if (getStopwatch1() > 200) { task_commandProcessor(); // Abfrage ob ein Commando gesendet wurde setStopwatch1(0); } task_I2CTWI(); // Call I2C Management routine } return 0;
Lesen von Daten von der WLAN Karte bereitgestellt über den I2C Bus
// **** Comandos von PC über WLAN Karte einlesen void task_commandProcessor(void) { uint16_t size; uint8_t messageBuf [100]; size = 0; if(!I2CTWI_isBusy()) { I2CTWI_readBytes (73<<1 | 1, &messageBuf[0], 38); // Daten von WLAN Karte einlesen. Hier werden einfach mal 38 Byte eingelesen size = messageBuf[0]<<8 | messageBuf[1]; // Ermitteln wie viel tatsächlich Byte gesendet wurden } // Diese Funktion muss noch optimiert werden } // In dem Feld messageBuf [2] bis messageBuf[size] befinden sich die Daten von PC gesendet
Senden von Daten an die WLAN Karte über den I2C Bus
// Mit folgender Routine können eine belibige Anzahl, hier 9 Byte, an die WLAN Karte gesendet werden // Daten im Feld „buffer“ zur WLAN Karte senden via I2C Bus if (!I2CTWI_isBusy ()) // Daten über I2C an WLAN senden I2CTWI_transmitBytes (73<<1, &buffer[0], 9);
Author: Peter Schneider
--cb2sn43 19:37, 22. Feb 2008 (CET)
![LiFePO4 Speicher Test LiFePO4 Speicher Test](https://www.roboternetz.de/partner/solarspeicher-speicher-akkus-test.jpg)