Subversion Repositories NaviCtrl

Compare Revisions

Ignore whitespace Rev 343 → Rev 344

/tags/V0.26e/uart0.c
0,0 → 1,534
/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!! */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + 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 oder Nutzung 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 the sources to other systems or using the software on other systems (except 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 <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "91x_lib.h"
#include "config.h"
#include "main.h"
#include "uart0.h"
#include "uart1.h"
#include "timer1.h"
#include "ubx.h"
#include "mkprotocol.h"
 
 
//------------------------------------------------------------------------------------
// global variables
 
MKOSD_VersionInfo_t MKOSD_VersionInfo;
 
// UART0 MUXER
UART0_MuxerState_t UART0_Muxer = UART0_UNDEF;
u16 Uart0Baudrate = UART0_BAUD_RATE;
u16 Uart0MK3MagBaudrate = UART0_BAUD_RATE;
 
// the tx buffer
#define UART0_TX_BUFFER_LEN 150
u8 UART0_tbuffer[UART0_TX_BUFFER_LEN];
Buffer_t UART0_tx_buffer;
 
// the rx buffer
#define UART0_RX_BUFFER_LEN 150
u8 UART0_rbuffer[UART0_RX_BUFFER_LEN];
Buffer_t UART0_rx_buffer;
 
u8 UART0_Request_VersionInfo = FALSE;
u8 UART0_Request_NaviData = FALSE;
u8 UART0_Request_ErrorMessage = FALSE;
u32 UART0_NaviData_Timer;
u32 UART0_NaviData_Interval = 0; // in ms
 
//------------------------------------------------------------------------------------
// functions
 
/********************************************************/
/* Configure uart 0 */
/********************************************************/
void UART0_Configure(u16 Baudrate)
{
UART_InitTypeDef UART_InitStructure;
 
SCU_APBPeriphClockConfig(__UART0, ENABLE); // Enable the UART0 Clock
 
/* UART0 configured as follow:
- Word Length = 8 Bits
- One Stop Bit
- No parity
- BaudRate taken from function argument
- Hardware flow control Disabled
- Receive and transmit enabled
- Receive and transmit FIFOs are Disabled
*/
UART_StructInit(&UART_InitStructure);
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 = Baudrate;
UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;
UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;
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(UART0); // reset uart 0 to default
UART_Init(UART0, &UART_InitStructure); // initialize uart 0
 
// enable uart 0 interrupts selective
UART_ITConfig(UART0, UART_IT_Receive | UART_IT_ReceiveTimeOut /*| UART_IT_FrameError*/, ENABLE);
UART_Cmd(UART0, ENABLE); // enable uart 0
// configure the uart 0 interupt line
VIC_Config(UART0_ITLine, VIC_IRQ, PRIORITY_UART0);
// enable the uart 0 IRQ
VIC_ITCmd(UART0_ITLine, ENABLE);
}
 
/********************************************************/
/* Connect RXD & TXD to GPS */
/********************************************************/
void UART0_Connect_to_MKGPS(u16 Baudrate)
{
GPIO_InitTypeDef GPIO_InitStructure;
 
UART0_Muxer = UART0_UNDEF;
 
SCU_APBPeriphClockConfig(__GPIO6, ENABLE); // Enable the GPIO6 Clock
// unmap UART0 from Compass
// set port pin 5.1 (serial data from compass) to input and disconnect from IP
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
GPIO_Init(GPIO5, &GPIO_InitStructure);
// set port pin 5.0 (serial data to compass) to input
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
GPIO_Init(GPIO5, &GPIO_InitStructure);
// map UART0 to GPS
// set port pin 6.6 (serial data from gps) to input and connect to IP
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; //UART0_RxD
GPIO_Init(GPIO6, &GPIO_InitStructure);
// set port pin 6.7 (serial data to gps) to output
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt3; //UART0_TX
GPIO_Init(GPIO6, &GPIO_InitStructure);
// configure the UART0
UART0_Configure(Baudrate);
UART0_Muxer = UART0_MKGPS;
}
 
/********************************************************/
/* Connect RXD & TXD to MK3MAG */
/********************************************************/
void UART0_Connect_to_MK3MAG(void)
{
u16 Baudrate;
 
GPIO_InitTypeDef GPIO_InitStructure;
 
UART0_Muxer = UART0_UNDEF;
 
SCU_APBPeriphClockConfig(__GPIO5, ENABLE);
// unmap UART0 from GPS
// set port pin 6.6 (serial data from gps) to input and disconnect from IP
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
GPIO_Init(GPIO6, &GPIO_InitStructure);
// set port pin 6.7 (serial data to gps) to input
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Disable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1;
GPIO_Init(GPIO6, &GPIO_InitStructure);
 
// map UART0 to Compass
// set port pin 5.1 (serial data from compass) to input and connect to IP
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; //UART0_RxD
GPIO_Init(GPIO5, &GPIO_InitStructure);
// set port pin 5.0 (serial data to compass) to output
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt3; //UART0_TX
GPIO_Init(GPIO5, &GPIO_InitStructure);
Baudrate = UART0_BAUD_RATE + ((UART0_BAUD_RATE * 2)/100); // MK3Mag baudrate is a little bit higher...
UART0_Configure(Baudrate);
UART0_Muxer = UART0_MK3MAG;
}
 
/********************************************************/
/* Initialize UART0 */
/********************************************************/
void UART0_Init(void)
{
UART1_PutString("\r\n UART0 init...");
 
UART0_Connect_to_MKGPS(UART0_BAUD_RATE);
 
// initialize txd buffer
Buffer_Init(&UART0_tx_buffer, UART0_tbuffer, UART0_TX_BUFFER_LEN);
// initialize rxd buffer
Buffer_Init(&UART0_rx_buffer, UART0_rbuffer, UART0_RX_BUFFER_LEN);
 
UART1_PutString("ok");
}
 
/********************************************************/
/* UART0 Interrupt Handler */
/********************************************************/
void UART0_IRQHandler(void)
{
u8 c;
// if receive irq (FIFO is over trigger level) or receive timeout irq (FIFO is not empty for longer times) has occured
if((UART_GetITStatus(UART0, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART0, UART_IT_ReceiveTimeOut) != RESET) )
{
UART_ClearITPendingBit(UART0, UART_IT_Receive); // clear receive interrupt flag
UART_ClearITPendingBit(UART0, UART_IT_ReceiveTimeOut); // clear receive timeout interrupt flag
 
// if debug UART is UART0
if (DebugUART == UART0)
{ // forward received data to the UART1 tx buffer
while(UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET)
{
// wait for space in the tx buffer of the UART1
while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == SET) {};
// move the byte from the rx buffer of UART0 to the tx buffer of UART1
UART_SendData(UART1, UART_ReceiveData(UART0));
}
}
else // UART0 is not the DebugUART (normal operation)
{
// repeat until no byte is in the RxFIFO
while (UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET)
{
c = UART_ReceiveData(UART0); // get byte from rx fifo
switch(UART0_Muxer)
{
case UART0_MKGPS:
UBX_RxParser(c); // if connected to GPS forward byte to ubx parser
MKProtocol_CollectSerialFrame(&UART0_rx_buffer, c); // ckeck for MK-Frames also
break;
case UART0_MK3MAG:
// ignore any byte send from MK3MAG
break;
case UART0_UNDEF:
default:
// ignore the byte from unknown source
break;
} // eof switch(UART0_Muxer)
} // eof while
} // eof UART0 is not the DebugUART
} // eof receive irq or receive timeout irq
}
 
