bufferStruct receiveSendData(bufferStruct buffer){
bufferStruct result;
if(getAck(buffer.bufferLength, buffer.buffer) & NEED_ACK > 0){
#if STATE_UART_DEBUG >= 2
uart_putstr ("seAck\r\n");
#endif
state = STATE_SENDING_ACK;
backupData.bufferLength = buffer.bufferLength;
memcpy(backupData.buffer, buffer.buffer, buffer.bufferLength);
sendAck(buffer);
} else {
result.bufferLength = getPayloadLength(buffer.bufferLength, buffer.buffer);
memcpy(result.buffer, getPayload(buffer.bufferLength, buffer.buffer), result.bufferLength);
#if STATE_UART_DEBUG >= 3
uart_putc('%');
uart_putc(result.bufferLength);
uart_putc('%');
for(uint8_t i = 0; i < result.bufferLength; ++i){
uart_putc(result.buffer[i]);
}
uart_putc('%');
#endif
}
return result;
}
TEST(RFM69W, getPayloadLength) {
unsigned int l;
std::queue<int> responses;
std::queue<std::tuple<unsigned char, unsigned char>> resps;
resps.push(std::make_tuple(0x38, 0x00));
resps.push(std::make_tuple(0x00, 0x40));
EXPECT_EQ(0, getPayloadLength(&l, fakeSpiFun, &resps));
EXPECT_EQ(64, l);
}
int main(void)
{
uint8_t src_packet[128] = {0x05, 0x30, 0x00, 0x00, 0x0A};
uint8_t rcvd_msg[128] = {0};
uint8_t rcvd_payload[128] = {0};
uint8_t rcvd_length;
uint8_t rcvd_payloadLength;
uint8_t rcvd_rssi;
uint8_t Type;
uint16_t Addr;
uint8_t radio_channel;
uint16_t radio_panID;
Type = Type_Light;
Addr = 0x0001;
radio_channel = 18;
radio_panID = 0x00AA;
Initial(Addr, Type, radio_channel, radio_panID);
setTimer(1,RETRANSMIT_PERIOD,UNIT_MS);
while(1){
// Periodically send the msg
if(checkTimer(1)){
RF_Tx(0xFFFF,src_packet,5);
}
// When received some packet
if(RF_Rx(rcvd_msg, &rcvd_length, &rcvd_rssi)){
getPayloadLength(&rcvd_payloadLength, rcvd_msg);
getPayload(rcvd_payload, rcvd_msg, rcvd_payloadLength);
// Check 1)header, 2)sequence number, 3)isACK field
if(rcvd_payload[0]==0x05 && rcvd_payload[1]==0x30 &&
rcvd_payload[2]==src_packet[2] && rcvd_payload[3]==1){
src_packet[2]++;
// Change the payload here
}
}
if(src_packet[2]==0x14)
break;
}
while(1){
if(checkTimer(1)){
setGPIO(1,1);
}
}
}
enum wsFrameType wsParseInputFrame(uint8_t *inputFrame, size_t inputLength,
uint8_t **dataPtr, size_t *dataLength)
{
assert(inputFrame && inputLength);
if (inputLength < 2)
return WS_INCOMPLETE_FRAME;
if ((inputFrame[0] & 0x70) != 0x0) // checks extensions off
return WS_ERROR_FRAME;
if ((inputFrame[0] & 0x80) != 0x80) // we haven't continuation frames support
return WS_ERROR_FRAME; // so, fin flag must be set
if ((inputFrame[1] & 0x80) != 0x80) // checks masking bit
return WS_ERROR_FRAME;
uint8_t opcode = inputFrame[0] & 0x0F;
if (opcode == WS_TEXT_FRAME ||
opcode == WS_BINARY_FRAME ||
opcode == WS_CLOSING_FRAME ||
opcode == WS_PING_FRAME ||
opcode == WS_PONG_FRAME
)
{
enum wsFrameType frameType = opcode;
uint8_t payloadFieldExtraBytes = 0;
size_t payloadLength = getPayloadLength(inputFrame, inputLength,
&payloadFieldExtraBytes, &frameType);
if (payloadLength > 0) {
if (payloadLength < inputLength-6-payloadFieldExtraBytes) // 4-maskingKey, 2-header
return WS_INCOMPLETE_FRAME;
uint8_t *maskingKey = &inputFrame[2 + payloadFieldExtraBytes];
assert(payloadLength == inputLength-6-payloadFieldExtraBytes);
*dataPtr = &inputFrame[2 + payloadFieldExtraBytes + 4];
*dataLength = payloadLength;
uint8_t i;
for (i = 0; i < *dataLength; i++) {
(*dataPtr)[i] = (*dataPtr)[i] ^ maskingKey[i%4];
}
}
return frameType;
}
return WS_ERROR_FRAME;
}
void HttpServer::processWebSocketFrame(pbuf *buf, HttpServerConnection& connection)
{
//TODO: process splitted payload
uint8_t* data; size_t size;
wsFrameType frameType = (wsFrameType) 0x01;
uint8_t payloadFieldExtraBytes = 0;
size_t payloadLength = 0;
size_t payloadShift = 0;
do
{
payloadLength = getPayloadLength((uint8_t*)buf->payload + payloadShift, buf->len, &payloadFieldExtraBytes, &frameType);
// debugf("payloadLength: %u, payLoadShift: %u, payloadFieldExtraBytes: %u\n", payloadLength, payloadShift, payloadFieldExtraBytes);
wsFrameType frameType = wsParseInputFrame((uint8_t*)buf->payload + payloadShift, (payloadLength + 6 + payloadFieldExtraBytes), &data, &size);
WebSocket* sock = getWebSocket(connection);
if (frameType == WS_TEXT_FRAME)
{
String msg;
msg.setString((char*)data, size);
debugf("WS: %s", msg.c_str());
if (sock && wsMessage) wsMessage(*sock, msg);
#if ENABLE_CMD_EXECUTOR
if (sock && sock->commandExecutor) sock->commandExecutor->executorReceive(msg+"\r");
#endif
}
else if (frameType == WS_BINARY_FRAME)
{
if (sock && wsMessage) wsBinary(*sock, data, size);
}
else if (frameType == WS_CLOSING_FRAME)
{
connection.close(); // it will be processed automatically in onCloseWebSocket callback
}
else if (frameType == WS_INCOMPLETE_FRAME || frameType == WS_ERROR_FRAME)
debugf("WS error reading frame: %X", frameType);
else
debugf("WS frame type: %X", frameType);
payloadShift += payloadLength + 6 + payloadFieldExtraBytes;
}
while (buf->len > payloadShift);
}
bufferStruct checkReceiveData(bufferStruct buffer){
rfm12_tick(); //periodic tick function - call that one once in a while
switch(state){
case STATE_TIMEOUT:
#if STATE_UART_DEBUG >= 2
uart_putstr ("tiOu\r\n");
#endif
++timoutCounter;
if(timoutCounter > 5){
#if STATE_UART_DEBUG >= 2
uart_putstr ("tiOuOverl\r\n");
#endif
state = STATE_FREE;
stopTimer();
timoutCounter = 0;
} else {
processNack();
}
break;
case STATE_SENDING_ACK:
if(rfm12_tx_status() == STATUS_FREE){
state = STATE_SENDING_DATA;
#if STATE_UART_DEBUG >= 2
uart_putstr ("finSeAck\r\n");
#endif
bufferStruct result;
result.bufferLength = getPayloadLength(backupData.bufferLength, backupData.buffer);
memcpy(result.buffer, getPayload(backupData.bufferLength, backupData.buffer), result.bufferLength);
uart_putc('%');
uart_putc(result.bufferLength);
uart_putc('%');
for(uint8_t i = 0; i < result.bufferLength; ++i){
uart_putc(result.buffer[i]);
}
uart_putc('%');
return result;
}
case STATE_SENDING_DATA:
if(rfm12_tx_status() == STATUS_FREE){
#if STATE_UART_DEBUG >= 2
uart_putstr ("finSeData\r\n");
#endif
state = STATE_FREE;
}
}
//uart_putstr (rfm12_rx_status());
if (rfm12_rx_status() == STATUS_COMPLETE){
bufferStruct tempBuffer;
tempBuffer.bufferLength = rfm12_rx_len();
memcpy(tempBuffer.buffer, rfm12_rx_buffer(), tempBuffer.bufferLength);
if(validateCrc(tempBuffer)){
#if STATE_UART_DEBUG >= 2
uart_putstr ("crcAck\r\n");
#endif
} else {
#if STATE_UART_DEBUG >= 2
uart_putstr ("crcNack\r\n");
#endif
rfm12_rx_clear();
sendNack(tempBuffer);
return buffer;
}
if(state > STATE_FREE){
if(getAck(tempBuffer.bufferLength, tempBuffer.buffer) & ACK){
#if STATE_UART_DEBUG >= 2
uart_putstr ("rxAck\r\n");
#endif
processAck();
} else if(getType(tempBuffer.bufferLength, tempBuffer.buffer) & NACK){
#if STATE_UART_DEBUG >= 2
uart_putstr ("rxNack\r\n");
#endif
processNack();
}
}
if(state == STATE_FREE){
switch(getType(tempBuffer.bufferLength, tempBuffer.buffer)){
case SEND_DATA:
#if STATE_UART_DEBUG >= 2
uart_putstr ("send\r\n");
#endif
buffer = receiveSendData(tempBuffer);
break;
// here we should implement the cases of repeating data therefore we would have to know all last data sent
// here we should implement the get back to in -> timeframe not yet implemented
}
}
// tell the implementation that the buffer
// can be reused for the next data.
rfm12_rx_clear();
}
return buffer;
}
