#include "AX25.h" AX25Frame::AX25Frame(const char* destCallsign, uint8_t destSSID, const char* srcCallsign, uint8_t srcSSID, uint8_t control) : AX25Frame(destCallsign, destSSID, srcCallsign, srcSSID, control, 0, NULL, 0) { } AX25Frame::AX25Frame(const char* destCallsign, uint8_t destSSID, const char* srcCallsign, uint8_t srcSSID, uint8_t control, uint8_t protocolID, const char* info) : AX25Frame(destCallsign, destSSID, srcCallsign, srcSSID, control, protocolID, (uint8_t*)info, strlen(info)) { } AX25Frame::AX25Frame(const char* destCallsign, uint8_t destSSID, const char* srcCallsign, uint8_t srcSSID, uint8_t control, uint8_t protocolID, uint8_t* info, uint16_t infoLen) { // destination callsign/SSID memcpy(this->destCallsign, destCallsign, strlen(destCallsign)); this->destCallsign[strlen(destCallsign)] = '\0'; this->destSSID = destSSID; // source callsign/SSID memcpy(this->srcCallsign, srcCallsign, strlen(srcCallsign)); this->srcCallsign[strlen(srcCallsign)] = '\0'; this->srcSSID = srcSSID; // set repeaters this->numRepeaters = 0; #ifndef RADIOLIB_STATIC_ONLY this->repeaterCallsigns = NULL; this->repeaterSSIDs = NULL; #endif // control field this->control = control; // sequence numbers this->rcvSeqNumber = 0; this->sendSeqNumber = 0; // PID field this->protocolID = protocolID; // info field this->infoLen = infoLen; if(infoLen > 0) { #ifndef RADIOLIB_STATIC_ONLY this->info = new uint8_t[infoLen]; #endif memcpy(this->info, info, infoLen); } } AX25Frame::~AX25Frame() { #ifndef RADIOLIB_STATIC_ONLY // deallocate info field if(infoLen > 0) { delete[] this->info; } // deallocate repeaters if(this->numRepeaters > 0) { for(uint8_t i = 0; i < this->numRepeaters; i++) { delete[] this->repeaterCallsigns[i]; } delete[] this->repeaterCallsigns; delete[] this->repeaterSSIDs; } #endif } int16_t AX25Frame::setRepeaters(char** repeaterCallsigns, uint8_t* repeaterSSIDs, uint8_t numRepeaters) { // check number of repeaters if((numRepeaters < 1) || (numRepeaters > 8)) { return(ERR_INVALID_NUM_REPEATERS); } // check repeater configuration if(!(((repeaterCallsigns == NULL) && (repeaterSSIDs == NULL) && (numRepeaters == 0)) || ((repeaterCallsigns != NULL) && (repeaterSSIDs != NULL) && (numRepeaters != 0)))) { return(ERR_INVALID_NUM_REPEATERS); } for(uint16_t i = 0; i < numRepeaters; i++) { if(strlen(repeaterCallsigns[i]) > AX25_MAX_CALLSIGN_LEN) { return(ERR_INVALID_REPEATER_CALLSIGN); } } // create buffers #ifndef RADIOLIB_STATIC_ONLY this->repeaterCallsigns = new char*[numRepeaters]; for(uint8_t i = 0; i < numRepeaters; i++) { this->repeaterCallsigns[i] = new char[strlen(repeaterCallsigns[i])]; } this->repeaterSSIDs = new uint8_t[numRepeaters]; #endif // copy data this->numRepeaters = numRepeaters; for(uint8_t i = 0; i < numRepeaters; i++) { memcpy(this->repeaterCallsigns[i], repeaterCallsigns[i], strlen(repeaterCallsigns[i])); } memcpy(this->repeaterSSIDs, repeaterSSIDs, numRepeaters); return(ERR_NONE); } void AX25Frame::setRecvSequence(uint8_t seqNumber) { this->rcvSeqNumber = seqNumber; } void AX25Frame::setSendSequence(uint8_t seqNumber) { this->sendSeqNumber = seqNumber; } AX25Client::AX25Client(PhysicalLayer* phy) { _phy = phy; _audio = nullptr; } AX25Client::AX25Client(AFSKClient* audio) { _phy = audio->_phy; _audio = audio; } int16_t AX25Client::begin(const char* srcCallsign, uint8_t srcSSID, uint8_t preambleLen) { // set source SSID _srcSSID = srcSSID; // check source callsign length (6 characters max) if(strlen(srcCallsign) > AX25_MAX_CALLSIGN_LEN) { return(ERR_INVALID_CALLSIGN); } // copy callsign memcpy(_srcCallsign, srcCallsign, strlen(srcCallsign)); _srcCallsign[strlen(srcCallsign)] = '\0'; // save preamble length _preambleLen = preambleLen; // set module frequency deviation to 0 if using FSK int16_t state = ERR_NONE; if(_audio == nullptr) { state = _phy->setFrequencyDeviation(0); RADIOLIB_ASSERT(state); state = _phy->setEncoding(0); } return(state); } int16_t AX25Client::transmit(const char* str, const char* destCallsign, uint8_t destSSID) { // create control field uint8_t controlField = AX25_CONTROL_U_UNNUMBERED_INFORMATION | AX25_CONTROL_POLL_FINAL_DISABLED | AX25_CONTROL_UNNUMBERED_FRAME; // build the frame AX25Frame frame(destCallsign, destSSID, _srcCallsign, _srcSSID, controlField, AX25_PID_NO_LAYER_3, (uint8_t*)str, strlen(str)); // send Unnumbered Information frame return(sendFrame(&frame)); } int16_t AX25Client::sendFrame(AX25Frame* frame) { // check destination callsign length (6 characters max) if(strlen(frame->destCallsign) > AX25_MAX_CALLSIGN_LEN) { return(ERR_INVALID_CALLSIGN); } // check repeater configuration #ifndef RADIOLIB_STATIC_ONLY if(!(((frame->repeaterCallsigns == NULL) && (frame->repeaterSSIDs == NULL) && (frame->numRepeaters == 0)) || ((frame->repeaterCallsigns != NULL) && (frame->repeaterSSIDs != NULL) && (frame->numRepeaters != 0)))) { return(ERR_INVALID_NUM_REPEATERS); } for(uint16_t i = 0; i < frame->numRepeaters; i++) { if(strlen(frame->repeaterCallsigns[i]) > AX25_MAX_CALLSIGN_LEN) { return(ERR_INVALID_REPEATER_CALLSIGN); } } #endif // calculate frame length without FCS (destination address, source address, repeater addresses, control, PID, info) size_t frameBuffLen = ((2 + frame->numRepeaters)*(AX25_MAX_CALLSIGN_LEN + 1)) + 1 + 1 + frame->infoLen; // create frame buffer without preamble, start or stop flags #ifndef RADIOLIB_STATIC_ONLY uint8_t* frameBuff = new uint8_t[frameBuffLen + 2]; #else uint8_t frameBuff[RADIOLIB_STATIC_ARRAY_SIZE]; #endif uint8_t* frameBuffPtr = frameBuff; // set destination callsign - all address field bytes are shifted by one bit to make room for HDLC address extension bit memset(frameBuffPtr, ' ' << 1, AX25_MAX_CALLSIGN_LEN); for(uint8_t i = 0; i < strlen(frame->destCallsign); i++) { *(frameBuffPtr + i) = frame->destCallsign[i] << 1; } frameBuffPtr += AX25_MAX_CALLSIGN_LEN; // set destination SSID *(frameBuffPtr++) = AX25_SSID_COMMAND_DEST | AX25_SSID_RESERVED_BITS | (frame->destSSID & 0x0F) << 1 | AX25_SSID_HDLC_EXTENSION_CONTINUE; // set source callsign - all address field bytes are shifted by one bit to make room for HDLC address extension bit memset(frameBuffPtr, ' ' << 1, AX25_MAX_CALLSIGN_LEN); for(uint8_t i = 0; i < strlen(frame->srcCallsign); i++) { *(frameBuffPtr + i) = frame->srcCallsign[i] << 1; } frameBuffPtr += AX25_MAX_CALLSIGN_LEN; // set source SSID *(frameBuffPtr++) = AX25_SSID_COMMAND_SOURCE | AX25_SSID_RESERVED_BITS | (frame->srcSSID & 0x0F) << 1 | AX25_SSID_HDLC_EXTENSION_END; // set repeater callsigns for(uint16_t i = 0; i < frame->numRepeaters; i++) { memset(frameBuffPtr, ' ' << 1, AX25_MAX_CALLSIGN_LEN); for(uint8_t j = 0; j < strlen(frame->repeaterCallsigns[i]); j++) { *(frameBuffPtr + j) = frame->repeaterCallsigns[i][j] << 1; } frameBuffPtr += AX25_MAX_CALLSIGN_LEN; *(frameBuffPtr++) = AX25_SSID_HAS_NOT_BEEN_REPEATED | AX25_SSID_RESERVED_BITS | (frame->repeaterSSIDs[i] & 0x0F) << 1 | AX25_SSID_HDLC_EXTENSION_CONTINUE; } // set HDLC extension end bit *frameBuffPtr |= AX25_SSID_HDLC_EXTENSION_END; // set sequence numbers of the frames that have it uint8_t controlField = frame->control; if((frame->control & 0x01) == 0) { // information frame, set both sequence numbers controlField |= frame->rcvSeqNumber << 5; controlField |= frame->sendSeqNumber << 1; } else if((frame->control & 0x02) == 0) { // supervisory frame, set only receive sequence number controlField |= frame->rcvSeqNumber << 5; } // set control field *(frameBuffPtr++) = controlField; // set PID field of the frames that have it if(frame->protocolID != 0x00) { *(frameBuffPtr++) = frame->protocolID; } // set info field of the frames that have it if(frame->infoLen > 0) { memcpy(frameBuffPtr, frame->info, frame->infoLen); frameBuffPtr += frame->infoLen; } // flip bit order for(size_t i = 0; i < frameBuffLen; i++) { frameBuff[i] = flipBits(frameBuff[i]); } // calculate FCS uint16_t fcs = getFrameCheckSequence(frameBuff, frameBuffLen); *(frameBuffPtr++) = (uint8_t)((fcs >> 8) & 0xFF); *(frameBuffPtr++) = (uint8_t)(fcs & 0xFF); // prepare buffer for the final frame (stuffed, with added preamble + flags and NRZI-encoded) #ifndef RADIOLIB_STATIC_ONLY // worst-case scenario: sequence of 1s, will have 120% of the original length, stuffed frame also includes both flags uint8_t* stuffedFrameBuff = new uint8_t[_preambleLen + 1 + (6*frameBuffLen)/5 + 2]; #else uint8_t stuffedFrameBuff[RADIOLIB_STATIC_ARRAY_SIZE]; #endif // stuff bits (skip preamble and both flags) uint16_t stuffedFrameBuffLenBits = 8*(_preambleLen + 1); uint8_t count = 0; for(uint16_t i = 0; i < frameBuffLen + 2; i++) { for(int8_t shift = 7; shift >= 0; shift--) { uint16_t stuffedFrameBuffPos = stuffedFrameBuffLenBits + 7 - 2*(stuffedFrameBuffLenBits%8); if((frameBuff[i] >> shift) & 0x01) { // copy 1 and increment counter SET_BIT_IN_ARRAY(stuffedFrameBuff, stuffedFrameBuffPos); stuffedFrameBuffLenBits++; count++; // check 5 consecutive 1s if(count == 5) { // get the new position in stuffed frame stuffedFrameBuffPos = stuffedFrameBuffLenBits + 7 - 2*(stuffedFrameBuffLenBits%8); // insert 0 and reset counter CLEAR_BIT_IN_ARRAY(stuffedFrameBuff, stuffedFrameBuffPos); stuffedFrameBuffLenBits++; count = 0; } } else { // copy 0 and reset counter CLEAR_BIT_IN_ARRAY(stuffedFrameBuff, stuffedFrameBuffPos); stuffedFrameBuffLenBits++; count = 0; } } } // deallocate memory #ifndef RADIOLIB_STATIC_ONLY delete[] frameBuff; #endif // set preamble bytes and start flag field for(uint16_t i = 0; i < _preambleLen + 1; i++) { stuffedFrameBuff[i] = AX25_FLAG; } // get stuffed frame length in bytes size_t stuffedFrameBuffLen = stuffedFrameBuffLenBits/8 + 1; uint8_t trailingLen = stuffedFrameBuffLenBits % 8; // set end flag field (may be split into two bytes due to misalignment caused by extra stuffing bits) if(trailingLen != 0) { stuffedFrameBuffLen++; stuffedFrameBuff[stuffedFrameBuffLen - 2] = AX25_FLAG >> trailingLen; stuffedFrameBuff[stuffedFrameBuffLen - 1] = AX25_FLAG << (8 - trailingLen); } else { stuffedFrameBuff[stuffedFrameBuffLen - 1] = AX25_FLAG; } // convert to NRZI for(size_t i = _preambleLen + 1; i < stuffedFrameBuffLen*8; i++) { size_t currBitPos = i + 7 - 2*(i%8); size_t prevBitPos = (i - 1) + 7 - 2*((i - 1)%8); if(TEST_BIT_IN_ARRAY(stuffedFrameBuff, currBitPos)) { // bit is 1, no change, copy previous bit if(TEST_BIT_IN_ARRAY(stuffedFrameBuff, prevBitPos)) { SET_BIT_IN_ARRAY(stuffedFrameBuff, currBitPos); } else { CLEAR_BIT_IN_ARRAY(stuffedFrameBuff, currBitPos); } } else { // bit is 0, transition, copy inversion of the previous bit if(TEST_BIT_IN_ARRAY(stuffedFrameBuff, prevBitPos)) { CLEAR_BIT_IN_ARRAY(stuffedFrameBuff, currBitPos); } else { SET_BIT_IN_ARRAY(stuffedFrameBuff, currBitPos); } } } // transmit int16_t state = ERR_NONE; if(_audio == nullptr) { state = _phy->transmit(stuffedFrameBuff, stuffedFrameBuffLen); } else { _phy->transmitDirect(); // iterate over all bytes in the buffer for(uint32_t i = 0; i < stuffedFrameBuffLen; i++) { // check each bit for(uint16_t mask = 0x80; mask >= 0x01; mask >>= 1) { uint32_t start = micros(); if(stuffedFrameBuff[i] & mask) { _audio->tone(AX25_AFSK_MARK, false); } else { _audio->tone(AX25_AFSK_SPACE, false); } while(micros() - start < 833) { yield(); } } } _audio->noTone(); } // deallocate memory #ifndef RADIOLIB_STATIC_ONLY delete[] stuffedFrameBuff; #endif return(state); } /* CCITT CRC implementation based on https://github.com/kicksat/ax25 Licensed under Creative Commons Attribution-ShareAlike 4.0 International https://creativecommons.org/licenses/by-sa/4.0/ */ uint16_t AX25Client::getFrameCheckSequence(uint8_t* buff, size_t len) { uint8_t outBit = 0; uint16_t mask = 0x0000; uint16_t shiftReg = CRC_CCITT_INIT; for(size_t i = 0; i < len; i++) { for(uint8_t b = 0x80; b > 0x00; b /= 2) { outBit = (shiftReg & 0x01) ? 0x01 : 0x00; shiftReg >>= 1; mask = XOR((buff[i] & b), outBit) ? CRC_CCITT_POLY_REVERSED : 0x0000; shiftReg ^= mask; } } return(flipBits16(~shiftReg)); } uint8_t AX25Client::flipBits(uint8_t b) { b = (b & 0xF0) >> 4 | (b & 0x0F) << 4; b = (b & 0xCC) >> 2 | (b & 0x33) << 2; b = (b & 0xAA) >> 1 | (b & 0x55) << 1; return b; } uint16_t AX25Client::flipBits16(uint16_t i) { i = (i & 0xFF00) >> 8 | (i & 0x00FF) << 8; i = (i & 0xF0F0) >> 4 | (i & 0x0F0F) << 4; i = (i & 0xCCCC) >> 2 | (i & 0x3333) << 2; i = (i & 0xAAAA) >> 1 | (i & 0x5555) << 1; return i; }