uint8_t BayRF24::sendPayload(void) {
if (_powerdown)
powerUp();
else
stopListening();
openWritingPipe (_pipe);
uint8_t res;
res = RF24::write(getPayload(), getPacketLength());
uint8_t curr_pa = 0;
while (!res && curr_pa < 4) {
setPALevel((rf24_pa_dbm_e) curr_pa);
delayMicroseconds(random(2000));
res = RF24::write(getPayload(), getPacketLength());
curr_pa++;
}
if (_powerdown)
powerDown();
else {
txStandBy();
startListening();
}
return !res;
}
void DS2Packet::printPacket(FILE* file) const
{
if(type == DS2_8BIT)
{
fprintf(file, "0x%02x 0x%02x ", getAddress(), getPacketLength());
}
else if(type == DS2_16BIT)
{
fprintf(file, "0x%02x 0x%02x 0x%02x ", getAddress(), getPacketLength() >> 8, getPacketLength() & 0xff);
}
void Client::parseTransmit()
{
qDebug() << "parseTransmit():";
if ( !(this->status_ == ST_ADMIN ||
this->status_ == ST_CLIENT))
{
qDebug() << "cmd not allowed";
this->disconnectFromHost();
return;
}
if (buf_.size()<9) // TODO: remove magic number
return; // not all data avaliable
qDebug() << "buf size" << buf_.size();
qDebug() << "packet len" << getPacketLength(buf_);
if (buf_.size()<getPacketLength(buf_)+9) // TODO: remove magic number
return; // not all data avaliable
qint16 clientId=getClientId(buf_);
QByteArray cmd=getPacketData(buf_);
QByteArray response;
response.append(CSPYP1_PROTOCOL_ID);
response.append(CSPYP1_PROTOCOL_VERSION);
response.append(CMD1_TRANSMIT);
response.append(toBytes(getId()));
response.append(toBytes(cmd.size()));
response.append(cmd);
auto destClient = getServer()->searchClient(clientId);
qDebug() << "Client to ID:" << clientId;
if (destClient != getServer()->clientEnd())
{
qDebug() << "transmiting data..";
destClient.value()->send(response);
}
buf_=buf_.right(buf_.size() - (getPacketLength(buf_) + 9));
if (buf_.size() > 0)
onDataReceived(); // If something in buffer - parse again
}
bool OctreeQueryNode::packetIsDuplicate() const {
// if shutting down, return immediately
if (_isShuttingDown) {
return false;
}
// since our packets now include header information, like sequence number, and createTime, we can't just do a memcmp
// of the entire packet, we need to compare only the packet content...
int numBytesPacketHeader = numBytesForPacketHeaderGivenPacketType(_myPacketType);
if (_lastOctreePacketLength == getPacketLength()) {
if (memcmp(_lastOctreePacket + (numBytesPacketHeader + OCTREE_PACKET_EXTRA_HEADERS_SIZE),
_octreePacket + (numBytesPacketHeader + OCTREE_PACKET_EXTRA_HEADERS_SIZE),
getPacketLength() - (numBytesPacketHeader + OCTREE_PACKET_EXTRA_HEADERS_SIZE)) == 0) {
return true;
}
}
return false;
}
uint8_t checksum(char * packet)
{
uint8_t checksum, i;
// packet_len = getTypeLength(mypacket->data_type) + 3;
for (i = 0; i < getPacketLength(packet) - 1; i++)
checksum += packet[i];
checksum = !checksum + 1;
return checksum;
}
void OctreeQueryNode::resetOctreePacket() {
// if shutting down, return immediately
if (_isShuttingDown) {
return;
}
// Whenever we call this, we will keep a copy of the last packet, so we can determine if the last packet has
// changed since we last reset it. Since we know that no two packets can ever be identical without being the same
// scene information, (e.g. the root node packet of a static scene), we can use this as a strategy for reducing
// packet send rate.
_lastOctreePacketLength = getPacketLength();
memcpy(_lastOctreePacket, _octreePacket, _lastOctreePacketLength);
// If we're moving, and the client asked for low res, then we force monochrome, otherwise, use
// the clients requested color state.
_currentPacketIsColor = getWantColor();
_currentPacketIsCompressed = getWantCompression();
OCTREE_PACKET_FLAGS flags = 0;
if (_currentPacketIsColor) {
setAtBit(flags,PACKET_IS_COLOR_BIT);
}
if (_currentPacketIsCompressed) {
setAtBit(flags,PACKET_IS_COMPRESSED_BIT);
}
_octreePacketAvailableBytes = MAX_PACKET_SIZE;
int numBytesPacketHeader = populatePacketHeader(reinterpret_cast<char*>(_octreePacket), _myPacketType);
_octreePacketAt = _octreePacket + numBytesPacketHeader;
_octreePacketAvailableBytes -= numBytesPacketHeader;
// pack in flags
OCTREE_PACKET_FLAGS* flagsAt = (OCTREE_PACKET_FLAGS*)_octreePacketAt;
*flagsAt = flags;
_octreePacketAt += sizeof(OCTREE_PACKET_FLAGS);
_octreePacketAvailableBytes -= sizeof(OCTREE_PACKET_FLAGS);
// pack in sequence number
OCTREE_PACKET_SEQUENCE* sequenceAt = (OCTREE_PACKET_SEQUENCE*)_octreePacketAt;
*sequenceAt = _sequenceNumber;
_octreePacketAt += sizeof(OCTREE_PACKET_SEQUENCE);
_octreePacketAvailableBytes -= sizeof(OCTREE_PACKET_SEQUENCE);
// pack in timestamp
OCTREE_PACKET_SENT_TIME now = usecTimestampNow();
OCTREE_PACKET_SENT_TIME* timeAt = (OCTREE_PACKET_SENT_TIME*)_octreePacketAt;
*timeAt = now;
_octreePacketAt += sizeof(OCTREE_PACKET_SENT_TIME);
_octreePacketAvailableBytes -= sizeof(OCTREE_PACKET_SENT_TIME);
_octreePacketWaiting = false;
}
void VoxelNodeData::resetVoxelPacket() {
// Whenever we call this, we will keep a copy of the last packet, so we can determine if the last packet has
// changed since we last reset it. Since we know that no two packets can ever be identical without being the same
// scene information, (e.g. the root node packet of a static scene), we can use this as a strategy for reducing
// packet send rate.
_lastVoxelPacketLength = getPacketLength();
memcpy(_lastVoxelPacket, _voxelPacket, _lastVoxelPacketLength);
// If we're moving, and the client asked for low res, then we force monochrome, otherwise, use
// the clients requested color state.
_currentPacketIsColor = (LOW_RES_MONO && getWantLowResMoving() && _viewFrustumChanging) ? false : getWantColor();
PACKET_TYPE voxelPacketType = _currentPacketIsColor ? PACKET_TYPE_VOXEL_DATA : PACKET_TYPE_VOXEL_DATA_MONOCHROME;
int numBytesPacketHeader = populateTypeAndVersion(_voxelPacket, voxelPacketType);
_voxelPacketAt = _voxelPacket + numBytesPacketHeader;
_voxelPacketAvailableBytes = MAX_VOXEL_PACKET_SIZE - numBytesPacketHeader;
_voxelPacketWaiting = false;
}
void Header::prependSerializedHeader(vpr::BufferObjectWriter* packetWriter)
{
// Set Packet length
setPacketLength( packetWriter->getData()->size() + RIM_PACKET_HEAD_SIZE );
std::vector<vpr::Uint8> header_data;
vpr::BufferObjectWriter writer( &header_data );
// Serialize all header data.
writer.writeUint16( mRIMCode );
writer.writeUint16( mPacketType );
writer.writeUint32( mFrame );
writer.writeUint32( mPacketLength );
// Prepend header onto packets data
packetWriter->getData()->insert( packetWriter->getData()->begin(),
header_data.begin(),
header_data.end() );
packetWriter->setCurPos( getPacketLength() );
}
void OctreeQueryNode::octreePacketSent() {
packetSent(_octreePacket, getPacketLength());
}
uint8_t ZBRxResponse::getDataLength() {
return getPacketLength() - getDataOffset() - 1;
}
/** Checks for availability of a valid response packet.
*
* This function should always be called and return true prior to using results
* of a command.
*
* @returns true if a valid response packet is available
*/
boolean SM130::available()
{
// If in SEEK mode and using DREADY pin, check the status
if (cmd == CMD_SEEK_TAG && pinDREADY != 0xff)
{
if (!digitalRead(pinDREADY))
return false;
}
// Set the maximum length of the expected response packet
byte len;
switch(cmd)
{
case CMD_ANTENNA_POWER:
case CMD_AUTHENTICATE:
case CMD_DEC_VALUE:
case CMD_INC_VALUE:
case CMD_WRITE_KEY:
case CMD_HALT_TAG:
case CMD_SLEEP:
len = 4;
break;
case CMD_WRITE4:
case CMD_WRITE_VALUE:
case CMD_READ_VALUE:
len = 8;
case CMD_SEEK_TAG:
case CMD_SELECT_TAG:
len = 11;
break;
default:
len = SIZE_PACKET;
}
// If valid data received, process the response packet
if (receiveData(len) > 0)
{
// Init response variables
tagType = tagLength = *tagString = 0;
// If packet length is 2, the command failed. Set error code.
errorCode = getPacketLength() < 3 ? data[2] : 0;
// Process command response
switch (getCommand())
{
case CMD_RESET:
case CMD_VERSION:
// RESET and VERSION commands produce the firmware version
len = min(getPacketLength(), sizeof(versionString)) - 1;
memcpy(versionString, data + 2, len);
versionString[len] = 0;
break;
case CMD_SEEK_TAG:
case CMD_SELECT_TAG:
// If no error, get tag number
if(errorCode == 0 && getPacketLength() >= 6)
{
tagLength = getPacketLength() - 2;
tagType = data[2];
memcpy(tagNumber, data + 3, tagLength);
arrayToHex(tagString, tagNumber, tagLength);
}
break;
case CMD_AUTHENTICATE:
break;
case CMD_READ16:
break;
case CMD_WRITE16:
case CMD_WRITE4:
break;
case CMD_ANTENNA_POWER:
errorCode = 0;
antennaPower = data[2];
break;
case CMD_SLEEP:
// If in SLEEP mode, no data is available
return false;
}
// Data available
return true;
}
// No data available
return false;
}
/*
** Return a pointer to the error block.
*/
PTR_ret findPacketV1ErrorStart (PACKET_ptr packet_ptr)
{
return (packet_ptr + getPacketLength(packet_ptr) -
getPacketV1ErrorLength(packet_ptr));
}
/** Checks for availability of a valid response packet.
*
* This function should always be called and return true prior to using results
* of a command.
*
* @returns true if a valid response packet is available
*/
boolean SL018::available()
{
// Set the maximum length of the expected response packet
byte len;
switch(cmd)
{
case CMD_IDLE:
case CMD_RESET:
len = 0;
break;
case CMD_LOGIN:
case CMD_SET_LED:
case CMD_SLEEP:
len = 3;
break;
case CMD_READ4:
case CMD_WRITE4:
case CMD_READ_VALUE:
case CMD_WRITE_VALUE:
case CMD_DEC_VALUE:
case CMD_INC_VALUE:
case CMD_COPY_VALUE:
len = 7;
break;
case CMD_WRITE_KEY:
len = 9;
break;
case CMD_SEEK:
case CMD_SELECT:
len = 11;
break;
default:
len = SIZE_PACKET;
}
// If valid data received, process the response packet
if (len && receiveData(len) > 0)
{
// Init response variables
tagType = tagLength = *tagString = 0;
errorCode = data[2];
// Process command response
switch (getCommand())
{
case CMD_SEEK:
case CMD_SELECT:
// If no error, get tag number
if(errorCode == 0 && getPacketLength() >= 7)
{
tagLength = getPacketLength() - 3;
tagType = data[getPacketLength()];
memcpy(tagNumber, data + 3, tagLength);
arrayToHex(tagString, tagNumber, tagLength);
}
else if(cmd == CMD_SEEK)
{
// Continue seek
seekTag();
return false;
}
}
// Data is available
return true;
}
// No data available
return false;
}
bool VoxelNodeData::packetIsDuplicate() const {
if (_lastVoxelPacketLength == getPacketLength()) {
return memcmp(_lastVoxelPacket, _voxelPacket, getPacketLength()) == 0;
}
return false;
}
QByteArray getPacketData(const QByteArray& buffer)
{
return buffer.mid(9,getPacketLength(buffer));
}
void readPacket() {
// reset previous response
if ((_response_Available == true) || (_response_ERROR > 0)) {
// discard previous packet and start over
resetResponse();
}
while (uart_available()) {
b = uart_getc();
if (_pos > 0 && b == START_BYTE && ATAP == 2) {
// new packet start before previous packeted completed -- discard previous packet and start over
_response_ERROR = UNEXPECTED_START_BYTE;
uart_putc(_response_ERROR);
return;
}
if (_pos > 0 && b == ESCAPE) {
if (uart_available()) {
b = uart_getc();
b = 0x20 ^ b;
} else {
// escape byte. next byte will be
_escape = true;
continue;
}
}
if (_escape == true) {
b = 0x20 ^ b;
_escape = false;
}
// checksum includes all bytes starting with api id
if (_pos >= API_ID_INDEX) {
_checksumTotal+= b;
}
switch(_pos) {
case 0:
if (b == START_BYTE) {
_pos++;
}
break;
case 1:
// length msb
_response_MsbLength = b;
_pos++;
break;
case 2:
// length lsb
_response_LsbLength = b;
_pos++;
break;
case 3:
_response_ApiId = b;
_pos++;
break;
default:
// starts at fifth byte
if (_pos > MAX_FRAME_DATA_SIZE) {
// exceed max size. should never occur
_response_ERROR = PACKET_EXCEEDS_BYTE_ARRAY_LENGTH;
uart_putc(_response_ERROR);
return;
}
// check if we're at the end of the packet
// packet length does not include start, length, or checksum bytes, so add 3
if (_pos == (getPacketLength() + 3)) {
// verify checksum
if ((_checksumTotal & 0xff) == 0xff) {
_response_Checksum = b;
_response_Available = true;
//no check
//uart_puts_P("OK\n");///////////////////////////
//DDRA = 0x02;////////////////////////////////////
//PORTA = 0x02;//////////////////////////
_response_ERROR = NO_ERROR;
} else {
// checksum failed
_response_ERROR = CHECKSUM_FAILURE;
uart_putc(_response_ERROR);
}
// minus 4 because we start after start,msb,lsb,api and up to but not including checksum
// e.g. if frame was one byte, _pos=4 would be the byte, pos=5 is the checksum, where end stop reading
_response_FrameLength = (_pos - 4);
// reset state vars
_pos = 0;
_checksumTotal = 0;
return;
} else {
// add to packet array, starting with the fourth byte of the apiFrame
_response_FrameData[_pos - 4] = b;
_pos++;
}
}
}
}
