Bluetooth UART support for the Adafruit BluefruitLE SPI, for the University of York Engineering Stage 1 project
Adafruit_BluefruitLE_SPI.cpp
- Committer:
- ajp109
- Date:
- 2021-03-12
- Revision:
- 3:bdfd15be7b82
- Parent:
- 2:8c341bac60b8
File content as of revision 3:bdfd15be7b82:
/**************************************************************************/ /*! @file Adafruit_BluefruitLE_SPI.cpp @author hathach, ktown (Adafruit Industries), ajp109 (University of York) @section LICENSE Software License Agreement (BSD License) Copyright (c) 2015, Adafruit Industries (adafruit.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /**************************************************************************/ #include "mbed.h" #include "Adafruit_BluefruitLE_SPI.h" #include <stdlib.h> #ifndef min #define min(a,b) ((a) < (b) ? (a) : (b)) #endif /******************************************************************************/ /*! @brief Instantiates a new instance of the Adafruit_BluefruitLE_SPI class @param[in] mosi The MOSI pin for the SPI interface @param[in] miso The MISO pin for the SPI interface @param[in] sck The SCK pin for the SPI interface @param[in] cs The CS pin for the SPI interface @param[in] irq The IRQ pin - this must be a HW interrupt pin @param[in] rstPin The RESET pin (optional) */ /******************************************************************************/ Adafruit_BluefruitLE_SPI::Adafruit_BluefruitLE_SPI(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName irq, PinName rst) : m_rx_fifo(m_rx_buffer, sizeof(m_rx_buffer), 1, true), m_spi(mosi, miso, sclk), m_cs(cs), m_irq(irq), m_rst(rst) { _physical_transport = BLUEFRUIT_TRANSPORT_HWSPI; m_spi.frequency(400000); // Mode 0, MSB-first is default if (m_rst.is_connected()) { m_rst = true; } m_cs = false; wait_us(5); m_cs = true; wait_us(35); m_tx_count = 0; m_mode_switch_command_enabled = true; } /******************************************************************************/ /*! @brief Initialize the HW to enable communication with the BLE module @return Returns 'true' if everything initialised correctly, otherwise 'false' if there was a problem during HW initialisation. If 'irqPin' is not a HW interrupt pin false will be returned. */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::begin(bool v, bool blocking) { _verbose = v; bool isOK; // Always try to send Initialize command to reset // Bluefruit since user can define but not wiring RST signal isOK = sendInitializePattern(); // use hardware reset if available if (m_rst.is_connected()) { // pull the RST to GND for 10 ms m_rst = false; thread_sleep_for(10); m_rst = true; isOK= true; } _reset_started_timestamp = Kernel::Clock::now(); // Bluefruit takes 1 second to reboot if (blocking) { thread_sleep_for(1000); } return isOK; } /******************************************************************************/ /*! @brief Uninitializes the SPI interface */ /******************************************************************************/ void Adafruit_BluefruitLE_SPI::end(void) { } /******************************************************************************/ /*! @brief Handle direct "+++" input command from user. User should use setMode instead */ /******************************************************************************/ void Adafruit_BluefruitLE_SPI::simulateSwitchMode(void) { _mode = 1 - _mode; char ch = '0' + _mode; m_rx_fifo.write(&ch); m_rx_fifo.write_n("\r\nOK\r\n", 6); } /******************************************************************************/ /*! @brief Simulate "+++" switch mode command */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::setMode(uint8_t new_mode) { // invalid mode if ( !(new_mode == BLUEFRUIT_MODE_COMMAND || new_mode == BLUEFRUIT_MODE_DATA) ) return false; // Already in the wanted mode if ( _mode == new_mode ) return true; // SPI use different SDEP command when in DATA/COMMAND mode. // --> does not switch using +++ command _mode = new_mode; // If we're entering DATA mode, flush any old response, so that it isn't // interpreted as incoming UART data if (_mode == BLUEFRUIT_MODE_DATA) sync(); return true; } /******************************************************************************/ /*! @brief Enable/disable recognition of "+++" switch mode command. Usage of setMode is not affected. */ /******************************************************************************/ void Adafruit_BluefruitLE_SPI::enableModeSwitchCommand(bool enabled) { m_mode_switch_command_enabled = enabled; } /******************************************************************************/ /*! @brief Send initialize pattern to Bluefruit LE to force a reset. This pattern follow the SDEP command syntax with command_id = SDEP_CMDTYPE_INITIALIZE. The command has NO response, and is expected to complete within 1 second */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::sendInitializePattern(void) { return sendPacket(SDEP_CMDTYPE_INITIALIZE, NULL, 0, 0); } /******************************************************************************/ /*! @brief Send out an packet with data in m_tx_buffer @param[in] more_data More Data bitfield, 0 indicates this is not end of transfer yet */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::sendPacket(uint16_t command, const uint8_t* buf, uint8_t count, uint8_t more_data) { // flush old response before sending the new command, but only if we're *not* // in DATA mode, as the RX FIFO may containg incoming UART data that hasn't // been read yet if (more_data == 0 && _mode != BLUEFRUIT_MODE_DATA) sync(); sdepMsgCommand_t msgCmd; msgCmd.header.msg_type = SDEP_MSGTYPE_COMMAND; msgCmd.header.cmd_id_high = (command >> 8) & 0xFF ; msgCmd.header.cmd_id_low = command & 0xFF; msgCmd.header.length = count; msgCmd.header.more_data = (count == SDEP_MAX_PACKETSIZE) ? more_data : 0; // Copy payload if ( buf != NULL && count > 0) memcpy(msgCmd.payload, buf, count); // Starting SPI transaction m_spi.select(); m_cs = false; TimeoutTimer tt(_timeout); // Bluefruit may not be ready while ( ( spixfer(msgCmd.header.msg_type) == SPI_IGNORED_BYTE ) && !tt.expired() ) { // Disable & Re-enable CS with a bit of delay for Bluefruit to ready itself m_cs = true; wait_us(SPI_DEFAULT_DELAY_US); m_cs = false; } bool result = !tt.expired(); if ( result ) { // transfer the rest of the data spixfer((void*) (((uint8_t*)&msgCmd) +1), sizeof(sdepMsgHeader_t)+count-1); } m_cs = true; m_spi.deselect(); return result; } /******************************************************************************/ /*! @brief Print API. Either buffer the data internally or send it to bus if possible. \r and \n are command terminators and will force the packet to be sent to the Bluefruit LE module. @param[in] c Character to send */ /******************************************************************************/ ssize_t Adafruit_BluefruitLE_SPI::_putc(int c_int) { uint8_t c = c_int & 0xFF; if (_mode == BLUEFRUIT_MODE_DATA) { sendPacket(SDEP_CMDTYPE_BLE_UARTTX, &c, 1, 0); getResponse(); return 1; } // Following code handle BLUEFRUIT_MODE_COMMAND // Final packet due to \r or \n terminator if (c == '\r' || c == '\n') { if (m_tx_count > 0) { // +++ command to switch mode if (m_mode_switch_command_enabled && memcmp(m_tx_buffer, "+++", 3) == 0) { simulateSwitchMode(); } else { sendPacket(SDEP_CMDTYPE_AT_WRAPPER, m_tx_buffer, m_tx_count, 0); } m_tx_count = 0; } } // More than max packet buffered --> send with more_data = 1 else if (m_tx_count == SDEP_MAX_PACKETSIZE) { sendPacket(SDEP_CMDTYPE_AT_WRAPPER, m_tx_buffer, m_tx_count, 1); m_tx_buffer[0] = c; m_tx_count = 1; } // Not enough data, continue to buffer else { m_tx_buffer[m_tx_count++] = c; } if (_verbose) ::printf("%c", (char) c); return 1; } /******************************************************************************/ /*! */ /******************************************************************************/ ssize_t Adafruit_BluefruitLE_SPI::write(const void *v_buf, size_t size) { uint8_t *buf = (uint8_t *)v_buf; if ( _mode == BLUEFRUIT_MODE_DATA ) { if (m_mode_switch_command_enabled && (size >= 3) && !memcmp(buf, "+++", 3) && !(size > 3 && buf[3] != '\r' && buf[3] != '\n') ) { simulateSwitchMode(); } else { size_t remain = size; while(remain) { size_t len = min(remain, SDEP_MAX_PACKETSIZE); remain -= len; sendPacket(SDEP_CMDTYPE_BLE_UARTTX, buf, (uint8_t) len, remain ? 1 : 0); buf += len; } getResponse(); } return size; } // Command mode else { size_t n = size; while (size--) { _putc(*buf++); } return n; } } /******************************************************************************/ /*! @brief Check if the response from the previous command is ready @return 'true' if a response is ready, otherwise 'false' */ /******************************************************************************/ int Adafruit_BluefruitLE_SPI::available(void) { if (! m_rx_fifo.empty() ) { return m_rx_fifo.count(); } if ( _mode == BLUEFRUIT_MODE_DATA ) { // DATA Mode: query for BLE UART data sendPacket(SDEP_CMDTYPE_BLE_UARTRX, NULL, 0, 0); // Waiting to get response from Bluefruit getResponse(); return m_rx_fifo.count(); } else { return (m_irq.read()); } } /******************************************************************************/ /*! @brief Get a byte from response data, perform SPI transaction if needed @return -1 if no data is available */ /******************************************************************************/ int Adafruit_BluefruitLE_SPI::_getc(void) { uint8_t ch; // try to grab from buffer first... if (!m_rx_fifo.empty()) { m_rx_fifo.read(&ch); return (int)ch; } if ( _mode == BLUEFRUIT_MODE_DATA ) { // DATA Mode: query for BLE UART data sendPacket(SDEP_CMDTYPE_BLE_UARTRX, NULL, 0, 0); // Waiting to get response from Bluefruit getResponse(); } else { // COMMAND Mode: Only read data from Bluefruit if IRQ is raised if ( m_irq.read() ) getResponse(); } return m_rx_fifo.read(&ch) ? ((int) ch) : EOF; } /******************************************************************************/ /*! @brief Flush current response data in the internal FIFO @return -1 if no data is available */ /******************************************************************************/ int Adafruit_BluefruitLE_SPI::sync(void) { m_rx_fifo.clear(); return Adafruit_BLE::sync(); } /******************************************************************************/ /*! @brief Try to perform an full AT response transfer from Bluefruit, or execute as many SPI transaction as internal FIFO can hold up. @note If verbose is enabled, all the received data will be print to Serial @return - true : if succeeded - false : if failed */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::getResponse(void) { // Try to read data from Bluefruit if there is enough room in the fifo while ( m_rx_fifo.remaining() >= SDEP_MAX_PACKETSIZE ) { // Get a SDEP packet sdepMsgResponse_t msg_response; memclr(&msg_response, sizeof(sdepMsgResponse_t)); if ( !getPacket(&msg_response) ) return false; // Write to fifo if ( msg_response.header.length > 0) { m_rx_fifo.write_n(msg_response.payload, msg_response.header.length); } // No more packet data if ( !msg_response.header.more_data ) break; // It takes a bit since all Data received to IRQ to get LOW // May need to delay a bit for it to be stable before the next try // delayMicroseconds(SPI_DEFAULT_DELAY_US); } return true; } /******************************************************************************/ /*! @brief Perform a single SPI SDEP transaction and is used by getReponse to get a full response composed of multiple packets. @param[in] buf Memory location where payload is copied to @return number of bytes in SDEP payload */ /******************************************************************************/ bool Adafruit_BluefruitLE_SPI::getPacket(sdepMsgResponse_t* p_response) { // Wait until IRQ is asserted, double timeout since some commands take long time to start responding TimeoutTimer tt(2*_timeout); while ( !m_irq.read() ) { if (tt.expired()) return false; } sdepMsgHeader_t* p_header = &p_response->header; tt.set(_timeout); m_spi.select(); m_cs = false; do { if ( tt.expired() ) break; p_header->msg_type = spixfer(0xff); if (p_header->msg_type == SPI_IGNORED_BYTE) { // Bluefruit may not be ready // Disable & Re-enable CS with a bit of delay for Bluefruit to ready itself m_cs = true; wait_us(SPI_DEFAULT_DELAY_US); m_cs = false; } else if (p_header->msg_type == SPI_OVERREAD_BYTE) { // IRQ may not be pulled down by Bluefruit when returning all data in previous transfer. // This could happen when Arduino MCU is running at fast rate comparing to Bluefruit's MCU, // causing an SPI_OVERREAD_BYTE to be returned at stage. // // Walkaround: Disable & Re-enable CS with a bit of delay and keep waiting // TODO IRQ is supposed to be OFF then ON, it is better to use GPIO trigger interrupt. m_cs = true; // wait for the clock to be enabled.. // while (!digitalRead(m_irq)) { // if ( tt.expired() ) break; // } // if (!digitalRead(m_irq)) break; wait_us(SPI_DEFAULT_DELAY_US); m_cs = false; } } while (p_header->msg_type == SPI_IGNORED_BYTE || p_header->msg_type == SPI_OVERREAD_BYTE); bool result=false; // Not a loop, just a way to avoid goto with error handling do { // Look for the header // note that we should always get the right header at this point, and not doing so will really mess up things. while ( p_header->msg_type != SDEP_MSGTYPE_RESPONSE && p_header->msg_type != SDEP_MSGTYPE_ERROR && !tt.expired() ) { p_header->msg_type = spixfer(0xff); } if ( tt.expired() ) break; memset( (&p_header->msg_type)+1, 0xff, sizeof(sdepMsgHeader_t) - 1); spixfer((&p_header->msg_type)+1, sizeof(sdepMsgHeader_t) - 1); // Command is 16-bit at odd address, may have alignment issue with 32-bit chip uint16_t cmd_id = (p_header->cmd_id_high << 8) | p_header->cmd_id_low; // Error Message Response if ( p_header->msg_type == SDEP_MSGTYPE_ERROR ) break; // Invalid command if (!(cmd_id == SDEP_CMDTYPE_AT_WRAPPER || cmd_id == SDEP_CMDTYPE_BLE_UARTTX || cmd_id == SDEP_CMDTYPE_BLE_UARTRX) ) { break; } // Invalid length if(p_header->length > SDEP_MAX_PACKETSIZE) break; // read payload memset(p_response->payload, 0xff, p_header->length); spixfer(p_response->payload, p_header->length); result = true; } while(0); m_cs = true; m_spi.deselect(); return result; } /******************************************************************************/ /*! */ /******************************************************************************/ void Adafruit_BluefruitLE_SPI::spixfer(void *buff, size_t len) { uint8_t *p = (uint8_t *)buff; while (len--) { *p = spixfer(*p); p++; } } /******************************************************************************/ /*! */ /******************************************************************************/ uint8_t Adafruit_BluefruitLE_SPI::spixfer(uint8_t x) { uint8_t reply = m_spi.write(x); //::printf("%x -> %x\n",x,reply); //SerialDebug.println(reply, HEX); return reply; }