/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!! */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Software Nutzungsbedingungen (english version: see below)
// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -
// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den
// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool
// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.
// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im
// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.
// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie
// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.
// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren
// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren
// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand
// + des Mitverschuldens offen.
// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.
// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.
// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang
// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.
// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.
// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'
// + Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Software LICENSING TERMS
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -
// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware
// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.
// + The Software may only be used with the Licensor's products.
// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this
// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this
// + agreement shall be the property of the Licensor.
// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other
// + features that can be used to identify the program may not be altered or defaced by the customer.
// + The customer shall be responsible for taking reasonable precautions
// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the
// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and
// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product
// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.
// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test
// + the software for his purpose before any operational usage. The customer will backup his data before using the software.
// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data
// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.
// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.
// + #### END OF LICENSING TERMS ####
// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#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
u16 GPS_Version
= 0;
//------------------------------------------------------------------------------------
// 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
VIC1
->VAR
= 0xFF; // write any value to VIC0 Vector address register
}
/**************************************************************/
/* 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
;
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))
if((UART0_tx_buffer.
Position == UART0_tx_buffer.
DataBytes) || (UART0_tx_buffer.
Position == UART0_tx_buffer.
Size))
{
Buffer_Clear
(&UART0_tx_buffer
);
}
}
}
/**************************************************************/
/* 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
, "\r\n 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 msg
[64];
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
))
{
retval
= UbxVersionParser
();
if(retval
!= 0xff)
{
UbxMsg.
Data[4] = 0; //Only the first 4 characters
sprintf(msg
, " V%d.%d SW:%s", retval
/10,retval
%10, (u8
*)&UbxMsg.
Data[0]);
UART1_PutString
(msg
);
}
else UART1_PutString
(" ! -> UNKNOWN <- ! ");
}
UbxMsg.
Status = INVALID
;
return(retval
);
}