Merge branch 'master' of ssh://eggertjung.de:222/Filamentstr/02_Wasserbecken

avrIOhelper/io-helper.h

@@ -70,6 +70,8 @@ void ioHelperEdgeDetector(void);
 
 #define BitPA0 24 //R0
 #define BitPA1 25 //R1
+#define BitPA2 26 //R0
+#define BitPA3 27 //R1
 
 
 #define LED_GRN_NOTAUS_ANLAGE   BitPE4
@@ -85,13 +87,21 @@ void ioHelperEdgeDetector(void);
 #define LED_KALTWASSER_DRAN_RT  22
 
 #define LED_PUMPE_AN            11
+#define LED_SLAVE_PUMPE_AN      BitPL6
+#define LED_HEIZUNG             12
 
 #define OUT_PUMPE_STARTSTOP     BitPB5
 #define OUT_PUMPE_PWM           BitPB6
 
+#define OUT_SLAVE_PUMPE_STARTSTOP     BitPH6
+#define OUT_SLAVE_PUMPE_PWM           BitPB4
+
 #define OUT_VENTIL_PUMPE        BitPA0
 #define OUT_VENTIL_ABLASS       BitPA1
 
+#define OUT_SLAVE_VENTIL_PUMPE        BitPA2
+#define OUT_SLAVE_VENTIL_ABLASS       BitPA3
+
 //Inputs
 //Verknüpfen von Pin | Bit mit Bitposition (0...n) inStates[0...n/8].
 #define BitPinF0 0  //A0
@@ -123,9 +133,15 @@ void ioHelperEdgeDetector(void);
 #define IN_NOTAUS_ANLAGE_KALT   BitPinK1
 #define IN_NOTAUS_SCHRANK       BitPinK0
 
-#define IN_KLATWASSER_DRAN      9
+#define IN_KLATWASSER_DRAN      6
 
 #define BTN_BECKEN_FUELLEN      11
 #define BTN_BECKEN_LEEREN       12
 
+#define BTN_HEIZEN_AN           13
+#define BTN_HEIZEN_AUS          14
+
+#define BTN_SLAVE_BECKEN_FUELLEN      18
+#define BTN_SLAVE_BECKEN_LEEREN       19
+
 #endif

gefran_gtf.c

@@ -0,0 +1,45 @@
+#include "modbus-master.h"
+#include "gefran_gtf.h"
+#include <stdint.h>
+
+uint16_t gtf_firmware_version(uint8_t address){
+    return gtf_read_register(address, GTF_FIRMWARE_VERSION);
+}
+
+void gtf_init(uint8_t addr){
+    gtf_write_register(addr, 55, 1<<4);
+    gtf_write_register(addr, 56, 0);
+}
+
+uint16_t gtf_read_register(uint8_t address, uint8_t reg){
+    uint16_t val = 0;
+    readReg(address, reg, 1);
+    int8_t res = wait_receive(1, &val, 50);
+
+    if(!res)
+        return val;
+    else
+        return res;
+}
+
+int8_t gtf_write_register(uint8_t address, uint8_t reg, uint16_t value){
+    writeReg(address, reg, value);
+    return wait_write(50);
+}
+
+int8_t gtf_read_coil(uint8_t address, uint8_t coil){
+    uint16_t val=0;
+    readCoil(address, coil);
+    uint8_t res = wait_receive_coil(20);
+    if(res)
+        return -1;
+    return val;
+}
+
+int8_t gtf_write_coil(uint8_t address, uint8_t coil, uint8_t val){
+    writeCoil(address, coil, val);
+    uint8_t res = wait_write(20);
+    if(res)
+        return -1;
+    return val;
+}

gefran_gtf.h

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+#define GTF_PV 0
+#define GTF_OuP 2
+#define GTF_FIRMWARE_VERSION 122
+#define GTF_OPERATING_HOURS  161
+#define GTF_BAUDRATE         24
+#define GTF_SETPOINT         27
+#define GTF_POWER            106
+
+uint16_t gtf_firmware_version(uint8_t address);
+void gtf_init(uint8_t addr);
+uint16_t gtf_read_register(uint8_t address, uint8_t reg);
+int8_t gtf_write_register(uint8_t address, uint8_t reg, uint16_t value);
+int8_t gtf_read_coil(uint8_t address, uint8_t coil);
+int8_t gtf_write_coil(uint8_t address, uint8_t coil, uint8_t val);

heizung.c

@@ -0,0 +1,44 @@
+#include "gefran_gtf.h"
+#include "avrIOhelper/io-helper.h"
+#include "temperature.h"
+#include <stdint.h>
+#include <stdio.h>
+
+uint8_t heizung_state = 0;
+uint8_t heizung_ontemp = 0;
+
+void do_heizung(){
+
+    if(ADC_reading[1] > 69)
+        heizung_ontemp = 1;
+    if(ADC_reading[1] < 66)
+        heizung_ontemp = 0;
+
+    if(heizung_state && !heizung_ontemp){
+        gtf_write_register(5, 56, 500);
+        gtf_write_register(6, 56, 500);
+        gtf_write_register(7, 56, 500);
+        set_Output(LED_HEIZUNG, BLINK);
+    }
+    else if(heizung_state && heizung_ontemp){
+        gtf_write_register(5, 56, 0);
+        gtf_write_register(6, 56, 0);
+        gtf_write_register(7, 56, 0);
+        set_Output(LED_HEIZUNG, ON);
+    }
+    else{
+        gtf_write_register(5, 56, 0);
+        gtf_write_register(6, 56, 0);
+        gtf_write_register(7, 56, 0);
+        set_Output(LED_HEIZUNG, OFF);
+    }
+
+    if(read_Input(BTN_HEIZEN_AN, LEVEL)){
+        heizung_state = 1;
+    }
+
+    if(read_Input(BTN_HEIZEN_AUS, LEVEL)){
+        heizung_state = 0;
+    }
+
+}

heizung.h

@@ -0,0 +1,2 @@
+
+void do_heizung(void);

main.c

