Schoumi
/
microbit-dal
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'rssi'

master
Joe Finney 2016-02-09 01:09:36 +00:00
parent eca55e279d 2f6d405e81
commit a61113f950
8 changed files with 677 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
inc/MicroBitRadio.h
View File

@ -2,6 +2,7 @@
#define MICROBIT_RADIO_H
#include "mbed.h"
#include "PacketBuffer.h"
/**
* Provides a simple broadcast radio abstraction, built upon the raw nrf51822 RADIO module.
@ -9,7 +10,7 @@
* The nrf51822 RADIO module supports a number of proprietary modes of operation in addition to the typical BLE usage.
* This class uses one of these modes to enable simple, point to multipoint communication directly between micro:bits.
*
* TODO: The protocols implemented here do not currently perform any significant form of energy management,
* TODO: The protocols implemented here do not currently perform any significant form of energy management,
* which means that they will consume far more energy than their BLE equivalent. Later versions of the protocol
* should look to address this through energy efficient broadcast techniques / sleep scheduling. In particular, the GLOSSY
* approach to efficienct rebroadcast and network synchronisation would likely provide an effective future step.
@ -17,7 +18,7 @@
* TODO: Meshing should also be considered - again a GLOSSY approach may be effective here, and highly complementary to
* the master/slave arachitecture of BLE.
*
* TODO: This implementation only operates whilst the BLE stack is disabled. The nrf51822 provides a timeslot API to allow
* TODO: This implementation only operates whilst the BLE stack is disabled. The nrf51822 provides a timeslot API to allow
* BLE to cohabit with other protocols. Future work to allow this colocation would be benefical, and would also allow for the
* creation of wireless BLE bridges.
*
@ -31,12 +32,12 @@
// Default configuration values
#define MICROBIT_RADIO_BASE_ADDRESS 0x75626974
#define MICROBIT_RADIO_DEFAULT_GROUP 0
#define MICROBIT_RADIO_DEFAULT_GROUP 0
#define MICROBIT_RADIO_DEFAULT_TX_POWER 6
#define MICROBIT_RADIO_DEFAULT_FREQUENCY 7
#define MICROBIT_RADIO_MAX_PACKET_SIZE 32
#define MICROBIT_RADIO_HEADER_SIZE 4
#define MICROBIT_RADIO_MAXIMUM_RX_BUFFERS 4
#define MICROBIT_RADIO_MAX_PACKET_SIZE 32
#define MICROBIT_RADIO_HEADER_SIZE 4
#define MICROBIT_RADIO_MAXIMUM_RX_BUFFERS 4
// Known Protocol Numbers
#define MICROBIT_RADIO_PROTOCOL_DATAGRAM 1 // A simple, single frame datagram. a little like UDP but with smaller packets. :-)
@ -45,7 +46,7 @@
// Events
#define MICROBIT_RADIO_EVT_DATAGRAM 1 // Event to signal that a new datagram has been received.
struct PacketBuffer
struct FrameBuffer
{
uint8_t length; // The length of the remaining bytes in the packet. includes protocol/version/group fields, excluding the length field itself.
uint8_t version; // Protocol version code.
@ -53,7 +54,8 @@ struct PacketBuffer
uint8_t protocol; // Inner protocol number c.f. those issued by IANA for IP protocols
uint8_t payload[MICROBIT_RADIO_MAX_PACKET_SIZE]; // User / higher layer protocol data
PacketBuffer *next; // Linkage, to allow this and other protocols to queue packets pending processing.
FrameBuffer *next; // Linkage, to allow this and other protocols to queue packets pending processing.
uint8_t rssi; // Received signal strength of this frame.
};
#include "MicroBitRadioDatagram.h"
@ -63,8 +65,9 @@ class MicroBitRadio : MicroBitComponent
{
uint8_t group; // The radio group to which this micro:bit belongs.
uint8_t queueDepth; // The number of packets in the receiver queue.
PacketBuffer *rxQueue; // A linear list of incoming packets, queued awaiting processing.
PacketBuffer *rxBuf; // A pointer to the buffer being actively used by the RADIO hardware.
uint8_t rssi;
FrameBuffer *rxQueue; // A linear list of incoming packets, queued awaiting processing.
FrameBuffer *rxBuf; // A pointer to the buffer being actively used by the RADIO hardware.
public:
MicroBitRadioDatagram datagram; // A simple datagram service.
@ -74,7 +77,7 @@ class MicroBitRadio : MicroBitComponent
/**
* Constructor.
*
* Initialise the MicroBitRadio. Note that this class is demand activated, so most resources are only
* Initialise the MicroBitRadio. Note that this class is demand activated, so most resources are only
* committed if send/recv or event registrations calls are made.
*/
MicroBitRadio(uint16_t id);
@ -82,7 +85,7 @@ class MicroBitRadio : MicroBitComponent
/**
* Change the output power level of the transmitter to the given value.
*
* @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest.
* @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest.
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range.
*
*/
@ -92,7 +95,7 @@ class MicroBitRadio : MicroBitComponent
* Change the transmission and reception band of the radio to the given channel
*
* @param band a frequency band in the range 0 - 100. Each step is 1MHz wide, based at 2400MHz.
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range,
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range,
* or MICROBIT_NOT_SUPPORTED if the BLE stack is running.
*
*/
@ -102,9 +105,9 @@ class MicroBitRadio : MicroBitComponent
* Retrieve a pointer to the currently allocated recieve buffer. This is the area of memory
* actively being used by the radio hardware to store incoming data.
*
* @return a pointer to the current receive buffer
* @return a pointer to the current receive buffer
*/
PacketBuffer* getRxBuf();
FrameBuffer * getRxBuf();
/**
* Attempt to queue a buffer received by the radio hardware, if sufficient space is available.
@ -115,7 +118,19 @@ class MicroBitRadio : MicroBitComponent
int queueRxBuf();
/**
* Initialises the radio for use as a multipoint sender/receiver
* Sets the RSSI for the most recent packet.
*
* @param rssi the new rssi value
*/
int setRSSI(uint8_t rssi);
/**
* Retrieves the current RSSI for the most recent packet.
*/
int getRSSI();
/**
* Initialises the radio for use as a multipoint sender/receiver
* @return MICROBIT_OK on success, MICROBIT_NOT_SUPPORTED if SoftDevice is enabled.
*/
int enable();
@ -138,7 +153,7 @@ class MicroBitRadio : MicroBitComponent
* A background, low priority callback that is triggered whenever the processor is idle.
* Here, we empty our queue of received packets, and pass them onto higher level protocol handlers.
*
* We provide optimised handling of well known, simple protocols and events on the MicroBitMessageBus
* We provide optimised handling of well known, simple protocols and events on the MicroBitMessageBus
* to provide extensibility to other protocols that may be written in the future.
*/
virtual void idleTick();
@ -152,14 +167,14 @@ class MicroBitRadio : MicroBitComponent
/**
* Retrieves the next packet from the receive buffer.
* If a data packet is available, then it will be returned immediately to
* the caller. This call will also dequeue the buffer.
* the caller. This call will also dequeue the buffer.
*
* NOTE: Once recv() has been called, it is the callers resposibility to
* NOTE: Once recv() has been called, it is the callers resposibility to
* delete the buffer when appropriate.
*
* @return The buffer containing the the packet. If no data is available, NULL is returned.
*/
PacketBuffer* recv();
FrameBuffer* recv();
/**
* Transmits the given buffer onto the broadcast radio.
@ -168,7 +183,7 @@ class MicroBitRadio : MicroBitComponent
* @param data The packet contents to transmit.
* @return MICROBIT_OK on success, or MICROBIT_NOT_SUPPORTED if the BLE stack is running.
*/
int send(PacketBuffer *buffer);
int send(FrameBuffer *buffer);
};
#endif

