void openserial_startInput() {
INTERRUPT_DECLARATION();
if (openserial_vars.inputBufFill>0) {
openserial_printError(COMPONENT_OPENSERIAL,ERR_INPUTBUFFER_LENGTH,
(errorparameter_t)openserial_vars.inputBufFill,
(errorparameter_t)0);
DISABLE_INTERRUPTS();
openserial_vars.inputBufFill=0;
ENABLE_INTERRUPTS();
}
uart_clearTxInterrupts();
uart_clearRxInterrupts(); // clear possible pending interrupts
uart_enableInterrupts(); // Enable USCI_A1 TX & RX interrupt
DISABLE_INTERRUPTS();
openserial_vars.busyReceiving = FALSE;
openserial_vars.mode = MODE_INPUT;
openserial_vars.reqFrameIdx = 0;
#ifdef FASTSIM
uart_writeBufferByLen_FASTSIM(
openserial_vars.reqFrame,
sizeof(openserial_vars.reqFrame)
);
openserial_vars.reqFrameIdx = sizeof(openserial_vars.reqFrame);
#else
uart_writeByte(openserial_vars.reqFrame[openserial_vars.reqFrameIdx]);
#endif
ENABLE_INTERRUPTS();
}
kick_scheduler_t uart_rx_isr() {
uart_clearRxInterrupts(); // TODO: do not clear, but disable when done
if (uart_vars.rxCb != NULL) {
uart_vars.rxCb();
}
return DO_NOT_KICK_SCHEDULER;
}
void cb_uartRxCb(void) {
// uint8_t byte;
uart_clearRxInterrupts();
// toggle LED
leds_debug_toggle();
}
/*
* @brief uart_rx_isr This function will be called from usart
* interrupt when RTXC interrupt flag is set
*
* @param return kick_scheduler_t
*
*/
kick_scheduler_t uart_rx_isr(void)
{
uart_clearRxInterrupts();
if (uart_vars.rxCb != NULL)
{
uart_vars.rxCb();
}
return DO_NOT_KICK_SCHEDULER;
}
void cb_uartRxCb() {
// uint8_t byte;
uart_clearRxInterrupts();
// toggle LED
leds_debug_toggle();
// read received byte
//byte = uart_readByte();
// echo that byte over serial
//uart_writeByte(byte);
}
void openserial_startInput() {
INTERRUPT_DECLARATION();
if (openserial_vars.input_buffer_fill_level>0) {
openserial_printError(COMPONENT_OPENSERIAL,ERR_INPUTBUFFER_LENGTH,
(errorparameter_t)openserial_vars.input_buffer_fill_level,
(errorparameter_t)0);
openserial_vars.input_buffer_fill_level = 0;
}
openserial_vars.input_command[4] = SERIAL_INPUT_BUFFER_SIZE;
uart_clearTxInterrupts();
uart_clearRxInterrupts(); // clear possible pending interrupts
uart_enableInterrupts(); // Enable USCI_A1 TX & RX interrupt
DISABLE_INTERRUPTS();
openserial_vars.mode = MODE_INPUT;
openserial_vars.input_command_index = 0;
openserial_vars.ready_receive_command = FALSE;
openserial_vars.ready_receive_length = FALSE;
uart_writeByte(openserial_vars.input_command[openserial_vars.input_command_index]);
ENABLE_INTERRUPTS();
}
void uart_init() {
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// reset local variables
memset(&uart_vars,0,sizeof(uart_vars_t));
// enable GPIO and USART clock
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
// configure USART TX pin as alternate function push-pull
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// configure USART RX as input floating
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_Init(GPIOA, &GPIO_InitStructure);
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART1, &USART_InitStructure);
// make sure no interrupts fire as we enable the UART
uart_clearTxInterrupts();
uart_clearRxInterrupts();
// enable USART1
USART_Cmd(USART1, ENABLE);
// enable NVIC uart
NVIC_uart();
}
/**
\brief The program starts executing here.
*/
int mote_main(void) {
// clear local variables
memset(&app_vars,0,sizeof(app_vars_t));
// initialize board
board_init();
// add callback functions radio
radio_setOverflowCb(cb_radioTimerOverflows);
radio_setCompareCb(cb_radioTimerCompare);
radio_setStartFrameCb(cb_startFrame);
radio_setEndFrameCb(cb_endFrame);
// setup UART
uart_setCallbacks(cb_uartTxDone,cb_uartRxCb);
// prepare radio
radio_rfOn();
radio_setFrequency(CHANNEL);
// switch in RX
radio_rxEnable();
while (1) {
// sleep while waiting for at least one of the rxpk_done to be set
app_vars.rxpk_done = 0;
while (app_vars.rxpk_done==0) {
board_sleep();
}
// if I get here, I just received a packet
//===== get packet from radio
// led
leds_sync_on();
// get packet from radio
radio_getReceivedFrame(
app_vars.rxpk_buf,
&app_vars.rxpk_len,
sizeof(app_vars.rxpk_buf),
&app_vars.rxpk_rssi,
&app_vars.rxpk_lqi,
&app_vars.rxpk_crc
);
// read the packet number
app_vars.rxpk_num = app_vars.rxpk_buf[0];
// led
leds_sync_off();
//===== send notification over serial port
// led
leds_error_on();
// format frame to send over serial port
app_vars.uart_txFrame[0] = app_vars.rxpk_len; // packet length
app_vars.uart_txFrame[1] = app_vars.rxpk_num; // packet number
app_vars.uart_txFrame[2] = app_vars.rxpk_rssi; // RSSI
app_vars.uart_txFrame[3] = app_vars.rxpk_lqi; // LQI
app_vars.uart_txFrame[4] = app_vars.rxpk_crc; // CRC
app_vars.uart_txFrame[5] = 0xff; // closing flag
app_vars.uart_txFrame[6] = 0xff; // closing flag
app_vars.uart_txFrame[7] = 0xff; // closing flag
app_vars.uart_done = 0;
app_vars.uart_lastTxByte = 0;
// send app_vars.uart_txFrame over UART
uart_clearTxInterrupts();
uart_clearRxInterrupts();
uart_enableInterrupts();
uart_writeByte(app_vars.uart_txFrame[app_vars.uart_lastTxByte]);
while (app_vars.uart_done==0); // busy wait to finish
uart_disableInterrupts();
// led
leds_error_off();
}
}
uint8_t uart_isr_rx() {
uart_clearRxInterrupts(); // TODO: do not clear, but disable when done
uart_vars.rxCb();
return 0;
}
/**
\brief The program starts executing here.
*/
int mote_main() {
// needed since we are disabling/enabling interrupts below
INTERRUPT_DECLARATION();
// clear local variables
memset(&app_vars,0,sizeof(app_vars_t));
// initialize board
board_init();
// add callback functions radio
radio_setOverflowCb(cb_radioTimerOverflows);
radio_setCompareCb(cb_radioTimerCompare);
radio_setStartFrameCb(cb_startFrame);
radio_setEndFrameCb(cb_endFrame);
// setup UART
uart_setCallbacks(cb_uartTxDone,cb_uartRxCb);
app_vars.uart_end=FALSE;
// prepare radio
radio_rfOn();
radio_setFrequency(CHANNEL);
// switch in RX by default
radio_rxEnable();
app_vars.flags=0x00; //wait for rx
while (1) {
// sleep while waiting for at least one of the flags to be set
while (app_vars.flags==0x00) {
board_sleep();
}
// handle and clear every flag
while(app_vars.flags) {
DISABLE_INTERRUPTS();
leds_sync_on();
// done receiving a packet
// get packet from radio
radio_getReceivedFrame(app_vars.packet,
&app_vars.packet_len,
sizeof(app_vars.packet),
&app_vars.rxpk_rssi,
&app_vars.rxpk_lqi,
&app_vars.rxpk_crc);
app_vars.packet_num=app_vars.packet[0];//packet number
leds_error_off();
stringToSend[0]=app_vars.packet_num;
stringToSend[1]=app_vars.rxpk_rssi;
stringToSend[2]=app_vars.rxpk_lqi;
stringToSend[3]=app_vars.rxpk_crc;
stringToSend[4]= 0xFF;
//clear this interrupt.
app_vars.flags = 0x00;
app_vars.uart_end=FALSE;
app_vars.uart_lastTxByte = 0;
ENABLE_INTERRUPTS();
// send stringToSend over UART
uart_clearTxInterrupts();
uart_clearRxInterrupts();
uart_enableInterrupts();
uart_writeByte(stringToSend[app_vars.uart_lastTxByte]);
while (app_vars.uart_end==FALSE);//wait to finish
uart_disableInterrupts();
// clear flag
leds_sync_off();
}
}
}
void openserial_startOutput() {
//schedule a task to get new status in the output buffer
uint8_t temp_openserial_debugPrintCounter; //to avoid many atomics
INTERRUPT_DECLARATION();
DISABLE_INTERRUPTS();
openserial_vars.debugPrintCounter=(openserial_vars.debugPrintCounter+1)%STATUS_MAX;
temp_openserial_debugPrintCounter = openserial_vars.debugPrintCounter;
ENABLE_INTERRUPTS();
switch (temp_openserial_debugPrintCounter) {
case STATUS_ISSYNC:
if (debugPrint_isSync()==TRUE) {
break;
}
case STATUS_ID:
if (debugPrint_id()==TRUE) {
break;
}
case STATUS_DAGRANK:
if (debugPrint_myDAGrank()==TRUE) {
break;
}
case STATUS_OUTBUFFERINDEXES:
if(debugPrint_outBufferIndexes()==TRUE) {
break;
}
case STATUS_ASN:
if(debugPrint_asn()==TRUE) {
break;
}
case STATUS_MACSTATS:
if (debugPrint_macStats()==TRUE) {
break;
}
case STATUS_SCHEDULE:
if(debugPrint_schedule()==TRUE) {
break;
}
case STATUS_QUEUE:
if(debugPrint_queue()==TRUE) {
break;
}
case STATUS_NEIGHBORS:
if(debugPrint_neighbors()==TRUE) {
break;
}
default:
DISABLE_INTERRUPTS();
openserial_vars.debugPrintCounter=0;
ENABLE_INTERRUPTS();
}
//print out what's in the buffer now
uart_clearTxInterrupts();
uart_clearRxInterrupts(); // clear possible pending interrupts
uart_enableInterrupts(); // Enable USCI_A1 TX & RX interrupt
DISABLE_INTERRUPTS();
openserial_vars.mode=MODE_OUTPUT;
if (openserial_vars.somethingInOutputBuffer) {
uart_writeByte(openserial_vars.output_buffer[output_buffer_index_read_increment()]);
} else {
openserial_stop();
}
ENABLE_INTERRUPTS();
}
void openserial_startOutput() {
//schedule a task to get new status in the output buffer
uint8_t debugPrintCounter;
INTERRUPT_DECLARATION();
DISABLE_INTERRUPTS();
openserial_vars.debugPrintCounter = (openserial_vars.debugPrintCounter+1)%STATUS_MAX;
debugPrintCounter = openserial_vars.debugPrintCounter;
ENABLE_INTERRUPTS();
// print debug information
switch (debugPrintCounter) {
case STATUS_ISSYNC:
if (debugPrint_isSync()==TRUE) {
break;
}
case STATUS_ID:
if (debugPrint_id()==TRUE) {
break;
}
case STATUS_DAGRANK:
if (debugPrint_myDAGrank()==TRUE) {
break;
}
case STATUS_OUTBUFFERINDEXES:
if (debugPrint_outBufferIndexes()==TRUE) {
break;
}
case STATUS_ASN:
if (debugPrint_asn()==TRUE) {
break;
}
case STATUS_MACSTATS:
if (debugPrint_macStats()==TRUE) {
break;
}
case STATUS_SCHEDULE:
if(debugPrint_schedule()==TRUE) {
break;
}
case STATUS_BACKOFF:
if(debugPrint_backoff()==TRUE) {
break;
}
case STATUS_QUEUE:
if(debugPrint_queue()==TRUE) {
break;
}
case STATUS_NEIGHBORS:
if (debugPrint_neighbors()==TRUE) {
break;
}
case STATUS_KAPERIOD:
if (debugPrint_kaPeriod()==TRUE) {
break;
}
default:
DISABLE_INTERRUPTS();
openserial_vars.debugPrintCounter=0;
ENABLE_INTERRUPTS();
}
// flush buffer
uart_clearTxInterrupts();
uart_clearRxInterrupts(); // clear possible pending interrupts
uart_enableInterrupts(); // Enable USCI_A1 TX & RX interrupt
DISABLE_INTERRUPTS();
openserial_vars.mode=MODE_OUTPUT;
if (openserial_vars.outputBufFilled) {
#ifdef FASTSIM
uart_writeCircularBuffer_FASTSIM(
openserial_vars.outputBuf,
&openserial_vars.outputBufIdxR,
&openserial_vars.outputBufIdxW
);
#else
uart_writeByte(openserial_vars.outputBuf[openserial_vars.outputBufIdxR++]);
#endif
} else {
openserial_stop();
}
ENABLE_INTERRUPTS();
}
kick_scheduler_t uart_rx_isr() {
uart_clearRxInterrupts();
uart_vars.rxCb();
return DO_NOT_KICK_SCHEDULER;
}
