From acc92ccf6a2adb870b07eadabfe1589ec2bf029b Mon Sep 17 00:00:00 2001 From: aurel Date: Wed, 26 Nov 2025 16:30:22 +0100 Subject: [PATCH] commit all --- .gitignore | 14 +- include/README | 37 +++ lib/README | 47 ++++ lib/sensor/led.cpp | 28 ++ lib/sensor/led.h | 19 ++ lib/sensor/photoresistance_ohm_retrieval.cpp | 28 ++ lib/sensor/photoresistance_ohm_retrieval.h | 27 ++ lib/sensor/sensormanager.cpp | 121 +++++++++ lib/sensor/sensormanager.h | 31 +++ lib/storage/storage_interface.cpp | 263 +++++++++++++++++++ lib/storage/storage_interface.h | 53 ++++ lib/traitement/traitement.cpp | 23 ++ lib/traitement/traitement.h | 19 ++ platformio.ini | 22 ++ src/Notes.txt | 24 ++ src/Robot_Go_West.code-workspace | 9 + src/main.cpp | 108 ++++++++ src/myFunction.cpp | 45 ++++ src/myFunction.h | 23 ++ storage_structure.drawio | 226 ++++++++++++++++ storage_structure.drawio.png | Bin 0 -> 170649 bytes test/EEPROM_test_struct.cpp | 12 + test/README | 11 + time.py | 12 + 24 files changed, 1197 insertions(+), 5 deletions(-) create mode 100755 include/README create mode 100755 lib/README create mode 100755 lib/sensor/led.cpp create mode 100755 lib/sensor/led.h create mode 100755 lib/sensor/photoresistance_ohm_retrieval.cpp create mode 100755 lib/sensor/photoresistance_ohm_retrieval.h create mode 100644 lib/sensor/sensormanager.cpp create mode 100644 lib/sensor/sensormanager.h create mode 100644 lib/storage/storage_interface.cpp create mode 100644 lib/storage/storage_interface.h create mode 100644 lib/traitement/traitement.cpp create mode 100644 lib/traitement/traitement.h create mode 100755 platformio.ini create mode 100755 src/Notes.txt create mode 100755 src/Robot_Go_West.code-workspace create mode 100755 src/main.cpp create mode 100644 src/myFunction.cpp create mode 100644 src/myFunction.h create mode 100644 storage_structure.drawio create mode 100644 storage_structure.drawio.png create mode 100644 test/EEPROM_test_struct.cpp create mode 100755 test/README create mode 100755 time.py diff --git a/.gitignore b/.gitignore index 49ec643..5e07603 100755 --- a/.gitignore +++ b/.gitignore @@ -1,9 +1,13 @@ .pio -.vscode/.browse.c_cpp.db* -.vscode/c_cpp_properties.json -.vscode/launch.json -.vscode/ipch -MinMaxPhoto-r +# .vscode/.browse.c_cpp.db* +# .vscode/c_cpp_properties.json +# .vscode/launch.json +# .vscode/ipch +.vscode +time +MinMaxPhoto-r.ods +serial +*.drawio.bkp # Created by https://www.toptal.com/developers/gitignore/api/platformio,c++ diff --git a/include/README b/include/README new file mode 100755 index 0000000..49819c0 --- /dev/null +++ b/include/README @@ -0,0 +1,37 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the convention is to give header files names that end with `.h'. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/lib/README b/lib/README new file mode 100755 index 0000000..6ed2022 --- /dev/null +++ b/lib/README @@ -0,0 +1,47 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into the executable file. + +The source code of each library should be placed in a separate directory +("lib/your_library_name/[Code]"). + +For example, see the structure of the following example libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional. for custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +Example contents of `src/main.c` using Foo and Bar: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +The PlatformIO Library Dependency Finder will find automatically dependent +libraries by scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html + diff --git a/lib/sensor/led.cpp b/lib/sensor/led.cpp new file mode 100755 index 0000000..5c0a355 --- /dev/null +++ b/lib/sensor/led.cpp @@ -0,0 +1,28 @@ +#include +#include "led.h" + +Led::Led(uint8_t pin) : pin(pin), state(false) { +} + +void Led::setup() { + pinMode(pin, OUTPUT); + state = false; +} + +void Led::turnOn() { + digitalWrite(pin, HIGH); + state = true; +} + +void Led::turnOff() { + digitalWrite(pin, LOW); + state = false; +} + +void Led::toggle() { + if (state) { + turnOff(); + } else { + turnOn(); + } +} \ No newline at end of file diff --git a/lib/sensor/led.h b/lib/sensor/led.h new file mode 100755 index 0000000..10a467d --- /dev/null +++ b/lib/sensor/led.h @@ -0,0 +1,19 @@ +#ifndef LED_H +#define LED_H + +#include + +class Led{ +public: + Led(uint8_t pin); + void setup(); + void turnOn(); + void turnOff(); + void toggle(); + +private: + uint8_t pin; + bool state; +}; + +#endif \ No newline at end of file diff --git a/lib/sensor/photoresistance_ohm_retrieval.cpp b/lib/sensor/photoresistance_ohm_retrieval.cpp new file mode 100755 index 0000000..f24c50b --- /dev/null +++ b/lib/sensor/photoresistance_ohm_retrieval.cpp @@ -0,0 +1,28 @@ +#include +#include "photoresistance_ohm_retrieval.h" + + +SensorOhm::SensorOhm(uint8_t pin_analog_read, float vcc, int32_t rFixed, float current) +: pin_analog_read(pin_analog_read), vcc(vcc), rFixed(rFixed), current(current) { + if (vcc > mega2560_max_vcc){ + Serial.println("FATAL: VCC too high !"); + while (true); // bloque le programme + } + if (current > mega2560_max_current){ + Serial.println("FATAL: Intensity too high !"); + while (true); + } +} + +void SensorOhm::setup() { + pinMode(pin_analog_read, INPUT); +} + +int32_t SensorOhm::readResistance() { + // The circuit is connected in series. + // The resistance of the photoresistor can be calculated using the voltage divider circuits. + int raw = analogRead(pin_analog_read); + float vOut = (raw / 1023.0f) * vcc; + int32_t res = (int32_t)(rFixed * (vcc - vOut)) / vOut; + return res; +} diff --git a/lib/sensor/photoresistance_ohm_retrieval.h b/lib/sensor/photoresistance_ohm_retrieval.h new file mode 100755 index 0000000..0cd37a3 --- /dev/null +++ b/lib/sensor/photoresistance_ohm_retrieval.h @@ -0,0 +1,27 @@ +#ifndef PHOTORESISANCE_OHM_RETRIEVAL_H +#define PHOTORESISANCE_OHM_RETRIEVAL_H + +#include + + +const float mega2560_max_current = 50e-3; // 50 mA +const float mega2560_max_vcc = 5.5; +const int32_t r_voltage_divider = 330e3; + +// SensorOhm calculate the value of the photoresistor with the voltage divider circuits +class SensorOhm { +public: + SensorOhm(uint8_t pin_analog_read = A0, float vcc = mega2560_max_vcc, int32_t rFixed = r_voltage_divider, float current = mega2560_max_current); + + void setup(); + int32_t readResistance(); + +private: + + uint8_t pin_analog_read; + float vcc; + int32_t rFixed; + float current; +}; + +#endif \ No newline at end of file diff --git a/lib/sensor/sensormanager.cpp b/lib/sensor/sensormanager.cpp new file mode 100644 index 0000000..08c4ff2 --- /dev/null +++ b/lib/sensor/sensormanager.cpp @@ -0,0 +1,121 @@ +#include +#include "sensormanager.h" + + +SensorManager::SensorManager(){} + +SensorManager::~SensorManager(){} + +/** +* @brief setup +* * init manager and photorésistor objects +* +* * @param nb_sensor @c uint8_t number of photoresistor +* @param analog_in @c uint8_t* array of pin identificators +* @return @c void +*/ +void SensorManager::setup(uint8_t nb_sensor, uint8_t *analog_in){ + nbPhotoSensor = nb_sensor; + for(uint8_t i = 0; i < nbPhotoSensor; i++){ + SensorOhm tmp(analog_in[i]); + sensor_list[i] = tmp; + sensor_list[i].setup(); + // init max and min array + if (unsigned_int){ + min[i]= 2e9; + max[i]= 0; + }else{ + min[i]= 2e9; + max[i]= -2e9; + } + } +} + +/** +* @brief get_resistance +* * Get resistives values of photosensors +* Warning res_tab +* * @param res_tab @c int32_t must be a local array pointer +* @param tab_lenght @c uint8_t equal to or greater than the number of photo-res managed +* @return @c void +*/ +void SensorManager::get_resistances(int32_t* res_tab, uint8_t tab_lenght){ + if (tab_lenght < nbPhotoSensor){ + Serial.print("Error bad tab size"); + return; + } + + for (uint8_t i = 0; i < nbPhotoSensor; i++) + { + res_tab[i] = get_resistances_at(i); + } +} + +void SensorManager::updateMinMax(uint8_t index, int32_t current_res) { + if(min[index] > current_res){ + min[index] = current_res; + } + if(max[index] < current_res){ + max[index] = current_res; + } +} + +/** +* @brief get_min_max +* * Get highest and lowest resistives values of photosensors +* Warning res_tab +* * @param min_res_tab_max_res_tab @c int32_t must be a local array pointer +* @param tab_lenght @c uint8_t equal to or greater than the number of photo-res managed +* @return @c void +*/ +void SensorManager::get_min_max(int32_t* min_res_tab, int32_t* max_res_tab, uint8_t tab_lenght){ + if (tab_lenght < nbPhotoSensor){ + Serial.print("Error bad tab size"); + return; + } + + for (uint8_t i = 0; i < nbPhotoSensor; i++) + { + min_res_tab[i] = min[i]; + max_res_tab[i] = max[i]; + } +} + +uint8_t SensorManager::get_nb_photores(){ + return nbPhotoSensor; +} + +void SensorManager::print_current_res(){ + int32_t curr[nbPhotoSensor]; + get_resistances(curr, nbPhotoSensor); + + for (uint8_t i = 0; i < nbPhotoSensor; i++) + { + Serial.print("Photo-resistance n°"); + Serial.print(i, DEC); + Serial.print(" : "); + Serial.print(curr[i], DEC); + Serial.print(" | "); + } + Serial.println(); +} + +void SensorManager::print_min_max_res(){ + for (uint8_t i = 0; i < nbPhotoSensor; i++) + { + Serial.print("Photo-resistance n°"); + Serial.print(i, DEC); + Serial.print(" : min = "); + Serial.print(min[i], DEC); + Serial.print(", max = "); + Serial.print(max[i], DEC); + Serial.print(" | "); + } + Serial.println(); +} + +int32_t SensorManager::get_resistances_at(uint8_t index){ + int32_t tmp = sensor_list[index].readResistance(); + updateMinMax(index, tmp); + return tmp; +} \ No newline at end of file diff --git a/lib/sensor/sensormanager.h b/lib/sensor/sensormanager.h new file mode 100644 index 0000000..cc774bd --- /dev/null +++ b/lib/sensor/sensormanager.h @@ -0,0 +1,31 @@ +#ifndef SENSORMANAGER_H +#define SENSORMANAGER_H + +#include +#include "photoresistance_ohm_retrieval.h" + +class SensorManager +{ +private: + static const uint8_t max_sensor = 10; + static const bool unsigned_int = 0; + uint8_t nbPhotoSensor; + SensorOhm sensor_list[max_sensor]; + int32_t min[max_sensor], max[max_sensor]; + + +public: + SensorManager(); + ~SensorManager(); + + void setup(uint8_t nb_sensor, uint8_t *analog_in); + uint8_t get_nb_photores(); + int32_t get_resistances_at(uint8_t index); + void get_resistances(int32_t* res_tab, uint8_t tab_lenght); + void get_min_max(int32_t* min_res_tab, int32_t* max_res_tab, uint8_t tab_lenght); + void updateMinMax(uint8_t index, int32_t current_res); + void print_current_res(); + void print_min_max_res(); +}; + +#endif \ No newline at end of file diff --git a/lib/storage/storage_interface.cpp b/lib/storage/storage_interface.cpp new file mode 100644 index 0000000..762f564 --- /dev/null +++ b/lib/storage/storage_interface.cpp @@ -0,0 +1,263 @@ +#include "storage_interface.h" +#include +#include + + +// Manual implements of EEPROM.put() for few uint type + +uint16_t inline read_eeprom_uint16(uint8_t idx){ + uint8_t tmp; + tmp = EEPROM.read(idx); // read high byte + return EEPROM.read(idx + 1) | (tmp << 8); // read low byte +} + +void inline write_eeprom_uint16(uint8_t idx, uint16_t value){ + EEPROM.write(idx, value >> 8); // write high byte + EEPROM.write(idx + 1, value & 0xFF); // write low byte +} + +uint32_t inline read_eeprom_uint32(uint8_t idx) { + uint32_t result = 0; + + // Byte 1 (High level : MSB) + result |= (uint32_t)EEPROM.read(idx) << 24; + + // Byte 2 + result |= (uint32_t)EEPROM.read(idx + 1) << 16; + + // Byte 3 + result |= (uint32_t)EEPROM.read(idx + 2) << 8; + + // Byte 4 (Low level : LSB) + result |= (uint32_t)EEPROM.read(idx + 3); + + return result; +} + +void inline write_eeprom_uint32(uint8_t idx, uint32_t value) { + + // Byte 1 (High level : MSB) + EEPROM.write(idx, (uint8_t)(value >> 24)); + + // Byte 2 + EEPROM.write(idx + 1, (uint8_t)(value >> 16)); + + // Byte 3 + EEPROM.write(idx + 2, (uint8_t)(value >> 8)); + + // Byte 4 (Low level : LSB) + EEPROM.write(idx + 3, (uint8_t)(value & 0xFF)); +} + +Storage_interface::Storage_interface(){} + +Storage_interface::~Storage_interface(){} + +void Storage_interface::clear_eeprom(){ + for (uint16_t i = 0 ; i < EEPROM.length() ; i++) { + EEPROM.write(i, 0); + } +} + +void Storage_interface::clear_eeprom_at(uint16_t idx){ + for (uint16_t i = idx ; i < EEPROM.length() ; i++) { + EEPROM.write(i, 0); + } +} + +// legacy function (don't finished and never tested) +/* +uint16_t get_nb_package_legacy(){ + uint8_t flags, nb_photo_sensor, nb_temp_sensor, temp_size_t, photo_size_t, schedule, tmp, timestamp_size_t; + uint16_t nb_package = 0, nb_measure, start_package = 0, timestamp_sum_size, next_position; + bool timestamp; + flags = EEPROM.read(start_package); + + while ((flags & 0b1) != 0){ + nb_package++; + nb_photo_sensor = EEPROM.read(start_package + OFFSET_NB_PHOTO_SENSOR); + photo_size_t = EEPROM.read(start_package + OFFSET_PHOTO_MEASURES_SIZE); + + nb_temp_sensor = EEPROM.read(start_package + OFFSET_NB_TEMP_SENSOR); + temp_size_t = EEPROM.read(start_package + OFFSET_TEMP_MEASURES_SIZE); + + tmp = EEPROM.read(start_package + OFFSET_NB_TEMP_SENSOR); // read high byte + nb_measure = EEPROM.read(start_package + OFFSET_NB_TEMP_SENSOR + 1) | (tmp << 8); // read low byte + + timestamp = false; + timestamp_size_t = EEPROM.read(start_package + OFFSET_timestamp_SIZE); + if ((flags & 0b001) != 0 ){ + timestamp = true; + schedule = EEPROM.read(start_package + OFFSET_MEASURES_SCH); + timestamp_sum_size = (nb_measure/schedule) * timestamp_size_t; + }else if ((flags & 0b01) != 0){ + timestamp = true; + timestamp_sum_size = nb_measure * timestamp_size_t; + }else{ + timestamp_sum_size = 0; + } + } + return nb_package; +}*/ + +/** +* @brief get_last_header_nbpackage +* * +* +* * @param last_header_idx @c uint16_t EEPROM index of the last header +* @return @c uint16_t EEPROM stored package number +*/ +uint16_t Storage_interface::get_last_header_nbpackage(uint16_t* last_header_idx){ + uint8_t flags; + uint16_t start_package = 0, nb_package = 0; + *last_header_idx = 0; + flags = EEPROM.read(start_package); + + while ((flags & 0b1) != 0){ + nb_package++; + *last_header_idx = start_package; + start_package = read_eeprom_uint16(start_package + OFFSET_NEXT_PACKAGE); + flags = EEPROM.read(start_package); + nb_package++; + } + return nb_package; +} + +// factorise reused code implementation and keep level acces +uint16_t Storage_interface::get_nb_package(){ + uint16_t pointer; + return get_last_header_nbpackage(&pointer); +} + + +void Storage_interface::get_store_struct(uint16_t offset, bool* timestamp, bool* is_final_set, bool* photo_sensor, bool* temp_sensor, uint8_t* timestamp_schedule, uint8_t* nb_photo_sensor, uint8_t* nb_temp_sensor, uint8_t* photo_size, uint8_t* temp_size, uint16_t* p_next_package, uint16_t* nb_measures){ + uint8_t flags; + flags = EEPROM.read(offset); + + // Checking there if a struct is possibly at the index + if ((flags & 0b1) == 0){ + Serial.println("Missing struct index or bad index"); + return; + } + + // timestamps reads + *timestamp = false; + if ((flags & 0b001) != 0 ){ + *timestamp = true; + *timestamp_schedule = EEPROM.read(offset + OFFSET_MEASURES_SCH); + } + *timestamp_schedule = 0; + if (flags & 0b01){ + *timestamp = true; + if (EEPROM.read(offset + OFFSET_MEASURES_SCH) != 0) + Serial.println("Incoherent timestamp parameter in the header."); + } + + // photo res reads + *photo_sensor = false; + if (flags & 0b0001){ + *photo_sensor = true; + *nb_photo_sensor = EEPROM.read(offset + OFFSET_NB_PHOTO_SENSOR); + } + + // temp res reads + *temp_sensor = false; + if (flags & 0b00001){ + *temp_sensor = true; + *nb_temp_sensor = EEPROM.read(offset + OFFSET_NB_TEMP_SENSOR); + } + + // gather the index of the next package in the EEPROM + *p_next_package = read_eeprom_uint16(offset + OFFSET_NEXT_PACKAGE); + + // gather the number of measures + *nb_measures = read_eeprom_uint16(offset + OFFSET_NB_TEMP_SENSOR); +} + +void Storage_interface::set_store_struct(uint16_t offset, bool timestamp, bool is_final_set, bool photo_sensor, bool temp_sensor, uint8_t timestamp_schedule, uint8_t nb_photo_sensor, uint8_t nb_temp_sensor, uint8_t photo_size, uint8_t temp_size){ + uint8_t flags = 0; + + // Existing package flag for function package searcher + flags = flags | 0b10000000; + + // Timestamp init struct + if(timestamp_schedule != 0){ + flags = flags | 0b00100000; + EEPROM.write(offset + OFFSET_MEASURES_SCH, timestamp_schedule); + if(!timestamp) + Serial.println("Bad timestamp parameter for header writer."); + }else{ + EEPROM.write(offset + OFFSET_MEASURES_SCH, 0); + if (timestamp) + flags = flags | 0b01000000; + } + + // Sensor part + if (photo_sensor){ + flags = flags | 0b00010000; + EEPROM.write(offset + OFFSET_NB_PHOTO_SENSOR, nb_photo_sensor); + }else{ + EEPROM.write(offset + OFFSET_NB_PHOTO_SENSOR, 0); + if (nb_photo_sensor != 0) + Serial.println("Bad photo sensor parameter for header writer."); + } + + if (temp_sensor){ + flags = flags | 0b00001000; + EEPROM.write(offset + OFFSET_NB_TEMP_SENSOR, nb_temp_sensor); + }else{ + EEPROM.write(offset + OFFSET_NB_TEMP_SENSOR, 0); + if (nb_temp_sensor != 0) + Serial.println("Bad temperature sensor parameter for header writer."); + } + + // TODO Analyse if is_final_set just be remove from parameter + if (is_final_set){ + flags = flags | 0b00000100; + } + + // uint16_t next package pointer set at 0 + write_eeprom_uint16(offset + OFFSET_NEXT_PACKAGE, offset + OFFSET_START_DATA_MEASURES); + + // set number of measures to 0 + write_eeprom_uint16(offset + OFFSET_NB_MEASURES, 0); + + // write flags header + EEPROM.write(offset , flags); + + clear_eeprom_at(offset + OFFSET_START_DATA_MEASURES); +} + +void Storage_interface::add_last_package(bool timestamp, bool is_final_set, bool photo_sensor, bool temp_sensor, uint8_t timestamp_schedule, uint8_t nb_photo_sensor, uint8_t nb_temp_sensor, uint8_t photo_size, uint8_t temp_size, uint16_t nb_measures){ + uint16_t p_last_header, free_space; + uint8_t flags; + + get_last_header_nbpackage(&p_last_header); + flags = EEPROM.read(p_last_header); + + // change is_last_package flag + flags = flags & 0b11111011; + EEPROM.write(p_last_header , flags); + + free_space = EEPROM.read(p_last_header + OFFSET_NEXT_PACKAGE); + set_store_struct(free_space, timestamp, is_final_set, photo_sensor, temp_sensor, timestamp_schedule, nb_photo_sensor, nb_temp_sensor, photo_size, temp_size); +} + +// Dont check if the stored measure structure match with the header +void Storage_interface::add_measure(uint8_t* photo_values, uint8_t* temp_values, uint32_t timestamp, uint8_t nb_photo, uint8_t nb_temp){ + uint16_t p_last_header, free_space, idx; + + get_last_header_nbpackage(&p_last_header); + + free_space = EEPROM.read(p_last_header + OFFSET_NEXT_PACKAGE); + EEPROM.write(p_last_header + OFFSET_NB_MEASURES, EEPROM.read(p_last_header + OFFSET_NB_MEASURES) + 1); + + EEPROM.put(free_space, timestamp); + idx = p_last_header + int32_size; + for(int i = 0; i < nb_photo; i++, idx += int8_size){ + EEPROM.put(idx, photo_values[i]); + } + for(int i = 0; i < nb_temp; i++, idx += int8_size){ + EEPROM.put(idx, temp_values[i]); + } +} \ No newline at end of file diff --git a/lib/storage/storage_interface.h b/lib/storage/storage_interface.h new file mode 100644 index 0000000..0b2813d --- /dev/null +++ b/lib/storage/storage_interface.h @@ -0,0 +1,53 @@ +#ifndef STORAGE_INTERFACE_H +#define STORAGE_INTERFACE_H +#include +#include + +// based on https://docs.arduino.cc/learn/programming/eeprom-guide/ + +class Storage_interface +{ +private: + + static constexpr uint8_t OFFSET_MEASURES_SCH = 1, OFFSET_NB_PHOTO_SENSOR = 2, OFFSET_NB_TEMP_SENSOR = 3, OFFSET_PHOTO_MEASURES_SIZE = 4, OFFSET_TEMP_MEASURES_SIZE = 5, OFFSET_NB_MEASURES = 6, OFFSET_NEXT_PACKAGE = 8, OFFSET_START_DATA_MEASURES = 10; // unit in byte + static constexpr uint8_t int32_size = sizeof(int32_t), int16_size = sizeof(int16_t), int8_size = sizeof(int8_t); + static constexpr uint16_t MEGA_2560_EEPROM_SIZE = 4096; + + void clear_eeprom(); + void clear_eeprom_at(uint16_t idx); + + void get_store_struct(uint16_t offset, bool* timestamp, bool* is_final_set, bool* photo_sensor, bool* temp_sensor, uint8_t* timestamp_schedule, uint8_t* nb_photo_sensor, uint8_t* nb_temp_sensor, uint8_t* photo_size, uint8_t* temp_size, uint16_t* p_next_package, uint16_t* nb_measures); + void set_store_struct(uint16_t offset, bool timestamp, bool is_final_set, bool photo_sensor, bool temp_sensor, uint8_t timestamp_schedule, uint8_t nb_photo_sensor, uint8_t nb_temp_sensor, uint8_t photo_size, uint8_t temp_size); + + uint16_t get_last_header_nbpackage(uint16_t* last_header_idx); + +public: + + uint16_t get_nb_package(); + void add_last_package(bool timestamp, bool is_final_set, bool photo_sensor, bool temp_sensor, uint8_t timestamp_schedule, uint8_t nb_photo_sensor, uint8_t nb_temp_sensor, uint8_t photo_size, uint8_t temp_size, uint16_t nb_measures); + void add_measure(uint8_t* photo_values, uint8_t* temp_values, uint32_t timestamp, uint8_t nb_photo, uint8_t nb_temp); + Storage_interface(); + ~Storage_interface(); + + // Dont check if the stored measure structure match with the header + template< typename T, typename TT> + void add_measure(T* photo_values, TT* temp_values, uint32_t timestamp, uint8_t nb_photo, uint8_t nb_temp){ + uint16_t p_last_header, free_space, idx; + + get_last_header_nbpackage(&p_last_header); + + free_space = EEPROM.read(p_last_header + OFFSET_NEXT_PACKAGE); + EEPROM.write(p_last_header + OFFSET_NB_MEASURES, EEPROM.read(p_last_header + OFFSET_NB_MEASURES) + 1); + + EEPROM.put(free_space, timestamp); + idx = p_last_header + int32_size; + for(int i = 0; i < nb_photo; i++, idx += sizeof(T)){ + EEPROM.put(idx, photo_values[i]); + } + for(int i = 0; i < nb_temp; i++, idx += sizeof(TT)){ + EEPROM.put(idx, temp_values[i]); + } + } +}; + +#endif \ No newline at end of file diff --git a/lib/traitement/traitement.cpp b/lib/traitement/traitement.cpp new file mode 100644 index 0000000..868831c --- /dev/null +++ b/lib/traitement/traitement.cpp @@ -0,0 +1,23 @@ +#include +#include "traitement.h" + +Traitement::Traitement(){} + +Traitement::~Traitement(){} + + +/** +* @brief map_r +* * Normalise resistance value +* +* * @param min_res_tab @c int32_t* +* @param max_res_tab @c int32_t* +* @param res_values @c int32_t* +* @param result @c int32_t* +* @param tab_lenght @c uint8_t +*/ +void Traitement::map_r(int32_t* min_res_tab, int32_t* max_res_tab, int32_t* res_values, int16_t* result, uint8_t tab_lenght){ + for(int i = 0; i < tab_lenght; i++){ + result[i] = map(res_values[i], min_res_tab[i], max_res_tab[i], min_out_norm, max_out_norm); + } +} \ No newline at end of file diff --git a/lib/traitement/traitement.h b/lib/traitement/traitement.h new file mode 100644 index 0000000..a8bf70d --- /dev/null +++ b/lib/traitement/traitement.h @@ -0,0 +1,19 @@ +#ifndef TRAITEMENT_H +#define TRAITEMENT_H + +#include + +class Traitement +{ +private: +const uint8_t min_out_norm = 0, max_out_norm = 255; + +public: + Traitement(); + ~Traitement(); + + void map_r(int32_t* min_res_tab, int32_t* max_res_tab, int32_t* res_values, int16_t* result, uint8_t tab_lenght); + +}; + +#endif \ No newline at end of file diff --git a/platformio.ini b/platformio.ini new file mode 100755 index 0000000..c2f1ac1 --- /dev/null +++ b/platformio.ini @@ -0,0 +1,22 @@ +; PlatformIO Project Configuration File +; +; Build options: build flags, source filter +; Upload options: custom upload port, speed and extra flags +; Library options: dependencies, extra library storages +; Advanced options: extra scripting +; +; Please visit documentation for the other options and examples +; https://docs.platformio.org/page/projectconf.html + +[env:megaADK] +platform = atmelavr +board = megaADK +framework = arduino +test_framework = unity +build_flags = -std=gnu++17 +lib_deps = + northernwidget/DS3231@^1.1.2 + arduino-libraries/Ethernet + robtillaart/CRC + +lib_ldf_mode = deep+ \ No newline at end of file diff --git a/src/Notes.txt b/src/Notes.txt new file mode 100755 index 0000000..675ea3b --- /dev/null +++ b/src/Notes.txt @@ -0,0 +1,24 @@ +40 en moyenne +700 grand max avec lumière téléphone +téléphoen 100 à 150 lumen +-> soit environ 100 lux a 1m contre 100 000 lux en plein jours sur 1m² +résistance 120 ohm + + +0 a 1024 en analogique + + + +DateTime of RTC: 2025-11-21 10:46:8 | Temp of RTC: 24.0000 +Photo-resistance n°0 : 620 | Photo-resistance n°1 : 686 | Photo-resistance n°2 : 854 | Photo-resistance n°3 : 653 | Photo-resistance n°4 : 1058 | Photo-resistance n°5 : 686 | +Photo-resistance n°0 : min = 128, max = 2062273 | Photo-resistance n°1 : min = 160, max = 5554006 | Photo-resistance n°2 : min = 193, max = 784809 | Photo-resistance n°3 : min = 96, max = 4755895 | Photo-resistance n°4 : min = 323, max = 1939035 | Photo-resistance n°5 : min = 96, max = 289546 | + + +DateTime of RTC: 2025-11-21 10:46:10 | Temp of RTC: 24.0000 +Photo-resistance n°0 : 620 | Photo-resistance n°1 : 686 | Photo-resistance n°2 : 888 | Photo-resistance n°3 : 653 | Photo-resistance n°4 : 1092 | Photo-resistance n°5 : 720 | +Photo-resistance n°0 : min = 128, max = 2062273 | Photo-resistance n°1 : min = 160, max = 5554006 | Photo-resistance n°2 : min = 193, max = 784809 | Photo-resistance n°3 : min = 96, max = 4755895 | Photo-resistance n°4 : min = 323, max = 1939035 | Photo-resistance n°5 : min = 96, max = 289546 | + + +DateTime of RTC: 2025-11-21 10:46:13 | Temp of RTC: 24.0000 +Photo-resistance n°0 : 620 | Photo-resistance n°1 : 720 | Photo-resistance n°2 : 888 | Photo-resistance n°3 : 653 | Photo-resistance n°4 : 1092 | Photo-resistance n°5 : 720 | +Photo-resistance n°0 : min = 128, max = 2062273 | Photo-resistance n°1 : min = 160, max = 5554006 | Photo-resistance n°2 : min = 193, max = 784809 | Photo-resistance n°3 : min = 96, max = 4755895 | Photo-resistance n°4 : min = 323, max = 1939035 | Photo-resistance n°5 : min = 96, max = 289546 | \ No newline at end of file diff --git a/src/Robot_Go_West.code-workspace b/src/Robot_Go_West.code-workspace new file mode 100755 index 0000000..8ddf12a --- /dev/null +++ b/src/Robot_Go_West.code-workspace @@ -0,0 +1,9 @@ +{ + "folders": [ + { + "name": "Robot_Go_West", + "path": ".." + } + ], + "settings": {} +} \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp new file mode 100755 index 0000000..550ca56 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,108 @@ +#include +#include +#include + +#include "photoresistance_ohm_retrieval.h" +#include "myFunction.h" +#include "sensormanager.h" +#include "traitement.h" +#include "storage_interface.h" + +int ledPin = 2, decTemp = 4; // nb decimal temperature printing +const int nbPhotoSensor = 6; +uint8_t analogPin [nbPhotoSensor] = {A0, A1, A2 ,A3 ,A5 ,A6}; +int32_t min_res [nbPhotoSensor] = {128, 160, 193, 96, 323, 96}; +int32_t max_res [nbPhotoSensor] = {2062273, 5554006, 784809, 4755895, 1939035, 289546}; +bool winter = 1; + +SensorOhm test[nbPhotoSensor]; +SensorManager s_manager; +Traitement tr; + +RTClib myRTC; +DS3231 Clock; + +// void setup() { +// Wire.begin(); +// Serial.begin(9600); +// Serial.println("\nScanning I2C bus..."); + +// for (byte addr = 1; addr < 127; addr++) { +// Wire.beginTransmission(addr); +// if (Wire.endTransmission() == 0) { +// Serial.print("I2C device found at address 0x"); +// Serial.println(addr, HEX); +// } +// } +// Serial.println("Scan complete."); +// constexpr time_t tstmp {1660644000UL}; + +// Clock.setEpoch(tstmp, false); +// // set to 24h +// Clock.setClockMode(false); +// } + +void setup() { + Wire.begin(); + Serial.begin(9600); + //pinMode(ledPin, OUTPUT); + + s_manager.setup(nbPhotoSensor, analogPin); +} + +void loop() { + DateTime now; + + if (Serial.available()) { + unsigned long epoch = Serial.parseInt(); // read epoch + if (epoch > 1000000000UL) { // sanity check + // summer or winter time + if (winter == 1) { + epoch += 3600; + } + Clock.setEpoch(epoch); + Serial.print("RTC mis à jour avec epoch: "); + Serial.println(epoch); + } + while (Serial.available()) Serial.read(); // clean buffer + + // Just for verification of DS3231 Data + // check now the data from ESP8266 and DS3231 + // get year + bool century = false; + bool h12Flag; + bool pmFlag; + now = myRTC.now(); + Serial.print("\n\n"); + Serial.print(" DateTime of DS3231: "); + Serial.print(Clock.getYear(), DEC); + Serial.print("-"); + Serial.print(Clock.getMonth(century), DEC); + Serial.print("-"); + Serial.print(Clock.getDate(), DEC); + Serial.print(" "); + Serial.print(Clock.getHour(h12Flag, pmFlag), DEC); + Serial.print(":"); + Serial.print(Clock.getMinute(), DEC); + Serial.print(":"); + Serial.print(Clock.getSecond(), DEC); + Serial.print(" - weekday "); + Serial.print(Clock.getDoW(), DEC); + Serial.println(); + } + + printDate(Clock, decTemp); + + s_manager.print_current_res(); + s_manager.print_min_max_res(); + + int32_t res_array[nbPhotoSensor]/*, min_array[nbPhotoSensor], max_array[nbPhotoSensor]*/; + int16_t result[nbPhotoSensor]; + s_manager.get_resistances(res_array, nbPhotoSensor); + + tr.map_r(min_res, max_res, res_array, result, nbPhotoSensor); + print_named_tab(result, nbPhotoSensor, "int32_t normalised",(uint8_t) 18); + + + delay(2000); +} diff --git a/src/myFunction.cpp b/src/myFunction.cpp new file mode 100644 index 0000000..cbf8d4a --- /dev/null +++ b/src/myFunction.cpp @@ -0,0 +1,45 @@ +#include +#include +#include + +#include "myFunction.h" + +void printDate(DS3231 Clock, int8_t decTemp){ + // RTClib myRTC; + + // DateTime now = myRTC.now(); + + // Serial.print(now.year(), DEC); + // Serial.print('/'); + // Serial.print(now.month(), DEC); + // Serial.print('/'); + // Serial.print(now.day(), DEC); + // Serial.print(' '); + // Serial.print(now.hour(), DEC); + // Serial.print(':'); + // Serial.print(now.minute(), DEC); + // Serial.print(':'); + // Serial.print(now.second(), DEC); + // Serial.println(); + + + float temp = Clock.getTemperature(); + RTClib myRTC; + DateTime now = myRTC.now(); + + Serial.print("\n\n"); + Serial.print("DateTime of RTC: "); + Serial.print(now.year(), DEC); + Serial.print("-"); + Serial.print(now.month(), DEC); + Serial.print("-"); + Serial.print(now.day(), DEC); + Serial.print(" "); + Serial.print(now.hour(), DEC); + Serial.print(":"); + Serial.print(now.minute(), DEC); + Serial.print(":"); + Serial.print(now.second(), DEC); + Serial.print(" | Temp of RTC: "); + Serial.println(temp, decTemp); +} \ No newline at end of file diff --git a/src/myFunction.h b/src/myFunction.h new file mode 100644 index 0000000..cccacd9 --- /dev/null +++ b/src/myFunction.h @@ -0,0 +1,23 @@ +#ifndef MYFUNCTION_H +#define MYFUNCTION_H + +#include +#include +#include + +void printDate(DS3231 Clock, int8_t decTemp); + + +template +void print_named_tab(T v_array, uint8_t array_size, const char *tab_name, uint8_t size_tab_name) { + char buffer [32]; + + for(int i = 0; i < array_size; i++){ + // snprintf(buffer, sizeof(buffer), tab_name, " n° "), i, " : ", v_array[i]; + snprintf(buffer, sizeof(buffer), "%s n° %d : ", tab_name, i); + Serial.print(buffer); + Serial.print(v_array[i], DEC); + Serial.println(); + } +} +#endif \ No newline at end of file diff --git a/storage_structure.drawio b/storage_structure.drawio new file mode 100644 index 0000000..1eae6cf --- /dev/null +++ b/storage_structure.drawio @@ -0,0 +1,226 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/storage_structure.drawio.png b/storage_structure.drawio.png new file mode 100644 index 0000000000000000000000000000000000000000..e2f9be28b1a86326caa75ff618aba357c6750be9 GIT binary patch literal 170649 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 z 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�_Qgw5cOM4(gz%(K!jns<_V8>konEySWh*R#% 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 M4kzuO*b=G#1Lu9SWB>pF literal 0 HcmV?d00001 diff --git a/test/EEPROM_test_struct.cpp b/test/EEPROM_test_struct.cpp new file mode 100644 index 0000000..1193260 --- /dev/null +++ b/test/EEPROM_test_struct.cpp @@ -0,0 +1,12 @@ +#include +#include +#include "storage_interface.h" + +void setUp(void) +{ + Serial.begin(9600); +} + +void test_put_struct(){ + +} diff --git a/test/README b/test/README new file mode 100755 index 0000000..9b1e87b --- /dev/null +++ b/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PlatformIO Test Runner and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PlatformIO Unit Testing: +- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html diff --git a/time.py b/time.py new file mode 100755 index 0000000..36b6d1e --- /dev/null +++ b/time.py @@ -0,0 +1,12 @@ +import serial +import time + +# Remplace par ton port Arduino +ser = serial.Serial('/dev/ttyACM0', 9600) +time.sleep(2) # attendre que l’Arduino démarre + +epoch = int(time.time()) # secondes depuis 1970 +ser.write(f"{epoch}\n".encode()) # envoie sous forme texte, terminé par \n + +ser.close() +print(f"Envoyé epoch: {epoch}")