@@ -19,6 +19,7 @@
 #include "modbus-master.h"
 #include "gefran_gtf.h"
 #include "pumpe.h"
+#include "heizung.h"
 
 #include "util/delay.h"
 
@@ -222,6 +223,11 @@ int main()
     send_value(&mqtt_client, "/Filamentanlage/02_Wasserbecken/connected", 1);
     send_value(&mqtt_client, "/Filamentanlage/02_Wasserbecken/state/pumpe_warm", -1);
 
+
+    gtf_init(5);
+    gtf_init(6);
+    gtf_init(7);
+
     while(1)
     {
         wdt_reset(); // WDT reset at least every sec
@@ -239,10 +245,19 @@ int main()
             outStates[3] ^= outStatesBlinking[3];
         }
 
-        if(millis() - timer_send_temps > 500){
+        if(millis() - timer_send_temps > 5000){
             timer_send_temps = millis();
             send_temperatures();
-            printf("gefran: 0x%02X\n", gtf_firmware_version(5));
+            //printf("gefran firm: 0x%02X\n", gtf_firmware_version(5));
+            printf("gefran 5 OuP: 0x%02X\n", gtf_read_register(5, GTF_OuP));
+            printf("gefran 6 OuP: 0x%02X\n", gtf_read_register(6, GTF_OuP));
+            printf("gefran 7 OuP: 0x%02X\n", gtf_read_register(7, GTF_OuP));
+            //printf("gefran stat3: 0x%02X\n", gtf_read_register(5, 117));
+            ////printf("gefran stell: 0x%02X\n", gtf_read_register(5, 56));
+            ////printf("gefran disp: 0x%02X\n", gtf_read_register(5, 0));
+            //printf("gefran coil: 0x%02X\n", gtf_read_coil(5, 0));
+
+            //send_value(&mqtt_client, "/Filamentanlage/02_Wasserbecken/state/gtf5_power", gtf_read_register(5, GTF_POWER));
 
             if(read_Input(IN_KLATWASSER_DRAN, LEVEL)){
                 send_value(&mqtt_client, "/Filamentanlage/03_Wasserbecken/state/connected", 1);
@@ -264,6 +279,7 @@ int main()
 
         do_pumpe();
         do_notaus();
+        do_heizung();
 
 #if PLC_MQTT_ENABLED
         ioHelperSetBit(outStates, LED_BUS_OK, 1);

modbus-master.c

@@ -0,0 +1,165 @@
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <stdio.h>
+#include <util/delay.h>
+#include "modbus.h"
+
+#define receiveOkay (modbusGetBusState() & (1<<ReceiveCompleted))
+
+void timer2_init()
+{
+    TCCR2A = (1<<WGM21); //TIMER0 SET-UP: CTC MODE
+    TCCR2B|=(1<<CS21); //prescaler 8
+    OCR2A = 200; 
+	TIMSK2|=(1<<OCIE2A);
+}
+
+void modbus_master_init(){
+    modbusSetAddress(1); //better set this to sth.
+	modbusInit();
+    timer2_init(); // modbus tick timer
+}
+
+int8_t wait_receive(uint8_t len, uint16_t dest[], uint8_t timeout){
+
+    uint8_t breaker = timeout;
+    while(!receiveOkay && breaker) { //wait for client response, time out after 1s
+        breaker--;
+        _delay_ms(1);
+        if(breaker==0)
+            return -1;
+    }
+
+    if(receiveOkay) { //if this fails, there was either no response or a crc error
+        if(rxbuffer[1]&0x80) { //client responded with an error code
+            //handle the error
+            return -1;
+        }
+        else {
+            for(uint8_t x=0;x<len;x++) { //rxbuffer[2] should be 8 (4 registers => 8 bytes). You might want to check this at this point.
+                dest[x]=(rxbuffer[3+x*2]<<8)+rxbuffer[4+x*2]; //do sth with the acquired data.
+            }
+        }
+
+    }
+    return 0;
+}
+
+int8_t wait_write(uint8_t timeout){                              
+    uint8_t breaker = timeout;                                   
+    while(!receiveOkay && breaker) { //wait for client response, time out after 1s
+        breaker--;            
+        _delay_ms(1);             
+        if(breaker==0)            
+            return -1;            
+    }                        
+                         
+    if(receiveOkay) { //if this fails, there was either no response or a crc error
+        if(rxbuffer[1]&0x80) { //client responded with an error code
+            return rxbuffer[1]&0x80;                              
+        }                                                         
+    }                                                             
+    return 0;                 
+}
+
+void readReg(uint8_t slaveid, uint16_t address, uint8_t amount) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x03;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=0x00;
+    rxbuffer[5]=amount;
+    modbusSendMessage(5);
+}
+
+void writeReg(uint8_t slaveid, uint16_t address, uint16_t value) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x06;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=(value>>8)&0xFF;;
+    rxbuffer[5]=value&0xFF;
+    modbusSendMessage(5);
+}
+
+void readInputReg(uint8_t slaveid, uint16_t address, uint16_t amount) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x04;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=0;
+    rxbuffer[5]=amount;
+    modbusSendMessage(5);
+}
+
+void readInputState(uint8_t slaveid, uint16_t address, uint16_t amount) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x02;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=0;
+    rxbuffer[5]=amount;
+    modbusSendMessage(5);
+}
+
+void writeCoil(uint8_t slaveid, uint16_t address, uint16_t value) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x05;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=value?0xFF:0x00;
+    rxbuffer[5]=0;
+    modbusSendMessage(5);
+}
+
+void readCoil(uint8_t slaveid, uint16_t address) {
+    _delay_ms(2);
+    rxbuffer[0]=slaveid;
+    modbusSetAddress(slaveid);
+    rxbuffer[1]=0x01;
+    rxbuffer[2]=(address>>8)&0xFF;
+    rxbuffer[3]=address&0xFF;
+    rxbuffer[4]=0x00;
+    rxbuffer[5]=1;
+    modbusSendMessage(5);
+}
+
+int8_t wait_receive_coil(uint8_t timeout){
+
+    uint8_t breaker = timeout;
+    while(!receiveOkay && breaker) { //wait for client response, time out after 1s
+        breaker--;
+        _delay_ms(1);
+        if(breaker==0)
+            return -1;
+    }
+
+    if(receiveOkay) { //if this fails, there was either no response or a crc error
+        if(rxbuffer[1]&0x80) { //client responded with an error code
+            //handle the error
+            printf("modbus error\n");
+            return -1;
+        }
+        else {
+            printf("coil: %d\n", rxbuffer[3]);
+            return (int8_t)rxbuffer[3];
+        }
+
+    }
+    else
+        return -1;
+}
+
+ISR(TIMER2_COMPA_vect) { //this ISR is called 9765.625 times per second
+	modbusTickTimer();
+}

