void uart_process() {
if (uart_has_data()) {
uint8_t command = uart_consume();
// Process factory reset commands:
// UTOK_RST_PROPOSE, UTOK_RST_CONFIRM, UTOK_RST_COMMIT
if (command == UTOK_RST_PROPOSE) {
uint8_t i;
for (i = 0; i < LED_COUNT; i++) leds_set_led(i,LED_SLOW_1);
wait_for_confirm();
uart_send_byte(UTOK_RST_CONFIRM);
for (i = 0; i < LED_COUNT; i++) leds_set_led(i,(i%2 == 0)?LED_FAST_1:LED_FAST_0);
otp_factory_reset();
for (i = 0; i < LED_COUNT; i++) leds_set_led(i,LED_OFF);
while(1){} // Loop forever
} else if (command == UTOK_BUTTON_QUERY) {
uart_send_byte(UTOK_BUTTON_RSP);
uart_send_byte(has_confirm()?0xff:0x00);
} else if (command == UTOK_REQ_CHKSM) {
uint16_t block;
struct checksum_ret sum;
block = uart_consume() << 8;
block |= uart_consume();
sum = nand_block_checksum(block);
if (sum.ok) {
uart_send_byte(UTOK_RSP_CHKSM);
uart_send_byte(sum.checksum >> 8);
uart_send_byte(sum.checksum & 0xff);
} else {
//Converts Pulse Width's into State Machine Changes
//0x2000 = As.wav
//0x4000 = Bs.wav
//0x7000 = Cs.wav
//0x9000 = Ds.wav
void pwm_decode(uint16_t width) {
uart_send_byte(&udata,'-');
uart_send_byte(&udata,'-');
uart_send_byte(&udata,'-');
uart_send_HEX16(&udata, width);
uart_send_byte(&udata,'-');
uart_send_byte(&udata, 13);
if (between(width,0x1000,0x2000) == true) {
//Found A code!
pwm_state('A');
}
if (between(width,0x2000,0x3000) == true) {
//Found B code!
pwm_state('B');
}
if (between(width,0x4000,0x5000) == true) {
//Found C code!
pwm_state('C');
}
if (between(width,0x7000,0x8000) == true) {
//Found D code!
pwm_state('D');
}
}
static int uart_push(void *user_data, unsigned char ch)
{
(void)user_data;
uart_send_byte(DEBUG_UART_PORT, ch);
if (ch == '\n')
uart_send_byte(DEBUG_UART_PORT, '\r');
return 1;
}
void printf_byte(int a){ // print a Byte in hex format
char b;
b=((0xF0&a)>>4);
b+= (b<10)?48:55;
uart_send_byte(b);
b=(0xF&a);
b+= (b<10)?48:55;
uart_send_byte(b);
}
void uart_send_string(char *sendString)
{
int length = 0;
while ((sendString[length] != '\0') && (length < 100))
{
uart_send_byte(NEW_ULTRASOUND3_BASE, sendString[length]);
length++;
}
uart_send_byte(NEW_ULTRASOUND3_BASE, 0x00);
}
void printf_byte(int a){ // print a Byte in hex format
#ifndef UART_ENABLED
return ;
#else
char b;
b=((0xF0&a)>>4);
b+= (b<10)?48:55;
uart_send_byte(b);
b=(0xF&a);
b+= (b<10)?48:55;
uart_send_byte(b);
#endif
}
return_type_t uart_send_array(const uint8_t *send_array, uint8_t size)
{
uint8_t i;
for(i = 0; i < size; i++)
uart_send_byte(send_array[i]);
return RC_SUCCESS;
}
void printf_string(char * str)
{
while(*str!=0)
{ // while not reach the last string character
uart_send_byte(*str); // send next string character
str++;
}
}
/*
Send/print character/string over UART.
Printable data for viewing on terminal.
Call this function: printString("test data");
Data must be string.
*/
void printString(char *data){
uint16_t i;
uint16_t str_length = strlen(data);
for(i = 0; i < str_length; i++)
{
uart_send_byte(data[i]);
}
}
bool
ComSlip_SendMessage(uint8_t* msg, uint16_t msgLength)
{
// send start of SLIP message
uart_send_byte(lora, SLIP_END);
// iterate over all message bytes
while(msgLength--)
{
switch (*msg)
{
case SLIP_END:
uart_send_byte(lora, SLIP_ESC);
uart_send_byte(lora, SLIP_ESC_END);
break;
case SLIP_ESC:
uart_send_byte(lora, SLIP_ESC);
uart_send_byte(lora, SLIP_ESC_ESC);
break;
default:
uart_send_byte(lora,*msg);
break;
}
// next byte
msg++;
}
// send end of SLIP message
uart_send_byte(lora, SLIP_END);
// always ok
return true;
}
int sys_dev_init()
{
char count = '0';
init_func_t *init_call;
extern init_func_t init_call_begin[], init_call_end[];
uart_send_byte('B');
uart_send_byte('\n');
init_call = init_call_begin;
while (init_call < init_call_end) {
uart_send_byte(count++);
uart_send_byte(':');
(*init_call)();
init_call++;
uart_send_byte('\n');
}
uart_send_byte('E');
uart_send_byte('\n');
return 0;
}
/****************************************************************************
Function:
unsigned int ultrasound_read(long Address, unsigned char settings)
Description:
// This function receives one Byte via the corresponding UART from the Address
Precondition:
Call ultrasound_init(long Address) prior to use this function
Parameters:
long Address - Address of the UART (and therefore of the Ultrasound)
unsigned char settings - defines maximum distance to measure (1: 11m; 0: 5m)
Returns:
unsigned int - distance in mm
Remarks:
Distance in meter
***************************************************************************/
unsigned int ultrasound_read(long Address, unsigned char settings)
{
unsigned int i;
unsigned char res_l, res_h;
uart_send_byte(Address, 0xe8);
for (i = 0; i < 300; i++);
uart_send_byte(Address, 0x02);
for (i = 0; i < 300; i++);
if (settings)
uart_send_byte(Address, 0xb8);
else
uart_send_byte(Address, 0xb0);
for (i = 0; i < 300; i++);
res_h = uart_receive_byte(Address);
for (i = 0; i < 300; i++);
res_l = uart_receive_byte(Address);
return (((unsigned int) res_h) << 8) + res_l;
}
bool uart_send_buf (unsigned dev, char *buf, unsigned len)
{
unsigned index=0;
while (index<len)
{
uart_send_byte (dev, buf[index]);
index++;
}
return true;
}
int main (void)
{
// Interrupt setup for sleep mode
interrupt_init();
// temp for debugging
DDRB |= (1 << PINB0);
PORTB |= (1 << PINB0);
// Select ADC channel
uint8_t ch = 0b00000000;
while(1)
{
if (asleep)
{
PORTB &= ~(1 << PINB0);
// Disable interrupt
cli();
// Power down
sleep_now();
PORTB ^= (1 << PINB0);
// Continue here at start up
// Disable interrupt for setting registers
cli();
external_clock_init();
interrupt_init();
timer_init();
uart_init();
adc_init();
sei();
} else if (!asleep) {
// Temp for debugging
_delay_ms(100);
// PORTB ^= (1 << PINB0);
// Read from ADC
uint16_t result = adc_read(ch);
// Send result
uart_send_byte((result >> 8));
uart_send_byte(result);
uart_send_byte('\n');
}
}
void printf_string(char * str){
#ifndef UART_ENABLED
return ;
#else
while(*str!=0){ // while not reach the last string character
uart_send_byte(*str); // send next string character
str++;
}
#endif
}
/*
Send raw data over UART.
Not "printable" data.
Call this function: writeData(&data, sizeof(data));
Data can be any type.
*/
void writeData(void *data, uint8_t dataSize){
uint8_t i, d;
d = dataSize/2;
for(i = 0; i < d; i++)
{
uart_send_byte(*( ((uint16_t *)data) + i ) );
}
}
static int my_itoa(__u32 num)
{
int i, ret;
char char_buff[32] = {0};
i = 0;
while (num) {
char_buff[i++] = (num % 10) + '0';
num /= 10;
}
ret = i--;
do {
uart_send_byte(char_buff[i]);
} while (i--);
uart_send_byte('\n');
return ret;
}
int main(void)
{
uint8_t data;
lcd_init();
uart_init(38400);
for (;;) {
data = uart_recv_byte();
lcd_put_char(data);
uart_send_byte(data);
}
}
/**
* Play one round of the contention game. If neither side received the force_master flag,
* they each wait a random amount of time before sending the ping packet. The first to acknowledge
* the other side's ping is the slave. If the two packets conflict, the came ends in a conflict and
* must be run again.
* If after a timeout passes no token has been received, the device assumes that the pad has
* been snapped and is disconnected from its twin.
* @param usb_present gives the usb-connected side precedence if force_master is not set.
*/
ConnectionState uart_play_round(bool force_master, bool usb_present) {
timer_reset();
uint16_t ms = 0;
while (timer_msec() < 1) {} // let uarts settle
if (!force_master) {
hwrng_start();
timer_reset(); while (timer_msec() < 2) {} // wait 2 ms
while (!hwrng_done()) {} // wait for random data to become available
if (!usb_present) {
ms = 3+(hwrng_bits()[0] & 0x3f); // additional delay of 3-67 ms
} else {
ms = 0; // skip additional delay on usb-connected end
}
}
timer_reset();
while (timer_msec() < ms) {
if (uart_has_data()) {
uint8_t b = uart_consume();
if (b == UTOK_GAME_PING) {
uart_send_byte(UTOK_GAME_ACK);
return CS_TWINNED_SLAVE;
} else if (b == UTOK_GAME_ACK) {
return CS_TWINNED_COLLISION;
}
}
}
uart_send_byte(UTOK_GAME_PING);
timer_reset();
ms = 1000 - ms;
while (timer_msec() < ms) {
if (uart_has_data()) {
uint8_t b = uart_consume();
if (b == UTOK_GAME_ACK) {
return CS_TWINNED_MASTER;
} else if (b == UTOK_GAME_PING) {
return CS_TWINNED_COLLISION;
}
}
}
return CS_SINGLE;
}
int main()
{
init();
print("Welcome to MSP430 Launchpad.\r\n");
while (1) {
char c = uart_recv_byte();
uart_send_byte(c);
}
return 0;
}
void handle_input(uint8 type)
{
/* check click times */
if (ClickNum > MAX_INPUT) {
if (type != LETTER || type != WORD)
reset_buff();
beer(WARN);
return;
}
if (type == DOT || type ==DASH) {
beer(type);
/* the ascii of '\0' is equal to number zero
it may cause some trouble */
buff[ClickNum++] = type + 1;
return;
}
if (type == LETTER || type == WORD) {
buff[ClickNum] = '\0';
/* decoding*/
for (p = &letter_a;p != NULL;p = p->next) {
if (strcmp(buff,p->morse_mask) == 0) {
/* send */
uart_send_byte(p->output);
if (type == WORD) uart_send_byte(SPACE);
reset_buff();
return;
}
}
/* not match */
reset_buff();
beer(WARN);
}
}
static int my_htoa(__u32 num)
{
int i, ret;
char char_buff[32];
i = 0;
while (num) {
char_buff[i++] = ((num % 16) > 9) ? num % 16 + 'a' - 10 : num % 16 + '0';
num = num >> 4;
}
uart_send_byte('0');
uart_send_byte('x');
ret = i--;
do {
uart_send_byte(char_buff[i]);
} while (i--);
uart_send_byte('\n');
return ret;
}
int main(void)
{
uint8_t chan, low, hi;
uint16_t adcval;
lcd_init();
uart_init(38400);
adc_enable();
for(;;)
{
chan = uart_recv_byte();
if (chan <=7)
{
adcval = read_adc(chan);
lcd_clear();
lcd_put_int(low);
low = adcval & 255;
hi = adcval >> 8;
uart_send_byte(low); // send LOW byte
uart_send_byte(hi); // send HI byte
}
}
// TODO: support MS hyper-term
static inline void modem_end_rx()
{
uart_send_byte(ACK);
// uart_send_byte('C');
// uart_send_byte(ACK);
uart_send_byte(CAN);
uart_send_byte(CAN);
uart_send_byte(CAN);
uart_send_byte(CAN);
uart_send_byte(CAN);
uart_send_byte(CAN);
}
void VCOM_bridge(void)
{
uint32_t recv_count;
recv_count = CDC_Device_BytesReceived(&VirtualSerial_CDC_Interface);
while(recv_count--)
{
out_buff[0] = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
uart_send_byte(out_buff[0]);
}
recv_count = uart_get_data(in_buff);
if(recv_count)
{
CDC_Device_SendData(&VirtualSerial_CDC_Interface, (char *)in_buff, recv_count);
Endpoint_ClearIN();
}
}
void conn_main()
{
if(conn_pipe_available != 7)
{
uint8_t len = NRF24L01_get_payload_len(conn_pipe_available);
if(len == 0)
{
uart_write_async("RX: Length of payload is 0");
return;
}
conn_frame_t* frame = conn_create_frame();
uint8_t* data = malloc(len);
if(frame == NULL || data == NULL)
{
conn_pipe_available = 7;
NRF24L01_LOW_set_register(NRF24L01_REG_STATUS, NRF24L01_MASK_STATUS_RX_DR); //Clear data-ready flag
return;
}
NRF24L01_get_received_data(data, len);
conn_pipe_available = 7;
NRF24L01_LOW_set_register(NRF24L01_REG_STATUS, NRF24L01_MASK_STATUS_RX_DR); //Clear data-ready flag
conn_pack_frame(data, frame);
free(data);
conn_process_result_t* process_result = conn_process_frame(frame);
conn_free_frame(frame);
if(process_result == NULL)
{
uart_write_async("RX: Too few memory to save result");
}
else
{
if(process_result->error_code != CONN_ERROR_OK)
{
conn_free_connection(process_result->connection);
uart_send_byte(process_result->error_code);
}
free(process_result);
}
}
}
//Most Significant Bit first
void uart_send_BIN4(USART_t* which, uint8_t lowb) {
switch(lowb) {
case(0):
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
break;
case(1):
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
break;
case(2):
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
break;
case(3):
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
break;
case(4):
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
break;
case(5):
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
break;
case(6):
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
break;
case(7):
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
break;
case(8):
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
break;
case(9):
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
break;
case(10):
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
break;
case(11):
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
break;
case(12):
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'0');
break;
case(13):
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
uart_send_byte(which,'1');
break;
case(14):
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'0');
break;
case(15):
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
uart_send_byte(which,'1');
break;
}
}
PROCESS_THREAD(zigbee_comunication, ev, data)
{
static struct etimer et;
unsigned char sum = 0;
struct st_UartRcv *pdata = NULL;
int i = 0;
PROCESS_BEGIN();
GPIO_DeInit(GPIOB);
GPIO_Init(GPIOC, GPIO_Pin_5, GPIO_Mode_Out_PP_High_Fast); //TXD
GPIO_Init(GPIOC, GPIO_Pin_6, GPIO_Mode_In_PU_No_IT); //RXD
//GPIO_Init(GPIOB,GPIO_Pin_6,GPIO_Mode_In_FL_IT); // ACK
GPIO_Init(GPIOB,GPIO_Pin_5,GPIO_Mode_Out_PP_High_Fast); // RESET
//GPIO_Init(GPIOB,GPIO_Pin_4,GPIO_Mode_In_FL_IT); // STATE
GPIO_Init(GPIOB,GPIO_Pin_3,GPIO_Mode_Out_PP_High_Fast); // WAKEUP
GPIO_Init(GPIOB,GPIO_Pin_2,GPIO_Mode_Out_PP_High_Fast); // SLEEP
GPIO_Init(GPIOB,GPIO_Pin_1,GPIO_Mode_Out_PP_High_Fast); // DEF
GPIO_Init(GPIOD,GPIO_Pin_0,GPIO_Mode_Out_PP_Low_Fast); // DIR
#if 0
GPIO_WriteBit(GPIOB, GPIO_Pin_1, RESET);
GPIO_WriteBit(GPIOB, GPIO_Pin_5, RESET);
etimer_set(&et, CLOCK_SECOND / 10);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
GPIO_WriteBit(GPIOB, GPIO_Pin_5, SET);
etimer_set(&et, CLOCK_SECOND / 10);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
GPIO_WriteBit(GPIOB, GPIO_Pin_1, SET);
#endif
SYSCFG_REMAPPinConfig(REMAP_Pin_USART1TxRxPortC,ENABLE);
CLK_PeripheralClockConfig(CLK_Peripheral_USART1, ENABLE);
/* USART configured as follow:
- BaudRate = 115200 baud
- Word Length = 8 Bits
- One Stop Bit
- Odd parity
- Receive and transmit enabled
- USART Clock disabled
*/
USART_Init(USART1, (uint32_t)115200, USART_WordLength_8b, USART_StopBits_1,
USART_Parity_No, (USART_Mode_TypeDef)(USART_Mode_Tx | USART_Mode_Rx));
/* Enable the USART Receive interrupt: this interrupt is generated when the USART
receive data register is not empty */
//USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
/* Enable the USART Transmit complete interrupt: this interrupt is generated when the USART
transmit Shift Register is empty */
//USART_ITConfig(USART1, USART_IT_TC, ENABLE);
/* Enable USART */
//USART_Cmd(USART1, ENABLE);
USART_Cmd(USART1, ENABLE);
//USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
#if 0
PUTSTRING("Now config ZM516X\r\n");
readLocalInfo:
memcpy(usart_buf,read_local_cfg,sizeof(read_local_cfg));
usart_buf[4] = usart_buf[0] + usart_buf[1] + usart_buf[2] + usart_buf[3];
uart_send_byte(5,usart_buf);
PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_MSG);
pdata = (struct st_UartRcv *)data;
if((pdata->buf[0] == 0xAB) && (pdata->buf[1] == 0xBC) && (pdata->buf[2] == 0xCD) && (pdata->buf[3] == 0xD1))
{
}
else
{
goto readLocalInfo;
}
memcpy(&stDevInfo,&pdata->buf[4],65);
usart_buf[0] = 0xab;
usart_buf[1] = 0xbc;
usart_buf[2] = 0xcd;
usart_buf[3] = enModifyCfg;
usart_buf[4] = stDevInfo.devLoacalNetAddr[0];
usart_buf[5] = stDevInfo.devLoacalNetAddr[1];
stDevInfo.devLoacalNetAddr[0] = 0x00;
stDevInfo.devLoacalNetAddr[1] = 0x03;
//memset(stDevInfo.devLoacalNetAddr,0,2);
stDevInfo.devDestNetAddr[0] = 0x00;
stDevInfo.devDestNetAddr[1] = 0x00;
stDevInfo.devChannel = 0x19;
stDevInfo.devPanid[0] = 0x10;
stDevInfo.devPanid[1] = 0x01;
memcpy(&usart_buf[6],&stDevInfo,65);
for(i = 0;i < (6 + 65);i++)
{
sum += usart_buf[i];
}
usart_buf[6 + 65] = sum;
uart_send_byte(6 + 65 + 1,usart_buf);
etimer_set(&et, CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
GPIO_WriteBit(GPIOB,GPIO_Pin_5,RESET);
etimer_set(&et, CLOCK_SECOND / CLOCK_SECOND);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
GPIO_WriteBit(GPIOB,GPIO_Pin_5,SET);
#endif
//uart_send_byte(5,"hello");
process_start(&hmc5983_work, NULL);
while(1)
{
//etimer_set(&et, CLOCK_SECOND);
//PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_MSG);
//pdata = (struct st_UartRcv *)data;
//if(memcmp(pdata->buf,"get",3) == 0)
if(flg)
{
usart_buf[0] = 0xAA;
usart_buf[1] = 0xBB;
usart_buf[2] = 0xCC;
*(int*)&usart_buf[3] = x;
*(int*)&usart_buf[5] = y;
*(int*)&usart_buf[7] = z;
usart_buf[9] = 0;
for(i = 0;i < 9;i ++)
{
usart_buf[9] += usart_buf[i];
}
usart_buf[9] = 0xff - usart_buf[9];
GPIO_WriteBit(GPIOD, GPIO_Pin_0, SET);
etimer_set(&et, CLOCK_SECOND / 20);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
uart_send_byte(10,usart_buf);
etimer_set(&et, CLOCK_SECOND / 20);
PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
GPIO_WriteBit(GPIOD, GPIO_Pin_0, RESET);
}
//etimer_set(&et, CLOCK_SECOND / 10);
//PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
//memcpy(usart_buf,"hello!\r\n",8);
//uart_send_byte(8,usart_buf);
}
PROCESS_EXIT();
PROCESS_END();
}
void uart_factory_reset_confirm() {
uart_send_byte(UTOK_RST_PROPOSE);
while (1) {
if (uart_has_data() && (uart_consume() == UTOK_RST_CONFIRM)) return;
}
}
int main(void)
{
// configure WDT
WDTCTL = WDTPW | WDTHOLD; // stop watch dog timer
_25mhz();
#ifdef TEST
// when compiled in test mode, use different main
// disconnect radio when testing to avoid damage!
test_main();
#endif
// configure LED1 and turn it off, we'll use that for error and other stuff
P1DIR |= LED1;
LED1_OFF;
P4DIR |= LED2;
LED2_ON;
// setup uart
uart_init();
#ifdef DEBUG_MESSAGES
uart_send_string("Hola mundo!\r\n");
#endif
// setup packet handler
ph_setup();
// setup an configure radio
radio_setup();
radio_configure();
// self-calibrate image rejection
radio_calibrate_ir();
// verify that radio configuration was successful
radio_get_chip_status(0);
if (radio_buffer.chip_status.chip_status & RADIO_CMD_ERROR) { // check for command error
uart_send_string("Error inicializando radio!!!\r\n");
while (1) {
LED1_TOGGLE;
_delay_cycles(8000000); // blink LED if there was an error
}
}
// start packet receiving
ph_start();
#ifdef DEBUG_MESSAGES
uart_send_string("dAISy 0.2 started\r\n");
LED2_OFF;
#endif
while (1) {
LPM0; // deep sleep until something worthwhile happens
__no_operation();
ph_loop(); // packet handler house-keeping, e.g. channel hopping
#ifdef DEBUG_MESSAGES
uint8_t channel;
int16_t rssi;
// debug code to monitor signal strength (RSSI)
if (ph_get_state() == PH_STATE_PREFETCH) { // found preamble and start flag
// record current channel and signal strength
channel = ph_get_radio_channel(); // read current channel
rssi = ph_get_radio_rssi(); // read current RSSI
}
#endif
// retrieve last packet handler error
uint8_t error = ph_get_last_error();
#ifdef DEBUG_MESSAGES
// report error if packet handler failed
if (error != PH_ERROR_NONE) {
dec_to_str(str_output_buffer, 3, rssi); // convert to decimal string (reuse radio buffer)
str_output_buffer[4] = 0; // terminate string
uart_send_string("sync "); // send debug message to UART
uart_send_byte(channel + 'A');
uart_send_string(" RSSI=");
uart_send_string(str_output_buffer);
uart_send_string("dBm\r\n");
uart_send_string("error: ");
switch (error) {
case PH_ERROR_NOEND:
uart_send_string("no end flag");
break;
case PH_ERROR_STUFFBIT:
uart_send_string("invalid stuff bit");
break;
case PH_ERROR_CRC:
uart_send_string("CRC error");
break;
case PH_ERROR_RSSI_DROP:
uart_send_string("RSSI drop");
break;
}
uart_send_string("\r\n");
ph_loop(); // house keeping, sending over UART takes time
}
#else
// toggle LED if packet handler failed after finding preamble and start flag
if (error == PH_ERROR_NOEND || error == PH_ERROR_STUFFBIT || error == PH_ERROR_CRC)
LED1_TOGGLE;
#endif
// check if a new valid packet arrived
uint16_t size = fifo_get_packet();
if (size > 0) { // if so, process packet
#ifdef DEBUG_MESSAGES
dec_to_str(str_output_buffer, 3, rssi); // convert to decimal string (reuse radio buffer)
str_output_buffer[4] = 0; // terminate string
uart_send_string("sync "); // send debug message to UART
uart_send_byte(channel + 'A');
uart_send_string(" RSSI=");
uart_send_string(str_output_buffer);
uart_send_string("dBm\r\n");
#endif
LED2_ON;
nmea_process_packet(); // process packet (NMEA message will be sent over UART)
fifo_remove_packet(); // remove processed packet from FIFO
LED2_OFF;
}
// enter low power mode LPM0 (everything off)
// TODO: wait for UART to complete transmission
// TODO: suspend UART
}
}
