commit 42e49ce2892b41e687c9a6a0dbc9b8c7f674d3c8 Author: chschloetel Date: Fri Nov 1 21:51:43 2024 +0100 Create Project diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..89cc49c --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.pio +.vscode/.browse.c_cpp.db* +.vscode/c_cpp_properties.json +.vscode/launch.json +.vscode/ipch diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..080e70d --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,10 @@ +{ + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "platformio.platformio-ide" + ], + "unwantedRecommendations": [ + "ms-vscode.cpptools-extension-pack" + ] +} diff --git a/fritzing_sketch.fzz b/fritzing_sketch.fzz new file mode 100644 index 0000000..3845870 Binary files /dev/null and b/fritzing_sketch.fzz differ diff --git a/include/GPIO.cpp b/include/GPIO.cpp new file mode 100644 index 0000000..8e3e8f8 --- /dev/null +++ b/include/GPIO.cpp @@ -0,0 +1,36 @@ +#include "GPIO.h" + +// Konstruktor ( Quasi das Setup in einer Arduino.cpp - für jedes Objekt einzeln) +IO::IO(byte pin, bool input) { + this->GPIOPin = pin; + this->GPIOinput = input; + + if (this->GPIOinput == false){ + pinMode(this->GPIOPin, OUTPUT); + } else { + pinMode(this->GPIOPin, INPUT); + } + +} + +byte IO::SetHigh() { + digitalWrite(this->GPIOPin, HIGH); + if (this->GetState() == HIGH){ + return 100; + } else { + return 200; + } +} + +byte IO::SetLow() { + digitalWrite(this->GPIOPin, LOW); + if (this->GetState() == LOW){ + return 101; + } else { + return 201; + } +} + +byte IO::GetState() { + return digitalRead(this->GPIOPin); +} diff --git a/include/GPIO.h b/include/GPIO.h new file mode 100644 index 0000000..e18c0a7 --- /dev/null +++ b/include/GPIO.h @@ -0,0 +1,19 @@ +#ifndef GPIO_h +#define GPIO_h + + +#include + +class IO { + private: + byte GPIOPin; // byte heißt 0-255 = 8 Bit + bool GPIOinput; + public: + IO(byte pin, bool input); + byte SetHigh(); + byte SetLow(); + byte GetState(); +}; + + +#endif \ No newline at end of file diff --git a/include/README b/include/README new file mode 100644 index 0000000..194dcd4 --- /dev/null +++ b/include/README @@ -0,0 +1,39 @@ + +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 usual convention is to give header files names that end with `.h'. +It is most portable to use only letters, digits, dashes, and underscores in +header file names, and at most one dot. + +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/ModbusSlaveConfigToEEPROM.h b/lib/ModbusSlaveConfigToEEPROM.h new file mode 100644 index 0000000..ace6470 --- /dev/null +++ b/lib/ModbusSlaveConfigToEEPROM.h @@ -0,0 +1,42 @@ +#ifndef ModbusSlaveConfigToEEPROM_H +#define ModbusSlaveConfigToEEPROM_H +#include +#include + +class ModBusConfig{ + public: + ModBusConfig(int ID, int BAUDRATE); + void SetModbusID(int ID); + void SetBaudRate(int BAUDRATE); + int GetModbusID(); + int GetBaudRate(); + private: + int ModBusID; + int ModBusBaudrate; +}; + +void ModBusConfig::SetModbusID(int BAUDRATE){ + EEPROM.write(0,BAUDRATE); +} + +void ModBusConfig::SetBaudRate(int BAUDRATE){ + // divide Baudrate / 100 - to save it in Eeprom (8Bit 0 - 255) + int dividedBaudrate = BAUDRATE/100; + + if ( dividedBaudrate != EEPROM.read(1)){ + EEPROM.write(1,dividedBaudrate); + } + +} + +int ModBusConfig::GetModbusID(){ + return EEPROM.read(0); + +} + +int ModBusConfig::GetBaudRate(){ + int Baudrate = EEPROM.read(1)*100; + return Baudrate; +} + +#endif \ No newline at end of file diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..6debab1 --- /dev/null +++ b/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into executable file. + +The source code of each library should be placed in a an own separate directory +("lib/your_library_name/[here are source files]"). + +For example, see a structure of the following two libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional, 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 + +and a contents of `src/main.c`: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +PlatformIO Library Dependency Finder will find automatically dependent +libraries scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/platformio.ini b/platformio.ini new file mode 100644 index 0000000..47d7265 --- /dev/null +++ b/platformio.ini @@ -0,0 +1,28 @@ +; 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:pro16MHzatmega328] +platform = atmelavr +board = pro16MHzatmega328 +framework = arduino +lib_deps = + yaacov/ModbusSlave@^2.1.1 + robtillaart/SHT2x@^0.3.0 +upload_port = COM4 + +; [env:esp32devkitv4] +; platform = espressif32 +; board = az-delivery-devkit-v4 +; framework = arduino +; upload_port = COM4 +; upload_speed = 115200 +; lib_deps = +; yaacov/ModbusSlave@^2.1.1 +; robtillaart/SHT2x@^0.3.0 diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..f3eba33 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,194 @@ +#include +#include +#include +#include +#include + +// ID und Baudrate sollten zukünftig im EEPROM hinterlegt sein. +#define SLAVE_ID 8 // The Modbus slave ID, change to the ID you want to use. +#define SERIAL_BAUDRATERS485 9600 // Change to the baudrate you want to use for Modbus communication. +#define SERIAL_PORTRS485 Serial // Serial port to use for RS485 communication, change to the port you're using. + +// Comment out the following line if your not using RS485 +#define RS485_CTRL_PIN 8 // Change to the pin the RE/DE pin of the RS485 controller is connected to. +#define OutPutPin 9 + + +// The position in the array determines the address. Position 0 will correspond to Coil, Discrete input or Input register 0. +uint8_t ReadCoilRegister[] = {0, 1, 2}; // Add the registers for DigitalPins or else. +uint8_t output_pins[] = {0,1}; // Add the registers for Controlling Outputs +uint8_t ReadInputRegister[] = {0,1,2,3,4,5,6,7}; // Add the registers for Sensors /Light Temp etc. + +// You shouldn't have to change anything below this to get this example to work + +uint8_t ReadCoilRegister_size = sizeof(ReadCoilRegister) / sizeof(ReadCoilRegister[0]); // Get the size of the ReadCoilRegister array +uint8_t output_pins_size = sizeof(output_pins) / sizeof(output_pins[0]); // Get the size of the output_pins array +uint8_t ReadInputRegister_size = sizeof(ReadInputRegister) / sizeof(ReadInputRegister[0]); // Get the size of the ReadInputRegister array + +int ValueInputOne = 0; + +#ifdef RS485_CTRL_PIN +// Modbus object declaration +Modbus slave(SERIAL_PORTRS485, SLAVE_ID, RS485_CTRL_PIN); +#else +Modbus slave(SERIAL_PORTRS485, SLAVE_ID); +#endif + +//SHT2x //SHT21EnvSensor; + +// Modbus handler functions +// The handler functions must return an uint8_t and take the following parameters: +// uint8_t fc - function code +// uint16_t address - first register/coil address +// uint16_t length/status - length of data / coil status + +// Handle the function codes Force Single Coil (FC=05) and Force Multiple Coils (FC=15) and set the corresponding digital output pins (coils). + uint8_t writeDigitalOut(uint8_t fc, uint16_t address, uint16_t length) + { + // Check if the requested addresses exist in the array + if (address > output_pins_size || (address + length) > output_pins_size) + { + return STATUS_ILLEGAL_DATA_ADDRESS; + } + +// // Set the output pins to the given state. + for (uint16_t i = 0; i < length; i++) + { + // Write the value in the input buffer to the digital pin. + if (i == 0) + { + if (slave.readCoilFromBuffer(i) == 1){ + digitalWrite(OutPutPin,HIGH); + } else { + digitalWrite(OutPutPin,LOW); + } + } + + } + + return STATUS_OK; +} + +// Handle the function code Read Input Status (FC=02) and write back the values from the digital input pins (discreet input). +uint8_t fReadCoilRegister(uint8_t fc, uint16_t address, uint16_t length) +{ + // Check if the requested addresses exist in the array + if (address > ReadCoilRegister_size || (address + length) > ReadCoilRegister_size) + { + return STATUS_ILLEGAL_DATA_ADDRESS; + } + + // Read the digital inputs. + for (uint16_t i = 0; i < length; i++) + { + // Write the state of the digital pin to the response buffer. + if (i == 0) { + slave.writeCoilToBuffer(i, digitalRead(OutPutPin)); + } + if (i == 1) { + slave.writeCoilToBuffer(i, 0); + } + if (i == 2) { + slave.writeCoilToBuffer(i, 1); + } + + } + + return STATUS_OK; +} + +// Handle the function code Read Input Registers (FC=04) and write back the values from analog input pins (input registers). +uint8_t fReadInputRegister(uint8_t fc, uint16_t address, uint16_t length) +{ + // Check if the requested addresses exist in the array + if (address > ReadInputRegister_size || (address + length) > ReadInputRegister_size) + { + return STATUS_ILLEGAL_DATA_ADDRESS; + } + + // Read the inputs + for (uint16_t i = 0; i < length; i++) + { + // Write the state of the analog pin to the response buffer. + slave.writeRegisterToBuffer(i, analogRead(ReadInputRegister[address + i])); + float temperatur = 21.21;//SHT21EnvSensor.getTemperature(); + float humidity = 55.55;//SHT21EnvSensor.getHumidity(); + + if (i == 0){ + slave.writeRegisterToBuffer(i, millis()/1000); // = Minuten + } + if (i == 1){ + slave.writeRegisterToBuffer(i, SERIAL_BAUDRATERS485); + } + if (i == 2){ + slave.writeRegisterToBuffer(i, SLAVE_ID); + } + if (i == 3){ + ////SHT21EnvSensor.read(); + //float temperatur = //SHT21EnvSensor.getTemperature()*100; + float temp_temperatur = temperatur*100; + slave.writeRegisterToBuffer(i, (int)temp_temperatur); + } + if (i == 4){ + ////SHT21EnvSensor.read(); + //float humidity = //SHT21EnvSensor.getHumidity()*100; + float humidity = 55.55; + float temp_humidity = humidity*100; + slave.writeRegisterToBuffer(i, (int)temp_humidity); + } + if (i == 5){ + const double UG = 8314.3; // J/(kmol*K) (universelle Gaskonstante) + const double mw = 18.016; // kg/kmol (Molekulargewicht des Wasserdampfes) + const double K = 273.15; // °K (Entspricht 0°K) + const double tp = 6.1078; // hPa Triplettpunkt von Wasser bei 0,01°C + double absolutHumidity = (100000 * mw / UG * humidity / 100 * tp * pow(10, ((7.5 * temperatur) / (239 + temperatur))) / (temperatur + K))*100; + + slave.writeRegisterToBuffer(i, (int)absolutHumidity); + } + if (i == 6){ + slave.writeRegisterToBuffer(i, 5); // Später für Rückgabe Helligkeit + } + if (i == 7){ + slave.writeRegisterToBuffer(i, digitalRead(OutPutPin)); // Später für Rückgabe Helligkeit + } + } + + return STATUS_OK; +} + + +void setup() +{ + pinMode(8, OUTPUT); + + + // Register functions to call when a certain function code is received. + //slave.cbVector[CB_WRITE_COILS] = writeDigitalOut; + slave.cbVector[CB_READ_DISCRETE_INPUTS] = fReadCoilRegister; + slave.cbVector[CB_READ_INPUT_REGISTERS] = fReadInputRegister; + slave.cbVector[CB_WRITE_COILS] = writeDigitalOut; + + // Set the serial port and slave to the given baudrate. + SERIAL_PORTRS485.begin(SERIAL_BAUDRATERS485); + slave.begin(SERIAL_BAUDRATERS485); + //SHT21EnvSensor.begin(); + //SHT21EnvSensor.read(); + //Serial.begin(115200); + //Serial.printf("Start Modbus-Server"); + pinMode(OutPutPin,OUTPUT); + digitalWrite(OutPutPin,LOW); + + } + +void loop() +{ + // Listen for modbus requests on the serial port. + // When a request is received it's going to get validated. + // And if there is a function registered to the received function code, this function will be executed. + slave.poll(); + // if (ValueInputOne == 100) { + // digitalWrite(OutPutPin,HIGH); + // } else { + // digitalWrite(OutPutPin,LOW); + // } +} diff --git a/test/README b/test/README new file mode 100644 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