modbus-master.h

@@ -0,0 +1,13 @@
+#include <stdint.h>
+
+void timer2_init(void);
+void modbus_master_init(void);
+int8_t wait_receive(uint8_t len, uint16_t dest[], uint8_t timeout);
+int8_t wait_write(uint8_t timeout);
+void readReg(uint8_t slaveid, uint16_t address, uint8_t amount);
+void writeReg(uint8_t slaveid, uint16_t address, uint16_t value);
+void readInputReg(uint8_t slaveid, uint16_t address, uint16_t amount);
+void readInputState(uint8_t slaveid, uint16_t address, uint16_t amount);
+void writeCoil(uint8_t slaveid, uint16_t address, uint16_t value);
+void readCoil(uint8_t slaveid, uint16_t address);
+int8_t wait_receive_coil(uint8_t timeout);

modbus.c

@@ -0,0 +1,436 @@
+/*************************************************************************
+Title:    Yet another (small) modbus (server) implementation for the avr.
+Author:   Max Brueggemann
+Hardware: any AVR with hardware UART, tested on Atmega 88/168 at 20Mhz
+License:  BSD-3-Clause
+          
+DESCRIPTION:
+    Refer to the header file yaMBSiavr.h.
+    
+USAGE:
+    Refer to the header file yaMBSiavr.h.
+                    
+LICENSE:
+
+Copyright 2017 Max Brueggemann, www.maxbrueggemann.de
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+                        
+*************************************************************************/
+
+#include <avr/io.h>
+#include "modbus.h"
+#include <avr/interrupt.h>
+
+volatile unsigned char BusState = 0;
+volatile uint16_t modbusTimer = 0;
+volatile unsigned char rxbuffer[MaxFrameIndex+1];
+volatile uint16_t DataPos = 0;
+volatile unsigned char PacketTopIndex = 7;
+volatile unsigned char modBusStaMaStates = 0;
+volatile uint16_t modbusDataAmount = 0;
+volatile uint16_t modbusDataLocation = 0;
+
+/* @brief: save address and amount
+*
+*/
+void modbusSaveLocation(void)
+{
+	modbusDataLocation=(rxbuffer[3]|(rxbuffer[2]<<8));
+	if (rxbuffer[1]==fcPresetSingleRegister || rxbuffer[1]==fcForceSingleCoil) modbusDataAmount=1;
+	else modbusDataAmount=(rxbuffer[5]|(rxbuffer[4]<<8));
+}
+
+/* @brief: returns 1 if data location adr is touched by current command
+*
+*         Arguments: - adr: address of the data object
+*
+*/
+uint8_t modbusIsInRange(uint16_t adr)
+{
+        if((modbusDataLocation <= adr) && (adr<(modbusDataLocation+modbusDataAmount)))
+                return 1;
+        return 0;
+}
+
+/* @brief: returns 1 if range of data locations is touched by current command
+*
+*         Arguments: - startAdr: address of first data object in range
+*                    - lastAdr: address of last data object in range
+*
+*/
+uint8_t modbusIsRangeInRange(uint16_t startAdr, uint16_t lastAdr)
+{
+        if(modbusIsInRange(startAdr) && modbusIsInRange(lastAdr))
+                return 1;
+        return 0;
+}
+
+uint8_t modbusGetBusState(void)
+{
+	return BusState;
+}
+
+#if ADDRESS_MODE == SINGLE_ADR
+volatile unsigned char Address = 0x00;
+uint8_t modbusGetAddress(void)
+{
+	return Address;
+}
+
+void modbusSetAddress(unsigned char newadr)
+{
+	Address = newadr;
+}
+#endif
+
+#if PHYSICAL_TYPE == 485
+void transceiver_txen(void)
+{
+	TRANSCEIVER_ENABLE_PORT|=(1<<TRANSCEIVER_ENABLE_PIN);
+	TRANSCEIVER_ENABLE_PORT|=(1<<TRANSCEIVER_ENABLE_PIN_2);
+}
+
+ void transceiver_rxen(void)
+{
+	TRANSCEIVER_ENABLE_PORT&=~(1<<TRANSCEIVER_ENABLE_PIN);
+	TRANSCEIVER_ENABLE_PORT&=~(1<<TRANSCEIVER_ENABLE_PIN_2);
+}
+#endif
+
+/* @brief: A fairly simple Modbus compliant 16 Bit CRC algorithm.
+*
+*  	Returns 1 if the crc check is positive, returns 0 and saves the calculated CRC bytes
+*	at the end of the data array if it fails.
+*  	
+*/
+uint8_t crc16(volatile uint8_t *ptrToArray,uint8_t inputSize) //A standard CRC algorithm
+{
+	uint16_t out=0xffff;
+	uint16_t carry;
+	unsigned char n;
+	inputSize++;
+	for (int l=0; l<inputSize; l++) {
+		out ^= ptrToArray[l];
+		for (n = 0; n < 8; n++) {
+			carry = out & 1;
+			out >>= 1;
+			if (carry) out ^= 0xA001;
+		}
+	}
+	//out=0x1234;
+	if ((ptrToArray[inputSize]==out%256) && (ptrToArray[inputSize+1]==out/256)) //check
+	{
+		return 1;
+	} else { 
+		ptrToArray[inputSize]=out%256; //append Lo
+		ptrToArray[inputSize+1]=out/256; //append Hi
+		return 0;	
+	}
+}
+
+/* @brief: copies a single bit from one char to another char (or arrays thereof)
+*
+*
+*/
+void listBitCopy(volatile uint8_t *source, uint16_t sourceNr,volatile uint8_t *target, uint16_t targetNr)
+{
+	if(*(source+(sourceNr/8))&(1<<(sourceNr-((sourceNr/8)*8))))
+	{
+		*(target+(targetNr/8))|=(1<<(targetNr-((targetNr/8)*8)));
+	} else *(target+(targetNr/8))&=~(1<<(targetNr-((targetNr/8)*8)));
+}
+
+/* @brief: Back to receiving state.
+*
+*/
+void modbusReset(void)
+{
+	BusState=(1<<TimerActive); //stop receiving (error)
+	modbusTimer=0;
+}
+
+void modbusTickTimer(void)
+{
+	if (BusState&(1<<TimerActive)) 
+	{
+		modbusTimer++;
+		if (BusState&(1<<Receiving)) //we are in receiving mode
+		{
+			if ((modbusTimer==modbusInterCharTimeout)) {
+				BusState|=(1<<GapDetected);
+			} else if ((modbusTimer==modbusInterFrameDelayReceiveEnd)) { //end of message
+				#if ADDRESS_MODE == MULTIPLE_ADR
+               		 if (crc16(rxbuffer,DataPos-3)) { //perform crc check only. This is for multiple/all address mode.
+				modbusSaveLocation();
+				BusState=(1<<ReceiveCompleted);
+			 } else modbusReset();
+				#endif
+				#if ADDRESS_MODE == SINGLE_ADR
+				if (rxbuffer[0]==Address && crc16(rxbuffer,DataPos-3)) { //is the message for us? => perform crc check
+					modbusSaveLocation();
+					BusState=(1<<ReceiveCompleted);
+				} else modbusReset();
+				#endif
+			}
+		} else if (modbusTimer==modbusInterFrameDelayReceiveStart){
+            BusState|=(1<<BusTimedOut);
+        }
+	}
+}
+
+ISR(UART_RECEIVE_INTERRUPT)
+{
+    unsigned char data;
+    data = UART_DATA;
+    //printf("%x ", data);
+    modbusTimer=0; //reset timer
+    if (!(BusState & (1<<ReceiveCompleted)) && !(BusState & (1<<TransmitRequested)) && !(BusState & (1<<Transmitting)) && (BusState & (1<<Receiving)) && !(BusState & (1<<BusTimedOut)))
+    {
+        if (DataPos>MaxFrameIndex) modbusReset();
+        else
+        {
+            rxbuffer[DataPos]=data;
+            DataPos++; //TODO: maybe prevent this from exceeding 255?
+        }	    
+    } else 
+        // Bus state is Timed out..
+        if (!(BusState & (1<<ReceiveCompleted)) && !(BusState & (1<<TransmitRequested)) && !(BusState & (1<<Transmitting)) && !(BusState & (1<<Receiving)) && (BusState & (1<<BusTimedOut))) 
+        { 
+            rxbuffer[0]=data;
+            BusState=((1<<Receiving)|(1<<TimerActive));
+            DataPos=1;
+        }
+}
+
+ISR(UART_TRANSMIT_INTERRUPT)
+{
+	BusState&=~(1<<TransmitRequested);
+	BusState|=(1<<Transmitting);
+	UART_DATA=rxbuffer[DataPos];
+	DataPos++;
+	if (DataPos==(PacketTopIndex+1)) {
+		UART_CONTROL&=~(1<<UART_UDRIE);
+	}
+}
+
+ISR(UART_TRANSMIT_COMPLETE_INTERRUPT)
+{
+	#if PHYSICAL_TYPE == 485
+	transceiver_rxen();
+	#endif
+	modbusReset();
+}
+
+void modbusInit(void)
+{
+	UBRRH = (unsigned char)((_UBRR) >> 8);
+	UBRRL = (unsigned char) _UBRR;
+	UART_STATUS = (1<<U2X); //double speed mode.
+#ifdef URSEL   // if UBRRH and UCSRC share the same I/O location , e.g. ATmega8
+	UCSRC = (1<<URSEL)|(3<<UCSZ0); //Frame Size
+#else
+    UCSRC = (3<<UCSZ0); //Frame Size
+#endif
+	UART_CONTROL = (1<<TXCIE)|(1<<RXCIE)|(1<<RXEN)|(1<<TXEN); // USART receiver and transmitter and receive complete interrupt
+	#if PHYSICAL_TYPE == 485
+	TRANSCEIVER_ENABLE_PORT_DDR|=(1<<TRANSCEIVER_ENABLE_PIN);
+	TRANSCEIVER_ENABLE_PORT_DDR|=(1<<TRANSCEIVER_ENABLE_PIN_2);
+	transceiver_rxen();
+	#endif
+	BusState=(1<<TimerActive);
+}
+
+/* @brief: Sends a response.
+*
+*         Arguments: - packtop: Position of the last byte containing data.
+*                               modbusSendException is a good usage example.
+*/
+void modbusSendMessage(unsigned char packtop)
+{
+	PacketTopIndex=packtop+2;
+	crc16(rxbuffer,packtop);
+	BusState|=(1<<TransmitRequested);
+	DataPos=0;
+	#if PHYSICAL_TYPE == 485
+	transceiver_txen();
+	#endif
+	UART_CONTROL|=(1<<UART_UDRIE);
+	BusState&=~(1<<ReceiveCompleted);
+}
+
+/* @brief: Sends an exception response.
+*
+*         Arguments: - exceptionCode
+*                              
+*/
+void modbusSendException(unsigned char exceptionCode)
+{
+	rxbuffer[1]|=(1<<7); //setting MSB of the function code (the exception flag)
+	rxbuffer[2]=exceptionCode; //Exceptioncode. Also the last byte containing data
+	modbusSendMessage(2);
+}
+
+
+/* @brief:  Returns the amount of requested data objects (coils, discretes, registers)
+*
+*/
+uint16_t modbusRequestedAmount(void)
+{
+	return modbusDataAmount;
+}
+
+/* @brief: Returns the address of the first requested data object (coils, discretes, registers)
+*
+*/
+uint16_t modbusRequestedAddress(void)
+{
+	return modbusDataLocation;
+}
+
+/* @brief: copies a single or multiple bytes from one array of bytes to an array of 16-bit-words
+*
+*/
+void intToModbusRegister(volatile uint16_t *inreg, volatile uint8_t *outreg, uint8_t amount)
+{
+	for (uint8_t c=0; c<amount; c++)
+	{
+			*(outreg+c*2) = (uint8_t)(*(inreg+c) >> 8);
+			*(outreg+1+c*2) = (uint8_t)(*(inreg+c));
+	}
+}
+
+/* @brief: copies a single or multiple 16-bit-words from one array of integers to an array of bytes
+*
+*/
+void modbusRegisterToInt(volatile uint8_t *inreg, volatile uint16_t *outreg, uint8_t amount)
+{
+	for (uint8_t c=0; c<amount; c++)
+	{
+		*(outreg+c) = (*(inreg+c*2) << 8) + *(inreg+1+c*2);
+	}
+}
+
+/* @brief: Handles single/multiple register reading and single/multiple register writing.
+*
+*         Arguments: - ptrToInArray: pointer to the user's data array containing registers
+*                    - startAddress: address of the first register in the supplied array
+*                    - size: input array size in the requested format (16bit-registers)
+*
+*/
+uint8_t modbusExchangeRegisters(volatile uint16_t *ptrToInArray, uint16_t startAddress, uint16_t size)
+{
+	if ((modbusDataLocation>=startAddress) && ((startAddress+size)>=(modbusDataAmount+modbusDataLocation))) {
+		
+		if ((rxbuffer[1]==fcReadHoldingRegisters) || (rxbuffer[1]==fcReadInputRegisters) )
+		{
+			if ((modbusDataAmount*2)<=(MaxFrameIndex-4)) //message buffer big enough?
+			{
+				rxbuffer[2]=(unsigned char)(modbusDataAmount*2);
+				intToModbusRegister(ptrToInArray+(modbusDataLocation-startAddress),rxbuffer+3,modbusDataAmount);
+				modbusSendMessage(2+rxbuffer[2]);
+				return 1;
+			} else modbusSendException(ecIllegalDataValue);
+		}
+		else if (rxbuffer[1]==fcPresetMultipleRegisters)
+		{
+			if (((rxbuffer[6])>=modbusDataAmount*2) && ((DataPos-9)>=rxbuffer[6])) //enough data received?
+			{
+				modbusRegisterToInt(rxbuffer+7,ptrToInArray+(modbusDataLocation-startAddress),(unsigned char)(modbusDataAmount));
+				modbusSendMessage(5);
+				return 1;
+			} else modbusSendException(ecIllegalDataValue);//too few data bytes received
+		}
+		else if (rxbuffer[1]==fcPresetSingleRegister)
+		{
+			modbusRegisterToInt(rxbuffer+4,ptrToInArray+(modbusDataLocation-startAddress),1);
+			modbusSendMessage(5);
+			return 1;
+		} 
+		//modbusSendException(ecSlaveDeviceFailure); //inapropriate call of modbusExchangeRegisters
+		return 0;
+		} else {
+		modbusSendException(ecIllegalDataValue);
+		return 0;
+	}
+}
+
+/* @brief: Handles single/multiple input/coil reading and single/multiple coil writing.
+*
+*         Arguments: - ptrToInArray: pointer to the user's data array containing bits
+*                    - startAddress: address of the first bit in the supplied array
+*                    - size: input array size in the requested format (bits)
+*
+*/
+uint8_t modbusExchangeBits(volatile uint8_t *ptrToInArray, uint16_t startAddress, uint16_t size)
+{
+	if ((modbusDataLocation>=startAddress) && ((startAddress+size)>=(modbusDataAmount+modbusDataLocation)))
+	{
+		if ((rxbuffer[1]==fcReadInputStatus) || (rxbuffer[1]==fcReadCoilStatus))
+		{
+			if (modbusDataAmount<=((MaxFrameIndex-4)*8)) //message buffer big enough?
+			{
+				rxbuffer[2]=(modbusDataAmount/8);
+				if (modbusDataAmount%8>0)
+				{
+					rxbuffer[(uint8_t)(modbusDataAmount/8)+3]=0x00; //fill last data byte with zeros
+					rxbuffer[2]++;
+				}
+				for (uint16_t c = 0; c<modbusDataAmount; c++)
+				{
+					listBitCopy(ptrToInArray,modbusDataLocation-startAddress+c,rxbuffer+3,c);
+				}
+				modbusSendMessage(rxbuffer[2]+2);
+				return 1;
+			} else modbusSendException(ecIllegalDataValue); //too many bits requested within single request
+		}
+		else if (rxbuffer[1]==fcForceMultipleCoils)
+		{
+			if (((rxbuffer[6]*8)>=modbusDataAmount) && ((DataPos-9)>=rxbuffer[6])) //enough data received?
+			{
+				for (uint16_t c = 0; c<modbusDataAmount; c++)
+				{
+					listBitCopy(rxbuffer+7,c,ptrToInArray,modbusDataLocation-startAddress+c);
+				}
+				modbusSendMessage(5);
+				return 1;
+			} else modbusSendException(ecIllegalDataValue);//exception too few data bytes received
+		}
+		else if (rxbuffer[1]==fcForceSingleCoil) {
+			listBitCopy(rxbuffer+4,0,ptrToInArray,modbusDataLocation-startAddress);
+			modbusSendMessage(5); 
+			return 1;
+		}
+		//modbusSendException(ecSlaveDeviceFailure); //inanpropriate call of modbusExchangeBits
+		return 0;
+	} else
+	{
+		modbusSendException(ecIllegalDataValue);
+		return 0;
+	}
+}
+

