2017-11-20 16:54:06 +01:00
# include "SBNetwork.h"
# include <SPI.h>
# include <RF24.h>
# include <EEPROM.h>
void printAddress ( byte address [ 5 ] ) {
Serial . print ( " 0x " ) ;
Serial . print ( address [ 0 ] , HEX ) ;
Serial . print ( " 0x " ) ;
Serial . print ( address [ 1 ] , HEX ) ;
Serial . print ( " 0x " ) ;
Serial . print ( address [ 2 ] , HEX ) ;
Serial . print ( " 0x " ) ;
Serial . print ( address [ 3 ] , HEX ) ;
Serial . print ( " 0x " ) ;
Serial . print ( address [ 4 ] , HEX ) ;
}
void printDeviceData ( SBNetworkDevice & device ) {
Serial . print ( F ( " Device MAC = " ) ) ;
printAddress ( device . MAC . Bytes ) ;
Serial . println ( ) ;
Serial . print ( F ( " Master MAC = " ) ) ;
printAddress ( device . MasterMAC . Bytes ) ;
2019-04-17 21:41:37 +02:00
Serial . println ( ) ;
2017-11-20 16:54:06 +01:00
Serial . print ( F ( " NetKey = " ) ) ;
Serial . print ( device . NetworkKey , DEC ) ;
2019-04-17 21:41:37 +02:00
Serial . println ( ) ;
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
SBNetwork : : SBNetwork ( bool client , uint8_t cePin , uint8_t csPin ) : radio ( cePin , csPin ) {
RunAsClient = client ;
2017-11-20 16:54:06 +01:00
}
2019-04-17 21:41:37 +02:00
int8_t SBNetwork : : initialize ( SBMacAddress mac ) {
2017-11-20 16:54:06 +01:00
Serial . print ( F ( " SBNetwork Version " ) ) ;
Serial . println ( F ( SB_VERSION ) ) ;
Serial . println ( F ( " ==================== " ) ) ;
Serial . println ( ) ;
_LastTime = 0 ;
_Uptime = 0 ;
_NextCheck = 0 ;
this - > initializeNetworkDevice ( NetworkDevice , mac ) ;
2017-11-21 23:50:29 +01:00
if ( ! this - > RunAsClient ) {
this - > MasterStorage = SBMasterStorage : : initialize ( ) ;
for ( uint8_t i = 0 ; i < MAX_CLIENTS ; i + + ) {
2018-02-11 14:14:40 +01:00
Serial . print ( F ( " Masterstorage Slot " ) ) ; Serial . print ( i ) ; Serial . print ( " " ) ;
2017-11-21 23:50:29 +01:00
printAddress ( MasterStorage . Slaves [ i ] ) ;
Serial . println ( ) ;
}
2017-11-20 16:54:06 +01:00
}
Serial . print ( F ( " Initializing NRF24L01 transmitter... " ) ) ;
this - > radio . begin ( ) ;
// Set the PA Level low to prevent power supply related issues since this is a
// getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.
2019-04-17 21:41:37 +02:00
this - > radio . setPALevel ( RF24_PA_LOW ) ;
2017-11-20 16:54:06 +01:00
this - > radio . enableDynamicPayloads ( ) ;
//this->radio.enableDynamicAck();
2018-02-11 14:14:40 +01:00
this - > radio . setAutoAck ( true ) ; // We use the integrated package handling
2017-11-20 16:54:06 +01:00
//this->radio.enableAckPayload();
2018-02-11 14:14:40 +01:00
this - > radio . setRetries ( 0 , 15 ) ;
2017-11-20 16:54:06 +01:00
// Listen at the own address
this - > radio . openReadingPipe ( 0 , NetworkDevice . MAC ) ;
// Listen at the broadcast address
this - > radio . openReadingPipe ( 1 , _BroadcastAddress ) ;
// Start the listening phase
this - > radio . startListening ( ) ;
Serial . println ( F ( " Done " ) ) ;
2019-04-17 21:41:37 +02:00
unsigned long startConnect = millis ( ) ;
2017-11-20 16:54:06 +01:00
2017-11-21 23:50:29 +01:00
if ( this - > RunAsClient ) {
// Connect to a master
_Connected = false ;
2019-04-17 21:41:37 +02:00
while ( ! _Connected & & millis ( ) - startConnect < = CONNECT_TIMEOUT ) {
2017-11-21 23:50:29 +01:00
_Connected = connectToNetwork ( ) ;
delay ( 500 ) ; // This can be an endless loop in case of no connection to master is available
}
2019-04-17 21:41:37 +02:00
if ( ! _Connected ) {
Serial . println ( F ( " Timeout on connect to network... " ) ) ;
return 1 ;
}
2017-11-20 16:54:06 +01:00
}
2019-04-17 21:41:37 +02:00
return 0 ;
2017-11-20 16:54:06 +01:00
}
void SBNetwork : : initializeNetworkDevice ( SBNetworkDevice & device , SBMacAddress mac ) {
Serial . print ( F ( " Try to read device config from internal flash... " ) ) ;
# if defined(ESP8266)
2017-12-15 13:55:09 +01:00
EEPROM . begin ( SB_NETWORK_FLASH_SIZE ) ;
2017-11-20 16:54:06 +01:00
# endif
EEPROM . get ( 0 , device ) ; // The first two bytes of a storage must always be 'D' 'S' ID to identifiy, that the device was already initiated
if ( device . ID [ 0 ] = = ' D ' & & device . ID [ 1 ] = = ' S ' ) {
Serial . println ( F ( " Done " ) ) ;
printDeviceData ( device ) ;
}
else {
Serial . println ( F ( " Failed " ) ) ;
Serial . println ( F ( " Creating new device config and stroing it to internal flash... " ) ) ;
device . ID [ 0 ] = ' D ' ;
device . ID [ 1 ] = ' S ' ;
device . MAC = mac ;
device . ConnectedToMaster = 0 ;
device . NetworkKey = 0 ;
// Write the data to EEPROM
EEPROM . put ( 0 , device ) ;
# if defined(ESP8266)
EEPROM . commit ( ) ;
# endif
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Done " ) ) ;
2017-11-20 16:54:06 +01:00
printDeviceData ( device ) ;
}
# if defined(ESP8266)
EEPROM . end ( ) ;
# endif
}
void SBNetwork : : resetData ( ) {
Serial . print ( F ( " Erasing device configuration data... " ) ) ;
# if defined(ESP8266)
2017-12-15 13:55:09 +01:00
EEPROM . begin ( SB_NETWORK_FLASH_SIZE ) ;
2017-11-20 16:54:06 +01:00
# endif
2017-12-15 13:55:09 +01:00
for ( uint16_t i = 0 ; i < SB_NETWORK_FLASH_SIZE ; i + + ) {
2017-11-20 16:54:06 +01:00
EEPROM . write ( i , 0 ) ;
}
# if defined(ESP8266)
EEPROM . commit ( ) ;
EEPROM . end ( ) ;
# endif
Serial . println ( F ( " Done " ) ) ;
}
bool SBNetwork : : sendToDevice ( SBMacAddress mac , void * message , uint8_t messageSize ) {
2017-12-11 01:02:26 +01:00
# if defined(_DEBUG)
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Sending transmission " ) ) ;
2017-12-11 01:02:26 +01:00
# endif
2017-11-20 16:54:06 +01:00
SBNetworkHeader header ;
header . ToAddress = mac ;
header . FromAddress = this - > NetworkDevice . MAC ;
2017-12-14 23:38:46 +01:00
header . CommandType = SB_COMMAND_NO_COMMAND ;
2017-11-20 16:54:06 +01:00
SBNetworkFrame frame = SBNetworkFrame ( ) ;
frame . Header = header ;
uint8_t maxPackageSize = MAX_PACKAGE_SIZE ;
if ( messageSize < = maxPackageSize ) {
// We can send directly without fragmentation
frame . Header . FragmentNr = 0 ;
frame . Header . FragmentCount = 1 ;
frame . Header . PackageId = millis ( ) ;
frame . MessageSize = messageSize ;
frame . Message = ( uint8_t * ) message ;
bool bSuccess = this - > sendToDevice ( frame ) ;
2017-12-11 01:02:26 +01:00
# if defined(_DEBUG)
2017-11-20 16:54:06 +01:00
if ( bSuccess ) {
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Done " ) ) ;
2017-11-20 16:54:06 +01:00
}
else {
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Failed " ) ) ;
2017-11-20 16:54:06 +01:00
}
2017-12-11 01:02:26 +01:00
# endif
2017-11-20 16:54:06 +01:00
return bSuccess ;
}
else {
// We have to send it in fragments
uint8_t fragmentCount = messageSize / maxPackageSize ;
if ( ( fragmentCount * maxPackageSize ) < messageSize ) {
fragmentCount + + ;
}
for ( uint8_t i = 0 ; i < fragmentCount ; i + + ) {
2018-02-11 14:14:40 +01:00
delay ( FRAGMENT_DELAY ) ;
2017-12-12 21:51:50 +01:00
# if defined(_DEBUG)
2017-11-20 16:54:06 +01:00
Serial . print ( " . " ) ;
2017-12-12 21:51:50 +01:00
# endif
2017-11-20 16:54:06 +01:00
uint8_t buffer [ 32 ] ;
if ( i ! = ( fragmentCount - 1 ) ) {
memcpy ( buffer , ( uint8_t * ) message + ( i * maxPackageSize ) , maxPackageSize ) ;
frame . Message = ( uint8_t * ) buffer ;
frame . MessageSize = maxPackageSize ;
}
else {
memcpy ( buffer , ( uint8_t * ) message + ( i * maxPackageSize ) , messageSize - ( i * maxPackageSize ) ) ;
frame . Message = ( uint8_t * ) buffer ;
frame . MessageSize = messageSize - ( i * maxPackageSize ) ;
}
frame . Header . FragmentCount = fragmentCount ;
frame . Header . FragmentNr = i ;
bool bSuccess = this - > sendToDevice ( frame ) ;
if ( ! bSuccess ) {
2017-12-12 21:51:50 +01:00
# if defined(_DEBUG)
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Failed " ) ) ;
2017-12-12 21:51:50 +01:00
# endif
2017-11-20 16:54:06 +01:00
return false ;
}
}
2017-12-12 21:51:50 +01:00
# if defined(_DEBUG)
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Done " ) ) ;
2017-12-12 21:51:50 +01:00
# endif
2017-11-20 16:54:06 +01:00
return true ;
}
}
2018-02-11 14:14:40 +01:00
bool SBNetwork : : sendToDeviceInternal ( SBNetworkFrame frame ) {
2017-11-20 16:54:06 +01:00
uint8_t bufferSize = sizeof ( SBNetworkHeader ) + frame . MessageSize ;
uint8_t buffer [ 32 ] ; // = (uint8_t*)malloc(bufferSize);
memcpy ( buffer , & frame . Header , sizeof ( SBNetworkHeader ) ) ;
2017-12-15 13:55:09 +01:00
if ( frame . MessageSize > 0 ) {
2017-11-20 16:54:06 +01:00
memcpy ( buffer + sizeof ( SBNetworkHeader ) , frame . Message , frame . MessageSize ) ;
}
2017-12-15 13:55:09 +01:00
bool bSuccess = false ;
2018-02-11 14:14:40 +01:00
radio . stopListening ( ) ;
radio . openWritingPipe ( frame . Header . ToAddress ) ;
2017-11-20 16:54:06 +01:00
2017-12-15 13:55:09 +01:00
# if defined(_DEBUG)
2018-02-11 14:14:40 +01:00
Serial . print ( millis ( ) ) ;
Serial . println ( F ( " Sending physical data " ) ) ;
2017-12-15 13:55:09 +01:00
# endif
2019-04-17 21:41:37 +02:00
2018-02-11 14:14:40 +01:00
bSuccess = radio . write ( buffer , bufferSize ) ;
2019-04-17 21:41:37 +02:00
2018-02-11 14:14:40 +01:00
radio . openReadingPipe ( 0 , this - > NetworkDevice . MAC ) ;
radio . startListening ( ) ;
return bSuccess ;
2017-12-15 13:55:09 +01:00
}
2018-02-11 14:14:40 +01:00
bool SBNetwork : : sendToDevice ( SBNetworkFrame frame ) {
return sendToDeviceInternal ( frame ) ;
2017-12-15 13:55:09 +01:00
}
2017-12-14 23:38:46 +01:00
bool SBNetwork : : receiveInternal ( SBNetworkFrame * frame ) {
2017-11-20 16:54:06 +01:00
uint8_t pipe = - 1 ;
2017-12-14 23:38:46 +01:00
if ( radio . available ( & pipe ) ) {
2017-11-20 16:54:06 +01:00
// Variable for the received timestamp
uint8_t size = radio . getDynamicPayloadSize ( ) ;
2017-12-14 23:38:46 +01:00
if ( size = = 0 ) {
2017-11-20 16:54:06 +01:00
return false ;
}
2017-12-14 23:38:46 +01:00
else {
2017-11-20 16:54:06 +01:00
byte buffer [ 32 ] ;
radio . read ( buffer , size ) ;
2017-12-10 23:54:23 +01:00
// We cant use the target address of frame, because the first element in frame is the header
2017-11-20 16:54:06 +01:00
memcpy ( frame , buffer , sizeof ( SBNetworkHeader ) ) ;
frame - > MessageSize = size - sizeof ( SBNetworkHeader ) ;
2017-12-14 23:38:46 +01:00
if ( frame - > MessageSize > 0 ) {
2017-11-20 16:54:06 +01:00
//uint8_t *payload = (uint8_t*)malloc(frame->MessageSize);
memcpy ( _ReceiveBuffer , buffer + sizeof ( SBNetworkHeader ) , frame - > MessageSize ) ;
frame - > Message = _ReceiveBuffer ;
}
2017-12-14 23:38:46 +01:00
return true ;
2017-11-20 16:54:06 +01:00
}
}
return false ;
}
2017-12-14 23:38:46 +01:00
bool SBNetwork : : receive ( SBNetworkFrame * frame ) {
if ( receiveInternal ( frame ) ) {
// We must check, if the received package is a NO_COMMAND_PACKAGE otherwise we have to handle it internally
return this - > handleCommandPackage ( frame ) ;
}
2018-02-11 14:14:40 +01:00
return false ;
2017-12-14 23:38:46 +01:00
}
2017-11-20 16:54:06 +01:00
bool SBNetwork : : receiveMessage ( void * * message , uint8_t * messageSize , SBMacAddress * mac ) {
uint8_t pipe = - 1 ;
uint8_t maxPackageSize = MAX_PACKAGE_SIZE ;
if ( radio . available ( ) ) {
2018-02-11 14:14:40 +01:00
# if defined(_DEBUG)
Serial . print ( millis ( ) ) ;
Serial . println ( F ( " Radio available " ) ) ;
# endif
2017-11-20 16:54:06 +01:00
SBNetworkFrame frame ;
bool bReceive = this - > receive ( & frame ) ;
if ( bReceive ) {
2017-12-11 01:02:26 +01:00
# ifdef _DEBUG
2018-02-11 14:14:40 +01:00
Serial . print ( F ( " Incomming transmission from " ) ) ;
2017-11-20 16:54:06 +01:00
printAddress ( frame . Header . FromAddress ) ;
Serial . println ( ) ;
2017-12-11 01:02:26 +01:00
# endif
2017-11-20 16:54:06 +01:00
if ( frame . Header . FragmentCount = = 1 ) {
2018-02-11 14:14:40 +01:00
# ifdef _DEBUG
Serial . println ( F ( " no fragments " ) ) ;
# endif
2017-11-20 16:54:06 +01:00
// We only have to receive this package
memcpy ( _ReadBuffer , frame . Message , maxPackageSize ) ;
( * message ) = _ReadBuffer ;
( * messageSize ) = frame . MessageSize ;
( * mac ) = frame . Header . FromAddress ;
2018-02-11 14:14:40 +01:00
2017-11-20 16:54:06 +01:00
return true ;
}
else if ( frame . Header . FragmentNr = = 0 ) {
2018-02-11 14:14:40 +01:00
# ifdef _DEBUG
Serial . println ( F ( " with fragments " ) ) ;
# endif
Serial . print ( millis ( ) ) ; Serial . print ( F ( " Fragment received " ) ) ; Serial . print ( frame . Header . FragmentNr + 1 ) ; Serial . print ( " / " ) ; Serial . println ( frame . Header . FragmentCount ) ;
2017-11-20 16:54:06 +01:00
// We have to receive more packages
memcpy ( _ReadBuffer , frame . Message , maxPackageSize ) ;
2018-02-11 14:14:40 +01:00
//delay(50); // We need a delay here, because the opposite needs time to send the next package
unsigned long timeout = millis ( ) + FRAGMENT_TIMEOUT ;
_AwaitingFragmentPackage = true ;
while ( radio . available ( ) | | timeout > millis ( ) ) {
if ( this - > receive ( & frame ) ) {
Serial . print ( millis ( ) ) ; Serial . print ( F ( " Fragment received " ) ) ; Serial . print ( frame . Header . FragmentNr + 1 ) ;
Serial . print ( F ( " / " ) ) ; Serial . println ( frame . Header . FragmentCount ) ;
2017-11-20 16:54:06 +01:00
memcpy ( _ReadBuffer + ( frame . Header . FragmentNr * maxPackageSize ) , frame . Message , frame . MessageSize ) ;
2018-02-11 14:14:40 +01:00
// Now wait again for the next fragment
timeout = millis ( ) + FRAGMENT_TIMEOUT ;
2017-11-20 16:54:06 +01:00
if ( frame . Header . FragmentNr = = ( frame . Header . FragmentCount - 1 ) ) {
// Last fragment received
* message = _ReadBuffer ;
* messageSize = ( ( frame . Header . FragmentCount - 1 ) * maxPackageSize ) + frame . MessageSize ;
( * mac ) = frame . Header . FromAddress ;
2018-02-11 14:14:40 +01:00
_AwaitingFragmentPackage = false ;
2017-11-20 16:54:06 +01:00
return true ;
}
2018-02-11 14:14:40 +01:00
//delay(10);
2017-11-20 16:54:06 +01:00
}
2018-02-11 14:14:40 +01:00
delay ( 1 ) ;
2017-11-20 16:54:06 +01:00
}
2018-02-11 14:14:40 +01:00
_AwaitingFragmentPackage = false ;
Serial . print ( millis ( ) ) ;
Serial . println ( F ( " Fragment timeout " ) ) ;
2017-11-20 16:54:06 +01:00
return false ;
}
else {
return false ;
}
}
else {
return false ;
}
}
return false ;
}
bool SBNetwork : : connectToNetwork ( ) {
2017-11-21 23:50:29 +01:00
if ( this - > RunAsClient ) {
Serial . print ( F ( " Try to connect to master... " ) ) ;
// First we have to check, if we already have a master stored
if ( ! this - > NetworkDevice . ConnectedToMaster ) {
2017-12-11 01:02:26 +01:00
Serial . println ( F ( " Warning - Not paired to a master " ) ) ;
2017-11-21 23:50:29 +01:00
Serial . print ( F ( " Sending broadcast transmission to find a master... " ) ) ;
// If not, we have to search for a master
SBNetworkHeader header ;
header . ToAddress = this - > _BroadcastAddress ;
header . FromAddress = this - > NetworkDevice . MAC ;
2017-12-14 23:38:46 +01:00
header . CommandType = SB_COMMAND_SEARCH_MASTER ;
2017-11-21 23:50:29 +01:00
header . FragmentCount = 1 ;
header . PackageId = millis ( ) ;
SBNetworkFrame frame ;
frame . Header = header ;
frame . Message = NULL ;
frame . MessageSize = 0 ;
2018-02-11 14:14:40 +01:00
bool bMasterAck = this - > sendToDeviceInternal ( frame ) ;
2017-11-21 23:50:29 +01:00
unsigned long started_waiting_at = millis ( ) ;
boolean timeout = false ;
while ( ! this - > receive ( & frame ) ) {
2019-04-17 21:41:37 +02:00
if ( ( millis ( ) - started_waiting_at ) > 2500 ) {
2017-11-21 23:50:29 +01:00
timeout = true ;
break ;
}
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
if ( timeout ) {
Serial . println ( F ( " Timeout " ) ) ;
2017-11-20 16:54:06 +01:00
return false ;
}
2017-11-21 23:50:29 +01:00
else {
2017-12-14 23:38:46 +01:00
if ( frame . Header . CommandType ! = SB_COMMAND_MASTER_ACK ) {
2017-11-21 23:50:29 +01:00
if ( frame . MessageSize > 0 ) {
2018-02-11 14:14:40 +01:00
//free(frame.Message);
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
Serial . println ( F ( " Failed - Got answer but no master ack " ) ) ;
2018-02-11 14:14:40 +01:00
Serial . println ( frame . Header . CommandType ) ;
2017-11-21 23:50:29 +01:00
return false ;
}
else {
Serial . println ( F ( " Done " ) ) ;
Serial . print ( F ( " Got answer from a master. Master-MAC is " ) ) ;
printAddress ( frame . Header . FromAddress ) ;
Serial . println ( ) ;
Serial . print ( F ( " Try to pair with master... " ) ) ;
SBNetworkFrame conFrame ;
2017-12-14 23:38:46 +01:00
conFrame . Header . CommandType = SB_COMMAND_REQUEST_PAIRING ;
2017-11-21 23:50:29 +01:00
conFrame . Header . FragmentCount = 1 ;
conFrame . Header . FragmentNr = 0 ;
conFrame . Header . FromAddress = this - > NetworkDevice . MAC ;
conFrame . Header . PackageId = millis ( ) ;
conFrame . Header . ToAddress = frame . Header . FromAddress ;
conFrame . MessageSize = 0 ;
2019-04-17 21:41:37 +02:00
started_waiting_at = millis ( ) ;
2018-02-11 14:14:40 +01:00
if ( ! this - > sendToDeviceInternal ( conFrame ) ) {
2017-12-11 01:02:26 +01:00
Serial . println ( F ( " Failed - Sending pairing request " ) ) ;
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
else {
while ( ! this - > receive ( & frame ) ) {
2019-04-17 21:41:37 +02:00
if ( millis ( ) - started_waiting_at > 5000 ) {
2017-11-21 23:50:29 +01:00
timeout = true ;
break ;
}
}
if ( timeout ) {
Serial . println ( F ( " Timeout " ) ) ;
return false ;
}
2017-12-14 23:38:46 +01:00
if ( frame . Header . CommandType ! = SB_COMMAND_PAIRING_ACK ) {
2017-11-21 23:50:29 +01:00
Serial . println ( F ( " Failed - Pairing rejected from the master " ) ) ;
2018-02-11 14:14:40 +01:00
Serial . println ( frame . Header . CommandType ) ;
2017-11-21 23:50:29 +01:00
return false ;
}
else {
this - > NetworkDevice . MasterMAC = frame . Header . FromAddress ;
this - > NetworkDevice . NetworkKey = * ( frame . Message ) ;
this - > NetworkDevice . ConnectedToMaster = - 1 ;
EEPROM . put ( 0 , NetworkDevice ) ;
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Suceeded " ) ) ;
Serial . print ( F ( " Try to ping to master... " ) ) ;
2017-11-21 23:50:29 +01:00
delay ( 100 ) ;
}
2017-11-20 16:54:06 +01:00
}
}
}
}
2017-11-21 23:50:29 +01:00
bool bMasterAvailable = this - > pingDevice ( this - > NetworkDevice . MasterMAC ) ;
2017-12-15 00:03:49 +01:00
return bMasterAvailable ;
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
else {
return false ;
2017-11-20 16:54:06 +01:00
}
}
2017-12-15 13:55:09 +01:00
bool SBNetwork : : pingDevice ( SBMacAddress mac ) {
2017-11-20 16:54:06 +01:00
SBNetworkHeader header ;
header . ToAddress = mac ;
header . FromAddress = this - > NetworkDevice . MAC ;
2017-12-14 23:38:46 +01:00
header . CommandType = SB_COMMAND_PING ;
2017-11-20 16:54:06 +01:00
header . FragmentCount = 1 ;
header . FragmentNr = 0 ;
header . PackageId = millis ( ) ;
SBNetworkFrame frame ;
frame . Header = header ;
frame . Message = NULL ;
frame . MessageSize = 0 ;
2017-12-15 00:03:49 +01:00
bool bSend = this - > sendToDevice ( frame ) ;
if ( bSend ) {
2017-12-15 13:55:09 +01:00
Serial . println ( F ( " Done - Device available " ) ) ;
2017-12-15 00:03:49 +01:00
}
else {
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Failed - Device not responding " ) ) ;
2017-12-15 00:03:49 +01:00
}
return bSend ;
}
2017-11-21 23:50:29 +01:00
bool SBNetwork : : handleCommandPackage ( SBNetworkFrame * frame ) {
if ( ! this - > RunAsClient ) {
// First check, if the device is listed in the storage
bool bFound = false ;
for ( uint8_t i = 0 ; i < MAX_CLIENTS ; i + + ) {
if ( this - > MasterStorage . Slaves [ i ] . isEquals ( frame - > Header . FromAddress ) ) {
_SlavePings [ i ] = _Uptime ;
bFound = true ;
break ;
}
2017-11-20 16:54:06 +01:00
}
2017-12-15 13:55:09 +01:00
// Look, if we must handle a command package
2017-11-21 23:50:29 +01:00
switch ( frame - > Header . CommandType ) {
2017-12-14 23:38:46 +01:00
case SB_COMMAND_PING : {
2017-11-20 16:54:06 +01:00
# ifdef _DEBUG
2017-12-11 01:02:26 +01:00
Serial . println ( F ( " Received 'PING' " ) ) ;
2017-11-20 16:54:06 +01:00
# endif
break ;
}
2017-12-14 23:38:46 +01:00
case SB_COMMAND_SEARCH_MASTER : {
2017-12-15 13:55:09 +01:00
Serial . print ( F ( " Received 'SEARCH_MASTER'. " ) ) ;
// When automatic Client adding is activated
2017-12-10 23:54:23 +01:00
if ( _EnableAutomaticClientAdding ) {
2017-12-15 13:55:09 +01:00
Serial . print ( F ( " Send MasterACK... " ) ) ;
2018-02-11 14:14:40 +01:00
delay ( 100 ) ;
2017-12-10 23:54:23 +01:00
bool bSend = sendMasterAck ( frame - > Header . FromAddress ) ;
if ( bSend ) {
2017-12-15 13:55:09 +01:00
Serial . println ( F ( " Done " ) ) ;
}
else {
Serial . println ( F ( " Failed " ) ) ;
2017-12-10 23:54:23 +01:00
}
}
else {
2017-12-11 01:02:26 +01:00
Serial . println ( F ( " AutomaticClientAdding is deactivaed. Ignoring package. " ) ) ;
2017-11-20 16:54:06 +01:00
}
break ;
}
2017-12-14 23:38:46 +01:00
case SB_COMMAND_REQUEST_PAIRING : {
2017-12-15 13:55:09 +01:00
Serial . print ( F ( " Received 'PAIRING_REQUEST'. " ) ) ;
// When automatic Client adding is activated
2017-12-10 23:54:23 +01:00
if ( _EnableAutomaticClientAdding ) {
2017-12-15 13:55:09 +01:00
Serial . print ( F ( " Send PairingACK... " ) ) ;
2018-02-11 14:14:40 +01:00
delay ( 100 ) ;
2017-12-15 13:55:09 +01:00
// This is the point where we could stop prpcessing and wait for an user input on the controller to let the new device access the network
2017-12-10 23:54:23 +01:00
bool bSend = sendPairingAck ( frame - > Header . FromAddress ) ;
2017-12-15 13:55:09 +01:00
// If sending was successfull, then add the new slave
2017-12-10 23:54:23 +01:00
if ( bSend ) {
2017-12-15 13:55:09 +01:00
Serial . println ( F ( " Done " ) ) ;
Serial . print ( F ( " Storing new MAC to MasterStorage... " ) ) ;
2017-12-10 23:54:23 +01:00
addMac ( frame - > Header . FromAddress ) ;
2017-12-15 13:55:09 +01:00
Serial . println ( F ( " Done " ) ) ;
}
else {
Serial . println ( F ( " Failed " ) ) ;
2017-12-10 23:54:23 +01:00
}
2017-11-20 16:54:06 +01:00
}
2017-12-10 23:54:23 +01:00
else {
2017-12-11 01:02:26 +01:00
Serial . println ( F ( " AutomaticClientAdding is deactivaed. Ignoring package. " ) ) ;
2017-12-10 23:54:23 +01:00
}
2017-11-20 16:54:06 +01:00
break ;
}
2018-02-11 14:14:40 +01:00
case SB_COMMAND_NO_COMMAND : {
2017-12-15 13:55:09 +01:00
# ifdef _DEBUG
Serial . println ( F ( " Received 'NO_COMMAND' " ) ) ;
# endif
if ( bFound ) {
2018-02-11 14:14:40 +01:00
if ( ( _AwaitingFragmentPackage & & frame - > Header . FragmentNr > 0 ) | | ( ! _AwaitingFragmentPackage & & frame - > Header . FragmentNr = = 0 ) ) {
return true ;
}
2017-12-15 13:55:09 +01:00
}
2018-02-11 14:14:40 +01:00
break ;
}
2017-11-21 23:50:29 +01:00
}
2017-12-10 23:54:23 +01:00
// Package was handled by handleCommandPackage();
2017-11-21 23:50:29 +01:00
return false ;
}
else {
2018-02-11 14:14:40 +01:00
// Look, if we must handle a command package for a client
switch ( frame - > Header . CommandType ) {
case SB_COMMAND_NO_COMMAND : {
# ifdef _DEBUG
Serial . println ( F ( " Received 'NO_COMMAND' " ) ) ;
# endif
if ( ( _AwaitingFragmentPackage & & frame - > Header . FragmentNr > 0 ) | | ( ! _AwaitingFragmentPackage & & frame - > Header . FragmentNr = = 0 ) ) {
return true ;
}
}
case SB_COMMAND_MASTER_ACK :
case SB_COMMAND_PAIRING_ACK :
return true ;
}
return false ;
2017-11-20 16:54:06 +01:00
}
}
bool SBNetwork : : sendMasterAck ( SBMacAddress mac ) {
2017-11-21 23:50:29 +01:00
if ( ! this - > RunAsClient ) {
SBNetworkHeader header ;
header . ToAddress = mac ;
header . FromAddress = this - > NetworkDevice . MAC ;
2017-12-14 23:38:46 +01:00
header . CommandType = SB_COMMAND_MASTER_ACK ;
2017-11-21 23:50:29 +01:00
header . FragmentCount = 1 ;
header . PackageId = millis ( ) ;
2017-11-20 16:54:06 +01:00
2017-11-21 23:50:29 +01:00
SBNetworkFrame frame ;
frame . Header = header ;
frame . Message = ( uint8_t * ) & ( this - > NetworkDevice . NetworkKey ) ;
frame . MessageSize = sizeof ( uint32_t ) ;
2018-02-11 14:14:40 +01:00
return this - > sendToDeviceInternal ( frame ) ;
2017-11-21 23:50:29 +01:00
}
else {
return false ;
}
2017-11-20 16:54:06 +01:00
}
bool SBNetwork : : sendPairingAck ( SBMacAddress mac ) {
2017-11-21 23:50:29 +01:00
if ( ! this - > RunAsClient ) {
SBNetworkHeader header ;
header . ToAddress = mac ;
header . FromAddress = this - > NetworkDevice . MAC ;
2017-12-14 23:38:46 +01:00
header . CommandType = SB_COMMAND_PAIRING_ACK ;
2017-11-21 23:50:29 +01:00
header . FragmentCount = 1 ;
header . PackageId = millis ( ) ;
2017-11-20 16:54:06 +01:00
2017-11-21 23:50:29 +01:00
SBNetworkFrame frame ;
frame . Header = header ;
frame . Message = NULL ;
frame . MessageSize = 0 ;
2018-02-11 14:14:40 +01:00
return this - > sendToDeviceInternal ( frame ) ;
2017-11-21 23:50:29 +01:00
}
else {
return false ;
}
2017-11-20 16:54:06 +01:00
}
bool SBNetwork : : checkMaster ( ) {
2017-11-21 23:50:29 +01:00
if ( this - > RunAsClient ) {
if ( this - > pingDevice ( this - > NetworkDevice . MasterMAC ) ) {
2017-12-11 01:02:26 +01:00
# ifdef _DEBUG
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Master OK " ) ) ;
2017-12-11 01:02:26 +01:00
# endif
2017-11-21 23:50:29 +01:00
return true ;
}
else {
2017-12-11 01:02:26 +01:00
# ifdef _DEBUG
2018-02-11 14:14:40 +01:00
Serial . println ( F ( " Master ERROR " ) ) ;
2017-12-11 01:02:26 +01:00
# endif
2017-11-21 23:50:29 +01:00
return false ;
}
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
else {
2017-11-20 16:54:06 +01:00
return false ;
}
}
void SBNetwork : : update ( ) {
// Update the uptime counter
if ( _LastTime > millis ( ) ) {
long add = millis ( ) ;
_Uptime + = add ;
}
else {
long add = millis ( ) - _LastTime ;
_Uptime + = add ;
}
_LastTime = millis ( ) ;
2017-11-21 23:50:29 +01:00
if ( this - > RunAsClient ) {
if ( NetworkDevice . ConnectedToMaster & & MASTER_CHECK_INTERVAL ) {
if ( _Uptime > _NextCheck ) {
// Now we have to check our sensors if they are still available
2017-12-15 00:03:49 +01:00
_NextCheck = _Uptime + MASTER_CHECK_INTERVAL ;
2017-11-21 23:50:29 +01:00
checkMaster ( ) ;
}
2017-11-20 16:54:06 +01:00
}
}
_LastReceivedMessageSize = 0 ;
_LastReceivedMessage = NULL ;
SBMacAddress fromAddress ;
if ( ! receiveMessage ( ( void * * ) & _LastReceivedMessage , & _LastReceivedMessageSize , & _LastReceivedFromAddress ) ) {
_LastReceivedMessageSize = 0 ;
_LastReceivedMessage = NULL ;
}
}
uint8_t SBNetwork : : addMac ( SBMacAddress mac ) {
2017-11-21 23:50:29 +01:00
if ( ! this - > RunAsClient ) {
// iterate through the storage and look if the mac already exists
uint8_t iPos ;
for ( iPos = 0 ; iPos < MAX_CLIENTS ; iPos + + ) {
if ( MasterStorage . Slaves [ iPos ] . isEquals ( mac ) ) {
return iPos ;
}
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
// Search the first free place and add the mac
for ( iPos = 0 ; iPos < MAX_CLIENTS ; iPos + + ) {
if ( MasterStorage . Slaves [ iPos ] . isEquals ( EMPTY_MAC ) ) {
MasterStorage . Slaves [ iPos ] = mac ;
MasterStorage . save ( ) ;
return iPos ;
}
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
return - 1 ;
}
else {
return - 1 ;
2017-11-20 16:54:06 +01:00
}
}
uint8_t SBNetwork : : removeMac ( SBMacAddress mac ) {
2017-11-21 23:50:29 +01:00
if ( ! this - > RunAsClient ) {
// iterate through the storage and look if the mac is in the list, if not, then return -1. If yes, remove it.
for ( uint8_t iPos = 0 ; iPos < MAX_CLIENTS ; iPos + + ) {
if ( MasterStorage . Slaves [ iPos ] . isEquals ( mac ) ) {
MasterStorage . Slaves [ iPos ] = EMPTY_MAC ;
MasterStorage . save ( ) ;
return iPos ;
}
2017-11-20 16:54:06 +01:00
}
2017-11-21 23:50:29 +01:00
return - 1 ;
2017-11-20 16:54:06 +01:00
}
}
2019-04-17 21:41:37 +02:00
bool SBNetwork : : shutdown ( ) {
radio . stopListening ( ) ;
delay ( 10 ) ;
radio . powerDown ( ) ;
return true ;
}