void println_C (char * str)
{
for (uint16_t i = 0; i<strlen(str);i++)
{
RingBuffer_Insert(&USARTtoUSB_Buffer,str[i]);
}
RingBuffer_Insert(&USARTtoUSB_Buffer, 13);
}
void send_ELM327_OK()
{
//Serial_SendByte('O'); //
RingBuffer_Insert(&FFtoBT_Buffer,'O');
//Serial_SendByte('K'); //
RingBuffer_Insert(&FFtoBT_Buffer,'K');
send_ELM327_CR();
}
/* UCOM interrupt EP_IN and EP_OUT endpoints handler */
static ErrorCode_t UCOM_int_hdlr(USBD_HANDLE_T hUsb, void *data, uint32_t event)
{
switch (event) {
case USB_EVT_IN:
/* USB_EVT_IN occurs when HW completes sending IN packet. So clear the
busy flag for main loop to queue next packet.
*/
g_usb.usbTxFlags &= ~UCOM_TX_BUSY;
if (RingBuffer_GetCount(&usb_txrb) >= 1) {
g_usb.usbTxFlags |= UCOM_TX_BUSY;
RingBuffer_Pop(&usb_txrb, g_usb.usbTx_buff);
USBD_API->hw->WriteEP(g_usb.hUsb, HID_EP_IN, g_usb.usbTx_buff, AVAM_P_COUNT);
}
break;
case USB_EVT_OUT:
g_usb.usbRx_count = USBD_API->hw->ReadEP(hUsb, HID_EP_OUT, g_usb.usbRx_buff);
#ifdef DEBUG_VERBOSE
if (RingBuffer_GetCount(&usb_rxrb) == RX_BUF_CNT) {
debug32("E:(%d-%x %x %x %x) usb_rxrb overflow evt out\n", g_usb.usbRx_count,
g_usb.usbRx_buff[0],
g_usb.usbRx_buff[1],
g_usb.usbRx_buff[2],
g_usb.usbRx_buff[3]);
}
#endif
if (g_usb.usbRx_count >= AVAM_P_COUNT) {
RingBuffer_Insert(&usb_rxrb, g_usb.usbRx_buff);
g_usb.usbRx_count -= AVAM_P_COUNT;
}
if (g_usb.usbRxFlags & UCOM_RX_BUF_QUEUED) {
g_usb.usbRxFlags &= ~UCOM_RX_BUF_QUEUED;
if (g_usb.usbRx_count != 0)
g_usb.usbRxFlags |= UCOM_RX_BUF_FULL;
}
break;
case USB_EVT_OUT_NAK:
/* queue free buffer for RX */
if ((g_usb.usbRxFlags & (UCOM_RX_BUF_FULL | UCOM_RX_BUF_QUEUED)) == 0) {
g_usb.usbRx_count = USBD_API->hw->ReadReqEP(hUsb, HID_EP_OUT, g_usb.usbRx_buff, UCOM_RX_BUF_SZ);
#ifdef DEBUG_VERBOSE
if (RingBuffer_GetCount(&usb_rxrb) == RX_BUF_CNT)
debug32("E: usb_rxrb overflow evt nak\n");
#endif
if (g_usb.usbRx_count >= AVAM_P_COUNT) {
RingBuffer_Insert(&usb_rxrb, g_usb.usbRx_buff);
g_usb.usbRx_count -= AVAM_P_COUNT;
}
g_usb.usbRxFlags |= UCOM_RX_BUF_QUEUED;
}
break;
default:
break;
}
return LPC_OK;
}
/** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
* for later transmission to the host.
*/
ISR(USART1_RX_vect, ISR_BLOCK)
{
uint8_t ReceivedByte = UDR1;
if (USB_DeviceState == DEVICE_STATE_Configured) {
if (eeprom_op) {
RingBuffer_Insert(&USARTtoEEPROM_Buffer, ReceivedByte);
} else {
RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
}
}
}
/* UCOM bulk EP_IN and EP_OUT endpoints handler */
static ErrorCode_t UCOM_bulk_hdlr(USBD_HANDLE_T hUsb, void *data, uint32_t event)
{
UCOM_DATA_T *pUcom = (UCOM_DATA_T *) data;
switch (event) {
/* A transfer from us to the USB host that we queued has completed. */
case USB_EVT_IN:
pUcom->usbTxFlags &= ~UCOM_TX_BUSY;
break;
/* We received a transfer from the USB host . */
case USB_EVT_OUT:
pUcom->usbRx_count = USBD_API->hw->ReadEP(hUsb, USB_CDC_OUT_EP, pUcom->usbRx_buff);
if(pUcom->usbRx_count){
if(1 == pUcom->usbRx_count){
RingBuffer_Insert(&usb_rxrb, pUcom->usbRx_buff);
}else
{
RingBuffer_InsertMult(&usb_rxrb, pUcom->usbRx_buff, pUcom->usbRx_count);
}
}
if (pUcom->usbRxFlags & UCOM_RX_BUF_QUEUED) {
pUcom->usbRxFlags &= ~UCOM_RX_BUF_QUEUED;
if (pUcom->usbRx_count != 0) {
pUcom->usbRxFlags |= UCOM_RX_BUF_FULL;
}
}
break;
case USB_EVT_OUT_NAK:
/* queue free buffer for RX */
if ((pUcom->usbRxFlags & (UCOM_RX_BUF_FULL | UCOM_RX_BUF_QUEUED)) == 0) {
pUcom->usbRx_count = USBD_API->hw->ReadReqEP(hUsb, USB_CDC_OUT_EP, pUcom->usbRx_buff, UCOM_RX_BUF_SZ);
if(pUcom->usbRx_count){
if(1 == pUcom->usbRx_count){
RingBuffer_Insert(&usb_rxrb, pUcom->usbRx_buff);
}else
{
RingBuffer_InsertMult(&usb_rxrb, pUcom->usbRx_buff, pUcom->usbRx_count);
}
}
pUcom->usbRxFlags |= UCOM_RX_BUF_QUEUED;
}
break;
default:
break;
}
return LPC_OK;
}
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
GlobalInterruptEnable();
for (;;)
{
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
}
/* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
if (BufferCount)
{
Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);
/* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data
* until it completes as there is a chance nothing is listening and a lengthy timeout could occur */
if (Endpoint_IsINReady())
{
/* Never send more than one bank size less one byte to the host at a time, so that we don't block
* while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */
uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BytesToSend--)
{
/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
{
break;
}
/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
RingBuffer_Remove(&USARTtoUSB_Buffer);
}
}
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
USB_USBTask();
}
}
//------------------------------------------------------------------------------
uint8_t serialAddByte(uint8_t byte)
{
uint16_t size;
size = RingBuffer_GetCount(&buffer_);
if(size == 0)
{
if(byte >= SERIAL_END_COMMANDS)
{
return false;
}
}
else if(size == 1)
{
frame_size_ = byte+2;
}
RingBuffer_Insert(&buffer_, byte);
size = RingBuffer_GetCount(&buffer_);
if(size == frame_size_)
{
frame_size_ = 0;
return true;
}
return false;
}
void CAN_rx(uint8_t msg_obj_num) {
msg_obj.msgobj = msg_obj_num;
LPC_CCAN_API->can_receive(&msg_obj);
if (msg_obj_num == 1) {
RingBuffer_Insert(&CAN_rx_buffer, &msg_obj);
}
}
void HandleSerial(void)
{
// Only try to read in bytes from the CDC interface if the transmit buffer is not full
if (!(RingBuffer_IsFull(&FromHost_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
// Read bytes from the USB OUT endpoint into the USART transmit buffer
if (!(ReceivedByte < 0)){
RingBuffer_Insert(&FromHost_Buffer, ReceivedByte);
CDC_Device_SendByte(&VirtualSerial_CDC_Interface, ReceivedByte);
}
}
while (RingBuffer_GetCount(&FromHost_Buffer) > 0)
{
int16_t c = RingBuffer_Remove(&FromHost_Buffer);
if(c == '\n' || c == '\r'){
if(cmd_cnt > 0 && (cmd[cmd_cnt-1] == '\n' || cmd[cmd_cnt-1] == '\r'))
cmd_cnt--;
cmd[cmd_cnt] = 0;
execute_command();
cmd_cnt = 0;
}
else{
cmd[cmd_cnt++] = c;
}
}
}
/**
* @details Moves received on-chip CAN messages into ring buffer
*
* @param msg_obj_num CAN message object that received message
*/
void CAN_rx(uint8_t msg_obj_num) {
/* Determine which CAN message has been received */
can_msg_obj.msgobj = msg_obj_num;
/* Now load up the msg_obj structure with the CAN message */
LPC_CCAN_API->can_receive(&can_msg_obj);
RingBuffer_Insert(&rx_buffer, &can_msg_obj);
}
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
RingBuffer_InitBuffer(&ToUSB_Buffer, ToUSB_Buffer_Data, sizeof(ToUSB_Buffer_Data));
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
sei();
for (;;)
{
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
cdc_send_USB_data(&VirtualSerial_CDC_Interface);
USB_USBTask();
}
}
/** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
* for later transmission to the host.
*/
ISR(USART1_RX_vect, ISR_BLOCK)
{
uint8_t ReceivedByte = UDR1;
if (USB_DeviceState == DEVICE_STATE_Configured)
RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
}
void RFM12B_Receive( void )
{
uint8_t ch = RFM12B_SPI_Transfer( RFM12B_RX_FIFO_READ ) & 0xFF;
if ( RxLength == 0 )
{
if ( ch == 0 )
{
RFM12B_EndOfPacket();
}
else
{
RxLength = ch;
RxTimeout = 0;
}
}
else
{
RingBuffer_Insert( &RF12toUSB_Buffer, ch );
/* Decrement the RxLength for each byte of payload received.
When it gets to zero that's the end of the packet */
if ( --RxLength == 0 ) RFM12B_EndOfPacket();
}
}
/* UART receive-only interrupt handler for ring buffers */
void Chip_UART_RXIntHandlerRB(LPC_USART_T *pUART, RINGBUFF_T *pRB)
{
/* New data will be ignored if data not popped in time */
while (Chip_UART_ReadLineStatus(pUART) & UART_LSR_RDR) {
uint8_t ch = Chip_UART_ReadByte(pUART);
RingBuffer_Insert(pRB, &ch);
}
}
/* UART receive-only interrupt handler for ring buffers */
void Chip_UARTN_RXIntHandlerRB(LPC_USARTN_T *pUART, RINGBUFF_T *pRB)
{
/* New data will be ignored if data not popped in time */
while ((Chip_UARTN_GetStatus(pUART) & UARTN_STAT_RXRDY) != 0) {
uint8_t ch = Chip_UARTN_ReadByte(pUART);
RingBuffer_Insert(pRB, &ch);
}
}
void RFM12B_Start_Transmit( void )
{
uint16_t BufferCount = RingBuffer_GetCount( &USBtoRF12_Buffer );
RingBuffer_InsertString( &Transmit_Buffer, "\xAA\xAA\x2D\x55" );
RingBuffer_Insert( &Transmit_Buffer, BufferCount & 0xFF );
while ( BufferCount-- )
{
RingBuffer_Insert( &Transmit_Buffer,
RingBuffer_Remove( &USBtoRF12_Buffer ));
}
RingBuffer_InsertString( &Transmit_Buffer, "\xAA\xAA" );
RFM12B_Transmit_Active = true;
PORTD &= ~0x20;
RFM12B_SPI_Transfer( RFM12B_CMD_TX_ON );
}
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&USBtoUSART_Buffer);
RingBuffer_InitBuffer(&USARTtoUSB_Buffer);
sei();
for (;;)
{
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
}
/* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
RingBuff_Count_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
if ((TIFR0 & (1 << TOV0)) || (BufferCount > BUFFER_NEARLY_FULL))
{
TIFR0 |= (1 << TOV0);
if (USARTtoUSB_Buffer.Count) {
LEDs_TurnOnLEDs(LEDMASK_TX);
PulseMSRemaining.TxLEDPulse = TX_RX_LED_PULSE_MS;
}
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BufferCount--)
CDC_Device_SendByte(&VirtualSerial_CDC_Interface, RingBuffer_Remove(&USARTtoUSB_Buffer));
/* Turn off TX LED(s) once the TX pulse period has elapsed */
if (PulseMSRemaining.TxLEDPulse && !(--PulseMSRemaining.TxLEDPulse))
LEDs_TurnOffLEDs(LEDMASK_TX);
/* Turn off RX LED(s) once the RX pulse period has elapsed */
if (PulseMSRemaining.RxLEDPulse && !(--PulseMSRemaining.RxLEDPulse))
LEDs_TurnOffLEDs(LEDMASK_RX);
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer))) {
Serial_TxByte(RingBuffer_Remove(&USBtoUSART_Buffer));
LEDs_TurnOnLEDs(LEDMASK_RX);
PulseMSRemaining.RxLEDPulse = TX_RX_LED_PULSE_MS;
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
USB_USBTask();
}
}
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
LEDs_SetAllLEDs(0);
sei();
for (;;)
{
if ((PINF & 0x01) == 0x01)
LEDs_SetAllLEDs(2);
else
LEDs_SetAllLEDs(0);
/* Only try to read in bytes from the CDC interface if the (outbound) transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);
}
/* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */
uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
if ((TIFR0 & (1 << TOV0)) || (BufferCount > (uint8_t)(sizeof(USARTtoUSB_Buffer_Data) * .75)))
{
/* Clear flush timer expiry flag */
TIFR0 |= (1 << TOV0);
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BufferCount--)
{
/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
{
break;
}
/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
RingBuffer_Remove(&USARTtoUSB_Buffer);
}
}
/* Load the next byte from the USART transmit buffer into the USART */
if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))
Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
USB_USBTask();
}
}
//------------------------------------------------------------------------------
void appUsbDataReceived(Application *app)
{
int16_t received_byte = 0;
while((received_byte = CDC_Device_ReceiveByte(app->cdc_info)) >= 0)
{
RingBuffer_Insert(&app->buffer_, received_byte);
}
serialProcess(app);
}
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));
RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
GlobalInterruptEnable();
while(1)
{
if(RTR==1)
{
if (ReceivedByte==0xFF)
{
for (uint8_t i = 0; i < 4; i++)
{
if (ReceivedByte==0)
{
ReceivedByte=1;
}
buff[i] = ReceivedByte;
RTR = 0;
while(RTR!=1){}
}
uint8_t range = ((buff[1]*256+buff[2])/100);
RingBuffer_Insert(&USARTtoUSB_Buffer,buff[1]);
RingBuffer_Insert(&USARTtoUSB_Buffer,buff[2]);
//RingBuffer_Insert(&USARTtoUSB_Buffer,range);
sendUSARTtoUSB();
_delay_ms(500);
}
}
// if (!RingBuffer_IsFull(&USBtoUSART_Buffer))
// {
// int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
// if (!(ReceivedByte < 0))
// {
// sendUSBtoUSART();
// }
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
USB_USBTask();
// }
}
}
/** Main program entry point. This routine contains the overall program flow, including initial
* setup of all components and the main program loop.
*/
int main(void)
{
SetupHardware();
RingBuffer_InitBuffer(&FromHost_Buffer, FromHost_Buffer_Data, sizeof(FromHost_Buffer_Data));
GlobalInterruptEnable();
for (;;)
{
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&FromHost_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the USART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&FromHost_Buffer, ReceivedByte);
}
while (RingBuffer_GetCount(&FromHost_Buffer) > 0)
{
static uint8_t EscapePending = 0;
int16_t HD44780Byte = RingBuffer_Remove(&FromHost_Buffer);
if (HD44780Byte == COMMAND_ESCAPE)
{
if (EscapePending)
{
HD44780_WriteData(HD44780Byte);
EscapePending = 0;
}
else
{
/* Next received character is the command byte */
EscapePending = 1;
}
}
else
{
if (EscapePending)
{
HD44780_WriteCommand(HD44780Byte);
EscapePending = 0;
}
else
{
HD44780_WriteData(HD44780Byte);
}
}
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
USB_USBTask();
}
}
// Read the dial commands and send them to the modem. Wait for the expected response then move on to the next command.
// Returns true if the last dial command has been processed.
static bool LinkManagement_DialConnection(const char** DialCommands)
{
static char* ResponsePtr = NULL;
char* CommandPtr = NULL;
static uint8_t CharsMatched = 0;
char c;
if (USB_HostState != HOST_STATE_Configured)
return false;
while (!RingBuffer_IsEmpty(&Modem_ReceiveBuffer)) // Read back the response
{
c = RingBuffer_Remove(&Modem_ReceiveBuffer);
Debug_PrintChar(c);
if (c == *(ResponsePtr + CharsMatched)) // Match the response character by character with the expected response
CharsMatched++;
else
CharsMatched = 0;
if (CharsMatched != 0 && CharsMatched == strlen(ResponsePtr)) // Look for the expected response
{
DialSteps += 2; // Move on to the next dial command
CharsMatched = 0;
}
}
if (SystemTicks > 100) // Space each command by 1 second
{
CommandPtr = (char*)DialCommands[DialSteps];
ResponsePtr = (char*)DialCommands[DialSteps + 1];
if (CommandPtr == NULL || ResponsePtr == NULL) // No more dial commands
{
DialSteps = 0;
return true; // Finished dialling
}
SystemTicks = 0;
Debug_Print("Send: "); Debug_Print(CommandPtr);
Debug_Print("(Expect: "); Debug_Print(ResponsePtr); Debug_Print(")\r\n");
while (*CommandPtr)
RingBuffer_Insert(&Modem_SendBuffer, *(CommandPtr++)); // Send the command to the modem
}
return false; // Haven't finished dialling
}
/* Send data to usb */
uint32_t UCOM_Write(uint8_t *pBuf)
{
uint32_t ret = 0;
RingBuffer_Insert(&usb_txrb, pBuf);
if (g_usb.usbTxFlags & UCOM_TX_CONNECTED) {
if (!(g_usb.usbTxFlags & UCOM_TX_BUSY) && RingBuffer_GetCount(&usb_txrb)) {
g_usb.usbTxFlags |= UCOM_TX_BUSY;
RingBuffer_Pop(&usb_txrb, g_usb.usbTx_buff);
ret = USBD_API->hw->WriteEP(g_usb.hUsb, HID_EP_IN, g_usb.usbTx_buff, AVAM_P_COUNT);
}
}
return ret;
}
/** ISR to manage the reception of data from the serial port, placing received bytes into a circular buffer
* for later transmission to the host.
*/
ISR(USART1_RX_vect, ISR_BLOCK)
{
uint8_t ReceivedByte = UDR1;
if (USB_DeviceState == DEVICE_STATE_Configured && !RingBuffer_IsFull(&USARTtoUSB_Buffer))
RingBuffer_Insert(&USARTtoUSB_Buffer, ReceivedByte);
RingBuff_Count_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);
if (BufferCount >= (sizeof(joyReport) + 1)) {
joyReport.X = (int8_t) RingBuffer_Remove(&USARTtoUSB_Buffer);
joyReport.Y = (int8_t) RingBuffer_Remove(&USARTtoUSB_Buffer);
joyReport.Button = (uint8_t) RingBuffer_Remove(&USARTtoUSB_Buffer);
/* Remove spacer at the end of the struct*/
RingBuffer_Remove(&USARTtoUSB_Buffer);
}
}
void UARTBridge_Task(void)
{
/* Must be in the configured state for the USART Bridge code to process data */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */
if (!(RingBuffer_IsFull(&USBtoUART_Buffer)))
{
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
/* Read bytes from the USB OUT endpoint into the UART transmit buffer */
if (!(ReceivedByte < 0))
RingBuffer_Insert(&USBtoUART_Buffer, ReceivedByte);
}
/* Check if the UART receive buffer flush timer has expired or buffer is nearly full */
uint16_t BufferCount = RingBuffer_GetCount(&UARTtoUSB_Buffer);
if ((TIFR0 & (1 << TOV0)) || (BufferCount > 200))
{
/* Clear flush timer expiry flag */
TIFR0 |= (1 << TOV0);
/* Read bytes from the USART receive buffer into the USB IN endpoint */
while (BufferCount--)
{
/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */
if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,
RingBuffer_Peek(&UARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)
{
break;
}
/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */
RingBuffer_Remove(&UARTtoUSB_Buffer);
}
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
}
/*---------------------------------------------------------------------------*/
int transport_getdata(uint8_t* buf, int count)
{
int i;
int t16;
int8_t res;
uint8_t sockId;
while(count > RingBuffer_GetCount(&tcpBuffer))
{
res = esp8266_getTCPData(ESP8266_1SecTimeout,commonBuffer,sizeof(commonBuffer),&rv,&sockId);
if(res == ESP8266_TIMEOUT)
{
return 0;
}
if(sockId != 0)
{
esp8266_hal_rebootSystem();
}
for(i=0;i<rv;i++)
{
if(!RingBuffer_IsFull(&tcpBuffer))
{
RingBuffer_Insert(&tcpBuffer,commonBuffer[i]);
}
}
}
for(i=0;i<count;i++)
{
buf[i] = RingBuffer_Remove(&tcpBuffer);
}
return count;
}
/**
* This method runs the ADC thread
*
* @param buff - The RingBuff type
*/
void ADXL335_Driver::run(RingBuff_t* buff){
//! Containers
int x_axis;
int y_axis;
int z_axis;
//! We get all axis values
x_axis = this->get_accel(X_AXIS);
delay(10);
y_axis = this->get_accel(Y_AXIS);
delay(10);
z_axis = this->get_accel(Z_AXIS);
delay(10);
//! Create a data container
uint8_t _data[SIZE_OF_DATA] = {x_axis, y_axis, z_axis, 0x00};
//! We put the data into the ringbuffer
for(uint8_t i = 0; i < sizeof(_data); i++){
RingBuffer_Insert(buff, _data[i]);
}
}
void UARTBridge_Task(void)
{
/* Must be in the configured state for the USART Bridge code to process data */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Read bytes from the USB OUT endpoint into the UART transmit buffer */
int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
if (!(ReceivedByte < 0) && !(RingBuffer_IsFull(&USBtoUART_Buffer)))
RingBuffer_Insert(&USBtoUART_Buffer, ReceivedByte);
/* Check if the UART receive buffer flush timer has expired or buffer is nearly full */
RingBuff_Count_t BufferCount = RingBuffer_GetCount(&UARTtoUSB_Buffer);
if ((TIFR0 & (1 << TOV0)) || (BufferCount > 200))
{
TIFR0 |= (1 << TOV0);
/* Read bytes from the UART receive buffer into the USB IN endpoint */
while (BufferCount--)
CDC_Device_SendByte(&VirtualSerial_CDC_Interface, RingBuffer_Remove(&UARTtoUSB_Buffer));
}
CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
}
void USBVirtualSerial::println(uint8_t val, uint8_t format) {
RingBuffer_Insert(&HostTXSerial_Buffer, val);
RingBuffer_Insert(&HostTXSerial_Buffer, '\r');
RingBuffer_Insert(&HostTXSerial_Buffer, '\n');
CDC_Task();
}
void USBVirtualSerial::println(const char *str) {
for (uint16_t i = 0; i < strlen(str); i++) RingBuffer_Insert(&HostTXSerial_Buffer, str[i]);
RingBuffer_Insert(&HostTXSerial_Buffer, '\r');
RingBuffer_Insert(&HostTXSerial_Buffer, '\n');
CDC_Task();
}