modbus.h

@@ -0,0 +1,421 @@
+#ifndef yaMBIavr_H
+#define yaMBIavr_H
+/************************************************************************
+Title:    Yet another (small) Modbus (server) implementation for the avr.
+Author:   Max Brueggemann
+Hardware: any AVR with hardware UART, tested on Atmega 88/168 at 20Mhz
+License:  BSD-3-Clause
+
+LICENSE:
+
+Copyright 2017 Max Brueggemann, www.maxbrueggemann.de
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+    
+************************************************************************/
+#include <avr/io.h>
+/** 
+ *  @code #include <yaMBSIavr.h> @endcode
+ * 
+ *  @brief   Interrupt-based Modbus implementation for small avr microcontrollers.
+ *           The Modbus implementation guidelines at modbus.org call for response
+ *           timeouts in the range of several seconds , hence only timing critical
+ *           parts have been implemented within ISRs. The actual handling of the Modbus
+ *           frame can easily be done in the main while loop.
+ *
+ *  @author Max Brueggemann www.maxbrueggemann.de
+ */
+
+/* define baudrate of modbus */
+#ifndef BAUD
+#define BAUD 19200L 
+#endif
+
+/*
+* Definitions for transceiver enable pin.
+*/
+#ifndef TRANSCEIVER_ENABLE_PORT
+#define TRANSCEIVER_ENABLE_PORT PORTJ
+#endif
+
+#ifndef TRANSCEIVER_ENABLE_PIN
+#define TRANSCEIVER_ENABLE_PIN 6
+#define TRANSCEIVER_ENABLE_PIN_2 5
+#endif
+
+#ifndef TRANSCEIVER_ENABLE_PORT_DDR
+#define TRANSCEIVER_ENABLE_PORT_DDR DDRJ
+#endif
+
+/**
+ * @brief    
+ *           At the moment the user has to set the value for Baudrate and
+ *           speed mode manually. The values depend on the operating frequency 
+ *           of your AVR and can be found in its datasheet.
+ */
+#if defined(__AVR_ATtiny2313__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART_UDRE_vect
+#define UART_STATUS   UCSRA
+#define UART_CONTROL  UCSRB
+#define UART_DATA     UDR
+#define UART_UDRIE    UDRIE
+
+#elif defined(__AVR_ATmega164P__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART1_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART1_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+#define UART_STATUS   UCSR1A
+#define UART_CONTROL  UCSR1B
+#define UART_DATA     UDR1
+#define UART_UDRIE    UDRIE1
+#define UCSRC UCSR1C
+#define RXCIE RXCIE1
+#define TXCIE TXCIE1
+#define RXEN RXEN1
+#define TXEN TXEN1
+#define UCSZ0 UCSZ10
+#define U2X U2X1
+#define UBRRH UBRR1H
+#define UBRRL UBRR1L
+
+#elif defined(__AVR_ATmega168PA__)|(__AVR_ATmega88PA__)|(__AVR_ATmega328P__)|(__AVR_ATmega168P__)|(__AVR_ATmega88P__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART_UDRE_vect
+#define UART_STATUS   UCSR0A
+#define UART_CONTROL  UCSR0B
+#define UART_DATA     UDR0
+#define UART_UDRIE    UDRIE0
+#define UCSRC UCSR0C
+#define RXCIE RXCIE0
+#define TXCIE TXCIE0
+#define RXEN RXEN0
+#define TXEN TXEN0
+#define UCSZ0 UCSZ00
+#define U2X U2X0
+#define UBRRH UBRR0H
+#define UBRRL UBRR0L
+
+#elif defined(__AVR_ATmega328PB__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART0_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART0_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+#define UART_STATUS   UCSR0A
+#define UART_CONTROL  UCSR0B
+#define UART_DATA     UDR0
+#define UART_UDRIE    UDRIE0
+#define UCSRC UCSR0C
+#define RXCIE RXCIE0
+#define TXCIE TXCIE0
+#define RXEN RXEN0
+#define TXEN TXEN0
+#define UCSZ0 UCSZ00
+#define U2X U2X0
+#define UBRRH UBRR0H
+#define UBRRL UBRR0L
+
+#elif defined(__AVR_ATtiny441__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART0_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART0_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+#define UART_STATUS   UCSR0A
+#define UART_CONTROL  UCSR0B
+#define UART_DATA     UDR0
+#define UART_UDRIE    UDRIE0
+#define UCSRC UCSR0C
+#define RXCIE RXCIE0
+#define TXCIE TXCIE0
+#define RXEN RXEN0
+#define TXEN TXEN0
+#define UCSZ0 UCSZ00
+#define U2X U2X0
+#define UBRRH UBRR0H
+#define UBRRL UBRR0L
+
+#elif defined(__AVR_ATmega8__)|| defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) || defined(__AVR_ATmega323__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART_TXC_vect
+#define UART_RECEIVE_INTERRUPT   USART_RXC_vect
+#define UART_TRANSMIT_INTERRUPT  USART_UDRE_vect
+#define UART_STATUS   UCSRA
+#define UART_CONTROL  UCSRB
+#define UART_DATA     UDR
+#define UART_UDRIE    UDRIE
+
+#elif defined(__AVR_AT90PWM3B__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART_UDRE_vect
+#define UART_STATUS   UCSRA
+#define UART_CONTROL  UCSRB
+#define UART_DATA     UDR
+#define UART_UDRIE    UDRIE
+
+#elif defined(__AVR_ATmega1284P__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART0_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART0_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+#define UART_STATUS   UCSR0A
+#define UART_CONTROL  UCSR0B
+#define UART_DATA     UDR0
+#define UART_UDRIE    UDRIE0
+#define UCSRC UCSR0C
+#define RXCIE RXCIE0
+#define TXCIE TXCIE0
+#define RXEN RXEN0
+#define TXEN TXEN0
+#define UCSZ0 UCSZ00
+#define U2X U2X0
+#define UBRRH UBRR0H
+#define UBRRL UBRR0L
+
+#elif defined(__AVR_ATmega2560__)
+#define UART_TRANSMIT_COMPLETE_INTERRUPT USART3_TX_vect
+#define UART_RECEIVE_INTERRUPT   USART3_RX_vect
+#define UART_TRANSMIT_INTERRUPT  USART3_UDRE_vect
+#define UART_STATUS   UCSR3A
+#define UART_CONTROL  UCSR3B
+#define UART_DATA     UDR3
+#define UART_UDRIE    UDRIE3
+#define UCSRC UCSR3C
+#define RXCIE RXCIE3
+#define TXCIE TXCIE3
+#define RXEN RXEN3
+#define TXEN TXEN3
+#define UCSZ0 UCSZ30
+#define U2X U2X0
+#define UBRRH UBRR3H
+#define UBRRL UBRR3L
+
+#else
+#error "no definition available"
+#endif
+
+#ifndef F_CPU
+#error " F_CPU not defined "
+#else
+   #define _UBRR (F_CPU / 8 / BAUD ) -1
+#endif /* F_CPU */
+/*
+ * Available address modes.
+*/
+#define MULTIPLE_ADR 2
+#define SINGLE_ADR 1
+
+/*
+* Use SINGLE_ADR or MULTIPLE_ADR, default: SINGLE_ADR
+* This is useful for building gateways, routers or clients that for whatever reason need multiple addresses.
+*/
+#define ADDRESS_MODE SINGLE_ADR
+
+/*
+* Use 485 or 232, default: 485
+* Use 232 for testing purposes or very simple applications that do not require RS485 and bus topology.
+*/
+#define PHYSICAL_TYPE 485 //possible values: 485, 232
+
+#if BAUD>=19200
+#define modbusInterFrameDelayReceiveStart 16
+#define modbusInterFrameDelayReceiveEnd 18
+#define modbusInterCharTimeout 7
+#else
+#define modbusBlocksize 10
+#define modbusBlockTime ((float)modbusBlocksize*1000000)/((float) BAUD) //is 260 for 38400
+#define timerISROccurenceTime 100 //time in microseconds between two calls of modbusTickTimer
+#define modbusInterFrameDelayReceiveStart  (uint16_t)(modbusBlockTime*3.5/(float)timerISROccurenceTime)
+#define modbusInterFrameDelayReceiveEnd (uint16_t)(modbusBlockTime*4/(float)timerISROccurenceTime)
+#define modbusInterCharTimeout  (uint16_t)(modbusBlockTime*1.5/(float)timerISROccurenceTime)
+#endif
+
+
+/**
+ * @brief    Defines the maximum Modbus frame size accepted by the device. 255 is the default
+ *           and also the maximum value. However, it might be useful to set this to lower
+ *           values, with 8 being the lowest possible value, in order to save on ram space.
+ */
+#define MaxFrameIndex 255
+
+/**
+ * @brief    Modbus Function Codes
+ *           Refer to modbus.org for further information.
+ *           It's good practice to return exception code 01 in case you receive a function code
+ *           that you haven't implemented in your application.
+ */
+#define fcReadCoilStatus 1 //read single/multiple coils
+#define fcReadInputStatus 2 //read single/multiple inputs
+#define fcReadHoldingRegisters 3 //read analog output registers
+#define fcReadInputRegisters 4 //read analog input registers (2 Bytes per register)
+#define fcForceSingleCoil 5 //write single bit
+#define fcPresetSingleRegister 6 //write analog output register (2 Bytes)
+#define fcForceMultipleCoils 15 //write multiple bits
+#define fcPresetMultipleRegisters 16 //write multiple analog output registers (2 Bytes each)
+#define fcReportSlaveID 17 //read device description, run status and other device specific information
+
+/**
+ * @brief    Modbus Exception Codes
+ *           Refer to modbus.org for further information.
+ *           It's good practice to return exception code 01 in case you receive a function code
+ *           that you haven't implemented in your application.
+ */
+#define ecIllegalFunction 1 
+#define ecIllegalDataAddress 2 
+#define ecIllegalDataValue 3
+#define ecSlaveDeviceFailure 4
+#define ecAcknowledge 5
+#define ecSlaveDeviceBusy 6
+#define ecNegativeAcknowledge 7
+#define ecMemoryParityError 8
+
+/**
+ * @brief    Internal bit definitions
+ */
+#define BusTimedOut 0
+#define Receiving 1
+#define Transmitting 2
+#define ReceiveCompleted 3
+#define TransmitRequested 4
+#define TimerActive 5
+#define GapDetected 6
+
+/**
+* @brief    Configures the UART. Call this function only once.
+*/
+extern void modbusInit(void);
+
+/**
+* @brief    receive/transmit data array
+*/
+extern volatile unsigned char rxbuffer[MaxFrameIndex+1];
+
+/**
+* @brief    Current receive/transmit position
+*/
+extern volatile uint16_t DataPos;
+
+/**
+ * This only applies to single address mode.
+ */
+#if ADDRESS_MODE == SINGLE_ADR
+	/**
+	* @brief: Read the device address   
+	*/
+	extern uint8_t modbusGetAddress(void);
+
+	/**
+	* @brief: Set the device address
+	*         Arguments: - newadr: the new device address
+	*/
+	extern void modbusSetAddress(unsigned char newadr);
+#endif
+
+/* @brief: Sends a response.
+*
+*         Arguments: - packtop, index of the last byte in rxbuffer
+*                      that contains payload. Maximum value is
+*				       MaxFrameIndex-2.
+*/
+extern void modbusSendMessage(unsigned char packtop);
+
+/* @brief: Sends a Modbus exception.
+*
+*         Arguments: - exceptionCode
+*/
+extern void modbusSendException(unsigned char exceptionCode);
+
+/* @brief: Discards the current transaction. For MULTIPLE_ADR-mode and general
+*		   testing purposes. Call this function if you don't want to reply at all.
+*/
+void modbusReset(void);
+
+/**
+ * @brief    Call this function whenever possible and check if its return value has the ReceiveCompleted Bit set.
+ *           Preferably do this in the main while. I do not recommend calling this function within ISRs.
+ * @example  if (modbusGetBusState() & (1<<ReceiveCompleted)) {
+ *           modbusSendExcepton(ecIllegalFunction);
+ *           }
+ */
+extern uint8_t modbusGetBusState(void);
+
+/**
+ * @brief    Call every 100us using a timer ISR.
+ */
+extern void modbusTickTimer(void);
+
+/**
+ * @brief    Returns amount of bits/registers requested.
+ */
+extern uint16_t modbusRequestedAmount(void);
+
+/**
+ * @brief    Returns the address of the first requested bit/register.
+ */
+extern uint16_t modbusRequestedAddress(void);
+
+/* A fairly simple and hopefully Modbus compliant 16 Bit CRC algorithm.
+*  Returns 1 if the crc check is positive, returns 0 if it fails.
+*  Appends two crc bytes to the array.
+*/
+extern uint8_t crc16(volatile uint8_t *ptrToArray,uint8_t inputSize);
+
+/* @brief: Handles single/multiple input/coil reading and single/multiple coil writing.
+*
+*         Arguments: - ptrToInArray: pointer to the user's data array containing bits
+*                    - startAddress: address of the first bit in the supplied array
+*                    - size: input array size in the requested format (bits)
+*
+*/
+extern uint8_t modbusExchangeBits(volatile uint8_t *ptrToInArray, uint16_t startAddress, uint16_t size);
+
+/* @brief: Handles single/multiple register reading and single/multiple register writing.
+*
+*         Arguments: - ptrToInArray: pointer to the user's data array containing registers
+*                    - startAddress: address of the first register in the supplied array
+*                    - size: input array size in the requested format (16bit-registers)
+*
+*/
+extern uint8_t modbusExchangeRegisters(volatile uint16_t *ptrToInArray, uint16_t startAddress, uint16_t size);
+
+/* @brief: returns 1 if data location adr is touched by current command
+*
+*         Arguments: - adr: address of the data object
+*
+*/
+extern uint8_t modbusIsInRange(uint16_t adr);
+
+/* @brief: returns 1 if range of data locations is touched by current command
+*
+*         Arguments: - startAdr: address of first data object in range
+*                    - lastAdr: address of last data object in range
+*
+*/
+extern uint8_t modbusIsRangeInRange(uint16_t startAdr, uint16_t lastAdr);
+
+extern volatile uint16_t modbusDataAmount;
+extern volatile uint16_t modbusDataLocation;
+#endif
+

