Device.cpp

/*
 Device.cpp - Handle the controlled device implementation
 Saul bertuccio 4 feb 2017
 Released into the public domain.
*/

#include "Device.h"

String Device::TYPES[Device::TYPE_NUM] = { "IRDA", "RF433" };
String Device::TYPES_DESCRIPTION[Device::TYPE_NUM] = { "Infrarossi", "Radio Freq. 433Mhz" };

Device::Device(const String &dev_name, const String &dev_type)
 : dev_name(dev_name),
 dev_type(dev_type)
{}

Device::~Device() {

 while (first_key) {
 Key * k = first_key->getNext();
 delete first_key;
 first_key = k;
 }
}

void Device::setName(const String &new_name) { dev_name = new_name; }
void Device::setType(const String &new_type) { dev_type = new_type; }

String Device::getName() { return dev_name; }
String Device::getType() { return dev_type; }

boolean Device::isValidPropertyById(int id, const String &val) {
 
 // IRDA
 if (dev_type == TYPES[0])
 return IrKey::validations[id](val);
 
 // RF433
 if (dev_type == TYPES[1])
 return RfKey::validations[id](val);

 return false;
}

int Device::getKeysPropertyNum() {

 // IRDA
 if (dev_type == TYPES[0])
 return IrKey::props_num;
 
 // RF433
 if (dev_type == TYPES[1])
 return RfKey::props_num;

}

String * Device::getKeysPropertyNames() {

 int len = 0;
 String * prop = NULL;
 
 // IRDA
 if (dev_type == TYPES[0])
 return getProperties(IrKey::props_names, IrKey::props_num);
 
 // RF433
 if (dev_type == TYPES[1])
 return getProperties(RfKey::props_names, RfKey::props_num);

}

Key * Device::getKeys() { return first_key; };


boolean Device::addKey(String * key_data) {

 Key *key;

 // Check name
 if (key_data[0].length() > Key::MAX_KEY_NAME_LEN)
 return false;

 // IRDA
 if (dev_type == TYPES[0])
 key = new IrKey( key_data[0], key_data[1] );
 
 // RF433
 if (dev_type == TYPES[1])
 key = new RfKey( key_data[0], key_data[1].toInt(), key_data[2].toInt() );

 if (!key)
 return false;

 if ( first_key == NULL ) {
 first_key = key;
 last_key = key;
 } else {
 last_key->setNext(key);
 last_key = key;
 }
 return true;
}

boolean Device::sendKeyData(const String & key_name) {

 Key * k = findPreviousKeyByName(key_name);

 if ( k == NULL) {
 if (first_key != NULL && first_key->getName() == key_name) {
 k = first_key;
 } else {
 return false;
 }
 } else {
 k = k->getNext();
 }

 if (dev_type == TYPES[0])
 Device::sendIrKeyData(k);
 
 // RF433
 if (dev_type == TYPES[1]) {
 Device::sendRfKeyData(k);
 }

 return true; 
}

Key * Device::acquireKeyData() {

 // IRDA
 Key * k;
 
 if (dev_type == TYPES[0])
 k = Device::acquireIrKeyData();
 
 // RF433
 if (dev_type == TYPES[1])
 k = Device::acquireRfKeyData();

 return k;
}


boolean Device::removeKey(const String &key_name ) {
 
 Key * prev_key = this->findPreviousKeyByName( key_name );

 if ( prev_key == NULL) {
 
 if ( first_key == NULL || first_key->getName() != key_name ) {
 return false;
 }
 
 prev_key = first_key;
 first_key = prev_key->getNext();
 delete prev_key;

 if ( first_key == NULL ) {
 last_key = NULL;
 }

 return true;
 }

 Key * next_key = prev_key->getNext();

 prev_key->setNext(next_key->getNext());

 if (next_key == last_key) {
 
 last_key = prev_key;

 }

 delete next_key;
 return true;
}

Key * Device::findPreviousKeyByName(const String &key_name) {

 if (first_key == NULL)
 return NULL;

 Key * key = first_key;

 while (Key * next = key->getNext()) {
 
 if ( next->getName() == key_name ) {
 return key;
 }
 
 key = next;
 }

 return NULL;
 
}

String * Device::getProperties(const String names[], int len) {

 String * props = new String[len];
 
 for (int i = 0; i < len; i++) {
 props[i] = names[i];
 }

 return props;
}


void Device::sendIrKeyData(Key *key) {

 static String hex_decode = "0123456789ABCDEF"; 
 IrKey *k = static_cast<IrKey *>(key);
 String code = k->getCode().substring(2);
 code.toUpperCase();

 if (code.length() % 2 != 0) {
 Serial.println("Errore: Codice da inviare valido");
 return;
 }

 SoftwareSerial sw(IR_RX_PIN, IR_TX_PIN, false, 16);
 int i=0;
 sw.begin(9600);
 // Protocollo
 sw.write(0xA1);
 sw.write(0xF1);
 while (i < code.length()) {
 char n = hex_decode.indexOf(code[i++]) << 4;
 n += hex_decode.indexOf(code[i++]);
 sw.write(n);
 }
}


void Device::sendRfKeyData(Key *key) {
 RCSwitch sw = RCSwitch();
 RfKey *k = static_cast<RfKey *>(key);
 sw.enableTransmit(Device::RF_TX_PIN);
 sw.send(k->getCode(), k->getLength());
 sw.disableTransmit();
}

Key * Device::acquireIrKeyData() {

 static char const hex_encode[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 char code[11] = {'0', 'x', '\0'};
 SoftwareSerial sw(IR_RX_PIN, IR_TX_PIN, false, 16);
 sw.begin(9600);
 boolean is_code_ok = false;
 int attempt = 3;
 for (int i=0; i < attempt; i++) {
 delay(500);
 int p = 2;
 while (sw.available() > 0 && p < 15) {
 char c = sw.read();
 code[p++] = hex_encode[ ( c & 0xF0 ) >> 4 ];
 code[p++] = hex_encode[ (c & 0x0F ) ];
 delay(40);
 }
 sw.flush();
 code[p] = '\0';
 if (p>4) {
 is_code_ok=true;
 break;
 }
 }

 IrKey * ir = NULL;
 if (is_code_ok) {
 ir = new IrKey("DUMMY", String(code));
 }
 return ir;
}

Key * Device::acquireRfKeyData() {

 RCSwitch sw = RCSwitch();
 RfKey * rf = NULL;
 sw.enableReceive(Device::RF_RX_PIN);

 int attempt = 3;
 for (int i=0; i < attempt; i++) {
 if (rf)
 break;
 delay(500);
 if (sw.available()) {
 rf = new RfKey("DUMMY", sw.getReceivedBitlength(), sw.getReceivedValue());
 sw.resetAvailable();
 }
 }
 sw.disableReceive();
 return rf;
}