uint32_t app_uart_put(uint8_t byte)
{
uint32_t err_code;
err_code = app_fifo_put(&m_tx_fifo, byte);
if (err_code == NRF_SUCCESS)
{
// The new byte has been added to FIFO. It will be picked up from there
// (in 'uart_event_handler') when all preceding bytes are transmitted.
// But if UART is not transmitting anything at the moment, we must start
// a new transmission here.
if (!nrf_drv_uart_tx_in_progress())
{
// This operation should be almost always successful, since we've
// just added a byte to FIFO, but if some bigger delay occurred
// (some heavy interrupt handler routine has been executed) since
// that time, FIFO might be empty already.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
err_code = nrf_drv_uart_tx(tx_buffer, 1);
}
}
}
return err_code;
}
/*====================================================================================================*/
void Serial_SendNum( StringType type, uint8_t lens, int32_t sendNum )
{
char tmpStr[32] = {0};
char *pWord = tmpStr;
num2Str(type, lens, tmpStr, sendNum);
nrf_drv_uart_tx((uint8_t*)pWord, lens);
}
/*---------------------------------------------------------------------------*/
void
uart0_writeb(unsigned char c)
{
if (nrf_drv_uart_tx(&c, 1) == NRF_ERROR_BUSY) {
while (ringbuf_put(&txbuf, c) == 0) {
__WFE();
}
}
}
static void uart_tx1() {
static uint16_t b;
QF_INT_DISABLE(); {
b = QS_getByte();
} QF_INT_ENABLE();
if (b != QS_EOD) { /* Have a byte to TX? */
nrf_drv_uart_tx((const uint8_t*)&b //This cast works only on LE
, 1);
}
}
uint32_t app_uart_put(uint8_t byte)
{
tx_buffer[0] = byte;
if (NRF_ERROR_BUSY == nrf_drv_uart_tx(tx_buffer,1))
{
return NRF_ERROR_NO_MEM;
}
else
{
return NRF_SUCCESS;
}
}
/**
* @brief Output debug string
*
* @param fmt Formatting strong
*/
void debug_printf(char *fmt, ...)
{
char buffer[256];
uint32_t size;
va_list args;
va_start(args, fmt);
size = vsnprintf (buffer, 256, fmt, args);
va_end(args);
if(size > 0) nrf_drv_uart_tx((uint8_t *)buffer, size);
}
static void uart_event_handler(nrf_drv_uart_event_t * p_event, void* p_context)
{
app_uart_evt_t app_uart_event;
if (p_event->type == NRF_DRV_UART_EVT_RX_DONE)
{
// Write received byte to FIFO
uint32_t err_code = app_fifo_put(&m_rx_fifo, p_event->data.rxtx.p_data[0]);
if (err_code != NRF_SUCCESS)
{
app_uart_event.evt_type = APP_UART_FIFO_ERROR;
app_uart_event.data.error_code = err_code;
m_event_handler(&app_uart_event);
}
// Notify that new data is available if this was first byte put in the buffer.
else if (FIFO_LENGTH(m_rx_fifo) == 1)
{
app_uart_event.evt_type = APP_UART_DATA_READY;
m_event_handler(&app_uart_event);
}
else
{
// Do nothing, only send event if first byte was added or overflow in FIFO occurred.
}
if (FIFO_LENGTH(m_rx_fifo) <= m_rx_fifo.buf_size_mask)
{
(void)nrf_drv_uart_rx(rx_buffer,1);
}
}
else if (p_event->type == NRF_DRV_UART_EVT_ERROR)
{
app_uart_event.evt_type = APP_UART_COMMUNICATION_ERROR;
app_uart_event.data.error_communication = p_event->data.error.error_mask;
(void)nrf_drv_uart_rx(rx_buffer,1);
m_event_handler(&app_uart_event);
}
else if (p_event->type == NRF_DRV_UART_EVT_TX_DONE)
{
// Get next byte from FIFO.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
(void)nrf_drv_uart_tx(tx_buffer,1);
}
if (FIFO_LENGTH(m_tx_fifo) == 0)
{
// Last byte from FIFO transmitted, notify the application.
// Notify that new data is available if this was first byte put in the buffer.
app_uart_event.evt_type = APP_UART_TX_EMPTY;
m_event_handler(&app_uart_event);
}
}
}
static void serial_tx(void const * p_context, char const * p_buffer, size_t len)
{
uint8_t len8 = (uint8_t)(len & 0x000000FF);
m_xfer_done = false;
ret_code_t err_code = nrf_drv_uart_tx(&m_uart, (uint8_t *)p_buffer, len8);
APP_ERROR_CHECK(err_code);
/* wait for completion since buffer is reused*/
while (m_async_mode && (m_xfer_done == false))
{
}
}
// The function returns false to signal that no more bytes can be passed to be
// sent (put into the TX buffer) until UART transmission is done.
static bool tx_buf_put(uint8_t data_byte)
{
ASSERT(m_tx_bytes < SER_PHY_HCI_SLIP_TX_BUF_SIZE);
mp_tx_buf[m_tx_bytes] = data_byte;
++m_tx_bytes;
bool flush = false;
ser_phy_hci_slip_evt_type_t slip_evt_type = NO_EVENT;
if (m_tx_phase == PHASE_ACK_END)
{
// Send buffer, then signal that an acknowledge packet has been sent.
flush = true;
slip_evt_type = SER_PHY_HCI_SLIP_EVT_ACK_SENT;
}
else if (m_tx_phase == PHASE_PACKET_END)
{
// Send buffer, then signal that a packet with payload has been sent.
flush = true;
slip_evt_type = SER_PHY_HCI_SLIP_EVT_PKT_SENT;
}
else if (m_tx_bytes >= SER_PHY_HCI_SLIP_TX_BUF_SIZE)
{
// Send buffer (because it is filled up), but don't signal anything,
// since the packet sending is not complete yet.
flush = true;
}
if (flush)
{
// If some TX transfer is being done at the moment, a new one cannot be
// started, it must be scheduled to be performed later.
if (m_tx_in_progress)
{
m_tx_pending_evt_type = slip_evt_type;
m_tx_pending = true;
// No more buffers available, can't continue filling.
return false;
}
m_tx_in_progress = true;
m_tx_evt_type = slip_evt_type;
APP_ERROR_CHECK(nrf_drv_uart_tx(&m_uart, mp_tx_buf, m_tx_bytes));
// Switch to the second buffer.
mp_tx_buf = (mp_tx_buf == m_tx_buf0) ? m_tx_buf1 : m_tx_buf0;
m_tx_bytes = 0;
}
return true;
}
static void response_send(serial_dfu_t * p_dfu,
serial_dfu_response_t * p_response)
{
uint8_t response_buffer[MAX_RESPONSE_SIZE];
uint8_t encoded_response[MAX_RESPONSE_SIZE*2 + 1];
uint32_t encoded_response_length;
uint16_t index = 0;
NRF_LOG_DEBUG("Sending Response: [0x%01x, 0x%01x]\r\n", p_response->op_code, p_response->resp_val);
response_buffer[index++] = SERIAL_DFU_OP_CODE_RESPONSE;
// Encode the Request Op code
response_buffer[index++] = p_response->op_code;
// Encode the Response Value.
response_buffer[index++] = (uint8_t)p_response->resp_val;
if (p_response->resp_val == NRF_DFU_RES_CODE_SUCCESS)
{
switch (p_response->op_code)
{
case SERIAL_DFU_OP_CODE_CALCULATE_CRC:
index += uint32_encode(p_response->crc_response.offset, &response_buffer[index]);
index += uint32_encode(p_response->crc_response.crc, &response_buffer[index]);
break;
case SERIAL_DFU_OP_CODE_SELECT_OBJECT:
index += uint32_encode(p_response->select_response.max_size, &response_buffer[index]);
index += uint32_encode(p_response->select_response.offset, &response_buffer[index]);
index += uint32_encode(p_response->select_response.crc, &response_buffer[index]);
break;
case SERIAL_DFU_OP_CODE_GET_SERIAL_MTU:
index += uint16_encode(p_response->serial_mtu_response.mtu, &response_buffer[index]);
break;
default:
// no implementation
break;
}
}
// encode into slip
(void)slip_encode(encoded_response, response_buffer, index, &encoded_response_length);
// send
(void)nrf_drv_uart_tx(&p_dfu->uart_instance, encoded_response, encoded_response_length);
}
void QS_onFlush(void) {
static uint16_t b;
QF_INT_DISABLE();
while ((b = QS_getByte()) != QS_EOD) { /* while not End-Of-Data... */
QF_INT_ENABLE();
while (nrf_drv_uart_tx_in_progress()) { /* while TXE not empty */
}
//static uint8_t byte;
//byte = b & 0xFF;
nrf_drv_uart_tx((const uint8_t*)&b, 1);
}
QF_INT_ENABLE();
}
uint32_t app_uart_put(uint8_t byte)
{
uint32_t err_code;
tx_tmp = byte;
err_code = nrf_drv_uart_tx(&tx_tmp, 1);
if (err_code == NRF_ERROR_BUSY)
{
err_code = app_fifo_put(&m_tx_fifo, byte);
}
return err_code;
}
uint32_t app_uart_put(uint8_t byte)
{
tx_buffer[0] = byte;
ret_code_t ret = nrf_drv_uart_tx(&app_uart_inst, tx_buffer, 1);
if (NRF_ERROR_BUSY == ret)
{
return NRF_ERROR_NO_MEM;
}
else if (ret != NRF_SUCCESS)
{
return NRF_ERROR_INTERNAL;
}
else
{
return NRF_SUCCESS;
}
}
/*---------------------------------------------------------------------------*/
static void
uart_event_handler(nrf_drv_uart_event_t * p_event, void * p_context)
{
ENERGEST_ON(ENERGEST_TYPE_IRQ);
if (p_event->type == NRF_DRV_UART_EVT_RX_DONE) {
if (uart0_input_handler != NULL) {
uart0_input_handler(p_event->data.rxtx.p_data[0]);
}
(void)nrf_drv_uart_rx(rx_buffer, 1);
} else if (p_event->type == NRF_DRV_UART_EVT_TX_DONE) {
if (ringbuf_elements(&txbuf) > 0) {
uint8_t c = ringbuf_get(&txbuf);
nrf_drv_uart_tx(&c, 1);
}
}
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
/*..........................................................................*/
void QV_onIdle(void) { /* called with interrupts disabled, see NOTE01 */
#ifdef Q_SPY
# if 0
QS_rxParse(); /* parse all the received bytes */
// Push out QS buffer to UART
if (!nrf_drv_uart_tx_in_progress()) { /* is TXE empty? */
static uint16_t b;
QF_INT_DISABLE();
b = QS_getByte();
QF_INT_ENABLE();
if (b != QS_EOD) { /* not End-Of-Data? */
nrf_drv_uart_tx((const uint8_t*)&b, 1);
}
}
# else
QF_INT_ENABLE();
//sd_app_evt_wait();
__WFE(); //__SEV(); __WFE();
# endif
#elif defined NDEBUG
/* Put the CPU and peripherals to the low-power mode.
* you might need to customize the clock management for your application,
* see the datasheet for your particular Cortex-M MCU.
*/
/* !!!CAUTION!!!
* The QF_CPU_SLEEP() contains the WFI instruction, which stops the CPU
* clock, which unfortunately disables the JTAG port, so the ST-Link
* debugger can no longer connect to the board. For that reason, the call
* to QF_CPU_SLEEP() has to be used with CAUTION.
*/
//QV_CPU_SLEEP(); //atomically go to SHALLOW sleep and enable interrupts
__WFE();
QF_INT_ENABLE(); /* for now, just enable interrupts */
#else
QF_INT_ENABLE(); /* just enable interrupts */
#endif
}
static void uart_event_handler(nrf_drv_uart_event_t * p_event, void* p_context)
{
app_uart_evt_t app_uart_event;
uint32_t err_code;
switch (p_event->type)
{
case NRF_DRV_UART_EVT_RX_DONE:
// Write received byte to FIFO.
err_code = app_fifo_put(&m_rx_fifo, p_event->data.rxtx.p_data[0]);
if (err_code != NRF_SUCCESS)
{
app_uart_event.evt_type = APP_UART_FIFO_ERROR;
app_uart_event.data.error_code = err_code;
m_event_handler(&app_uart_event);
}
// Notify that there are data available.
else if (FIFO_LENGTH(m_rx_fifo) != 0)
{
app_uart_event.evt_type = APP_UART_DATA_READY;
m_event_handler(&app_uart_event);
}
// Start new RX if size in buffer.
if (FIFO_LENGTH(m_rx_fifo) <= m_rx_fifo.buf_size_mask)
{
(void)nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);
}
else
{
// Overflow in RX FIFO.
m_rx_ovf = true;
}
break;
case NRF_DRV_UART_EVT_ERROR:
app_uart_event.evt_type = APP_UART_COMMUNICATION_ERROR;
app_uart_event.data.error_communication = p_event->data.error.error_mask;
(void)nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);
m_event_handler(&app_uart_event);
break;
case NRF_DRV_UART_EVT_TX_DONE:
// Get next byte from FIFO.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
(void)nrf_drv_uart_tx(&app_uart_inst, tx_buffer, 1);
}
else
{
// Last byte from FIFO transmitted, notify the application.
app_uart_event.evt_type = APP_UART_TX_EMPTY;
m_event_handler(&app_uart_event);
}
break;
default:
break;
}
}
/*====================================================================================================*/
void Serial_SendStr( char *pWord )
{
uint8_t strLens = lenOfStr(pWord);
nrf_drv_uart_tx((uint8_t*)pWord, strLens);
}
/*====================================================================================================*/
void Serial_SendData( uint8_t *sendData, uint16_t lens )
{
nrf_drv_uart_tx(sendData, lens);
}
/*====================================================================================================*/
void Serial_SendByte( uint8_t sendByte )
{
nrf_drv_uart_tx(&sendByte, 1);
}
/*====================================================================================================*/
int fputc( int ch, FILE *f )
{
uint8_t data = (uint8_t)ch;
nrf_drv_uart_tx(&data, 1);
return ch;
}
void uart_write(char *data, uint8_t length)
{
uint32_t errCode;
errCode = nrf_drv_uart_tx((uint8_t *)data, length);
APP_ERROR_CHECK(errCode);
}
static void uart_event_handler(nrf_drv_uart_event_t * p_event,
void * p_context)
{
(void)p_context;
switch (p_event->type)
{
case NRF_DRV_UART_EVT_ERROR:
// Process the error only if this is a parity or overrun error.
// Break and framing errors will always occur before the other
// side becomes active.
if (p_event->data.error.error_mask &
(NRF_UART_ERROR_PARITY_MASK | NRF_UART_ERROR_OVERRUN_MASK))
{
// Pass error source to upper layer
m_ser_phy_hci_slip_event.evt_type =
SER_PHY_HCI_SLIP_EVT_HW_ERROR;
m_ser_phy_hci_slip_event.evt_params.hw_error.error_code =
p_event->data.error.error_mask;
m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
}
APP_ERROR_CHECK(nrf_drv_uart_rx(&m_uart, m_rx_buf, 1));
break;
case NRF_DRV_UART_EVT_TX_DONE:
// If there is a pending transfer (the second buffer is ready to
// be sent), start it immediately.
if (m_tx_pending)
{
APP_ERROR_CHECK(nrf_drv_uart_tx(&m_uart, mp_tx_buf, m_tx_bytes));
// Switch to the buffer that has just been sent completely
// and now can be filled again.
mp_tx_buf = (mp_tx_buf == m_tx_buf0) ? m_tx_buf1 : m_tx_buf0;
m_tx_bytes = 0;
m_ser_phy_hci_slip_event.evt_type = m_tx_evt_type;
m_tx_evt_type = m_tx_pending_evt_type;
m_tx_pending = false;
}
else
{
m_tx_in_progress = false;
m_ser_phy_hci_slip_event.evt_type = m_tx_evt_type;
}
// If needed, notify the upper layer that the packet transfer is
// complete (note that this notification may result in another
// packet send request, so everything must be cleaned up above).
if (m_ser_phy_hci_slip_event.evt_type != NO_EVENT)
{
m_ser_phy_hci_slip_event_handler(&m_ser_phy_hci_slip_event);
}
// And if the sending process is not yet finished, look what is
// to be done next.
if (m_tx_phase != PHASE_IDLE)
{
tx_buf_fill();
}
break;
case NRF_DRV_UART_EVT_RX_DONE:
{
uint8_t rx_byte = m_rx_buf[0];
APP_ERROR_CHECK(nrf_drv_uart_rx(&m_uart, m_rx_buf, 1));
ser_phi_hci_rx_byte(rx_byte);
}
break;
default:
APP_ERROR_CHECK(NRF_ERROR_INTERNAL);
}
}