mqtt.c

@@ -41,7 +41,7 @@ void mqtt_pub(Client* mqtt_client, char * mqtt_topic, char * mqtt_msg, int mqtt_
 	static uint8_t mqtt_err_cnt = 0;
 	int32_t mqtt_rc;
 
-	printf(">>MQTT pub msg nr%lu ", ++mqtt_pub_count);
+	//printf(">>MQTT pub msg nr%lu ", ++mqtt_pub_count);
 	MQTTMessage pubMessage;
 	pubMessage.qos = QOS0;
 	pubMessage.id = mes_id++;
@@ -52,7 +52,7 @@ void mqtt_pub(Client* mqtt_client, char * mqtt_topic, char * mqtt_msg, int mqtt_
 	if (mqtt_rc == SUCCESSS)
 	{
 		mqtt_err_cnt  = 0;
-		printf(" - OK\r\n");
+		//printf(" - OK\r\n");
 	}
 	else
 	{

pumpe.c

@@ -21,4 +21,21 @@ void do_pumpe(){
             set_Output(LED_PUMPE_AN, 0);
             send_value(&mqtt_client, "/Filamentanlage/02_Wasserbecken/state/pumpe_warm", 0);
         }
+        if(read_Input(BTN_SLAVE_BECKEN_FUELLEN, RISING)){
+            set_Output(OUT_SLAVE_PUMPE_STARTSTOP, 1);
+            set_Output(OUT_SLAVE_PUMPE_PWM, 1);
+            set_Output(OUT_SLAVE_VENTIL_ABLASS, 0);
+            set_Output(OUT_SLAVE_VENTIL_PUMPE, 0);
+            set_Output(LED_SLAVE_PUMPE_AN, 1);
+            send_value(&mqtt_client, "/Filamentanlage/03_Wasserbecken/state/pumpe_warm", 1);
+        }
+
+        if(read_Input(BTN_SLAVE_BECKEN_LEEREN, RISING)){
+            set_Output(OUT_SLAVE_PUMPE_STARTSTOP, 0);
+            set_Output(OUT_SLAVE_PUMPE_PWM, 0);
+            set_Output(OUT_SLAVE_VENTIL_ABLASS, 1);
+            set_Output(OUT_SLAVE_VENTIL_PUMPE, 1);
+            set_Output(LED_SLAVE_PUMPE_AN, 0);
+            send_value(&mqtt_client, "/Filamentanlage/03_Wasserbecken/state/pumpe_warm", 0);
+        }
 }

uart.c

@@ -8,8 +8,14 @@ FILE uart_output = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);
 void uart_init()
 {
     DDRD |= 1 << 1; // TX
-    UART_BAUD_REGH  = (BAUDRATE>>8);
+    UART_BAUD_REGH  = UBRRH_VALUE;//(BAUDRATE>>8);
-    UART_BAUD_REGL  = BAUDRATE;               // set baud rate
+    UART_BAUD_REGL  = UBRRL_VALUE;//BAUDRATE;               // set baud rate
+
+#if USE_2X
+    UART_CTRL_REGA |= (1 << USE_2X);
+#else
+    UART_CTRL_REGA &= ~(1 << USE_2X);
+#endif
 
     UART_CTRL_REGB |= (1<<UART_TXEN_BM)
                      //|(1<<UART_RXEN_BM)

uart.h

@@ -1,9 +1,11 @@
 #ifndef _UART_H_
 #define _UART_H_
 
+#define BAUD 115200
+
 #include <stdio.h>
+#include <util/setbaud.h>
 
-#define BAUD 9600 
 #define BAUDRATE ((F_CPU)/(BAUD*16UL)-1)
 
 #define UART_BAUD_REGH UBRR0H