aaribaud/ESPSomfy-RTS
0
0
Fork 0
mirror of https://github.com/rstrouse/ESPSomfy-RTS.git synced 2025-12-12 18:42:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
ESPSomfy-RTS/ConfigFile.cpp
Robert Strouse f8b3bc4133 Fix byte alignments #273
2024-04-18 18:56:33 -07:00

1046 lines
38 KiB
C++
Raw Blame History

#include <Arduino.h>
#include <LittleFS.h>
#include <Preferences.h>
#include "ConfigFile.h"
#include "Utils.h"
#include "ConfigSettings.h"
extern Preferences pref;
#define SHADE_HDR_VER 22
#define SHADE_HDR_SIZE 76
#define SHADE_REC_SIZE 276
#define GROUP_REC_SIZE 194
#define TRANS_REC_SIZE 74
#define ROOM_REC_SIZE 29
#define REPEATER_REC_SIZE 77
extern ConfigSettings settings;
bool ConfigFile::begin(const char* filename, bool readOnly) {
this->file = LittleFS.open(filename, readOnly ? "r" : "w");
this->_opened = true;
return true;
}
void ConfigFile::end() {
if(this->isOpen()) {
if(!this->readOnly) this->file.flush();
this->file.close();
}
this->_opened = false;
}
bool ConfigFile::isOpen() { return this->_opened; }
bool ConfigFile::seekChar(const char val) {
if(!this->isOpen()) return false;
char ch;
do {
ch = this->readChar('\0');
if(ch == '\0') return false;
} while(ch != val);
return true;
}
bool ConfigFile::writeSeparator() {return this->writeChar(CFG_VALUE_SEP); }
bool ConfigFile::writeRecordEnd() { return this->writeChar(CFG_REC_END); }
bool ConfigFile::writeHeader() { return this->writeHeader(this->header); }
bool ConfigFile::writeHeader(const config_header_t &hdr) {
if(!this->isOpen()) return false;
this->writeUInt8(hdr.version);
this->writeUInt8(hdr.length);
this->writeUInt16(hdr.roomRecordSize);
this->writeUInt8(hdr.roomRecords);
this->writeUInt16(hdr.shadeRecordSize);
this->writeUInt8(hdr.shadeRecords);
this->writeUInt16(hdr.groupRecordSize);
this->writeUInt8(hdr.groupRecords);
this->writeUInt16(hdr.repeaterRecordSize);
this->writeUInt8(hdr.repeaterRecords);
this->writeUInt16(hdr.settingsRecordSize);
this->writeUInt16(hdr.netRecordSize);
this->writeUInt16(hdr.transRecordSize);
this->writeString(settings.serverId, sizeof(hdr.serverId), CFG_REC_END);
return true;
}
bool ConfigFile::readHeader() {
if(!this->isOpen()) return false;
//if(this->file.position() != 0) this->file.seek(0, SeekSet);
Serial.printf("Reading header at %u\n", this->file.position());
this->header.version = this->readUInt8(this->header.version);
this->header.length = this->readUInt8(0);
if(this->header.version >= 19) {
this->header.roomRecordSize = this->readUInt16(this->header.roomRecordSize);
this->header.roomRecords = this->readUInt8(this->header.roomRecords);
}
if(this->header.version >= 13) this->header.shadeRecordSize = this->readUInt16(this->header.shadeRecordSize);
else this->header.shadeRecordSize = this->readUInt8((uint8_t)this->header.shadeRecordSize);
this->header.shadeRecords = this->readUInt8(this->header.shadeRecords);
if(this->header.version > 10) {
if(this->header.version >= 13) this->header.groupRecordSize = this->readUInt16(this->header.groupRecordSize);
else this->header.groupRecordSize = this->readUInt8(this->header.groupRecordSize);
this->header.groupRecords = this->readUInt8(this->header.groupRecords);
}
if(this->header.version >= 21) {
this->header.repeaterRecordSize = this->readUInt16(this->header.repeaterRecordSize);
this->header.repeaterRecords = this->readUInt8(this->header.repeaterRecords);
}
if(this->header.version > 13) {
this->header.settingsRecordSize = this->readUInt16(this->header.settingsRecordSize);
this->header.netRecordSize = this->readUInt16(this->header.netRecordSize);
this->header.transRecordSize = this->readUInt16(this->header.transRecordSize);
this->readString(this->header.serverId, sizeof(this->header.serverId));
}
Serial.printf("version:%u len:%u roomSize:%u roomRecs:%u shadeSize:%u shadeRecs:%u groupSize:%u groupRecs: %u pos:%d\n", this->header.version, this->header.length, this->header.roomRecordSize, this->header.roomRecords, this->header.shadeRecordSize, this->header.shadeRecords, this->header.groupRecordSize, this->header.groupRecords, this->file.position());
return true;
}
/*
bool ConfigFile::seekRecordByIndex(uint16_t ndx) {
if(!this->file) {
return false;
}
if(((this->header.recordSize * ndx) + this->header.length) > this->file.size()) return false;
return true;
}
*/
bool ConfigFile::readString(char *buff, size_t len) {
if(!this->file) return false;
memset(buff, 0x00, len);
uint16_t i = 0;
while(i < len) {
uint8_t val;
if(this->file.read(&val, 1) == 1) {
switch(val) {
case CFG_REC_END:
case CFG_VALUE_SEP:
_rtrim(buff);
return true;
}
buff[i++] = val;
if(i == len) {
_rtrim(buff);
return true;
}
}
else
return false;
}
_rtrim(buff);
return true;
}
bool ConfigFile::skipValue(size_t len) {
if(!this->file) return false;
uint8_t quotes = 0;
uint8_t j = 0;
while(j < len) {
uint8_t val;
j++;
if(this->file.read(&val, 1) == 1) {
switch(val) {
case CFG_VALUE_SEP:
if(quotes >= 2 || quotes == 0) return true;
break;
case CFG_REC_END:
return true;
case CFG_TOK_QUOTE:
quotes++;
break;
}
}
else return false;
}
return true;
}
bool ConfigFile::readVarString(char *buff, size_t len) {
if(!this->file) return false;
memset(buff, 0x00, len);
uint8_t quotes = 0;
uint16_t i = 0;
uint16_t j = 0;
while(j < len) {
uint8_t val;
j++;
if(this->file.read(&val, 1) == 1) {
switch(val) {
case CFG_VALUE_SEP:
if(quotes >= 2) {
_rtrim(buff);
return true;
}
break;
case CFG_REC_END:
return true;
case CFG_TOK_QUOTE:
quotes++;
continue;
}
buff[i++] = val;
if(i == len) {
_rtrim(buff);
return true;
}
}
else
return false;
}
_rtrim(buff);
return true;
}
bool ConfigFile::writeString(const char *val, size_t len, const char tok) {
if(!this->isOpen()) return false;
int slen = strlen(val);
if(slen > 0)
if(this->file.write((uint8_t *)val, slen) != slen) return false;
// Now we need to pad the end of the string so that it is of a fixed length.
while(slen < len - 1) {
this->file.write(' ');
slen++;
}
// 255 = len = 4 slen = 3
if(tok != CFG_TOK_NONE)
return this->writeChar(tok);
return true;
}
bool ConfigFile::writeVarString(const char *val, const char tok) {
if(!this->isOpen()) return false;
int slen = strlen(val);
this->writeChar(CFG_TOK_QUOTE);
if(slen > 0) if(this->file.write((uint8_t *)val, slen) != slen) return false;
this->writeChar(CFG_TOK_QUOTE);
if(tok != CFG_TOK_NONE) return this->writeChar(tok);
return true;
}
bool ConfigFile::writeChar(const char val) {
if(!this->isOpen()) return false;
if(this->file.write(static_cast<uint8_t>(val)) == 1) return true;
return false;
}
bool ConfigFile::writeInt8(const int8_t val, const char tok) {
char buff[5];
snprintf(buff, sizeof(buff), "%4d", val);
return this->writeString(buff, sizeof(buff), tok);
}
bool ConfigFile::writeUInt8(const uint8_t val, const char tok) {
char buff[4];
snprintf(buff, sizeof(buff), "%3u", val);
return this->writeString(buff, sizeof(buff), tok);
}
bool ConfigFile::writeUInt16(const uint16_t val, const char tok) {
char buff[6];
snprintf(buff, sizeof(buff), "%5u", val);
return this->writeString(buff, sizeof(buff), tok);
}
bool ConfigFile::writeUInt32(const uint32_t val, const char tok) {
char buff[11];
snprintf(buff, sizeof(buff), "%10u", val);
return this->writeString(buff, sizeof(buff), tok);
}
bool ConfigFile::writeFloat(const float val, const uint8_t prec, const char tok) {
char buff[20];
snprintf(buff, sizeof(buff), "%*.*f", 7 + prec, prec, val);
return this->writeString(buff, 8 + prec, tok);
}
bool ConfigFile::writeBool(const bool val, const char tok) {
return this->writeString(val ? "true" : "false", 6, tok);
}
char ConfigFile::readChar(const char defVal) {
uint8_t ch;
if(this->file.read(&ch, 1) == 1) return (char)ch;
return defVal;
}
int8_t ConfigFile::readInt8(const int8_t defVal) {
char buff[5];
if(this->readString(buff, sizeof(buff)))
return static_cast<int8_t>(atoi(buff));
return defVal;
}
uint8_t ConfigFile::readUInt8(const uint8_t defVal) {
char buff[4];
if(this->readString(buff, sizeof(buff)))
return static_cast<uint8_t>(atoi(buff));
return defVal;
}
uint16_t ConfigFile::readUInt16(const uint16_t defVal) {
char buff[6];
if(this->readString(buff, sizeof(buff)))
return static_cast<uint16_t>(atoi(buff));
return defVal;
}
uint32_t ConfigFile::readUInt32(const uint32_t defVal) {
char buff[11];
if(this->readString(buff, sizeof(buff)))
return static_cast<uint32_t>(atoi(buff));
return defVal;
}
float ConfigFile::readFloat(const float defVal) {
char buff[25];
if(this->readString(buff, sizeof(buff)))
return atof(buff);
return defVal;
}
bool ConfigFile::readBool(const bool defVal) {
char buff[6];
if(this->readString(buff, sizeof(buff))) {
switch(buff[0]) {
case 't':
case 'T':
case '1':
return true;
default:
return false;
}
}
return defVal;
}
/*
bool ShadeConfigFile::seekRecordById(uint8_t id) {
if(this->isOpen()) return false;
this->file.seek(this->header.length, SeekSet); // Start at the beginning of the file after the header.
uint8_t i = 0;
while(i < SOMFY_MAX_SHADES) {
uint32_t pos = this->file.position();
uint8_t len = this->readUInt8(this->header.recordSize);
uint8_t cid = this->readUInt8(255);
if(cid == id) {
this->file.seek(pos, SeekSet);
return true;
}
pos += len;
this->file.seek(pos, SeekSet);
}
return false;
}
*/
bool ShadeConfigFile::begin(bool readOnly) { return this->begin("/shades.cfg", readOnly); }
bool ShadeConfigFile::begin(const char *filename, bool readOnly) { return ConfigFile::begin(filename, readOnly); }
void ShadeConfigFile::end() { ConfigFile::end(); }
bool ShadeConfigFile::save(SomfyShadeController *s) {
this->header.version = SHADE_HDR_VER;
this->header.roomRecordSize = ROOM_REC_SIZE;
this->header.roomRecords = s->roomCount();
this->header.shadeRecordSize = SHADE_REC_SIZE;
this->header.length = SHADE_HDR_SIZE;
this->header.shadeRecords = s->shadeCount();
this->header.groupRecordSize = GROUP_REC_SIZE;
this->header.groupRecords = s->groupCount();
this->header.repeaterRecords = 1;
this->header.repeaterRecordSize = REPEATER_REC_SIZE;
this->header.settingsRecordSize = 0;
this->header.netRecordSize = 0;
this->header.transRecordSize = 0;
this->writeHeader();
for(uint8_t i = 0; i < SOMFY_MAX_ROOMS; i++) {
SomfyRoom *room = &s->rooms[i];
if(room->roomId != 0)
this->writeRoomRecord(room);
}
for(uint8_t i = 0; i < SOMFY_MAX_SHADES; i++) {
SomfyShade *shade = &s->shades[i];
if(shade->getShadeId() != 255)
this->writeShadeRecord(shade);
}
for(uint8_t i = 0; i < SOMFY_MAX_GROUPS; i++) {
SomfyGroup *group = &s->groups[i];
if(group->getGroupId() != 255)
this->writeGroupRecord(group);
}
this->writeRepeaterRecord(s);
return true;
}
bool ShadeConfigFile::backup(SomfyShadeController *s) {
this->header.version = SHADE_HDR_VER;
this->header.roomRecordSize = ROOM_REC_SIZE;
this->header.roomRecords = s->roomCount();
this->header.shadeRecordSize = SHADE_REC_SIZE;
this->header.length = SHADE_HDR_SIZE;
this->header.shadeRecords = s->shadeCount();
this->header.groupRecordSize = GROUP_REC_SIZE;
this->header.groupRecords = s->groupCount();
this->header.repeaterRecords = 1;
this->header.repeaterRecordSize = REPEATER_REC_SIZE;
this->header.settingsRecordSize = settings.calcSettingsRecSize();
this->header.netRecordSize = settings.calcNetRecSize();
this->header.transRecordSize = TRANS_REC_SIZE;
this->writeHeader();
for(uint8_t i = 0; i < SOMFY_MAX_ROOMS; i++) {
SomfyRoom *room = &s->rooms[i];
if(room->roomId != 0)
this->writeRoomRecord(room);
}
for(uint8_t i = 0; i < SOMFY_MAX_SHADES; i++) {
SomfyShade *shade = &s->shades[i];
if(shade->getShadeId() != 255)
this->writeShadeRecord(shade);
}
for(uint8_t i = 0; i < SOMFY_MAX_GROUPS; i++) {
SomfyGroup *group = &s->groups[i];
if(group->getGroupId() != 255)
this->writeGroupRecord(group);
}
this->writeRepeaterRecord(s);
this->writeSettingsRecord();
this->writeNetRecord();
this->writeTransRecord(s->transceiver.config);
return true;
}
bool ShadeConfigFile::validate() {
this->readHeader();
if(this->header.version < 1) {
Serial.print("Invalid Header Version:");
Serial.println(this->header.version);
return false;
}
if(this->header.shadeRecordSize < 100) {
Serial.print("Invalid Shade Record Size:");
Serial.println(this->header.shadeRecordSize);
return false;
}
/*
if(this->header.shadeRecords != SOMFY_MAX_SHADES) {
Serial.print("Invalid Shade Record Count:");
Serial.println(this->header.shadeRecords);
return false;
}
*/
if(this->header.version > 10) {
if(this->header.groupRecordSize < 100) {
Serial.print("Invalid Group Record Size:");
Serial.println(this->header.groupRecordSize);
return false;
}
/*
if(this->header.groupRecords != SOMFY_MAX_GROUPS) {
Serial.print("Invalid Group Record Count:");
Serial.println(this->header.groupRecords);
return false;
}
*/
}
if(this->file.position() != this->header.length) {
Serial.printf("File not positioned at %u end of header: %d\n", this->header.length, this->file.position());
return false;
}
// We should know the file size based upon the record information in the header
uint32_t fsize = this->header.length + (this->header.shadeRecordSize * this->header.shadeRecords);
if(this->header.version > 10) fsize += (this->header.groupRecordSize * this->header.groupRecords);
if(this->header.version >= 19) fsize += (this->header.roomRecordSize * this->header.roomRecords);
if(this->header.version > 13) {
fsize += (this->header.settingsRecordSize);
fsize += (this->header.netRecordSize);
fsize += (this->header.transRecordSize);
}
if(this->header.version >= 21) {
fsize += (this->header.repeaterRecordSize * this->header.repeaterRecords);
}
if(this->file.size() != fsize) {
Serial.printf("File size is not correct should be %d and got %d\n", fsize, this->file.size());
}
// Next check to see if the records match the header length.
uint8_t recs = 0;
uint32_t startPos = this->file.position();
if(this->header.version >= 19) {
while(recs < this->header.roomRecords) {
uint32_t pos = this->file.position();
if(!this->seekChar(CFG_REC_END)) {
Serial.printf("Failed to find the room record end %d\n", recs);
return false;
}
if(this->file.position() - pos != this->header.roomRecordSize) {
Serial.printf("Room record length is %d and should be %d\n", this->file.position() - pos, this->header.roomRecordSize);
return false;
}
recs++;
}
recs = 0;
}
while(recs < this->header.shadeRecords) {
uint32_t pos = this->file.position();
if(!this->seekChar(CFG_REC_END)) {
Serial.printf("Failed to find the shade record end %d\n", recs);
return false;
}
if(this->file.position() - pos != this->header.shadeRecordSize) {
Serial.printf("Shade record length is %d and should be %d\n", this->file.position() - pos, this->header.shadeRecordSize);
return false;
}
recs++;
}
if(this->header.version > 10) {
recs = 0;
while(recs < this->header.groupRecords) {
uint32_t pos = this->file.position();
if(!this->seekChar(CFG_REC_END)) {
Serial.printf("Failed to find the group record end %d\n", recs);
return false;
}
recs++;
if(this->file.position() - pos != this->header.groupRecordSize) {
Serial.printf("Group record length is %d and should be %d\n", this->file.position() - pos, this->header.groupRecordSize);
return false;
}
}
}
if(this->header.version >= 21) {
recs = 0;
while(recs < this->header.repeaterRecords) {
//uint32_t pos = this->file.position();
if(!this->seekChar(CFG_REC_END)) {
Serial.printf("Failed to find the repeater record end %d\n", recs);
}
recs++;
}
}
this->file.seek(startPos, SeekSet);
return true;
}
bool ShadeConfigFile::load(SomfyShadeController *s, const char *filename) {
ShadeConfigFile file;
if(file.begin(filename, true)) {
bool success = file.loadFile(s, filename);
file.end();
return success;
}
return false;
}
bool ShadeConfigFile::restore(SomfyShadeController *s, const char *filename, restore_options_t &opts) {
ShadeConfigFile file;
if(file.begin(filename, true)) {
bool success = file.restoreFile(s, filename, opts);
file.end();
return success;
}
return false;
}
bool ShadeConfigFile::restoreFile(SomfyShadeController *s, const char *filename, restore_options_t &opts) {
bool opened = false;
if(!this->isOpen()) {
Serial.println("Opening shade restore file");
this->begin(filename, true);
opened = true;
}
if(!this->validate()) {
Serial.println("Shade restore file invalid!");
if(opened) this->end();
return false;
}
if(opts.shades) {
Serial.println("Restoring Rooms...");
for(uint8_t i = 0; i < this->header.roomRecords; i++) {
this->readRoomRecord(&s->rooms[i]);
if(i > 0) Serial.print(",");
Serial.print(s->rooms[i].roomId);
}
Serial.println("Restoring Shades...");
// We should be valid so start reading.
for(uint8_t i = 0; i < this->header.shadeRecords; i++) {
this->readShadeRecord(&s->shades[i]);
if(i > 0) Serial.print(",");
Serial.print(s->shades[i].getShadeId());
}
Serial.println("");
if(this->header.shadeRecords < SOMFY_MAX_SHADES) {
uint8_t ndx = this->header.shadeRecords;
// Clear out any positions that are not in the shade file.
while(ndx < SOMFY_MAX_SHADES) {
((SomfyShade *)&s->shades[ndx++])->clear();
}
}
Serial.println("Restoring Groups...");
for(uint8_t i = 0; i < this->header.groupRecords; i++) {
if(i > 0) Serial.print(",");
Serial.print(s->groups[i].getGroupId());
this->readGroupRecord(&s->groups[i]);
}
Serial.println("");
if(this->header.groupRecords < SOMFY_MAX_GROUPS) {
uint8_t ndx = this->header.groupRecords;
// Clear out any positions that are not in the shade file.
while(ndx < SOMFY_MAX_GROUPS) {
((SomfyGroup *)&s->groups[ndx++])->clear();
}
}
}
else {
Serial.println("Shade data ignored");
// FF past the shades and groups.
this->file.seek(this->file.position()
+ (this->header.shadeRecords * this->header.shadeRecordSize)
+ (this->header.groupRecords * this->header.groupRecordSize), SeekSet); // Start at the beginning of the file after the header.
}
if(opts.repeaters) {
Serial.println("Restoring Repeaters...");
if(this->header.repeaterRecords > 0) {
memset(s->repeaters, 0x00, sizeof(uint32_t) * SOMFY_MAX_REPEATERS);
for(uint8_t i = 0; i < this->header.repeaterRecords; i++) {
this->readRepeaterRecord(s);
}
}
}
else {
this->file.seek(this->file.position() + this->header.repeaterRecordSize, SeekSet);
}
if(opts.settings) {
// First read out the data.
this->readSettingsRecord();
}
else {
this->file.seek(this->file.position() + this->header.settingsRecordSize, SeekSet);
}
if(opts.network || opts.mqtt) {
this->readNetRecord(opts);
}
else {
this->file.seek(this->file.position() + this->header.netRecordSize, SeekSet);
}
if(opts.shades) s->commit();
if(opts.transceiver)
{
this->readTransRecord(s->transceiver.config);
s->transceiver.save();
}
if(opts.settings || opts.network) settings.save();
if(opts.settings) settings.NTP.save();
if(opts.network) {
settings.IP.save();
settings.WIFI.save();
settings.Ethernet.save();
}
if(opts.mqtt) settings.MQTT.save();
return true;
}
bool ShadeConfigFile::readNetRecord(restore_options_t &opts) {
if(this->header.netRecordSize > 0) {
uint32_t startPos = this->file.position();
if(opts.network) {
Serial.println("Reading network settings from file...");
settings.connType = static_cast<conn_types>(this->readUInt8(static_cast<uint8_t>(conn_types::unset)));
settings.IP.dhcp = this->readBool(true);
char ip[24];
this->readVarString(ip, sizeof(ip));
settings.IP.ip.fromString(ip);
this->readVarString(ip, sizeof(ip));
settings.IP.gateway.fromString(ip);
this->readVarString(ip, sizeof(ip));
settings.IP.subnet.fromString(ip);
this->readVarString(ip, sizeof(ip));
settings.IP.dns1.fromString(ip);
this->readVarString(ip, sizeof(ip));
settings.IP.dns2.fromString(ip);
}
else {
this->skipValue(4); // connType
this->skipValue(6); // dhcp flag
this->skipValue(24); // ip
this->skipValue(24); // gateway
this->skipValue(24); // subnet
this->skipValue(24); // dns1
this->skipValue(24); // dns2
}
if(this->header.version >= 22) {
if(opts.mqtt) {
this->readVarString(settings.MQTT.protocol, sizeof(settings.MQTT.protocol));
this->readVarString(settings.MQTT.hostname, sizeof(settings.MQTT.hostname));
settings.MQTT.port = this->readUInt16(1883);
settings.MQTT.pubDisco = this->readBool(false);
this->readVarString(settings.MQTT.rootTopic, sizeof(settings.MQTT.rootTopic));
this->readVarString(settings.MQTT.discoTopic, sizeof(settings.MQTT.discoTopic));
}
else {
this->skipValue(sizeof(settings.MQTT.protocol));
this->skipValue(sizeof(settings.MQTT.hostname));
this->skipValue(6); // Port
this->skipValue(6); // pubDisco
this->skipValue(sizeof(settings.MQTT.rootTopic));
this->skipValue(sizeof(settings.MQTT.discoTopic));
}
}
// Now lets check to see if we are the same board. If we are then we will restore
// the ethernet phy settings.
if(opts.network) {
if(strncmp(settings.serverId, this->header.serverId, sizeof(settings.serverId)) == 0) {
Serial.println("Restoring Ethernet adapter settings");
settings.Ethernet.boardType = this->readUInt8(1);
settings.Ethernet.phyType = static_cast<eth_phy_type_t>(this->readUInt8(0));
settings.Ethernet.CLKMode = static_cast<eth_clock_mode_t>(this->readUInt8(0));
settings.Ethernet.phyAddress = this->readInt8(1);
settings.Ethernet.PWRPin = this->readInt8(1);
settings.Ethernet.MDCPin = this->readInt8(16);
settings.Ethernet.MDIOPin = this->readInt8(23);
}
}
if(this->file.position() != startPos + this->header.netRecordSize) {
Serial.println("Reading to end of network record");
this->seekChar(CFG_REC_END);
}
}
return true;
}
bool ShadeConfigFile::readTransRecord(transceiver_config_t &cfg) {
if(this->header.transRecordSize > 0) {
uint32_t startPos = this->file.position();
Serial.println("Reading Transceiver settings from file...");
cfg.enabled = this->readBool(false);
cfg.proto = static_cast<radio_proto>(this->readUInt8(0));
cfg.type = this->readUInt8(56);
cfg.SCKPin = this->readUInt8(cfg.SCKPin);
cfg.CSNPin = this->readUInt8(cfg.CSNPin);
cfg.MOSIPin = this->readUInt8(cfg.MOSIPin);
cfg.MISOPin = this->readUInt8(cfg.MISOPin);
cfg.TXPin = this->readUInt8(cfg.TXPin);
cfg.RXPin = this->readUInt8(cfg.RXPin);
cfg.frequency = this->readFloat(cfg.frequency);
cfg.rxBandwidth = this->readFloat(cfg.rxBandwidth);
cfg.deviation = this->readFloat(cfg.deviation);
cfg.txPower = this->readInt8(cfg.txPower);
if(this->file.position() != startPos + this->header.transRecordSize) {
Serial.println("Reading to end of transceiver record");
this->seekChar(CFG_REC_END);
}
}
return true;
}
bool ShadeConfigFile::readSettingsRecord() {
if(this->header.settingsRecordSize > 0) {
uint32_t startPos = this->file.position();
Serial.println("Reading settings from file...");
char ver[24];
this->readVarString(ver, sizeof(ver));
this->readVarString(settings.hostname, sizeof(settings.hostname));
this->readVarString(settings.NTP.ntpServer, sizeof(settings.NTP.ntpServer));
this->readVarString(settings.NTP.posixZone, sizeof(settings.NTP.posixZone));
settings.ssdpBroadcast = this->readBool(false);
if(this->header.version >= 20) settings.checkForUpdate = this->readBool(true);
if(this->file.position() != startPos + this->header.settingsRecordSize) {
Serial.println("Reading to end of settings record");
this->seekChar(CFG_REC_END);
}
}
return true;
}
bool ShadeConfigFile::readGroupRecord(SomfyGroup *group) {
pref.begin("ShadeCodes");
uint32_t startPos = this->file.position();
group->setGroupId(this->readUInt8(255));
group->groupType = static_cast<group_types>(this->readUInt8(0));
group->setRemoteAddress(this->readUInt32(0));
this->readString(group->name, sizeof(group->name));
group->proto = static_cast<radio_proto>(this->readUInt8(0));
group->bitLength = this->readUInt8(56);
if(group->getRemoteAddress() != 0) {
uint16_t rc = pref.getUShort(group->getRemotePrefId(), 0);
group->lastRollingCode = max(rc, group->lastRollingCode);
if(rc < group->lastRollingCode) pref.putUShort(group->getRemotePrefId(), group->lastRollingCode);
}
uint8_t lsd = 0;
for(uint8_t j = 0; j < SOMFY_MAX_GROUPED_SHADES; j++) {
uint8_t shadeId = this->readUInt8(0);
// Do this to eliminate gaps.
if(shadeId > 0) group->linkedShades[lsd++] = shadeId;
}
if(this->header.version >= 12) group->repeats = this->readUInt8(1);
if(this->header.version >= 13) group->sortOrder = this->readUInt8(group->getGroupId() - 1);
else group->sortOrder = group->getGroupId() - 1;
if(group->getGroupId() == 255) group->clear();
else group->compressLinkedShadeIds();
if(this->header.version >= 18) group->flipCommands = this->readBool(false);
if(this->header.version >= 19) group->roomId = this->readUInt8(0);
pref.end();
if(this->file.position() != startPos + this->header.groupRecordSize) {
Serial.println("Reading to end of group record");
this->seekChar(CFG_REC_END);
}
return true;
}
bool ShadeConfigFile::readRepeaterRecord(SomfyShadeController *s) {
uint32_t startPos = this->file.position();
for(uint8_t i = 0; i < SOMFY_MAX_REPEATERS; i++) {
s->linkRepeater(this->readUInt32(0));
}
if(this->file.position() != startPos + this->header.repeaterRecordSize) {
Serial.println("Reading to end of repeater record");
this->seekChar(CFG_REC_END);
}
return true;
}
bool ShadeConfigFile::readRoomRecord(SomfyRoom *room) {
uint32_t startPos = this->file.position();
room->roomId = this->readUInt8(0);
this->readString(room->name, sizeof(room->name));
room->sortOrder = this->readUInt8(room->roomId - 1);
if(this->file.position() != startPos + this->header.roomRecordSize) {
Serial.println("Reading to end of room record");
this->seekChar(CFG_REC_END);
}
return true;
}
bool ShadeConfigFile::readShadeRecord(SomfyShade *shade) {
pref.begin("ShadeCodes");
uint32_t startPos = this->file.position();
shade->setShadeId(this->readUInt8(255));
shade->paired = this->readBool(false);
shade->shadeType = static_cast<shade_types>(this->readUInt8(0));
shade->setRemoteAddress(this->readUInt32(0));
this->readString(shade->name, sizeof(shade->name));
if(this->header.version < 3)
shade->tiltType = this->readBool(false) ? tilt_types::none : tilt_types::tiltmotor;
else
shade->tiltType = static_cast<tilt_types>(this->readUInt8(0));
if(this->header.version > 6) shade->proto = static_cast<radio_proto>(this->readUInt8(0));
if(this->header.version > 1) shade->bitLength = this->readUInt8(56);
shade->upTime = this->readUInt32(shade->upTime);
shade->downTime = this->readUInt32(shade->downTime);
shade->tiltTime = this->readUInt32(shade->tiltTime);
if(this->header.version > 5) shade->stepSize = this->readUInt16(100);
for(uint8_t j = 0; j < SOMFY_MAX_LINKED_REMOTES; j++) {
SomfyLinkedRemote *rem = &shade->linkedRemotes[j];
rem->setRemoteAddress(this->readUInt32(0));
if(rem->getRemoteAddress() != 0) rem->lastRollingCode = pref.getUShort(rem->getRemotePrefId(), 0);
if(this->header.version < 5 && j == 4) break; // Prior to version 5 we only supported 5 linked remotes.
}
shade->lastRollingCode = this->readUInt16(0);
if(this->header.version > 7) shade->flags = this->readUInt8(0);
if(shade->getRemoteAddress() != 0) {
// If the last rolling code stored on the nvs is less than the rc we currently have
// then we need to set it.
uint16_t rc = pref.getUShort(shade->getRemotePrefId(), 0);
shade->lastRollingCode = max(rc, shade->lastRollingCode);
if(rc < shade->lastRollingCode) pref.putUShort(shade->getRemotePrefId(), shade->lastRollingCode);
}
if(this->header.version < 4)
shade->myPos = static_cast<float>(this->readUInt8(255));
else {
shade->myPos = this->readFloat(-1);
shade->myTiltPos = this->readFloat(-1);
}
if(shade->myPos > 100 || shade->myPos < 0) shade->myPos = -1;
if(shade->myTiltPos > 100 || shade->myTiltPos < 0) shade->myTiltPos = -1;
shade->currentPos = this->readFloat(0);
shade->currentTiltPos = this->readFloat(0);
if(shade->tiltType == tilt_types::none || shade->shadeType != shade_types::blind) {
shade->myTiltPos = -1;
shade->currentTiltPos = 0;
shade->tiltType = tilt_types::none;
}
if(this->header.version < 3) {
shade->currentPos = shade->currentPos * 100;
shade->currentTiltPos = shade->currentTiltPos * 100;
}
shade->target = floor(shade->currentPos);
shade->tiltTarget = floor(shade->currentTiltPos);
if(this->header.version >= 9) shade->flipCommands = this->readBool(false);
if(this->header.version >= 10) shade->flipPosition = this->readBool(false);
if(this->header.version >= 12) shade->repeats = this->readUInt8(1);
if(this->header.version >= 13) shade->sortOrder = this->readUInt8(shade->getShadeId() - 1);
else shade->sortOrder = shade->getShadeId() - 1;
if(this->header.version > 14) {
shade->gpioUp = this->readUInt8(shade->gpioUp);
shade->gpioDown = this->readUInt8(shade->gpioDown);
}
if(this->header.version > 15)
shade->gpioMy = this->readUInt8(shade->gpioMy);
if(this->header.version > 16)
shade->gpioFlags = this->readUInt8(shade->gpioFlags);
if(shade->getShadeId() == 255) shade->clear();
else if(shade->tiltType == tilt_types::tiltonly) {
shade->myPos = shade->currentPos = shade->target = 100.0f;
}
pref.end();
if(shade->proto == radio_proto::GP_Relay || shade->proto == radio_proto::GP_Remote) {
pinMode(shade->gpioUp, OUTPUT);
pinMode(shade->gpioDown, OUTPUT);
}
if(shade->proto == radio_proto::GP_Remote)
pinMode(shade->gpioMy, OUTPUT);
if(this->header.version >= 19) shade->roomId = this->readUInt8(0);
if(this->file.position() != startPos + this->header.shadeRecordSize) {
Serial.println("Reading to end of shade record");
this->seekChar(CFG_REC_END);
}
return true;
}
bool ShadeConfigFile::loadFile(SomfyShadeController *s, const char *filename) {
bool opened = false;
if(!this->isOpen()) {
Serial.println("Opening shade config file");
this->begin(filename, true);
opened = true;
}
if(!this->validate()) {
Serial.println("Shade config file invalid!");
if(opened) this->end();
return false;
}
for(uint8_t i = 0; i < this->header.roomRecords;i++) {
this->readRoomRecord(&s->rooms[i]);
}
if(this->header.roomRecords < SOMFY_MAX_ROOMS) {
uint8_t ndx = this->header.roomRecords;
// Clear out any positions that are not in the shade file.
while(ndx < SOMFY_MAX_ROOMS) {
((SomfyRoom *)&s->rooms[ndx++])->clear();
}
}
// We should be valid so start reading.
for(uint8_t i = 0; i < this->header.shadeRecords; i++) {
this->readShadeRecord(&s->shades[i]);
}
if(this->header.shadeRecords < SOMFY_MAX_SHADES) {
uint8_t ndx = this->header.shadeRecords;
// Clear out any positions that are not in the shade file.
while(ndx < SOMFY_MAX_SHADES) {
((SomfyShade *)&s->shades[ndx++])->clear();
}
}
for(uint8_t i = 0; i < this->header.groupRecords; i++) {
this->readGroupRecord(&s->groups[i]);
}
if(this->header.groupRecords < SOMFY_MAX_GROUPS) {
uint8_t ndx = this->header.groupRecords;
// Clear out any positions that are not in the shade file.
while(ndx < SOMFY_MAX_GROUPS) {
((SomfyGroup *)&s->groups[ndx++])->clear();
}
}
if(this->header.repeaterRecords > 0) {
memset(s->repeaters, 0x00, sizeof(uint32_t) * SOMFY_MAX_REPEATERS);
for(uint8_t i = 0; i < this->header.repeaterRecords; i++)
this->readRepeaterRecord(s);
}
if(opened) {
Serial.println("Closing shade config file");
this->end();
}
return true;
}
bool ShadeConfigFile::writeGroupRecord(SomfyGroup *group) {
this->writeUInt8(group->getGroupId());
this->writeUInt8(static_cast<uint8_t>(group->groupType));
this->writeUInt32(group->getRemoteAddress());
this->writeString(group->name, sizeof(group->name));
this->writeUInt8(static_cast<uint8_t>(group->proto));
this->writeUInt8(group->bitLength);
for(uint8_t j = 0; j < SOMFY_MAX_GROUPED_SHADES; j++) {
this->writeUInt8(group->linkedShades[j]);
}
this->writeUInt8(group->repeats);
this->writeUInt8(group->sortOrder);
this->writeBool(group->flipCommands);
this->writeUInt8(group->roomId, CFG_REC_END);
return true;
}
bool ShadeConfigFile::writeRepeaterRecord(SomfyShadeController *s) {
for(uint8_t i = 0; i < SOMFY_MAX_REPEATERS; i++) {
this->writeUInt32(s->repeaters[i], i == SOMFY_MAX_REPEATERS - 1 ? CFG_REC_END : CFG_VALUE_SEP);
}
return true;
}
bool ShadeConfigFile::writeRoomRecord(SomfyRoom *room) {
this->writeUInt8(room->roomId);
this->writeString(room->name, sizeof(room->name));
this->writeUInt8(room->sortOrder, CFG_REC_END);
return true;
}
bool ShadeConfigFile::writeShadeRecord(SomfyShade *shade) {
if(shade->tiltType == tilt_types::none || shade->shadeType != shade_types::blind) {
shade->myTiltPos = -1;
shade->currentTiltPos = 0;
shade->tiltType = tilt_types::none;
}
this->writeUInt8(shade->getShadeId());
this->writeBool(shade->paired);
this->writeUInt8(static_cast<uint8_t>(shade->shadeType));
this->writeUInt32(shade->getRemoteAddress());
this->writeString(shade->name, sizeof(shade->name));
this->writeUInt8(static_cast<uint8_t>(shade->tiltType));
this->writeUInt8(static_cast<uint8_t>(shade->proto));
this->writeUInt8(shade->bitLength);
this->writeUInt32(shade->upTime);
this->writeUInt32(shade->downTime);
this->writeUInt32(shade->tiltTime);
this->writeUInt16(shade->stepSize);
for(uint8_t j = 0; j < SOMFY_MAX_LINKED_REMOTES; j++) {
SomfyLinkedRemote *rem = &shade->linkedRemotes[j];
this->writeUInt32(rem->getRemoteAddress());
}
this->writeUInt16(shade->lastRollingCode);
if(shade->getShadeId() != 255) {
this->writeUInt8(shade->flags & 0xFF);
this->writeFloat(shade->myPos, 5);
this->writeFloat(shade->myTiltPos, 5);
this->writeFloat(shade->currentPos, 5);
this->writeFloat(shade->currentTiltPos, 5);
}
else {
// Make sure that we write cleared values when the shade is deleted.
this->writeUInt8(0);
this->writeFloat(-1.0f, 5); // MyPos
this->writeFloat(-1.0f, 5); // MyTiltPos
this->writeFloat(0.0f, 5); // currentPos
this->writeFloat(0.0f, 5); // currentTiltPos
}
this->writeBool(shade->flipCommands);
this->writeBool(shade->flipPosition);
this->writeUInt8(shade->repeats);
this->writeUInt8(shade->sortOrder);
this->writeUInt8(shade->gpioUp);
this->writeUInt8(shade->gpioDown);
this->writeUInt8(shade->gpioMy);
this->writeUInt8(shade->gpioFlags);
this->writeUInt8(shade->roomId, CFG_REC_END);
return true;
}
bool ShadeConfigFile::writeSettingsRecord() {
this->writeVarString(settings.fwVersion.name);
this->writeVarString(settings.hostname);
this->writeVarString(settings.NTP.ntpServer);
this->writeVarString(settings.NTP.posixZone);
this->writeBool(settings.ssdpBroadcast);
this->writeBool(settings.checkForUpdate, CFG_REC_END);
return true;
}
bool ShadeConfigFile::writeNetRecord() {
this->writeUInt8(static_cast<uint8_t>(settings.connType));
this->writeBool(settings.IP.dhcp);
this->writeVarString(settings.IP.ip.toString().c_str());
this->writeVarString(settings.IP.gateway.toString().c_str());
this->writeVarString(settings.IP.subnet.toString().c_str());
this->writeVarString(settings.IP.dns1.toString().c_str());
this->writeVarString(settings.IP.dns2.toString().c_str());
this->writeVarString(settings.MQTT.protocol);
this->writeVarString(settings.MQTT.hostname);
this->writeUInt16(settings.MQTT.port);
this->writeBool(settings.MQTT.pubDisco);
this->writeVarString(settings.MQTT.rootTopic);
this->writeVarString(settings.MQTT.discoTopic);
this->writeUInt8(settings.Ethernet.boardType);
this->writeUInt8(static_cast<uint8_t>(settings.Ethernet.phyType));
this->writeUInt8(static_cast<uint8_t>(settings.Ethernet.CLKMode));
this->writeInt8(settings.Ethernet.phyAddress);
this->writeInt8(settings.Ethernet.PWRPin);
this->writeInt8(settings.Ethernet.MDCPin);
this->writeInt8(settings.Ethernet.MDIOPin, CFG_REC_END);
return true;
}
bool ShadeConfigFile::writeTransRecord(transceiver_config_t &cfg) {
this->writeBool(cfg.enabled);
this->writeUInt8(static_cast<uint8_t>(cfg.proto));
this->writeUInt8(cfg.type);
this->writeUInt8(cfg.SCKPin);
this->writeUInt8(cfg.CSNPin);
this->writeUInt8(cfg.MOSIPin);
this->writeUInt8(cfg.MISOPin);
this->writeUInt8(cfg.TXPin);
this->writeUInt8(cfg.RXPin);
this->writeFloat(cfg.frequency, 3);
this->writeFloat(cfg.rxBandwidth, 2);
this->writeFloat(cfg.deviation, 2);
this->writeInt8(cfg.txPower, CFG_REC_END);
return true;
}
bool ShadeConfigFile::exists() { return LittleFS.exists("/shades.cfg"); }
Reference in a new issue View git blame Copy permalink