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); } }