| 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; |
| } |
| |
| } |
| |