0,0 → 1,542 |
/*#######################################################################################*/ |
/* !!! THIS IS NOT FREE SOFTWARE !!! */ |
/*#######################################################################################*/ |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Copyright (c) 2008 Ingo Busker, Holger Buss |
// + Nur für den privaten Gebrauch |
// + FOR NON COMMERCIAL USE ONLY |
// + www.MikroKopter.com |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. |
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
// + bzgl. der Nutzungsbedingungen aufzunehmen. |
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
// + Verkauf von Luftbildaufnahmen, usw. |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
// + eindeutig als Ursprung verlinkt werden |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
// + Benutzung auf eigene Gefahr |
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
// + mit unserer Zustimmung zulässig |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
// + this list of conditions and the following disclaimer. |
// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
// + from this software without specific prior written permission. |
// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted |
// + for non-commercial use (directly or indirectly) |
// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
// + with our written permission |
// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be |
// + clearly linked as origin |
// + * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed |
// |
// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
// + POSSIBILITY OF SUCH DAMAGE. |
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
|
#include "main.h" |
|
u8 DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0; |
unsigned volatile char SioTmp = 0; |
unsigned volatile char SendeBuffer[MAX_SENDE_BUFF]; |
unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF]; |
unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF]; |
unsigned volatile char NeuerDatensatzEmpfangen = 0; |
unsigned volatile char NeueKoordinateEmpfangen = 0; |
unsigned volatile char UebertragungAbgeschlossen = 1; |
unsigned volatile char SendGPSPosAnforderung = 0; |
unsigned volatile char CntCrcError = 0; |
unsigned volatile char AnzahlEmpfangsBytes = 0; |
unsigned volatile char PC_DebugTimeout = 0; |
volatile unsigned char DebugTextAnforderung = 255; |
unsigned char NurKanalAnforderung = 0; |
|
UART_TypeDef *DebugUART = UART1; |
|
unsigned char RemotePollDisplayLine = 0; |
u8 PcZugriff = 100; |
u8 MotorTest[4] = {0,0,0,0}; |
u8 MeineSlaveAdresse; |
volatile struct str_DebugOut DebugOut; |
struct str_ExternControl ExternControl; |
struct str_GPSPosition GPS_Position; |
struct str_VersionInfo VersionInfo; |
struct str_PCTargetGPSPosition PCTargetGPSPosition; |
s32 Debug_Timer; |
static u16 ptr = 0; |
unsigned char ConfirmFrame; |
|
#define FIFO_TX_LEVEL 2 |
|
UART_InitTypeDef UART_InitStructure; |
|
const unsigned char ANALOG_TEXT[32][16] = |
{ |
//1234567890123456 |
"WinkelNick ", //0 |
"WinkelRoll ", |
"AccNick ", |
"AccRoll ", |
"AN4 ", |
"AN5 ", //5 |
"GPS-Data Counter", |
"7 ", |
"8 ", |
"9 ", |
"10 ", //10 |
"Poti1 ", |
"SPI Error ", |
"SPI Okay ", |
"Poti2 ", |
"Poti3 ", //15 |
"I2C_ReadByte ", |
"ACC_Speed_N ", |
"ACC_Speed_E ", |
" ", |
" ", //20 |
// "Distance_N ", |
// "Distance_E ", //20 |
"N_Speed ", |
"E_Speed ", |
"I_North ", |
"I_East ", |
"GyroKompass ", //25 |
"Heading ", |
// "Distance2Target ", |
// "Direction2Target", |
"Distance N ", |
"Distance E ", |
"GPS_NICK ", |
"GPS_ROLL ", //30 |
"Used_Sat " |
}; |
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
//++ Sende- und Empfangs-Part der Datenübertragung, incl. CRC-Auswertung |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
void UART1_IRQHandler(void) |
{ |
// ---------------------------- Receive ------------------------------------ |
|
if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET)|| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) ) |
{ |
static u16 crc; |
static u8 crc1,crc2,buf_ptr; |
static u8 UartState = 0; |
u8 CrcOkay = 0; |
|
if (DebugUART != UART1) |
{ |
while (UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET) |
UART_SendData(DebugUART, UART_ReceiveData(UART1)); |
} |
else |
while ((UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)&& (!NeuerDatensatzEmpfangen)) |
{ |
|
SioTmp = UART_ReceiveData(UART1); |
|
|
if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0; |
if(SioTmp == '\r' && UartState == 2) |
{ |
UartState = 0; |
crc -= RxdBuffer[buf_ptr-2]; |
crc -= RxdBuffer[buf_ptr-1]; |
crc %= 4096; |
crc1 = '=' + crc / 64; |
crc2 = '=' + crc % 64; |
CrcOkay = 0; |
if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;}; |
if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet |
{ |
NeuerDatensatzEmpfangen = 1; |
|
// GPIO_ToggleBit(GPIO6, GPIO_Pin_2); |
|
AnzahlEmpfangsBytes = buf_ptr; |
RxdBuffer[buf_ptr] = '\r'; |
if(RxdBuffer[2] == 'R') |
{ |
PowerOff(); |
VIC_DeInit(); |
Execute_Bootloader(); // Reset-Commando - Bootloader starten |
} |
// while (UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET) SioTmp = UART_ReceiveData(UART1); |
|
//BearbeiteRxDaten(); |
break; |
} |
} |
else |
switch(UartState) |
{ |
case 0: |
if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet |
buf_ptr = 0; |
RxdBuffer[buf_ptr++] = SioTmp; |
crc = SioTmp; |
break; |
case 1: // Adresse auswerten |
UartState++; |
RxdBuffer[buf_ptr++] = SioTmp; |
crc += SioTmp; |
break; |
case 2: // Eingangsdaten sammeln |
RxdBuffer[buf_ptr] = SioTmp; |
if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++; |
else UartState = 0; |
crc += SioTmp; |
break; |
default: |
UartState = 0; |
break; |
} |
|
|
} |
|
} |
|
UART_ClearITPendingBit(UART1, UART_IT_Receive); |
UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut); |
|
} |
|
// -------------------------------------------------------------------------- |
void UART1_Transmit(void) |
{ |
u8 tmp_tx; |
|
if((!UebertragungAbgeschlossen) && (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == RESET)) |
{ |
|
tmp_tx = SendeBuffer[ptr]; |
|
if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF)) |
{ |
ptr = 0; |
UebertragungAbgeschlossen = 1; |
} |
|
UART_SendData(UART1, tmp_tx); |
|
ptr++; |
} |
} |
|
// -------------------------------------------------------------------------- |
void AddCRC(u16 wieviele) |
{ |
u16 tmpCRC = 0,i; |
//u8 count = FIFO_TX_LEVEL + 2 ; |
|
for(i = 0; i < wieviele;i++) |
{ |
tmpCRC += SendeBuffer[i]; |
} |
tmpCRC %= 4096; |
SendeBuffer[i++] = '=' + tmpCRC / 64; |
SendeBuffer[i++] = '=' + tmpCRC % 64; |
SendeBuffer[i++] = '\r'; |
|
|
ptr = 0; |
|
|
// USB_Send_Data((u8 *) SendeBuffer,i); |
|
{ |
UART_SendData(UART1,SendeBuffer[ptr++]); |
UebertragungAbgeschlossen = 0; |
|
} |
} |
|
|
|
// -------------------------------------------------------------------------- |
void SendOutData(u8 cmd,u8 modul, u8 *snd, u8 len) |
{ |
u16 pt = 0; |
u8 a,b,c; |
u8 ptr = 0; |
|
SendeBuffer[pt++] = '#'; // Startzeichen |
SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...) |
SendeBuffer[pt++] = cmd; // Commando |
|
while(len) |
{ |
if(len) { a = snd[ptr++]; len--;} else a = 0; |
if(len) { b = snd[ptr++]; len--;} else b = 0; |
if(len) { c = snd[ptr++]; len--;} else c = 0; |
SendeBuffer[pt++] = '=' + (a >> 2); |
SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4)); |
SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6)); |
SendeBuffer[pt++] = '=' + ( c & 0x3f); |
} |
AddCRC(pt); |
} |
|
|
// -------------------------------------------------------------------------- |
void Decode64(u8 *ptrOut, u8 len, u8 ptrIn,u8 max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer |
{ |
u8 a,b,c,d; |
u8 ptr = 0; |
u8 x,y,z; |
while(len) |
{ |
a = RxdBuffer[ptrIn++] - '='; |
b = RxdBuffer[ptrIn++] - '='; |
c = RxdBuffer[ptrIn++] - '='; |
d = RxdBuffer[ptrIn++] - '='; |
if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden |
|
x = (a << 2) | (b >> 4); |
y = ((b & 0x0f) << 4) | (c >> 2); |
z = ((c & 0x03) << 6) | d; |
|
if(len--) ptrOut[ptr++] = x; else break; |
if(len--) ptrOut[ptr++] = y; else break; |
if(len--) ptrOut[ptr++] = z; else break; |
} |
|
} |
|
// -------------------------------------------------------------------------- |
void BearbeiteRxDaten(void) |
{ |
if(!NeuerDatensatzEmpfangen) return; |
|
// u16 tmp_int_arr1[1]; |
// u16 tmp_int_arr2[2]; |
// u16 tmp_int_arr3[3]; |
u8 tmp_char_arr2[2]; |
s32 tmp_long_arr2[2]; |
// u8 tmp_char_arr3[3]; |
// u8 tmp_char_arr4[4]; |
//if(!MotorenEin) |
PcZugriff = 255; |
switch(RxdBuffer[2]) |
{ |
case 'a':// Texte der Analogwerte |
Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes); |
DebugTextAnforderung = tmp_char_arr2[0]; |
break; |
case 'b': |
Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes); |
RemoteTasten |= ExternControl.RemoteTasten; |
ConfirmFrame = ExternControl.Frame; |
break; |
case 'c': |
Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes); |
RemoteTasten |= ExternControl.RemoteTasten; |
ConfirmFrame = ExternControl.Frame; |
DebugDataAnforderung = 1; |
break; |
case 'h':// x-1 Displayzeilen |
Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes); |
RemoteTasten |= tmp_char_arr2[0]; |
if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten |
DebugDisplayAnforderung = 1; |
break; |
case 't':// Motortest |
Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes); |
break; |
case 's':// neue PCTargetGPSPosition |
Decode64((unsigned char *) &tmp_long_arr2[0],sizeof(tmp_long_arr2),3,AnzahlEmpfangsBytes); |
PCTargetGPSPosition.Longitude = tmp_long_arr2[0]; |
PCTargetGPSPosition.Latitude = tmp_long_arr2[1]; |
NewPCTargetGPSPosition = 1; |
break; |
case 'k':// Keys von DubWise |
// Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes); |
ConfirmFrame = 1; |
break; |
case 'v': // Version-Anforderung und Ausbaustufe |
GetVersionAnforderung = 1; |
break; |
case 'g':// "Get"-Anforderung für Debug-Daten |
// Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
DebugGetAnforderung = 1; |
break; |
|
case 'l': |
case 'm': |
case 'n': |
case 'o': |
case 'p': // Parametersatz speichern |
/* Decode64((u8 *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes); |
WriteParameterSet(RxdBuffer[2] - 'l' + 1, (u8 *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken |
Piep(GetActiveParamSetNumber());*/ |
break; |
|
|
} |
// DebugOut.AnzahlZyklen = Debug_Timer_Intervall; |
NeuerDatensatzEmpfangen = 0; |
|
} |
|
|
//############################################################################ |
//Routine für die Serielle Ausgabe |
s16 uart_putchar (char c) |
//############################################################################ |
{ |
if (c == '\n') |
uart_putchar('\r'); |
|
while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET); |
UART_SendData(UART1, c); |
|
return (0); |
} |
// -------------------------------------------------------------------------- |
void SerialPutString(u8 *s) |
{ |
while (*s != '\0') |
{ |
uart_putchar(*s); |
s ++; |
} |
} |
|
//############################################################################ |
//Init der Seriellen Schnittstelle |
void Debug_UART1_Init (void) |
//############################################################################ |
{ |
GPIO_InitTypeDef GPIO_InitStructure; |
|
SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock |
SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock |
|
/*Configure UART1_Rx pin GPIO3.2*/ |
GPIO_DeInit(GPIO3); |
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput; |
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; |
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ; |
GPIO_InitStructure.GPIO_IPConnected = GPIO_IPConnected_Enable; |
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1 ; |
GPIO_Init(GPIO3, &GPIO_InitStructure); |
|
/*Configure UART1_Tx pin GPIO3.3*/ |
GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput; |
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; |
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ; |
GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2 ; |
GPIO_Init(GPIO3, &GPIO_InitStructure); |
|
/* UART1 configured as follow: |
- Word Length = 8 Bits |
- One Stop Bit |
- No parity |
- BaudRate = 57600 baud |
- Hardware flow control Disabled |
- Receive and transmit enabled |
- Receive and transmit FIFOs are Disabled |
*/ |
UART_InitStructure.UART_WordLength = UART_WordLength_8D; |
UART_InitStructure.UART_StopBits = UART_StopBits_1; |
UART_InitStructure.UART_Parity = UART_Parity_No ; |
UART_InitStructure.UART_BaudRate = BAUD_RATE ; |
UART_InitStructure. UART_HardwareFlowControl = UART_HardwareFlowControl_None; |
UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx; |
//UART_InitStructure.UART_FIFO = UART_FIFO_Disable; |
UART_InitStructure.UART_FIFO = UART_FIFO_Enable; |
UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2; |
UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2; |
|
UART_DeInit(UART1); |
UART_Init(UART1, &UART_InitStructure); |
|
UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut /*| UART_IT_Transmit */, ENABLE); |
//UART_ITConfig(UART1, UART_IT_Receive , ENABLE); |
|
|
|
UART_Cmd(UART1, ENABLE); |
|
VIC_Config(UART1_ITLine, VIC_IRQ, 4); |
VIC_ITCmd(UART1_ITLine, ENABLE); |
|
Debug_Timer = SetDelay(3000); |
//---------------------------------------- |
|
|
} |
|
|
//--------------------------------------------------------------------------------------------- |
void DatenUebertragung(void) |
{ |
|
if(!UebertragungAbgeschlossen) return; |
|
if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
{ |
SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl)); |
DebugGetAnforderung = 0; |
} |
|
if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen) |
{ |
SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut)); |
DebugDataAnforderung = 0; |
Debug_Timer = SetDelay(2000); |
} |
if(DebugTextAnforderung != 255) // Texte für die Analogdaten |
{ |
SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16); |
DebugTextAnforderung = 255; |
} |
if(DebugDisplayAnforderung && UebertragungAbgeschlossen) |
{ |
Menu(); |
DebugDisplayAnforderung = 0; |
if(++RemotePollDisplayLine == 4 || NurKanalAnforderung) |
{ |
SendOutData('4',0,(unsigned char *) &VersionInfo,sizeof(VersionInfo)); // DisplayZeile übertragen |
RemotePollDisplayLine = -1; |
} |
else SendOutData('0' + RemotePollDisplayLine,0,(unsigned char *)&DisplayBuff[20 * RemotePollDisplayLine],20); // DisplayZeile übertragen |
} |
if(GetVersionAnforderung && UebertragungAbgeschlossen) |
{ |
SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo)); |
GetVersionAnforderung = 0; |
} |
if(SendGPSPosAnforderung && UebertragungAbgeschlossen) |
{ |
SendOutData('Q',MeineSlaveAdresse,(unsigned char *) &GPS_Position,sizeof(GPS_Position)); |
SendGPSPosAnforderung = 0; |
} |
|
} |
|