/**************************************************************/
/* Process incomming data from debug uart */
/**************************************************************/
void UART0_ProcessRxData(void)
{
SerialMsg_t SerialMsg;
// if data in the rxd buffer are not locked immediately return
if((UART0_rx_buffer.Locked == FALSE) || (DebugUART == UART0) ) return;
 
MKProtocol_DecodeSerialFrameHeader(&UART0_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
MKProtocol_DecodeSerialFrameData(&UART0_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
 
switch(SerialMsg.Address) // check for Slave Address
{
case MKOSD_ADDRESS: // answers from the MKOSD
switch(SerialMsg.CmdID)
{
case 'V':
memcpy(&MKOSD_VersionInfo, SerialMsg.pData, sizeof(MKOSD_VersionInfo)); // copy echo pattern
break;
default:
break;
} // case MKOSD_ADDRESS
break;
 
case NC_ADDRESS: // own Slave Address
switch(SerialMsg.CmdID)
{
case 'e': // request for the text of the error status
UART0_Request_ErrorMessage = TRUE;
break;
case 'o': // request for navigation information
UART0_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
if(UART0_NaviData_Interval > 0) UART0_Request_NaviData = TRUE;
break;
default:
break;
} // case NC_ADDRESS
// "break;" is missing here to fall thru to the common commands
 
default: // and any other Slave Address
switch(SerialMsg.CmdID) // check CmdID
{
case 'v': // request for version info
UART0_Request_VersionInfo = TRUE;
break;
default:
// unsupported command recieved
break;
}
break; // default:
}
Buffer_Clear(&UART0_rx_buffer);
}
 
/**************************************************************/
/* Transmit tx buffer via uart0 */
/**************************************************************/
void UART0_Transmit(void)
{
u8 tmp_tx;
 
IENABLE;
 
if(DebugUART == UART0) return; // no data output if debug uart is rederected to UART0
// if something has to be send and the txd fifo is not full
if((UART0_tx_buffer.Locked == TRUE) && (UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) == RESET))
{
tmp_tx = UART0_tx_buffer.pData[UART0_tx_buffer.Position++]; // read next byte from txd buffer
UART_SendData(UART0, tmp_tx); // put character to txd fifo
// if terminating character or end of txd buffer reached
if((tmp_tx == '\r') || (UART0_tx_buffer.Position == UART0_tx_buffer.Size))
{
Buffer_Clear(&UART0_tx_buffer);
}
}
 
IDISABLE;
}
 
 
/**************************************************************/
/* Send the answers to incomming commands at the uart0 */
/**************************************************************/
void UART0_TransmitTxData(void)
{
if(DebugUART == UART0) return;
UART0_Transmit(); // output pending bytes in tx buffer
if(UART0_tx_buffer.Locked == TRUE) return;
 
else if(UART0_Request_ErrorMessage && (UART0_tx_buffer.Locked == FALSE))
{
MKProtocol_CreateSerialFrame(&UART0_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
UART0_Request_ErrorMessage = FALSE;
}
else if(UART0_Request_VersionInfo && (UART0_tx_buffer.Locked == FALSE))
{
MKProtocol_CreateSerialFrame(&UART0_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
UART0_Request_VersionInfo = FALSE;
}
else if(( ((UART0_NaviData_Interval >0) && CheckDelay(UART0_NaviData_Timer) ) || UART0_Request_NaviData) && (UART0_tx_buffer.Locked == FALSE))
{
NaviData.Errorcode = ErrorCode;
MKProtocol_CreateSerialFrame(&UART0_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
UART0_NaviData_Timer = SetDelay(UART0_NaviData_Interval);
UART0_Request_NaviData = FALSE;
}
UART0_Transmit(); // output pending bytes in tx buffer
}
 
 
/**************************************************************/
/* Get the version of the MKOSD */
/**************************************************************/
u8 UART0_GetMKOSDVersion(void)
{
u32 timeout;
u8 msg[64];
u8 retval = 0;
 
MKOSD_VersionInfo.SWMajor = 0xFF;
MKOSD_VersionInfo.SWMinor = 0xFF;
MKOSD_VersionInfo.SWPatch = 0xFF;
 
if(UART0_Muxer != UART0_MKGPS) UART0_Connect_to_MKGPS(UART0_BAUD_RATE);
while(UART0_tx_buffer.Locked == TRUE) UART0_Transmit(); // output pending bytes in tx buffer;
 
MKProtocol_CreateSerialFrame(&UART0_tx_buffer, 'v', MKOSD_ADDRESS, 0); // request for version info
while(UART0_tx_buffer.Locked == TRUE) UART0_Transmit(); // output pending bytes in tx buffer;
timeout = SetDelay(500);
do
{
UART0_ProcessRxData();
if(MKOSD_VersionInfo.SWMajor != 0xFF) break;
}while(!CheckDelay(timeout));
if(MKOSD_VersionInfo.SWMajor != 0xFF)
{
sprintf(msg, "\n\r MK-OSD V%d.%d%c", MKOSD_VersionInfo.SWMajor, MKOSD_VersionInfo.SWMinor, 'a'+MKOSD_VersionInfo.SWPatch);
UART1_PutString(msg);
retval = 1;
}
//else UART1_PutString("\n\r No version information from MK-OSD.");
return(retval);
}
 
/**************************************************************/
/* Send a message to the UBLOX device */
/**************************************************************/
u8 UART0_UBXSendMsg(u8* pData, u16 Len)
{
u8 retval = 0;
// check for connection to GPS
if(UART0_Muxer != UART0_MKGPS) return(retval);
while(UART0_tx_buffer.Locked == TRUE) UART0_Transmit(); // output pending bytes in tx buffer;
UBX_CreateMsg(&UART0_tx_buffer, pData, Len); // build ubx message frame
while(UART0_tx_buffer.Locked == TRUE) UART0_Transmit(); // output pending bytes in tx buffer;
return(1);
}
 
/**************************************************************/
/* Send a configuration message to the UBLOX device */
/**************************************************************/
u8 UART0_UBXSendCFGMsg(u8* pData, u16 Len)
{
u32 timeout;
u8 retval = 0;
// if data are not a CFG MSG
if(pData[0]!= UBX_CLASS_CFG) return(retval);
// prepare rx msg filter
UbxMsg.Hdr.Class = UBX_CLASS_ACK;
UbxMsg.Hdr.Id = 0xFF;
UbxMsg.Hdr.Length = 0;
UbxMsg.ClassMask = 0xFF;
UbxMsg.IdMask = 0x00;
UbxMsg.Status = INVALID;
UART0_UBXSendMsg(pData, Len);
// check for acknowledge msg
timeout = SetDelay(100);
do
{
if(UbxMsg.Status == NEWDATA) break;
}while(!CheckDelay(timeout));
if(UbxMsg.Status == NEWDATA)
{ // 2 bytes payload
if((UbxMsg.Data[0] == pData[0]) && (UbxMsg.Data[1] == pData[1]) && (UbxMsg.Hdr.Length == 2)) retval = UbxMsg.Hdr.Id;
}
UbxMsg.Status = INVALID;
return(retval);
}
 
/**************************************************************/
/* Get Version Info from UBX Module */
/**************************************************************/
u8 UART0_GetUBXVersion(void)
{
u32 timeout;
u8 retval = 0xFF;
u8 ubxmsg[]={0x0A, 0x04, 0x00, 0x00}; //MON-VER
// prepare rx msg filter
UbxMsg.Hdr.Class = 0x0A;
UbxMsg.Hdr.Id = 0x04;
UbxMsg.Hdr.Length = 0;
UbxMsg.ClassMask = 0xFF;
UbxMsg.IdMask = 0xFF;
UbxMsg.Status = INVALID;
UART0_UBXSendMsg(ubxmsg, sizeof(ubxmsg));
// check for answer
timeout = SetDelay(100);
do
{
if(UbxMsg.Status == NEWDATA) break;
}while(!CheckDelay(timeout));
if((UbxMsg.Hdr.Length >= 40) && (UbxMsg.Status == NEWDATA))
{
UbxMsg.Data[4] = 0; //Only the fisrt 4 chsracters
UbxMsg.Data[39] = 0;
UART1_PutString(" V");
UART1_PutString((u8*)&UbxMsg.Data);
UART1_PutString(" HW:");
UART1_PutString((u8*)&UbxMsg.Data[30]);
retval = UbxMsg.Data[0]-'0'; // major sw version
}
UbxMsg.Status = INVALID;
return(retval);
}