pcc.c-Dateireferenz


Ausführliche Beschreibung

Dieses Programm soll eine PC Kommunikation herstellen.

Funktionsweise:
Das Programm empfangt einzelne datenpackete und fürgt diese zu einer nachricht zusammen. Anhand des Kommandos der Nachricht werden entsprechende Aktionen ausgeführt.
Kommandos: vollgende kommandos sind implementiert:
-- Board Port Status (01) -- Board Systemzeit (05) -- Motor Links Encoder (10) -- Motor Links Istdrehzahl (12) -- Motor Links Solldrehzahl (13) -- Motor Rechts Encoder (10) -- Motor Rechts Istdrehzahl (12) -- Motor Rechts Solldrehzahl (13)
Version:
V--- - 16.04.2007 - Olaf Petersen
Created

Definiert in Datei pcc.c.

#include <avr/io.h>
#include <stdint.h>
#include <stdlib.h>
#include "pcc.h"
#include "../nbot_lib/uart.h"

Include-Abhängigkeitsdiagramm für pcc.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define pcc_rx_ready   1
#define pcc_rx_befehlsempfang   2
#define pcc_rx_fehler   3
#define pcc_rx_done   4

Funktionen

void pcc_reset (void)
 zurücksetzen aller Inhalte
void pcc_sendError (void)
void pcc_init (const pcc_t *daten)
 Initialisiert die PC Kommunikation.
void pcc_rx (uint8_t buf)
 Hier werden die empfangenen Daten ausgewertet.
void pcc (void)
 Server.
void pcc_send (tstMessage *message)

Variablen

const pcc_tppcc
tunHeader header
tstMessage receivedMessage
tstMessage transmitMessage
uint8_t empfangeneBytes
uint8_t versendeteBytes
uint8_t sm_rx


Makro-Dokumentation

#define pcc_rx_befehlsempfang   2

Definiert in Zeile 35 der Datei pcc.c.

Wird benutzt von pcc() und pcc_rx().

#define pcc_rx_done   4

Definiert in Zeile 37 der Datei pcc.c.

Wird benutzt von pcc() und pcc_rx().

#define pcc_rx_fehler   3

Definiert in Zeile 36 der Datei pcc.c.

Wird benutzt von pcc() und pcc_rx().

#define pcc_rx_ready   1

Definiert in Zeile 34 der Datei pcc.c.

Wird benutzt von pcc(), pcc_init() und pcc_rx().


Dokumentation der Funktionen

void pcc ( void   ) 

Server.

Definiert in Zeile 123 der Datei pcc.c.

Benutzt tunHeader::cmdid, tstMessage::header, LEFT, tunHeader::length, tstMessage::message, PCC_ACTION_MOVE, PCC_ACTION_TURN, PCC_BOARD_AKKU, PCC_BOARD_GET, PCC_BOARD_I2C, PCC_BOARD_SET, PCC_BOARD_TIME, PCC_MOT_L_ACS, PCC_MOT_L_CUR, PCC_MOT_L_ENC, PCC_MOT_L_SRS, PCC_MOT_L_TMP, PCC_MOT_R_ACS, PCC_MOT_R_CUR, PCC_MOT_R_ENC, PCC_MOT_R_SRS, PCC_MOT_R_TMP, pcc_reset(), pcc_rx_befehlsempfang, pcc_rx_done, pcc_rx_fehler, pcc_rx_ready, pcc_send(), pcc_sendError(), PCC_SENS_ACC, PCC_SENS_IR1, PCC_SENS_IR2, PCC_SENS_ORI, PCC_SYNC, receivedMessage, RIGHT, sm_rx und transmitMessage.

Wird benutzt von main().

