Xbee.h

Go to the documentation of this file.

/* Copyright (c) 2021 Skyward Experimental Rocketry
 * Author: Luca Erbetta
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <diagnostic/PrintLogger.h>
#include <drivers/spi/SPIDriver.h>
#include <miosix.h>
#include <radio/Transceiver.h>
#include <utils/collections/CircularBuffer.h>
 
#include <functional>
 
#include "APIFrameParser.h"
#include "XbeeStatus.h"
 
using miosix::FastMutex;
 
#ifndef USE_MOCK_PERIPHERALS
using GpioType = miosix::GpioPin;
#else
#include <utils/TestUtils/MockGpioPin.h>
using GpioType = Boardcore::MockGpioPin;
#endif
 
namespace Boardcore
{
 
namespace Xbee
{
using ParseResult = APIFrameParser::ParseResult;
 
static constexpr unsigned int FRAME_POLL_INTERVAL = 10;    // ms
static constexpr unsigned int DEFAULT_TX_TIMEOUT  = 5000;  // ms
 
// Size (in frames) of the receive circular buffer
static constexpr unsigned int RX_FRAMES_BUF_SIZE = 3;
 
class Xbee : public Transceiver
{
public:
    using OnFrameReceivedListener = std::function<void(APIFrame& frame)>;
 
    Xbee(SPIBusInterface& bus, GpioType cs, GpioType attn, GpioType rst,
         long long txTimeout = DEFAULT_TX_TIMEOUT);
 
    Xbee(SPIBusInterface& bus, SPIBusConfig config, GpioType cs, GpioType attn,
         GpioType rst, long long txTimeout = DEFAULT_TX_TIMEOUT);
 
    ~Xbee();
 
    bool send(uint8_t* pkt, size_t packetLength) override;
 
    ssize_t receive(uint8_t* buf, size_t bufferMaxSize) override;
 
    void reset();
 
    void handleATTNInterrupt();
 
    void wakeReceiver(bool forceReturn = false);
 
    void sendATCommand(const char* cmd, uint8_t* params = nullptr,
                       size_t paramsLength = 0);
 
    bool sendATCommand(const char* cmd, ATCommandResponseFrame* response,
                       uint8_t* params = nullptr, size_t paramsLength = 0,
                       unsigned int timeout = 1000);
 
    void setOnFrameReceivedListener(OnFrameReceivedListener listener);
 
    XbeeStatus getStatus();
 
private:
    void handleFrame(APIFrame& frame);
 
    uint8_t sendATCommandInternal(const char* cmd, uint8_t* params = nullptr,
                                  size_t paramsLength = 0);
 
    uint8_t sendATCommandInternal(uint8_t frameId, const char* cmd,
                                  uint8_t* params     = nullptr,
                                  size_t paramsLength = 0);
 
    uint8_t buildTXRequestFrame(TXRequestFrame& txReq, uint8_t* pkt,
                                size_t packetLength);
 
    size_t fillReceiveBuf(uint8_t* buf, size_t bufferMaxSize);
 
    ParseResult readOneFrame();
 
    bool readRXFrame();
 
    void writeFrame(APIFrame& frame);
 
    uint8_t getNewFrameID();
 
    bool waitForFrame(uint8_t frameType, unsigned int pollInterval,
                      long long timeoutTick);
 
    // Synchronizes all communications to the xbee, as they may happen on
    // multiple threads
    FastMutex mutexXbeeCommunication;
 
    APIFrameParser parser;
    // Frame being parsed. Only valid if last call to
    // parser.parse() returned ParseResult::SUCCESS
    APIFrame parsingApiFrame;
 
    // Temporary storage for RX packet frames, waiting to be returned by
    // receive()
    CircularBuffer<RXPacketFrame, RX_FRAMES_BUF_SIZE> rxFramesBuffer;
    FastMutex mutexRxFrames;
    // RX Packet currently being returned by receive()
    RXPacketFrame currRxFrame;
    // Index of the first byte of the payload of currRxFrame that will be
    // returned on the next call to receive()
    int currRxPayloadPointer = -1;
 
    // SPI defs
    SPISlave spiXbee;
    GpioType attn;
    GpioType rst;
 
    // How long to wait for a TX Status
    long long txTimeout;
 
    OnFrameReceivedListener frameListener;
 
    // Used to generate a unique frame id
    uint8_t frameIdCounter = 1;
 
    // Forces receive() to return even if there is no new data
    bool forceRcvReturn = false;
 
    // Status structs
    XbeeStatus status;
    Stats timeToSendStats;
 
    // Waiting thread to be woken when something has been received.
    miosix::Thread* receiveThread = 0;
 
    PrintLogger logger = Logging::getLogger("xbee");
};
 
}  // namespace Xbee
 
}  // namespace Boardcore