6
inc/MicroBitRadioDatagram.h
View File

@ -18,7 +18,7 @@
class MicroBitRadioDatagram
{
PacketBuffer *rxQueue; // A linear list of incoming packets, queued awaiting processing.
FrameBuffer *rxQueue; // A linear list of incoming packets, queued awaiting processing.
public:
@ -46,7 +46,7 @@ class MicroBitRadioDatagram
*
* @return the data received, or the EmptyString if no data is available.
*/
ManagedString recv();
PacketBuffer recv();
/**
* Transmits the given buffer onto the broadcast radio.
@ -65,7 +65,7 @@ class MicroBitRadioDatagram
* @param data The packet contents to transmit.
* @return MICROBIT_OK on success.
*/
int send(ManagedString data);
int send(PacketBuffer data);
/**
* Protocol handler callback. This is called when the radio receives a packet marked as a datagram.

239
inc/PacketBuffer.h Normal file
View File

@ -0,0 +1,239 @@
#ifndef MICROBIT_PACKET_BUFFER_H
#define MICROBIT_PACKET_BUFFER_H
#include "mbed.h"
#include "RefCounted.h"
struct PacketData : RefCounted
{
uint16_t rssi; // The radio signal strength this packet was received.
uint8_t length; // The length of the payload in bytes
uint8_t payload[0]; // User / higher layer protocol data
};
/**
* Class definition for a PacketBuffer.
* A PacketBuffer holds a series of bytes that can be sent or received from the MicroBitRadio channel.
* n.b. This is a mutable, managed type.
*/
class PacketBuffer
{
PacketData *ptr; // Pointer to payload data
public:
/**
* Provide an array containing the packet data.
* @return The contents of this packet, as an array of bytes.
*/
uint8_t *getBytes();
/**
* Default Constructor.
* Creates an empty Packet Buffer.
*
* Example:
* @code
* PacketBuffer p();
* @endcode
*/
PacketBuffer();
/**
* Constructor.
* Creates a new PacketBuffer of the given size.
*
* @param length The length of the buffer to create.
*
* Example:
* @code
* PacketBuffer p(16); // Creates a PacketBuffer 16 bytes long.
* @endcode
*/
PacketBuffer(int length);
/**
* Constructor.
* Creates an empty Packet Buffer of the given size,
* and fills it with the data provided.
*
* @param data The data with which to fill the buffer.
* @param length The length of the buffer to create.
* @param rssi The radio signal strength at the time this pacer was recieved.
*
* Example:
* @code
* uint8_t buf = {13,5,2};
* PacketBuffer p(buf, 3); // Creates a PacketBuffer 3 bytes long.
* @endcode
*/
PacketBuffer(uint8_t *data, int length, int rssi = 0);
/**
* Copy Constructor.
* Add ourselves as a reference to an existing PacketBuffer.
*
* @param buffer The PacketBuffer to reference.
*
* Example:
* @code
* PacketBuffer p();
* PacketBuffer p2(i); // Refers to the same packet as p.
* @endcode
*/
PacketBuffer(const PacketBuffer &buffer);
/**
* Internal constructor-initialiser.
*
* @param data The data with which to fill the buffer.
* @param length The length of the buffer to create.
* @param rssi The radio signal strength at the time this packet was recieved.
*
*/
void init(uint8_t *data, int length, int rssi);
/**
* Destructor.
* Removes buffer resources held by the instance.
*/
~PacketBuffer();
/**
* Copy assign operation.
*
* Called when one PacketBuffer is assigned the value of another using the '=' operator.
* Decrements our reference count and free up the buffer as necessary.
* Then, update our buffer to refer to that of the supplied PacketBuffer,
* and increase its reference count.
*
* @param p The PacketBuffer to reference.
*
* Example:
* @code
* uint8_t buf = {13,5,2};
* PacketBuffer p1(16);
* PacketBuffer p2(buf, 3);
*
* p1 = p2;
* @endcode
*/
PacketBuffer& operator = (const PacketBuffer& p);
/**
* Array access operation (read).
*
* Called when a PacketBuffer is dereferenced with a [] operation.
* Transparently map this through to the underlying payload for elegance of programming.
*
* Example:
* @code
* PacketBuffer p1(16);
* uint8_t data = p1[0];
* @endcode
*/
uint8_t operator [] (int i) const;
/**
* Array access operation (modify).
*
* Called when a PacketBuffer is dereferenced with a [] operation.
* Transparently map this through to the underlying payload for elegance of programming.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1[0] = 42;
* @endcode
*/
uint8_t& operator [] (int i);
/**
* Equality operation.
*
* Called when one PacketBuffer is tested to be equal to another using the '==' operator.
*
* @param p The PacketBuffer to test ourselves against.
* @return true if this PacketBuffer is identical to the one supplied, false otherwise.
*
* Example:
* @code
*
* uint8_t buf = {13,5,2};
* PacketBuffer p1(16);
* PacketBuffer p2(buf, 3);
*
* if(p1 == p2) // will be true
* uBit.display.scroll("same!");
* @endcode
*/
bool operator== (const PacketBuffer& p);
/**
* Sets the byte at the given index to value provided.
* @param position The index of the byte to change.
* @param value The new value of the byte (0-255).
* @return MICROBIT_OK, or MICROBIT_INVALID_PARAMETER.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setByte(0,255); // Sets the first byte in the buffer to the value 255.
* @endcode
*/
int setByte(int position, uint8_t value);
/**
* Determines the value of the given byte in the packet.
*
* @param position The index of the byte to read.
* @return The value of the byte at the given position, or MICROBIT_INVALID_PARAMETER.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setByte(0,255); // Sets the first byte in the buffer to the value 255.
* p1.getByte(0); // Returns 255.
* @endcode
*/
int getByte(int position);
/**
* Gets number of bytes in this buffer
* @return The size of the buffer in bytes.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.length(); // Returns 16.
* @endcode
*/
int length();
/**
* Gets the received signal strength of this packet.
*
* @return The signal strength of the radio when this packet was received, in -dbM.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.getRSSI(); // Returns the received signal strength.
* @endcode
*/
int getRSSI();
/**
* Sets the received signal strength of this packet.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setRSSI(37);
* @endcode
*/
void setRSSI(uint8_t rssi);
};
#endif

1
source/CMakeLists.txt
View File

@ -33,6 +33,7 @@ set(YOTTA_AUTO_MICROBIT-DAL_CPP_FILES
"RefCounted.cpp"
"MemberFunctionCallback.cpp"
"MicroBitStorage.cpp"
"PacketBuffer.cpp"
"ble-services/MicroBitBLEManager.cpp"
"ble-services/MicroBitDFUService.cpp"
"ble-services/MicroBitEventService.cpp"

296
source/PacketBuffer.cpp Normal file
View File

@ -0,0 +1,296 @@
#include "MicroBit.h"
/**
* Default Constructor.
* Creates an empty Packet Buffer.
*
* Example:
* @code
* PacketBuffer p();
* @endcode
*/
PacketBuffer::PacketBuffer()
{
this->init(NULL, 0, 0);
}
/**
* Constructor.
* Creates an empty Packet Buffer of the given size.
*
* @param length The length of the buffer to create.
*
* Example:
* @code
* PacketBuffer p(16); // Creates a PacketBuffer 16 bytes long.
* @endcode
*/
PacketBuffer::PacketBuffer(int length)
{
this->init(NULL, length, 0);
}
/**
* Constructor.
* Creates a new PacketBuffer of the given size,
* and fills it with the data provided.
*
* @param data The data with which to fill the buffer.
* @param length The length of the buffer to create.
* @param rssi The radio signal strength at the time this packet was recieved.
*
* Example:
* @code
* uint8_t buf = {13,5,2};
* PacketBuffer p(buf, 3); // Creates a PacketBuffer 3 bytes long.
* @endcode
*/
PacketBuffer::PacketBuffer(uint8_t *data, int length, int rssi)
{
this->init(data, length, rssi);
}
/**
* Copy Constructor.
* Add ourselves as a reference to an existing PacketBuffer.
*
* @param buffer The PacketBuffer to reference.
*
* Example:
* @code
* PacketBuffer p();
* PacketBuffer p2(i); // Refers to the same packet as p.
* @endcode
*/
PacketBuffer::PacketBuffer(const PacketBuffer &buffer)
{
ptr = buffer.ptr;
ptr->incr();
}
/**
* Internal constructor-initialiser.
*
* @param data The data with which to fill the buffer.
* @param length The length of the buffer to create.
* @param rssi The radio signal strength at the time this pacer was recieved.
*
*/
void PacketBuffer::init(uint8_t *data, int length, int rssi)
{
if (length < 0)
length = 0;
ptr = (PacketData *) malloc(sizeof(PacketData) + length);
ptr->init();
ptr->length = length;
ptr->rssi = rssi;
// Copy in the data buffer, if provided.
if (data)
memcpy(ptr->payload, data, length);
}
/**
* Destructor.
* Removes buffer resources held by the instance.
*/
PacketBuffer::~PacketBuffer()
{
ptr->decr();
}
/**
* Copy assign operation.
*
* Called when one PacketBuffer is assigned the value of another using the '=' operator.
* Decrements our reference count and free up the buffer as necessary.
* Then, update our buffer to refer to that of the supplied PacketBuffer,
* and increase its reference count.
*
* @param p The PacketBuffer to reference.
*
* Example:
* @code
* uint8_t buf = {13,5,2};
* PacketBuffer p1(16);
* PacketBuffer p2(buf, 3);
*
* p1 = p2;
* @endcode
*/
PacketBuffer& PacketBuffer::operator = (const PacketBuffer &p)
{
if(ptr == p.ptr)
return *this;
ptr->decr();
ptr = p.ptr;
ptr->incr();
return *this;
}
/**
* Array access operation (read).
*
* Called when a PacketBuffer is dereferenced with a [] operation.
* Transparently map this through to the underlying payload for elegance of programming.
*
* Example:
* @code
* PacketBuffer p1(16);
* uint8_t data = p1[0];
* @endcode
*/
uint8_t PacketBuffer::operator [] (int i) const
{
return ptr->payload[i];
}
/**
* Array access operation (modify).
*
* Called when a PacketBuffer is dereferenced with a [] operation.
* Transparently map this through to the underlying payload for elegance of programming.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1[0] = 42;
* @endcode
*/
uint8_t& PacketBuffer::operator [] (int i)
{
return ptr->payload[i];
}
/**
* Equality operation.
*
* Called when one PacketBuffer is tested to be equal to another using the '==' operator.
*
* @param p The PacketBuffer to test ourselves against.
* @return true if this PacketBuffer is identical to the one supplied, false otherwise.
*
* Example:
* @code
*
* uint8_t buf = {13,5,2};
* PacketBuffer p1(16);
* PacketBuffer p2(buf, 3);
*
* if(p1 == p2) // will be true
* uBit.display.scroll("same!");
* @endcode
*/
bool PacketBuffer::operator== (const PacketBuffer& p)
{
if (ptr == p.ptr)
return true;
else
return (ptr->length == p.ptr->length && (memcmp(ptr->payload, p.ptr->payload, ptr->length)==0));
}
/**
* Sets the byte at the given index to value provided.
* @param position The index of the byte to change.
* @param value The new value of the byte (0-255).
* @return MICROBIT_OK, or MICROBIT_INVALID_PARAMETER.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setByte(0,255); // Sets the firts byte in the buffer to the value 255.
* @endcode
*/
int PacketBuffer::setByte(int position, uint8_t value)
{
if (position < ptr->length)
{
ptr->payload[position] = value;
return MICROBIT_OK;
}
else
{
return MICROBIT_INVALID_PARAMETER;
}
}
/**
* Determines the value of the given byte in the packet.
*
* @param position The index of the byte to read.
* @return The value of the byte at the given position, or MICROBIT_INVALID_PARAMETER.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setByte(0,255); // Sets the firts byte in the buffer to the value 255.
* p1.getByte(0); // Returns 255.
* @endcode
*/
int PacketBuffer::getByte(int position)
{
if (position < ptr->length)
return ptr->payload[position];
else
return MICROBIT_INVALID_PARAMETER;
}
/**
* Provide an array containing the packet data.
* @return The contents of this packet, as an array of bytes.
*/
uint8_t*PacketBuffer::getBytes()
{
return ptr->payload;
}
/**
* Gets number of bytes in this buffer
* @return The size of the buffer in bytes.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.length(); // Returns 16.
* @endcode
*/
int PacketBuffer::length()
{
return ptr->length;
}
/**
* Gets the received signal strength of this packet.
*
* @return The signal strength of the radio when this packet was received.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.getRSSI();
* @endcode
*/
int PacketBuffer::getRSSI()
{
return ptr->rssi;
}
/**
* Sets the received signal strength of this packet.
*
* Example:
* @code
* PacketBuffer p1(16);
* p1.setRSSI(37);
* @endcode
*/
void PacketBuffer::setRSSI(uint8_t rssi)
{
ptr->rssi = rssi;
}

128
source/ble-services/MicroBitRadio.cpp
View File

@ -6,7 +6,7 @@
* The nrf51822 RADIO module supports a number of proprietary modes of operation oher than the typical BLE usage.
* This class uses one of these modes to enable simple, point to multipoint communication directly between micro:bits.
*
* TODO: The protocols implemented here do not currently perform any significant form of energy management,
* TODO: The protocols implemented here do not currently perform any significant form of energy management,
* which means that they will consume far more energy than their BLE equivalent. Later versions of the protocol
* should look to address this through energy efficient broadcast techbiques / sleep scheduling. In particular, the GLOSSY
* approach to efficient rebroadcast and network synchronisation would likely provide an effective future step.
@ -14,7 +14,7 @@
* TODO: Meshing should also be considered - again a GLOSSY approach may be effective here, and highly complementary to
* the master/slave arachitecture of BLE.
*
* TODO: This implementation may only operated whilst the BLE stack is disabled. The nrf51822 provides a timeslot API to allow
* TODO: This implementation may only operated whilst the BLE stack is disabled. The nrf51822 provides a timeslot API to allow
* BLE to cohabit with other protocols. Future work to allow this colocation would be benefical, and would also allow for the
* creation of wireless BLE bridges.
*
@ -31,15 +31,34 @@ extern "C" void RADIO_IRQHandler(void)
MicroBitRadio::instance->queueRxBuf();
NRF_RADIO->PACKETPTR = (uint32_t) MicroBitRadio::instance->getRxBuf();
// Start listening for the next packet.
NRF_RADIO->EVENTS_END = 0;
NRF_RADIO->TASKS_START = 1;
if(NRF_RADIO->EVENTS_READY)
{
NRF_RADIO->EVENTS_READY = 0;
// Start listening and wait for the END event
NRF_RADIO->TASKS_START = 1;
}
if(NRF_RADIO->EVENTS_END)
{
NRF_RADIO->EVENTS_END = 0;
if(NRF_RADIO->CRCSTATUS == 1)
{
uint8_t sample = NRF_RADIO->RSSISAMPLE;
uBit.radio.setRSSI(sample);
}
// Start listening and wait for the END event
NRF_RADIO->TASKS_START = 1;
}
}
/**
* Constructor.
*
* Initialise the MicroBitRadio. Note that this class is demand activated, so most resources are only committed
* Initialise the MicroBitRadio. Note that this class is demand activated, so most resources are only committed
* if send/recv or event registrations calls are made.
*/
MicroBitRadio::MicroBitRadio(uint16_t id) : datagram()
@ -48,6 +67,7 @@ MicroBitRadio::MicroBitRadio(uint16_t id) : datagram()
this->status = 0;
this->group = 0;
this->queueDepth = 0;
this->rssi = 0;
this->rxQueue = NULL;
this->rxBuf = NULL;
@ -57,7 +77,7 @@ MicroBitRadio::MicroBitRadio(uint16_t id) : datagram()
/**
* Change the output power level of the transmitter to the given value.
*
* @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest.
* @param power a value in the range 0..7, where 0 is the lowest power and 7 is the highest.
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range.
*
*/
@ -75,7 +95,7 @@ int MicroBitRadio::setTransmitPower(int power)
* Change the transmission and reception band of the radio to the given channel
*
* @param band a frequency band in the range 0 - 100. Each step is 1MHz wide, based at 2400MHz.
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range,
* @return MICROBIT_OK on success, or MICROBIT_INVALID_PARAMETER if the value is out of range,
* or MICROBIT_NOT_SUPPORTED if the BLE stack is running.
*
*/
@ -96,9 +116,9 @@ int MicroBitRadio::setFrequencyBand(int band)
* Retrieve a pointer to the currently allocated receive buffer. This is the area of memory
* actively being used by the radio hardware to store incoming data.
*
* @return a pointer to the current receive buffer
* @return a pointer to the current receive buffer
*/
PacketBuffer* MicroBitRadio::getRxBuf()
FrameBuffer* MicroBitRadio::getRxBuf()
{
return rxBuf;
}
@ -117,8 +137,11 @@ int MicroBitRadio::queueRxBuf()
if (queueDepth >= MICROBIT_RADIO_MAXIMUM_RX_BUFFERS)
return MICROBIT_NO_RESOURCES;
// Store the received RSSI value in the frame
rxBuf->rssi = getRSSI();
// Ensure that a replacement buffer is available before queuing.
PacketBuffer *newRxBuf = new PacketBuffer();
FrameBuffer *newRxBuf = new FrameBuffer();
if (newRxBuf == NULL)
return MICROBIT_NO_RESOURCES;
@ -132,7 +155,7 @@ int MicroBitRadio::queueRxBuf()
}
else
{
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
while (p->next != NULL)
p = p->next;
@ -148,6 +171,34 @@ int MicroBitRadio::queueRxBuf()
return MICROBIT_OK;
}
/**
* Sets the RSSI for the most recent packet.
*
* @param rssi the new rssi value
*
* @note should only be called from RADIO_IRQHandler...
*/
int MicroBitRadio::setRSSI(uint8_t rssi)
{
if (!(status & MICROBIT_RADIO_STATUS_INITIALISED))
return MICROBIT_NOT_SUPPORTED;
this->rssi = rssi;
return MICROBIT_OK;
}
/**
* Retrieves the current RSSI for the most recent packet.
*/
int MicroBitRadio::getRSSI()
{
if (!(status & MICROBIT_RADIO_STATUS_INITIALISED))
return MICROBIT_NOT_SUPPORTED;
return this->rssi;
}
/**
* Initialises the radio for use as a multipoint sender/receiver.
* This is currently only possible if the BLE stack (Soft Device) is disabled.
@ -166,7 +217,7 @@ int MicroBitRadio::enable()
// If this is the first time we've been enable, allocate out receive buffers.
if (rxBuf == NULL)
rxBuf = new PacketBuffer();
rxBuf = new FrameBuffer();
if (rxBuf == NULL)
return MICROBIT_NO_RESOURCES;
@ -181,15 +232,15 @@ int MicroBitRadio::enable()
setTransmitPower(MICROBIT_RADIO_DEFAULT_TX_POWER);
setFrequencyBand(MICROBIT_RADIO_DEFAULT_FREQUENCY);
// Configure for 1Mbps throughput.
// Configure for 1Mbps throughput.
// This may sound excessive, but running a high data rates reduces the chances of collisions...
NRF_RADIO->MODE = RADIO_MODE_MODE_Nrf_1Mbit;
// Configure the addresses we use for this protocol. We run ANONYMOUSLY at the core.
// A 40 bit addresses is used. The first 32 bits match the ASCII character code for "uBit".
// A 40 bit addresses is used. The first 32 bits match the ASCII character code for "uBit".
// Statistically, this provides assurance to avoid other similar 2.4GHz protocols that may be in the vicinity.
// We also map the assigned 8-bit GROUP id into the PREFIX field. This allows the RADIO hardware to perform
// address matching for us, and only generate an interrupt when a packet matching our group is received.
// We also map the assigned 8-bit GROUP id into the PREFIX field. This allows the RADIO hardware to perform
// address matching for us, and only generate an interrupt when a packet matching our group is received.
NRF_RADIO->BASE0 = MICROBIT_RADIO_BASE_ADDRESS;
// Join the default group. This will configure the remaining byte in the RADIO hardware module.
@ -197,8 +248,8 @@ int MicroBitRadio::enable()
// The RADIO hardware module supports the use of multiple addresses, but as we're running anonymously, we only need one.
// Configure the RADIO module to use the default address (address 0) for both send and receive operations.
NRF_RADIO->TXADDRESS = 0;
NRF_RADIO->RXADDRESSES = 1;
NRF_RADIO->TXADDRESS = 0;
NRF_RADIO->RXADDRESSES = 1;
// Packet layout configuration. The nrf51822 has a highly capable and flexible RADIO module that, in addition to transmission
// and reception of data, also contains a LENGTH field, two optional additional 1 byte fields (S0 and S1) and a CRC calculation.
@ -212,21 +263,23 @@ int MicroBitRadio::enable()
// and we know we can't trust it. The nrf51822 RADIO uses a CRC for this - a very effective checksum calculation.
//
// Enable automatic 16bit CRC generation and checking, and configure how the CRC is calculated.
NRF_RADIO->CRCCNF = RADIO_CRCCNF_LEN_Two;
NRF_RADIO->CRCINIT = 0xFFFF;
NRF_RADIO->CRCPOLY = 0x11021;
NRF_RADIO->CRCCNF = RADIO_CRCCNF_LEN_Two;
NRF_RADIO->CRCINIT = 0xFFFF;
NRF_RADIO->CRCPOLY = 0x11021;
// Set the start random value of the data whitening algorithm. This can be any non zero number.
NRF_RADIO->DATAWHITEIV = 0x18;
NRF_RADIO->DATAWHITEIV = 0x18;
// Set up the RADIO module to read and write from our internal buffer.
NRF_RADIO->PACKETPTR = (uint32_t)rxBuf;
// Set up the RADIO module to read and write from our internal buffer.
NRF_RADIO->PACKETPTR = (uint32_t)rxBuf;
// Configure the hardware to issue an interrupt whenever a task is complete (e.g. send/receive).
NRF_RADIO->INTENSET = 0x00000008;
NVIC_ClearPendingIRQ(RADIO_IRQn);
NVIC_EnableIRQ(RADIO_IRQn);
NRF_RADIO->SHORTS |= RADIO_SHORTS_ADDRESS_RSSISTART_Msk;
// Start listening for the next packet
NRF_RADIO->EVENTS_READY = 0;
NRF_RADIO->TASKS_RXEN = 1;
@ -253,7 +306,7 @@ int MicroBitRadio::disable()
// Only attempt to enable.disable the radio if the protocol is alreayd running.
if (uBit.ble)
return MICROBIT_NOT_SUPPORTED;
if (!(status & MICROBIT_RADIO_STATUS_INITIALISED))
return MICROBIT_OK;
@ -294,7 +347,7 @@ int MicroBitRadio::setGroup(uint8_t group)
* A background, low priority callback that is triggered whenever the processor is idle.
* Here, we empty our queue of received packets, and pass them onto higher level protocol handlers.
*
* We provide optimised handling of well known, simple protocols and events on the MicroBitMessageBus
* We provide optimised handling of well known, simple protocols and events on the MicroBitMessageBus
* to provide extensibility to other protocols that may be written in the future.
*/
void MicroBitRadio::idleTick()
@ -302,7 +355,7 @@ void MicroBitRadio::idleTick()
// Walk the list of packets and process each one.
while(rxQueue)
{
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
switch (p->protocol)
{
@ -314,11 +367,11 @@ void MicroBitRadio::idleTick()
event.packetReceived();
break;
default:
default:
MicroBitEvent(MICROBIT_ID_RADIO_DATA_READY, p->protocol);
}
// If the packet was processed, it will have been recv'd, and taken from the queue.
// If the packet was processed, it will have been recv'd, and taken from the queue.
// If this was a packet for an unknown protocol, it will still be there, so simply free it.
if (p == rxQueue)
{
@ -340,16 +393,16 @@ int MicroBitRadio::dataReady()
/**
* Retrieves the next packet from the receive buffer.
* If a data packet is available, then it will be returned immediately to
* the caller. This call will also dequeue the buffer.
* the caller. This call will also dequeue the buffer.
*
* NOTE: Once recv() has been called, it is the callers resposibility to
* NOTE: Once recv() has been called, it is the callers resposibility to
* delete the buffer when appropriate.
*
* @return The buffer containing the the packet. If no data is available, NULL is returned.
*/
PacketBuffer* MicroBitRadio::recv()
FrameBuffer* MicroBitRadio::recv()
{
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
if (p)
{
@ -365,9 +418,9 @@ PacketBuffer* MicroBitRadio::recv()
* The call will wait until the transmission of the packet has completed before returning.
*
* @param data The packet contents to transmit.
* @return MICROBIT_OK on success, or MICROBIT_NOT_SUPPORTED if the BLE stack is running.
* @return MICROBIT_OK on success, or MICROBIT_NOT_SUPPORTED if the BLE stack is running.
*/
int MicroBitRadio::send(PacketBuffer *buffer)
int MicroBitRadio::send(FrameBuffer *buffer)
{
if (uBit.ble)
return MICROBIT_NOT_SUPPORTED;
@ -421,4 +474,3 @@ int MicroBitRadio::send(PacketBuffer *buffer)
return MICROBIT_OK;
}

20
source/ble-services/MicroBitRadioDatagram.cpp
View File

@ -36,7 +36,7 @@ int MicroBitRadioDatagram::recv(uint8_t *buf, int len)
return MICROBIT_INVALID_PARAMETER;
// Take the first buffer from the queue.
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
rxQueue = rxQueue->next;
int l = min(len, p->length - (MICROBIT_RADIO_HEADER_SIZE - 1));
@ -55,15 +55,15 @@ int MicroBitRadioDatagram::recv(uint8_t *buf, int len)
*
* @return the data received, or the EmptyString if no data is available.
*/
ManagedString MicroBitRadioDatagram::recv()
PacketBuffer MicroBitRadioDatagram::recv()
{
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
rxQueue = rxQueue->next;
ManagedString s((const char *)p->payload, p->length - (MICROBIT_RADIO_HEADER_SIZE - 1));
PacketBuffer packet(p->payload, p->length - (MICROBIT_RADIO_HEADER_SIZE - 1), p->rssi);
delete p;
return s;
return packet;
}
/**
@ -79,7 +79,7 @@ int MicroBitRadioDatagram::send(uint8_t *buffer, int len)
if (buffer == NULL || len < 0 || len > MICROBIT_RADIO_MAX_PACKET_SIZE + MICROBIT_RADIO_HEADER_SIZE - 1)
return MICROBIT_INVALID_PARAMETER;
PacketBuffer buf;
FrameBuffer buf;
buf.length = len + MICROBIT_RADIO_HEADER_SIZE - 1;
buf.version = 1;
@ -97,9 +97,9 @@ int MicroBitRadioDatagram::send(uint8_t *buffer, int len)
* @param data The packet contents to transmit.
* @return MICROBIT_OK on success.
*/
int MicroBitRadioDatagram::send(ManagedString data)
int MicroBitRadioDatagram::send(PacketBuffer data)
{
return send((uint8_t *)data.toCharArray(), data.length());
return send((uint8_t *)data.getBytes(), data.length());
}
/**
@ -108,7 +108,7 @@ int MicroBitRadioDatagram::send(ManagedString data)
*/
void MicroBitRadioDatagram::packetReceived()
{
PacketBuffer *packet = uBit.radio.recv();
FrameBuffer *packet = uBit.radio.recv();
int queueDepth = 0;
// We add to the tail of the queue to preserve causal ordering.
@ -120,7 +120,7 @@ void MicroBitRadioDatagram::packetReceived()
}
else
{
PacketBuffer *p = rxQueue;
FrameBuffer *p = rxQueue;
while (p->next != NULL)
{
p = p->next;

4
source/ble-services/MicroBitRadioEvent.cpp
View File

@ -55,7 +55,7 @@ int MicroBitRadioEvent::ignore(uint16_t id, uint16_t value)
*/
void MicroBitRadioEvent::packetReceived()
{
PacketBuffer *p = uBit.radio.recv();
FrameBuffer *p = uBit.radio.recv();
MicroBitEvent *e = (MicroBitEvent *) p->payload;
suppressForwarding = true;
@ -75,7 +75,7 @@ void MicroBitRadioEvent::eventReceived(MicroBitEvent e)
if(suppressForwarding)
return;
PacketBuffer buf;
FrameBuffer buf;
buf.length = sizeof(MicroBitEvent) + MICROBIT_RADIO_HEADER_SIZE - 1;
buf.version = 1;