00124 {
00125   switch (sm_rx)
00126   {
00127     case pcc_rx_ready:
00128     case pcc_rx_befehlsempfang: 
00129       break;
00130     case pcc_rx_fehler:
00131       pcc_sendError();
00132       pcc_reset();
00133       sm_rx = pcc_rx_ready;
00134       break;
00135     case pcc_rx_done:
00136       switch (receivedMessage.header.cmdid)
00137       {
00138         case PCC_SYNC: 
00139           pcc_reset();
00140           break;
00141         case PCC_BOARD_GET:
00142           if(receivedMessage.header.length == 1)
00143           {
00144             transmitMessage.header.cmdid = PCC_BOARD_GET;
00145             transmitMessage.header.length = 2;
00146             switch (receivedMessage.message[0])
00147             {
00148               case 'A': 
00149                 transmitMessage.message[0] = DDRA;
00150                 transmitMessage.message[1] = PINA;
00151                 break;
00152               case 'B': 
00153                 transmitMessage.message[0] = DDRB;
00154                 transmitMessage.message[1] = PINB;
00155                 break;
00156               case 'C': 
00157                 transmitMessage.message[0] = DDRC;
00158                 transmitMessage.message[1] = PINC;
00159                 break;
00160               case 'D': 
00161                 transmitMessage.message[0] = DDRD;
00162                 transmitMessage.message[1] = PIND;
00163                 break;
00164               default: 
00165                 transmitMessage.message[0] = 0;
00166                 transmitMessage.message[1] = 0;
00167             }
00168             pcc_send(&transmitMessage);
00169           } else 
00170             pcc_sendError();
00171           break;
00172         case PCC_BOARD_SET:
00173           if(receivedMessage.header.length == 3)
00174           {
00175           }
00176           else
00177             pcc_sendError();
00178           break;
00179         case PCC_BOARD_AKKU:
00180           if(receivedMessage.header.length == 0)
00181           {
00182           }
00183           else
00184             pcc_sendError();
00185           break;
00186         case PCC_BOARD_I2C:
00187         case PCC_BOARD_TIME:
00188           if(receivedMessage.header.length == 0)
00189           {
00190             transmitMessage.header.cmdid = PCC_BOARD_TIME;
00191             transmitMessage.header.length = 4;
00192             transmitMessage.message[0] = *((*ppcc).time)>>24;
00193             transmitMessage.message[1] = *((*ppcc).time)>>16;
00194             transmitMessage.message[2] = *((*ppcc).time)>>8;
00195             transmitMessage.message[3] = *((*ppcc).time);
00196             pcc_send(&transmitMessage);
00197           }
00198           else
00199             pcc_sendError();
00200           break;
00201         case PCC_MOT_L_ENC:
00202           if(receivedMessage.header.length == 0)
00203           {
00204             transmitMessage.header.cmdid = PCC_MOT_L_ENC;
00205             transmitMessage.header.length = 2;  
00206             transmitMessage.message[0] = *((*ppcc).encoder[LEFT])>>8;
00207             transmitMessage.message[1] = *((*ppcc).encoder[LEFT]);
00208             pcc_send(&transmitMessage);         
00209           }
00210           else
00211             pcc_sendError();
00212           break;
00213         case PCC_MOT_L_CUR:
00214         case PCC_MOT_L_ACS:
00215           if(receivedMessage.header.length == 0)
00216           {
00217             transmitMessage.header.cmdid = PCC_MOT_L_ACS;
00218             transmitMessage.header.length = 2;  
00219             transmitMessage.message[0] = *((*ppcc).istwert[LEFT])>>8;
00220             transmitMessage.message[1] = *((*ppcc).istwert[LEFT]);
00221             pcc_send(&transmitMessage);         
00222           }
00223           else
00224             pcc_sendError();
00225           break;
00226         case PCC_MOT_L_SRS:
00227           if(receivedMessage.header.length == 0)
00228           {
00229             transmitMessage.header.cmdid = PCC_MOT_L_SRS;
00230             transmitMessage.header.length = 2;  
00231             transmitMessage.message[0] = *((*ppcc).sollwert[LEFT])>>8;
00232             transmitMessage.message[1] = *((*ppcc).sollwert[LEFT]);
00233             pcc_send(&transmitMessage);         
00234           }
00235           else
00236             pcc_sendError();
00237           break;
00238         case PCC_MOT_L_TMP:
00239         case PCC_MOT_R_ENC:
00240           if(receivedMessage.header.length == 0)
00241           {
00242             transmitMessage.header.cmdid = PCC_MOT_R_ENC;
00243             transmitMessage.header.length = 2;  
00244             transmitMessage.message[0] = *((*ppcc).encoder[RIGHT])>>8;
00245             transmitMessage.message[1] = *((*ppcc).encoder[RIGHT]);
00246             pcc_send(&transmitMessage);         
00247           }
00248           else
00249             pcc_sendError();
00250           break;
00251         case PCC_MOT_R_CUR:
00252         case PCC_MOT_R_ACS:
00253           if(receivedMessage.header.length == 0)
00254           {
00255             transmitMessage.header.cmdid = PCC_MOT_L_ACS;
00256             transmitMessage.header.length = 2;  
00257             transmitMessage.message[0] = *((*ppcc).istwert[RIGHT])>>8;
00258             transmitMessage.message[1] = *((*ppcc).istwert[RIGHT]);
00259             pcc_send(&transmitMessage);         
00260           }
00261           else
00262             pcc_sendError();
00263           break;
00264         case PCC_MOT_R_SRS:
00265           if(receivedMessage.header.length == 0)
00266           {
00267             transmitMessage.header.cmdid = PCC_MOT_L_SRS;
00268             transmitMessage.header.length = 2;  
00269             transmitMessage.message[0] = *((*ppcc).sollwert[RIGHT])>>8;
00270             transmitMessage.message[1] = *((*ppcc).sollwert[RIGHT]);
00271             pcc_send(&transmitMessage);         
00272           }
00273           else
00274             pcc_sendError();
00275           break;
00276         case PCC_MOT_R_TMP:
00277         case PCC_SENS_IR1:
00278         case PCC_SENS_IR2:
00279         case PCC_SENS_ACC:
00280         case PCC_SENS_ORI:
00281         case PCC_ACTION_MOVE:
00282         case PCC_ACTION_TURN: 
00283           break;
00284         default:
00285           pcc_sendError();
00286       }
00287       pcc_reset();
00288       sm_rx = pcc_rx_ready;
00289       break;
00290   }
00291 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void pcc_init ( const pcc_t daten  ) 

Initialisiert die PC Kommunikation.

Definiert in Zeile 64 der Datei pcc.c.

Benutzt pcc_reset(), pcc_rx_ready, ppcc und sm_rx.

Wird benutzt von main().

00065 {
00066   ppcc = daten; // datenpoiter übergeben
00067   sm_rx = pcc_rx_ready;
00068   pcc_reset();
00069 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void pcc_reset ( void   ) 

zurücksetzen aller Inhalte

Definiert in Zeile 76 der Datei pcc.c.

Benutzt empfangeneBytes, tstMessage::header, header, tstMessage::message, receivedMessage, transmitMessage und tunHeader::y.

Wird benutzt von pcc() und pcc_init().

00077 {
00078   header.y = 0;
00079   receivedMessage.header.y = 0;
00080   transmitMessage.header.y = 0;
00081   for(int i = 0; i<8;i++)
00082   {
00083     receivedMessage.message[i] = 0;
00084     transmitMessage.message[i] = 0;
00085   }
00086   empfangeneBytes = 0;
00087 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void pcc_rx ( uint8_t  buf  ) 

Hier werden die empfangenen Daten ausgewertet.

Definiert in Zeile 94 der Datei pcc.c.

Benutzt empfangeneBytes, tstMessage::header, tunHeader::length, tstMessage::message, pcc_rx_befehlsempfang, pcc_rx_done, pcc_rx_fehler, pcc_rx_ready, receivedMessage, sm_rx und tunHeader::y.

Wird benutzt von main().

00095 {
00096   if(sm_rx == pcc_rx_ready || sm_rx == pcc_rx_befehlsempfang)
00097   {
00098     sm_rx = pcc_rx_befehlsempfang;
00099     
00100     if(empfangeneBytes == 0)                                          // Header wird empfangen
00101     {
00102       receivedMessage.header.y = buf;
00103     } else if((receivedMessage.header.length) >= empfangeneBytes)   // Daten werden empfangen
00104     {
00105       receivedMessage.message[(empfangeneBytes-1)] = buf;     
00106     } 
00107     if((receivedMessage.header.length) == empfangeneBytes)            // Nachricht vollständig empfangen
00108     {
00109       sm_rx = pcc_rx_done;                  
00110     }
00111   } else                                                              // alter Befehl noch nicht abgearbeitet
00112   {
00113     sm_rx = pcc_rx_fehler;            
00114   }
00115   empfangeneBytes++;
00116 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void pcc_send ( tstMessage message  ) 

Definiert in Zeile 293 der Datei pcc.c.

Benutzt versendeteBytes.

Wird benutzt von pcc() und pcc_sendError().

00294 {
00295   uint8_t *buf = (uint8_t *)message;
00296   uint8_t versendeteBytes = 0;
00297   
00298   
00299   
00300   do 
00301   {
00302     uart_putc(*buf++);
00303     versendeteBytes++;
00304   }while(versendeteBytes < ((*message).header.length)+1);
00305 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void pcc_sendError ( void   ) 

Definiert in Zeile 307 der Datei pcc.c.

Benutzt tunHeader::cmdid, tstMessage::header, tunHeader::length, pcc_send(), PCC_SYNC und transmitMessage.

Wird benutzt von pcc().

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:


Variablen-Dokumentation

uint8_t empfangeneBytes

Definiert in Zeile 55 der Datei pcc.c.

Wird benutzt von pcc_reset() und pcc_rx().

tunHeader header

Definiert in Zeile 51 der Datei pcc.c.

Wird benutzt von pcc_reset().

const pcc_t* ppcc

Definiert in Zeile 49 der Datei pcc.c.

Wird benutzt von pcc_init().

tstMessage receivedMessage

Definiert in Zeile 52 der Datei pcc.c.

Wird benutzt von pcc(), pcc_reset() und pcc_rx().

uint8_t sm_rx

Definiert in Zeile 57 der Datei pcc.c.

Wird benutzt von pcc(), pcc_init() und pcc_rx().

tstMessage transmitMessage

Definiert in Zeile 53 der Datei pcc.c.

Wird benutzt von pcc(), pcc_reset() und pcc_sendError().

uint8_t versendeteBytes

Definiert in Zeile 56 der Datei pcc.c.

Wird benutzt von pcc_send().


Erzeugt am Sun Apr 22 20:00:40 2007 für nBot von  doxygen 1.5.1-p1