You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
152 lines
3.5 KiB
152 lines
3.5 KiB
#include "EasyTransfer2.h"
|
|
|
|
|
|
|
|
|
|
//Captures address and size of struct
|
|
void EasyTransfer2::begin(HardwareSerial *theSerial){
|
|
_serial = theSerial;
|
|
|
|
//dynamic creation of rx parsing buffer in RAM
|
|
//rx_buffer = (uint8_t*) malloc(size);
|
|
|
|
resetData();
|
|
}
|
|
|
|
void EasyTransfer2::writeByte(uint8_t dat){
|
|
if(position<20)
|
|
data[position++]=dat;
|
|
size++;
|
|
}
|
|
void EasyTransfer2::writeInt(int dat){
|
|
if(position<19){
|
|
data[position++]=dat>>8;
|
|
data[position++]=dat;
|
|
size+=2;
|
|
}
|
|
}
|
|
uint8_t EasyTransfer2::readByte(){
|
|
if(position>=size)return 0;
|
|
return data[position++];
|
|
}
|
|
int EasyTransfer2::readInt(){
|
|
if(position+1>=size)return 0;
|
|
int dat_1=data[position++]<<8;
|
|
int dat_2=data[position++];
|
|
int dat= dat_1 | dat_2;
|
|
return dat;
|
|
}
|
|
|
|
void EasyTransfer2::resetData(){
|
|
for(int i=0;i<20;i++){
|
|
data[i]=0;
|
|
}
|
|
size=0;
|
|
position=0;
|
|
}
|
|
|
|
//Sends out struct in binary, with header, length info and checksum
|
|
void EasyTransfer2::sendData(){
|
|
uint8_t CS = size;
|
|
_serial->write(0x06);
|
|
_serial->write(0x85);
|
|
_serial->write(size);
|
|
for(int i = 0; i<size; i++){
|
|
CS^=*(data+i);
|
|
_serial->write(*(data+i));
|
|
//Serial.print(*(data+i));
|
|
//Serial.print(",");
|
|
}
|
|
//Serial.println("");
|
|
_serial->write(CS);
|
|
|
|
resetData();
|
|
}
|
|
|
|
boolean EasyTransfer2::receiveData(){
|
|
|
|
//start off by looking for the header bytes. If they were already found in a previous call, skip it.
|
|
if(rx_len == 0){
|
|
//this size check may be redundant due to the size check below, but for now I'll leave it the way it is.
|
|
if(_serial->available() >= 3){
|
|
//this will block until a 0x06 is found or buffer size becomes less then 3.
|
|
while(_serial->read() != 0x06) {
|
|
//This will trash any preamble junk in the serial buffer
|
|
//but we need to make sure there is enough in the buffer to process while we trash the rest
|
|
//if the buffer becomes too empty, we will escape and try again on the next call
|
|
if(_serial->available() < 3)
|
|
return false;
|
|
}
|
|
//Serial.println("head");
|
|
if (_serial->read() == 0x85){
|
|
rx_len = _serial->read();
|
|
//Serial.print("rx_len:");
|
|
//Serial.println(rx_len);
|
|
resetData();
|
|
|
|
//make sure the binary structs on both Arduinos are the same size.
|
|
/*if(rx_len != size){
|
|
rx_len = 0;
|
|
return false;
|
|
}*/
|
|
}
|
|
}
|
|
//Serial.println("nothing");
|
|
}
|
|
|
|
//we get here if we already found the header bytes, the struct size matched what we know, and now we are byte aligned.
|
|
if(rx_len != 0){
|
|
|
|
while(_serial->available() && rx_array_inx <= rx_len){
|
|
data[rx_array_inx++] = _serial->read();
|
|
}
|
|
|
|
if(rx_len == (rx_array_inx-1)){
|
|
//seem to have got whole message
|
|
//last uint8_t is CS
|
|
calc_CS = rx_len;
|
|
//Serial.print("len:");
|
|
//Serial.println(rx_len);
|
|
for (int i = 0; i<rx_len; i++){
|
|
calc_CS^=data[i];
|
|
//Serial.print("m");
|
|
//Serial.print(data[i]);
|
|
//Serial.print(",");
|
|
}
|
|
//Serial.println();
|
|
//Serial.print(data[rx_array_inx-1]);
|
|
//Serial.print(" ");
|
|
//Serial.println(calc_CS);
|
|
|
|
if(calc_CS == data[rx_array_inx-1]){//CS good
|
|
//resetData();
|
|
//memcpy(data,d,rx_len);
|
|
for(int i=0;i<20;i++){
|
|
//Serial.print(data[i]);
|
|
//Serial.print(",");
|
|
}
|
|
//Serial.println("");
|
|
size=rx_len;
|
|
rx_len = 0;
|
|
rx_array_inx = 0;
|
|
return true;
|
|
}
|
|
|
|
else{
|
|
//Serial.println("CS");
|
|
resetData();
|
|
//failed checksum, need to clear this out anyway
|
|
rx_len = 0;
|
|
rx_array_inx = 0;
|
|
return false;
|
|
}
|
|
|
|
}
|
|
}
|
|
//Serial.print(rx_len);
|
|
//Serial.print(" ");
|
|
//Serial.print(rx_array_inx);
|
|
//Serial.print(" ");
|
|
//Serial.println("Short");
|
|
return false;
|
|
} |