428 lines
15 KiB
C
428 lines
15 KiB
C
char receivedChars[buffsize]; // an array to store the received data
|
|
char tempChars[buffsize]; // an array to manipulate the received data
|
|
char recv_label[num_keywords][label_bytes] = {0}; // {0} tells the compiler to initalize it with 0.
|
|
char recv_value[num_keywords][value_bytes] = {0}; // That does not mean it is filled with 0's
|
|
char value[num_keywords][value_bytes] = {0}; // The array that holds the verified data
|
|
static byte blockindex = 0;
|
|
bool blockend = false;
|
|
double tension_batterie;
|
|
|
|
double intensite_decharge = 0;
|
|
int outVal = 0;
|
|
bool new_data = false;
|
|
|
|
long temps = 0;
|
|
String last_serial_string = "";
|
|
//
|
|
//// ===================================================================
|
|
//struct DataPair {
|
|
// char key[10];
|
|
// char value[20];
|
|
//};
|
|
//DataPair data[num_keywords]; // Tableau pour stocker les paires
|
|
//int currentIndex = 0;
|
|
//
|
|
//
|
|
//void storeDataPair(String line) {
|
|
// int delimiterIndex = line.indexOf('\t'); // Trouver la position de la tabulation
|
|
// if (delimiterIndex > 0 && currentIndex < num_keywords) {
|
|
// // Extraire la clé et la valeur de la ligne
|
|
// String key = line.substring(0, delimiterIndex);
|
|
// String value = line.substring(delimiterIndex + 1);
|
|
//
|
|
// // Stocker la clé et la valeur dans le tableau
|
|
// key.toCharArray(data[currentIndex].key, sizeof(data[currentIndex].key));
|
|
// value.toCharArray(data[currentIndex].value, sizeof(data[currentIndex].value));
|
|
// currentIndex++;
|
|
// }
|
|
//}
|
|
//
|
|
//void processReceivedData(String data) {
|
|
// currentIndex = 0; // Réinitialiser l'index pour les nouvelles données
|
|
// int start = 0;
|
|
// while (start < data.length()) {
|
|
// int end = data.indexOf('\n', start);
|
|
// if (end == -1) {
|
|
// break;
|
|
// }
|
|
// String line = data.substring(start, end);
|
|
// storeDataPair(line);
|
|
// start = end + 1;
|
|
// }
|
|
//}
|
|
//
|
|
//
|
|
//bool receivingData = false; // Indicateur pour savoir si nous sommes en train de recevoir des données
|
|
//String receivedData = "";
|
|
//// ===============================================================================
|
|
|
|
|
|
|
|
void addTension( struct tm* timeinfo, int value) {
|
|
|
|
if(value > 30000) {
|
|
return;
|
|
}
|
|
// Si le tableau est plein, décaler toutes les valeurs vers la gauche
|
|
if (to_store.total_elements >= maxSize) {
|
|
for (int i = 1; i < maxSize; i++) {
|
|
to_store.hour[i - 1] = to_store.hour[i];
|
|
to_store.min[i - 1] = to_store.min[i];
|
|
to_store.tensions[i - 1] = to_store.tensions[i];
|
|
}
|
|
to_store.hour[maxSize - 1] = timeinfo->tm_hour;
|
|
to_store.min[maxSize - 1] = timeinfo->tm_min;
|
|
to_store.tensions[maxSize - 1] = value; // Ajouter la nouvelle valeur à la fin
|
|
} else {
|
|
// Ajouter la nouvelle valeur à la fin
|
|
//hour.toCharArray(to_store.hour[to_store.total_elements], sizeof(to_store.hour));
|
|
to_store.hour[to_store.total_elements] = timeinfo->tm_hour;
|
|
to_store.min[to_store.total_elements] = timeinfo->tm_min;
|
|
to_store.tensions[to_store.total_elements] = value;
|
|
to_store.total_elements++;
|
|
}
|
|
to_store.total_elements %= maxSize;
|
|
|
|
EEPROM.put(TO_STORE_ADDRESS, to_store);
|
|
EEPROM.commit();
|
|
}
|
|
|
|
// Serial Handling
|
|
// ---
|
|
// This block handles the serial reception of the data in a
|
|
// non blocking way. It checks the Serial line for characters and
|
|
// parses them in fields. If a block of data is send, which always ends
|
|
// with "Checksum" field, the whole block is checked and if deemed correct
|
|
// copied to the 'value' array.
|
|
|
|
void recvWithEndMarker() {
|
|
static byte ndx = 0;
|
|
char endMarker = '\n';
|
|
char rc;
|
|
// new_data = false;
|
|
#ifdef ESP8266
|
|
while (victronSerial.available() > 0 && new_data == false) {
|
|
rc = victronSerial.read();
|
|
#else
|
|
while (Serial1.available() > 0 && new_data == false) {
|
|
rc = Serial1.read();
|
|
#endif
|
|
last_serial_string += rc;
|
|
if (rc != endMarker) {
|
|
receivedChars[ndx] = rc;
|
|
ndx++;
|
|
if (ndx >= buffsize) {
|
|
ndx = buffsize - 1;
|
|
}
|
|
}
|
|
else {
|
|
receivedChars[ndx] = '\0'; // terminate the string
|
|
ndx = 0;
|
|
new_data = true;
|
|
}
|
|
last_serial_string = String(receivedChars);
|
|
|
|
yield();
|
|
}
|
|
}
|
|
|
|
void parseData() {
|
|
char * strtokIndx; // this is used by strtok() as an index
|
|
strtokIndx = strtok(tempChars,"\t"); // get the first part - the label
|
|
// The last field of a block is always the Checksum
|
|
if (strcmp(strtokIndx, "Checksum") == 0) {
|
|
blockend = true;
|
|
}
|
|
strcpy(recv_label[blockindex], strtokIndx); // copy it to label
|
|
|
|
// Now get the value
|
|
strtokIndx = strtok(NULL, "\r"); // This continues where the previous call left off until '/r'.
|
|
if (strtokIndx != NULL) { // We need to check here if we don't receive NULL.
|
|
strcpy(recv_value[blockindex], strtokIndx);
|
|
}
|
|
blockindex++;
|
|
|
|
if (blockend) {
|
|
// We got a whole block into the received data.
|
|
// Check if the data received is not corrupted.
|
|
// Sum off all received bytes should be 0;
|
|
byte checksum = 0;
|
|
for (int x = 0; x < blockindex; x++) {
|
|
// Loop over the labels and value gotten and add them.
|
|
// Using a byte so the the % 256 is integrated.
|
|
char *v = recv_value[x];
|
|
char *l = recv_label[x];
|
|
while (*v) {
|
|
checksum += *v;
|
|
v++;
|
|
}
|
|
while (*l) {
|
|
checksum+= *l;
|
|
l++;
|
|
}
|
|
// Because we strip the new line(10), the carriage return(13) and
|
|
// the horizontal tab(9) we add them here again.
|
|
checksum += 32;
|
|
}
|
|
// Checksum should be 0, so if !0 we have correct data.
|
|
if (!checksum) {
|
|
// Since we are getting blocks that are part of a
|
|
// keyword chain, but are not certain where it starts
|
|
// we look for the corresponding label. This loop has a trick
|
|
// that will start searching for the next label at the start of the last
|
|
// hit, which should optimize it.
|
|
int start = 0;
|
|
for (int i = 0; i < blockindex; i++) {
|
|
for (int j = start; (j - start) < num_keywords; j++) {
|
|
if (strcmp(recv_label[i], keywords[j % num_keywords]) == 0) {
|
|
// found the label, copy it to the value array
|
|
strcpy(value[j], recv_value[i]);
|
|
start = (j + 1) % num_keywords; // start searching the next one at this hit +1
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Reset the block index, and make sure we clear blockend.
|
|
blockindex = 0;
|
|
blockend = false;
|
|
}
|
|
}
|
|
|
|
void cleanValues() {
|
|
// new_data = false;
|
|
// strcpy("RESET", recv_value[CHECKSUM]);
|
|
// for (int i = 0; i < num_keywords; i++){
|
|
// strcpy("", recv_value[i]);
|
|
// }
|
|
}
|
|
|
|
void printValues() {
|
|
for (int i = 0; i < num_keywords; i++){
|
|
Serial.print(keywords[i]);
|
|
Serial.print("=");
|
|
Serial.print(value[i]);
|
|
Serial.print("|");
|
|
}
|
|
Serial.println("");
|
|
}
|
|
|
|
void printData() {
|
|
static unsigned long prev_millis;
|
|
if (millis() - prev_millis > PRINT_EVERY_SECONDS * 1000) {
|
|
printValues();
|
|
prev_millis = millis();
|
|
}
|
|
}
|
|
|
|
void handleNewData() {
|
|
|
|
// We have gotten a field of data
|
|
if (new_data == true) {
|
|
//Copy it to the temp array because parseData will alter it.
|
|
strcpy(tempChars, receivedChars);
|
|
parseData();
|
|
new_data = false;
|
|
}
|
|
|
|
}
|
|
|
|
// Méthode pour gérer la requête '/getData'
|
|
void handleVictron() {
|
|
blink();
|
|
|
|
#ifdef PIN_HALL
|
|
getHall();
|
|
#endif
|
|
|
|
#ifdef PIN_DALLAS
|
|
// Command all devices on bus to read temperature
|
|
// Serial.print("Temperature is: ");
|
|
temperature = printTemperature(Probe);
|
|
//Serial.println();
|
|
#endif
|
|
|
|
#ifdef SERIAL_XY6020L
|
|
printMem();
|
|
#endif
|
|
|
|
#ifdef SERIAL_XY6020L_2
|
|
printMem2();
|
|
#endif
|
|
|
|
String JSON = F("[");
|
|
for (int i = 0; i < num_keywords; i++){
|
|
// String key = data[i].key; //String(keywords[i]);
|
|
// String val = data[i].value; //String(value[i]);
|
|
String key = String(keywords[i]);
|
|
String val = String(value[i]);
|
|
String label = "";
|
|
String key_label = "";
|
|
// if (key.equals("CS")) {
|
|
// label = "Etat";
|
|
// val = operationStates[val.toInt()].label;
|
|
// }
|
|
|
|
for (int i = 0; i < mpptDataSize; i++) {
|
|
if (key.equals(mpptData[i].code)) {
|
|
key_label= key + " " + mpptData[i].label;
|
|
}
|
|
}
|
|
if (key.equals("OR")) {
|
|
for (int i = 0; i < offReasonsSize; i++) {
|
|
if (val.equals(offReasons[i].code)) {
|
|
label = offReasons[i].label;
|
|
}
|
|
}
|
|
}
|
|
if (key.equals("CS")) {
|
|
for (int i = 0; i < operationStatesSize; i++) {
|
|
if (val.equals(operationStates[i].code)) {
|
|
label = operationStates[i].label;
|
|
}
|
|
}
|
|
}
|
|
if (key.equals("MPPT")) {
|
|
for (int i = 0; i < mpptStatesSize; i++) {
|
|
if (val.equals(mpptStates[i].code)) {
|
|
label = mpptStates[i].label;
|
|
}
|
|
}
|
|
}
|
|
if (key.equals("ERR")) {
|
|
for (int i = 0; i < errorCodesSize; i++) {
|
|
if (val.equals(errorCodes[i].code)) {
|
|
label = errorCodes[i].label;
|
|
}
|
|
}
|
|
}
|
|
if (key.equals("IL")) {
|
|
intensite_decharge = val.toFloat() / 1000;
|
|
}
|
|
if (key.equals("V")) {
|
|
tension_batterie = val.toFloat() / 1000;
|
|
|
|
}
|
|
if (key.equals("Checksum")) {
|
|
String tensions = "";
|
|
String labels = "";
|
|
for (int i = 0; i < maxSize; i++) {
|
|
if (i == 0) {
|
|
tensions = String(to_store.tensions[i]);
|
|
labels = String(to_store.hour[i]) + ":" + String(to_store.min[i]);
|
|
}
|
|
else {
|
|
tensions += "," + String(to_store.tensions[i]);
|
|
labels += "," + String((to_store.hour[i] < 10 ? "0" : "") + String(to_store.hour[i]))
|
|
+ ":"
|
|
+ String((to_store.min[i] < 10 ? "0" : "") + String(to_store.min[i])) ;
|
|
|
|
}
|
|
}
|
|
JSON += "{\"id\":\"output-power\", \"value\":\"" + String(tension_batterie * intensite_decharge,1) + "\"},";
|
|
|
|
#ifdef TUYA
|
|
JSON += "{\"id\":\"CONSO\", \"value\":\"" + String(String(conso_apparente).toFloat(),1) + "\"},";
|
|
JSON += "{\"id\":\"PROD\", \"value\":\"" + String(String(production).toFloat(),1) + "\"},";
|
|
|
|
#endif
|
|
|
|
|
|
#ifdef PIN_DALLAS
|
|
JSON += "{\"id\":\"TEMPERATURE\", \"value\":\"" + String(temperature,1) + "\"},";
|
|
#endif
|
|
|
|
#ifdef PIN_REGULATION
|
|
JSON += "{\"id\":\"REGULATION\", \"value\":\"" + String(current_regulation) + "\"},";
|
|
#endif
|
|
|
|
#ifdef PIN_DIMMER_OUTPUT
|
|
JSON += "{\"id\":\"RADIATEUR\", \"value\":\"" + String(pwm) + "\"},";
|
|
#endif
|
|
#ifdef PIN_HALL
|
|
getHall();
|
|
JSON += "{\"id\":\"HALL_V\", \"value\":\"" + String(VRMS) + "\"},";
|
|
JSON += "{\"id\":\"HALL_I\", \"value\":\"" + String(Amps) + "\"},";
|
|
JSON += "{\"id\":\"HALL_W\", \"value\":\"" + String(Amps * 230) + "\"},";
|
|
#endif
|
|
#ifdef SERIAL_XY6020L
|
|
if(xy.HRegUpdated()) {
|
|
xy.ReadAllHRegs();
|
|
}
|
|
|
|
JSON += "{\"id\":\"CHRG\", \"value\":\"" + String(digitalRead(PIN_CHARGE)) + "\"},";
|
|
JSON += "{\"id\":\"XY_ON\", \"value\":\"" + String(xy.getOutputOn()) + "\"},";
|
|
JSON += "{\"id\":\"XY_inV\", \"value\":\"" + String(xy.getInV()) + "\"},";
|
|
JSON += "{\"id\":\"XY_V\", \"value\":\"" + String(xy.getCV()) + "\"},";
|
|
JSON += "{\"id\":\"XY_C\", \"value\":\"" + String(xy.getCC()) + "\"},";
|
|
JSON += "{\"id\":\"XY_T\", \"value\":\"" + String(xy.getTemp()) + "\"},";
|
|
JSON += "{\"id\":\"XY_AV\", \"value\":\"" + String(xy.getActV()) + "\"},";
|
|
JSON += "{\"id\":\"XY_AC\", \"value\":\"" + String(xy.getActC()) + "\"},";
|
|
JSON += "{\"id\":\"XY_AW\", \"value\":\"" + String(xy.getActP()) + "\"},";
|
|
JSON += "{\"id\":\"XY_CHG\", \"value\":\"" + String(xy.getCharge()) + "\"},";
|
|
JSON += "{\"id\":\"XY_NRJ\", \"value\":\"" + String(xy.getEnergy()) + "\"},";
|
|
#endif
|
|
#ifdef SERIAL_XY6020L_2
|
|
if(xy2.HRegUpdated()) {
|
|
xy2.ReadAllHRegs();
|
|
}
|
|
JSON += "{\"id\":\"INJC\", \"value\":\"" + String(digitalRead(PIN_INJECTION)) + "\"},";
|
|
|
|
JSON += "{\"id\":\"XY2_ON\", \"value\":\"" + String(xy2.getOutputOn()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_inV\", \"value\":\"" + String(xy2.getInV()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_V\", \"value\":\"" + String(xy2.getCV()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_C\", \"value\":\"" + String(xy2.getCC()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_T\", \"value\":\"" + String(xy2.getTemp()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_AV\", \"value\":\"" + String(xy2.getActV()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_AC\", \"value\":\"" + String(xy2.getActC()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_AW\", \"value\":\"" + String(xy2.getActP()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_CHG\", \"value\":\"" + String(xy2.getCharge()) + "\"},";
|
|
JSON += "{\"id\":\"XY2_NRJ\", \"value\":\"" + String(xy2.getEnergy()) + "\"},";
|
|
#endif
|
|
JSON += "{\"id\":\"MESSAGE\", \"value\":\"" + last_message + "\"},";
|
|
|
|
JSON += "{\"id\":\"tensions\", \"value\":\"" + tensions + "\",\"labels\":\"" + labels + "\"},";
|
|
|
|
// #ifndef SERIAL_BLUE_SOLAR
|
|
// JSON += "{\"id\":\"" + key + "\",\"key_label\":\"" + key_label + "\",\"label\":\"" + label + "\", \"value\":\"" + val + "\"},";
|
|
// #endif
|
|
}
|
|
else {
|
|
// if (i == ERR) {
|
|
//
|
|
// }
|
|
//
|
|
// #ifdef SERIAL_BLUE_SOLAR
|
|
JSON += "{\"id\":\"" + key + "\",\"key_label\":\"" + key_label + "\",\"label\":\"" + label + "\", \"value\":\"" + val + "\"},";
|
|
// #endif
|
|
}
|
|
}
|
|
//to_store.tensions
|
|
//JSON += "{\"id\":\"last_serial_string\", \"value\":\"" + last_serial_string + "\"},";
|
|
|
|
|
|
JSON += "{\"id\":\"end\", \"value\":\"end\"}";
|
|
JSON += "]";
|
|
blink();
|
|
server.send(200, "application/json", JSON);
|
|
|
|
// // Créer un objet JSON
|
|
// DynamicJsonDocument doc(200);
|
|
//
|
|
// for (int i = 0; i < num_keywords; i++){
|
|
// doc[String(keywords[i])] = String(value[i]);
|
|
// }
|
|
//
|
|
// // Convertir l'objet jsonData en chaîne
|
|
// String jsonData;
|
|
// serializeJson(doc, jsonData);
|
|
//
|
|
// // Envoyer la réponse JSON au client
|
|
// server.send(200, "application/json", jsonData);
|
|
}
|
|
|
|
void handleDebug() {
|
|
// Envoyer la réponse au client
|
|
server.send(200, "text/plain", last_serial_string);
|
|
}
|