diff --git a/lib/radio_esp8266.c b/lib/radio_esp8266.c
new file mode 100644
index 0000000..9dd5655
--- /dev/null
+++ b/lib/radio_esp8266.c
@@ -0,0 +1,175 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to send data using ESP8266 WiFi SoC (code)
+ *  @file radio_esp8266.c
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref radio_esp8266_usart
+ */
+
+/* standard libraries */
+#include <stdint.h> // standard integer types
+#include <stdlib.h> // general utilities
+#include <string.h> // string and memory utilities
+#include <stdio.h> // string utilities
+
+/* STM32 (including CM3) libraries */
+#include <libopencm3/stm32/rcc.h> // real-time control clock library
+#include <libopencm3/stm32/gpio.h> // general purpose input output library
+#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
+#include <libopencm3/cm3/nvic.h> // interrupt handler
+#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
+
+#include "radio_esp8266.h" // radio header and definitions
+#include "global.h" // common methods
+
+/** @defgroup radio_esp8266_usart USART peripheral used for communication with radio
+ *  @{
+ */
+#define RADIO_ESP8266_USART 1 /**< USART peripheral */
+/** @} */
+
+/* input and output buffers and used memory */
+static uint8_t rx_buffer[24] = {0}; /**< buffer for received data (we only expect AT responses) */
+static volatile uint16_t rx_used = 0; /**< number of byte in receive buffer */
+static uint8_t tx_buffer[256] = {0}; /**< buffer for data to transmit */
+static volatile uint16_t tx_used = 0; /**< number of bytes used in transmit buffer */
+
+volatile bool radio_esp8266_activity = false;
+volatile bool radio_esp8266_success = false;
+
+/** transmit data to radio
+ *  @param[in] data data to transmit
+ *  @param[in] length length of data to transmit
+ */
+static void radio_esp8266_transmit(uint8_t* data, uint8_t length) {
+	while (tx_used || !usart_get_flag(USART(RADIO_ESP8266_USART), USART_SR_TXE)) { // wait until ongoing transmission completed
+		usart_enable_tx_interrupt(USART(RADIO_ESP8266_USART)); // enable transmit interrupt
+		__WFI(); // sleep until something happened
+	}
+	usart_disable_tx_interrupt(USART(RADIO_ESP8266_USART)); // ensure transmit interrupt is disable to prevent index corruption (the ISR should already have done it)
+	radio_esp8266_activity = false; // reset status because of new activity
+	for (tx_used=0; tx_used<length && tx_used<LENGTH(tx_buffer); tx_used++) { // copy data
+		tx_buffer[tx_used] = data[length-1-tx_used]; // put character in buffer (in reverse order)
+	}
+	if (tx_used) {
+		usart_enable_tx_interrupt(USART(RADIO_ESP8266_USART)); // enable interrupt to send bytes
+	}
+}
+
+void radio_esp8266_setup(void)
+{
+	/* enable USART I/O peripheral */
+	rcc_periph_clock_enable(RCC_AFIO); // enable pin alternate function (USART)
+	rcc_periph_clock_enable(USART_PORT_RCC(RADIO_ESP8266_USART)); // enable clock for USART port peripheral
+	rcc_periph_clock_enable(USART_RCC(RADIO_ESP8266_USART)); // enable clock for USART peripheral
+	gpio_set_mode(USART_PORT(RADIO_ESP8266_USART), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX(RADIO_ESP8266_USART)); // setup GPIO pin USART transmit
+	gpio_set_mode(USART_PORT(RADIO_ESP8266_USART), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX(RADIO_ESP8266_USART)); // setup GPIO pin USART receive
+	gpio_set(USART_PORT(RADIO_ESP8266_USART), USART_PIN_RX(RADIO_ESP8266_USART)); // pull up to avoid noise when not connected
+
+	/* setup USART parameters for ESP8266 AT firmware */
+	usart_set_baudrate(USART(RADIO_ESP8266_USART), 115200); // AT firmware 0.51 (SDK 1.5.0) uses 115200 bps
+	usart_set_databits(USART(RADIO_ESP8266_USART), 8);
+	usart_set_stopbits(USART(RADIO_ESP8266_USART), USART_STOPBITS_1);
+	usart_set_mode(USART(RADIO_ESP8266_USART), USART_MODE_TX_RX);
+	usart_set_parity(USART(RADIO_ESP8266_USART), USART_PARITY_NONE);
+	usart_set_flow_control(USART(RADIO_ESP8266_USART), USART_FLOWCONTROL_NONE);
+
+	nvic_enable_irq(USART_IRQ(RADIO_ESP8266_USART)); // enable the USART interrupt
+	usart_enable_rx_interrupt(USART(RADIO_ESP8266_USART)); // enable receive interrupt
+	usart_enable(USART(RADIO_ESP8266_USART)); // enable USART
+
+	/* reset buffer states */
+	rx_used = 0;
+	tx_used = 0;
+	radio_esp8266_activity = false;
+	radio_esp8266_success = false;
+
+	radio_esp8266_transmit((uint8_t*)"AT\r\n",4); // verify if module is present
+	while (!radio_esp8266_activity || !radio_esp8266_success) { // wait for response
+		__WFI(); // sleep until something happened
+	}
+	radio_esp8266_transmit((uint8_t*)"AT+RST\r\n",8); // reset module
+	while (!radio_esp8266_activity || !radio_esp8266_success) { // wait for response
+		__WFI(); // sleep until something happened
+	}
+	while(rx_used<13 || memcmp((char*)&rx_buffer[rx_used-13], "WIFI GOT IP\r\n", 13)!=0) { // wait to have IP
+		 __WFI(); // sleep until something happened
+	}
+	radio_esp8266_transmit((uint8_t*)"ATE0\r\n",6); // disable echoing
+	while (!radio_esp8266_activity || !radio_esp8266_success) { // wait for response
+		__WFI(); // sleep until something happened
+	}
+}
+
+void radio_esp8266_tcp_open(char* host, uint16_t port)
+{
+	char command[256] = {0}; // string to create command
+	int length = snprintf(command, LENGTH(command), "AT+CIPSTART=\"TCP\",\"%s\",%u\r\n", host, port); // create AT command to establish a TCP connection
+	if (length>0) {
+		radio_esp8266_transmit((uint8_t*)command, length);
+	}
+}
+
+void radio_esp8266_send(uint8_t* data, uint8_t length)
+{
+	char command[16+1] = {0}; // string to create command
+	int command_length = snprintf(command, LENGTH(command), "AT+CIPSEND=%u\r\n", length); // create AT command to send data
+	if (command_length>0) {
+		radio_esp8266_transmit((uint8_t*)command, command_length); // transmit AT command
+		while (!radio_esp8266_activity || !radio_esp8266_success) { // wait for response
+			__WFI(); // sleep until something happened
+		}
+		if (!radio_esp8266_success) { // send AT command did not succeed
+			return; // don't transmit data
+		}
+		radio_esp8266_transmit(data, length); // transmit data
+	}
+}
+
+void radio_esp8266_close(void)
+{
+	radio_esp8266_transmit((uint8_t*)"AT+CIPCLOSE\r\n", 13); // send AT command to close established connection
+}
+
+/** USART interrupt service routine called when data has been transmitted or received */
+void USART_ISR(RADIO_ESP8266_USART)(void)
+{
+	if (usart_get_interrupt_source(USART(RADIO_ESP8266_USART), USART_SR_TXE)) { // data has been transmitted
+		if (tx_used) { // there is still data in the buffer to transmit
+			usart_send(USART(RADIO_ESP8266_USART),tx_buffer[tx_used-1]); // put data in transmit register
+			tx_used--; // update used size
+		} else { // no data in the buffer to transmit
+			usart_disable_tx_interrupt(USART(RADIO_ESP8266_USART)); // disable transmit interrupt
+		}
+	}
+	if (usart_get_interrupt_source(USART(RADIO_ESP8266_USART), USART_SR_RXNE)) { // data has been received
+		while (rx_used>=LENGTH(rx_buffer)) { // if buffer is full
+			memmove(rx_buffer,&rx_buffer[1],LENGTH(rx_buffer)-1); // drop old data to make space (ring buffer are more efficient but harder to handle)
+			rx_used--; // update used buffer information
+		}
+		rx_buffer[rx_used++] = usart_recv(USART(RADIO_ESP8266_USART)); // put character in buffer
+		// if the used send a packet with these strings during the commands detection the AT command response will break (AT commands are hard to handle perfectly)
+		if (rx_used>=4 && memcmp((char*)&rx_buffer[rx_used-4], "OK\r\n", 4)==0) { // OK received
+			radio_esp8266_activity = true; // response received
+			radio_esp8266_success = true; // command succeeded
+			rx_used = 0; // reset buffer
+		} else if (rx_used>=7 && memcmp((char*)&rx_buffer[rx_used-7], "ERROR\r\n", 7)==0) { // ERROR received
+			radio_esp8266_activity = true; // response received
+			radio_esp8266_success = false; // command failed
+			rx_used = 0; // reset buffer
+		}
+	}
+}
diff --git a/lib/radio_esp8266.h b/lib/radio_esp8266.h
new file mode 100644
index 0000000..193db70
--- /dev/null
+++ b/lib/radio_esp8266.h
@@ -0,0 +1,47 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to send data using ESP8266 WiFi SoC (API)
+ *  @file radio_esp8266.h
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref radio_esp8266_usart
+ */
+#pragma once
+
+/** a response has been returned by the radio */
+extern volatile bool radio_esp8266_activity;
+/** the last command has succeeded */
+extern volatile bool radio_esp8266_success;
+
+/** setup peripherals to communicate with radio
+ *  @note this is blocking to ensure we are connected to the WiFi network
+ */
+void radio_esp8266_setup(void);
+/** establish TCP connection
+ *  @param[in] host host to connect to
+ *  @param[in] port TCP port to connect to
+ *  @note wait for activity to get success status
+ */
+void radio_esp8266_tcp_open(char* host, uint16_t port);
+/** send data (requires established connection)
+ *  @param[in] data data to send
+ *  @param[in] length size of data to send
+ *  @note wait for activity to get success status
+ */
+void radio_esp8266_send(uint8_t* data, uint8_t length);
+/** close established connection
+ *  @note wait for activity to get success status
+ */
+void radio_esp8266_close(void);
diff --git a/lib/sensor_pzem.c b/lib/sensor_pzem.c
new file mode 100644
index 0000000..f714dce
--- /dev/null
+++ b/lib/sensor_pzem.c
@@ -0,0 +1,170 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to query measurements from peacefair PZEM-004 and PZEM-004T electricity meter (code)
+ *  @file sensor_pzem.c
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref sensor_pzem_usart
+ */
+
+/* standard libraries */
+#include <stdint.h> // standard integer types
+#include <stdlib.h> // general utilities
+
+/* STM32 (including CM3) libraries */
+#include <libopencm3/stm32/rcc.h> // real-time control clock library
+#include <libopencm3/stm32/gpio.h> // general purpose input output library
+#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
+#include <libopencm3/cm3/nvic.h> // interrupt handler
+#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
+
+#include "sensor_pzem.h" // PZEM electricity meter header and definitions
+#include "global.h" // common methods
+
+/** @defgroup sensor_pzem_usart USART peripheral used for communication with electricity meter
+ *  @{
+ */
+#define SENSOR_PZEM_USART 2 /**< USART peripheral */
+/** @} */
+
+/* input and output ring buffer, indexes, and available memory */
+static uint8_t rx_buffer[7] = {0}; /**< buffer for received response */
+static volatile uint8_t rx_i = 0; /**< current position of read received data */
+static uint8_t tx_buffer[7] = {0}; /**< buffer for request to transmit */
+static volatile uint8_t tx_i = 0; /**< current position of transmitted data */
+
+volatile bool sensor_pzem_measurement_received = false;
+
+void sensor_pzem_setup(void)
+{
+	/* enable USART I/O peripheral */
+	rcc_periph_clock_enable(RCC_AFIO); // enable pin alternate function (USART)
+	rcc_periph_clock_enable(USART_PORT_RCC(SENSOR_PZEM_USART)); // enable clock for USART port peripheral
+	rcc_periph_clock_enable(USART_RCC(SENSOR_PZEM_USART)); // enable clock for USART peripheral
+	gpio_set_mode(USART_PORT(SENSOR_PZEM_USART), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX(SENSOR_PZEM_USART)); // setup GPIO pin USART transmit
+	gpio_set_mode(USART_PORT(SENSOR_PZEM_USART), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX(SENSOR_PZEM_USART)); // setup GPIO pin USART receive
+	gpio_set(USART_PORT(SENSOR_PZEM_USART), USART_PIN_RX(SENSOR_PZEM_USART)); // pull up to avoid noise when not connected
+
+	/* setup USART parameters for electricity meter: 9600 8N1 */
+	usart_set_baudrate(USART(SENSOR_PZEM_USART), 9600); // the electricity meter uses a fixed baud rate of 9600 bps
+	usart_set_databits(USART(SENSOR_PZEM_USART), 8);
+	usart_set_stopbits(USART(SENSOR_PZEM_USART), USART_STOPBITS_1);
+	usart_set_mode(USART(SENSOR_PZEM_USART), USART_MODE_TX_RX);
+	usart_set_parity(USART(SENSOR_PZEM_USART), USART_PARITY_NONE);
+	usart_set_flow_control(USART(SENSOR_PZEM_USART), USART_FLOWCONTROL_NONE);
+
+	nvic_enable_irq(USART_IRQ(SENSOR_PZEM_USART)); // enable the USART interrupt
+	usart_enable_rx_interrupt(USART(SENSOR_PZEM_USART)); // enable receive interrupt
+	usart_enable(USART(SENSOR_PZEM_USART)); // enable USART
+
+	/* reset buffer states */
+	tx_i = 0;
+	rx_i = 0;
+	sensor_pzem_measurement_received = false;
+}
+
+void sensor_pzem_measurement_request(uint32_t address, enum sensor_pzem_measurement_type_t type)
+{
+	if (tx_i!=0) { // transmission is ongoing
+		return;
+	}
+	if (type>=SENSOR_PZEM_MAX) { // invalid type
+		return;
+	}
+	tx_buffer[0] = 0xB0+type; // set request nibble and type nibble
+	tx_buffer[1] = (address>>24)&0xff; // set address
+	tx_buffer[2] = (address>>16)&0xff; // set address
+	tx_buffer[3] = (address>>8)&0xff; // set address
+	tx_buffer[4] = (address>>0)&0xff; // set address
+	tx_buffer[5] = 0; // only used to set alarm
+	tx_buffer[6] = 0; // to calculate checksum (sum of all previous bytes)
+	for (uint8_t i=0; i<LENGTH(tx_buffer)-1; i++) {
+		tx_buffer[6] += tx_buffer[i]; // calculate buffer
+	}
+
+	usart_enable_tx_interrupt(USART(SENSOR_PZEM_USART)); // enable interrupt to send other bytes
+	usart_send(USART(SENSOR_PZEM_USART),tx_buffer[tx_i++]); // start transmission
+}
+
+struct sensor_pzem_measurement_t sensor_pzem_measurement_decode(void)
+{
+	struct sensor_pzem_measurement_t measurement; // decoded measurement to return
+	measurement.valid = false; // wait until the end to ensure validity
+	if (!sensor_pzem_measurement_received) { // no measurement received
+		return measurement;
+	}
+	if ((rx_buffer[0]&0xf0)!=0xa0) { // not a response received
+		return measurement;
+	}
+	if ((rx_buffer[0]&0x0f)>=SENSOR_PZEM_MAX) { // not a valid response type received (actually 4 and 5 are valid, but should not happen when using this code
+		return measurement;
+	}
+	uint8_t checksum = 0; // calculate checksum (sum of all other bytes)
+	for (uint8_t i=0; i<LENGTH(rx_buffer)-1; i++) {
+		checksum += rx_buffer[i]; // calculate buffer
+	}
+	if (checksum!=rx_buffer[6]) { // checksum does not match
+		return measurement;
+	}
+	measurement.valid = true; // all checks passed
+	measurement.type = rx_buffer[0]&0x0f; // save type
+	switch (measurement.type) { // decode value depending on type
+		case SENSOR_PZEM_VOLTAGE:
+			measurement.value.voltage = ((uint16_t)rx_buffer[1]<<8)+rx_buffer[2]+rx_buffer[3]*0.1;
+			break;
+		case SENSOR_PZEM_CURRENT:
+			measurement.value.current = rx_buffer[2]+rx_buffer[3]/100;
+			break;
+		case SENSOR_PZEM_POWER:
+			measurement.value.power = ((uint16_t)rx_buffer[1]<<8)+rx_buffer[2];
+			break;
+		case SENSOR_PZEM_ENERGY:
+			measurement.value.energy = ((uint32_t)rx_buffer[1]<<16)+((uint16_t)rx_buffer[2]<<8)+rx_buffer[3];
+			break;
+/* not used in this application
+		case SENSOR_PZEM_ADDRESS:
+		case SENSOR_PZEM_ALARM:
+			break; // no value is returned
+*/
+		default:
+			measurement.valid = false; // unexpected type
+	}
+	sensor_pzem_measurement_received = false; // reset flag
+	rx_i = 0; // prepare buffer to receive next measurement
+	return measurement;
+}
+	
+/** USART interrupt service routine called when data has been transmitted or received */
+void USART_ISR(SENSOR_PZEM_USART)(void)
+{
+	if (usart_get_interrupt_source(USART(SENSOR_PZEM_USART), USART_SR_TXE)) { // data has been transmitted
+		if (tx_i<LENGTH(tx_buffer)) { // not all bytes transmitted
+			usart_send(USART(SENSOR_PZEM_USART),tx_buffer[tx_i++]); // transmit next byte
+		} else { // request transmitted
+			usart_disable_tx_interrupt(USART(SENSOR_PZEM_USART)); // disable transmit interrupt
+			tx_i = 0; // ready for next transmission
+		}
+	}
+	if (usart_get_interrupt_source(USART(SENSOR_PZEM_USART), USART_SR_RXNE)) { // data has been received
+		if (rx_i<LENGTH(rx_buffer)) { // receiving response
+			rx_buffer[rx_i++] = usart_recv(USART(SENSOR_PZEM_USART)); // put received byte in buffer
+			if (rx_i>=LENGTH(rx_buffer)) { // buffer full
+				sensor_pzem_measurement_received = true; // notify used response has been received
+			}
+		} else { // previous response not read before receiving the next
+			usart_recv(USART(SENSOR_PZEM_USART)); // drop received buffer
+		}
+	}
+}
diff --git a/lib/sensor_pzem.h b/lib/sensor_pzem.h
new file mode 100644
index 0000000..c7fa818
--- /dev/null
+++ b/lib/sensor_pzem.h
@@ -0,0 +1,60 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to query measurements from peacefair PZEM-004 and PZEM-004T electricity meter (API)
+ *  @file sensor_pzem.h
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref sensor_pzem_usart
+ */
+#pragma once
+
+/** a measurement response has been received */
+extern volatile bool sensor_pzem_measurement_received;
+
+/** measurements (and configurations) offered by electricity meter */
+enum sensor_pzem_measurement_type_t {
+	SENSOR_PZEM_VOLTAGE = 0,
+	SENSOR_PZEM_CURRENT = 1,
+	SENSOR_PZEM_POWER = 2,
+	SENSOR_PZEM_ENERGY = 3,
+//	SENSOR_PZEM_ADDRESS = 4, // this is a setting, not a measurement
+//	SENSOR_PZEM_ALARM = 5, // this is a setting, not a measurement
+	SENSOR_PZEM_MAX
+};
+
+/** measurement returned by electricity meter */
+struct sensor_pzem_measurement_t {
+	enum sensor_pzem_measurement_type_t type; /**< measurement type */
+	bool valid; /**< is the measurement valid (e.g. format and checksum are correct) */
+	/** possible measurement values */
+	union measurement_t {
+		float voltage; /**< measured voltage in volts */
+		float current; /**< measured current in amperes */
+		uint16_t power; /**< measured power in watts */
+		uint32_t energy; /**< measured energy in watts/hour (24 bits) */
+	} value; /**< measurement value */
+};
+
+/** setup peripherals to communicate with electricity meter */
+void sensor_pzem_setup(void);
+/** request measurement from electricity meter
+ *  @param[in] address electricity meter device address
+ *  @param[in] type measurement type to request
+ */
+void sensor_pzem_measurement_request(uint32_t address, enum sensor_pzem_measurement_type_t type);
+/** decode received measurement
+ *  @return decoded measurement (invalid if no new measurement has been received)
+ */
+struct sensor_pzem_measurement_t sensor_pzem_measurement_decode(void);
diff --git a/lib/sensor_sdm120.c b/lib/sensor_sdm120.c
new file mode 100644
index 0000000..ba6d3e3
--- /dev/null
+++ b/lib/sensor_sdm120.c
@@ -0,0 +1,371 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to query measurements from eastron SDM120-ModBus electricity meter (code)
+ *  @file sensor_sdm120.c
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref sensor_sdm120_usart , GPIO @ref sensor_sdm120_gpio , timer @ref sensor_sdm120_timer
+ */
+/* standard libraries */
+#include <stdint.h> // standard integer types
+#include <stdlib.h> // general utilities
+#include <math.h> // mathematical utilities
+
+/* STM32 (including CM3) libraries */
+#include <libopencm3/stm32/rcc.h> // real-time control clock library
+#include <libopencm3/stm32/gpio.h> // general purpose input output library
+#include <libopencm3/stm32/usart.h> // universal synchronous asynchronous receiver transmitter library
+#include <libopencm3/stm32/timer.h> // timer utilities
+#include <libopencm3/cm3/nvic.h> // interrupt handler
+#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
+
+#include "sensor_sdm120.h" // SDM120 electricity meter header and definitions
+#include "global.h" // common methods
+
+/** @defgroup sensor_sdm120_usart USART peripheral used for communication with electricity meter
+ *  @{
+ */
+#define SENSOR_SDM120_USART 3 /**< USART peripheral */
+/** @} */
+
+/** @defgroup sensor_sdm120_gpio GPIO peripheral used for controlling RS-485 adapter
+ *  @note driver output is enabled on high while receiver output is enabled on low, thus one pin can be used to control both
+ *  @{
+ */
+#define SENSOR_SDM120_REDE_PORT B /**< GPIO port for RS-485 receiver and driver output enable signal */
+#define SENSOR_SDM120_REDE_PIN 12 /**< GPIO pin for RS-485 receiver and driver output enable signal */
+/** @} */
+
+/** @defgroup sensor_sdm120_timer timer peripheral to enforce waiting time between messages
+ *  @note 60 ms are recommended between messages in SDM630 ModBus protocol implementation and this seem to also apply to SDM120
+ *  @{
+ */
+#define SENSOR_SDM120_TIMER 3 /**< timer number to count time */
+/** @} */
+
+/* input and output ring buffer, indexes, and available memory */
+static uint8_t rx_buffer[9] = {0}; /**< buffer for received response (ModBus response messages can be 2+256+2 long but we will only read up to 2 registers) */
+static volatile uint8_t rx_used = 0; /**< number of received data bytes in buffer */
+static uint8_t tx_buffer[13] = {0}; /**< buffer for request to transmit (ModBus request messages can be 7+256+2 long but we will only write up to 2 registers */
+static volatile uint8_t tx_used = 0; /**< number of byte to transmit */
+
+volatile bool sensor_sdm120_measurement_received = false;
+
+/** the ModBus timeouts to respect for sending messages **/
+static enum timeout_t {
+	TIMEOUT_BEGIN = 0, /**< silent time before sending data */
+	TIMEOUT_END, /**< silent time after sending data */
+	TIMEOUT_BETWEEN, /**< time to wait between messages */
+	TIMEOUT_MAX /**< last element (useful to no the number of elements) */
+} timeout; /**< the current timeout used */
+/** current timeout used */
+static uint16_t timeout_times[TIMEOUT_MAX] = {0};
+
+/** SDM120 3xxxx input register start addresses for the measurement types */ 
+static const uint16_t register_input[] = {
+    0x0000, // 30001 voltage (in volts)
+	0x0006, // 30007 current (in amperes)
+	0x000c, // 30013 active power (in watts)
+	0x0012, // 30019 apparent power (in volt amperes)
+	0x0018, // 30025 reactive power (in volt amperes reactive)
+	0x001e,	// 30031 power factor (0-1)
+	0x0046, // 30071 frequency (in hertz)
+	0x0048, // 30073 import active energy (in kWh)
+	0x004a, // 30075 export active energy (in kWh)
+	0x004c, // 30077 import reactive energy (in kVArh)
+	0x004e, // 30079 export reactive energy (in kVArh)
+	0x0156, // 30343 total active energy (in kWh)
+	0x0158  // 30345 total reactive energy (in kVArh)
+};
+
+/** SDM120 4xxxx holding register start addresses for the configuration types */
+static const uint16_t register_holding[] = {
+	0x000c, // relay pulse width (60, 100, or 200 ms)
+	0x0012, // network parity stop (0: 1 stop bit no parity, 1: one stop bit even parity, 2: one stop bit odd parity, 3: two stop bits no parity)
+	0x0014, // meter slave address (1-247)
+	0x001c, // baud rate (0: 2400 bps, 1: 4800 bps, 2: 9600 bps, 5: 1200 bps)
+	0x0056, // pulse 1 output mode (1: import active energy, 2: import+export active energy, 4: export active energy, 5: import reactive energy, 6: import+export reactive energy, 8: export reactive energy)
+	0xf900, // time of scroll display (0-30 s)
+	0xf910, // pulse 1 output (0: 0.001 kWh/imp, 1: 0.01 kWh/imp, 2: 0.1 kWh/imp, 3: 1 kWh/imp)
+	0xf920  // measurement mode (1: total=import, 2: total=import+export, 3: total=import-export)
+};
+
+/** compute CRC for ModBus
+ *  @note ModBus uses ANSi/IBM 16-bits CRC (with normal polynomial 0x8005, reverse polynomial 0xA001, start value 0xfff)
+ *  @param[in] buffer data on which to compute the CRC for
+ *  @param[in] size number of byte to compute the CRC for
+ *  @return computed CRC checksum
+ */
+static uint16_t crc_modbus(uint8_t* buffer, uint8_t size)
+{
+	uint16_t crc = 0xffff; // initial value (for ModBus)
+	for (uint8_t i=0; i<size; i++) { // go through every byte
+		crc ^= (uint16_t)buffer[i]; // XOR byte
+		for (uint8_t b=0; b<8; b++) { // go through every bit
+			if (crc&0x0001) { // least significant bit is set (we are using the reverse way)
+				crc = (crc>>1)^0xA001; // // shift to the right (for the next bit) and XOR with (reverse) polynomial
+			} else {
+				crc >>= 1; // just shift right (for the next bit)
+			}
+		}
+	}
+	return crc;
+}
+
+void sensor_sdm120_setup(uint32_t baudrate)
+{
+	// enable USART I/O peripheral
+	rcc_periph_clock_enable(RCC_AFIO); // enable pin alternate function (USART)
+	rcc_periph_clock_enable(USART_PORT_RCC(SENSOR_SDM120_USART)); // enable clock for USART port peripheral
+	rcc_periph_clock_enable(USART_RCC(SENSOR_SDM120_USART)); // enable clock for USART peripheral
+	gpio_set_mode(USART_PORT(SENSOR_SDM120_USART), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, USART_PIN_TX(SENSOR_SDM120_USART)); // setup GPIO pin USART transmit
+	gpio_set_mode(USART_PORT(SENSOR_SDM120_USART), GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, USART_PIN_RX(SENSOR_SDM120_USART)); // setup GPIO pin USART receive
+	gpio_clear(USART_PORT(SENSOR_SDM120_USART), USART_PIN_RX(SENSOR_SDM120_USART)); // pull down to avoid noise when not connected (it will be set low by RS485 chip when RO is enabled)
+
+	// setup USART parameters for electricity meter
+	usart_set_baudrate(USART(SENSOR_SDM120_USART), baudrate); // get baud rate by scrolling through the measurements on the electricity meter's screen (default 2400)
+	usart_set_databits(USART(SENSOR_SDM120_USART), 8);
+	usart_set_stopbits(USART(SENSOR_SDM120_USART), USART_STOPBITS_1);
+	usart_set_mode(USART(SENSOR_SDM120_USART), USART_MODE_TX_RX);
+	usart_set_parity(USART(SENSOR_SDM120_USART), USART_PARITY_NONE); // get parity by scrolling through the measurements on the electricity meter's screen (default none)
+	usart_set_flow_control(USART(SENSOR_SDM120_USART), USART_FLOWCONTROL_NONE);
+
+	nvic_enable_irq(USART_IRQ(SENSOR_SDM120_USART)); // enable the USART interrupt
+	usart_enable_rx_interrupt(USART(SENSOR_SDM120_USART)); // enable receive interrupt
+	usart_enable(USART(SENSOR_SDM120_USART)); // enable USART
+
+	// setup GPIO
+	rcc_periph_clock_enable(RCC_GPIO(SENSOR_SDM120_REDE_PORT)); // enable clock for GPIO peripheral
+	gpio_set_mode(GPIO(SENSOR_SDM120_REDE_PORT), GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO(SENSOR_SDM120_REDE_PIN)); // setup GPIO pin for receiver and driver output enable pin
+	gpio_clear(GPIO(SENSOR_SDM120_REDE_PORT),GPIO(SENSOR_SDM120_REDE_PIN)); // disable driver output and enable receive output
+
+	// setup timer to wait for minimal time before sending transmitting
+	rcc_periph_clock_enable(RCC_TIM(SENSOR_SDM120_TIMER)); // enable clock for timer block
+	timer_reset(TIM(SENSOR_SDM120_TIMER)); // reset timer state
+	timer_set_mode(TIM(SENSOR_SDM120_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock,edge alignment (simple count), and count up
+	timer_one_shot_mode(TIM(SENSOR_SDM120_TIMER)); // stop counter after update event (we only need to count down once)
+	timer_set_prescaler(TIM(SENSOR_SDM120_TIMER), 66-1); // set the prescaler so this 16 bits timer allows to wait for 60 ms ( 1/(72E6/66/(2**16))=60.07ms )
+	timeout_times[TIMEOUT_BEGIN] = (rcc_ahb_frequency/(TIM_PSC(TIM(SENSOR_SDM120_TIMER))+1))/baudrate/8/2.5; // wait at least 2.5 characters before sending data
+	timeout_times[TIMEOUT_END] = (rcc_ahb_frequency/(TIM_PSC(TIM(SENSOR_SDM120_TIMER))+1))/baudrate/8/2.5; // wait at least 2.5 characters after sending data
+	timeout_times[TIMEOUT_BETWEEN] = 0.06*(rcc_ahb_frequency/(TIM_PSC(TIM(SENSOR_SDM120_TIMER))+1)); // wait at least 60 ms before sending the next message
+	timer_clear_flag(TIM(SENSOR_SDM120_TIMER), TIM_SR_UIF); // clear flag
+	timer_enable_irq(TIM(SENSOR_SDM120_TIMER), TIM_DIER_UIE); // enable update interrupt for timer
+	nvic_enable_irq(NVIC_TIM_IRQ(SENSOR_SDM120_TIMER)); // catch interrupt in service routine
+
+	// reset states
+	tx_used = 0;
+	rx_used = 0;
+	sensor_sdm120_measurement_received = false;
+}
+
+/** send request to electricity meter
+ *  @param[in] meter_id electricity meter device id (ModBus salve address)
+ *  @param[in] function ModBus function: 0x03 read two 16 bits holding registers, 0x04 read two 16 bits input registers, 0x10 write two 16 bits holding registers
+ *  @param[in] address register start point address
+ *  @param[in] value value to store in holding register (if function 0x10 is used)
+ *  @return if request is correct and transmission started
+ */
+static bool sensor_sdm120_transmit_request(uint8_t meter_id, uint8_t function, uint16_t address, float value)
+{
+	if (meter_id==0) { // broadcast request are not supported
+		return false;
+	}
+	if (function!=0x03 && function!=0x04 && function!=0x10) { // function not supported
+		return false;
+	}
+	if (address%2) { // even register addresses are not supported by device
+		return false;
+	}
+	while (tx_used) { // transmission is ongoing
+		__WFI(); // wait until something happens (transmission ended)
+	}
+	// build request packet
+	uint8_t packet[11]; // buffer to build ModBus message (without error check)
+	uint8_t packet_size = 0; // ModBus message size (without error check)
+	packet[0] = meter_id; // set slave device address
+	packet[1] = function; // set function
+	packet[2] = address>>8; // set high register address
+	packet[3] = address; // set low register address
+	packet[4] = 0; // set high number of registers to read
+	packet[5] = 2; // set low number of register to read (the measurement are encoded using 32 bits IEE745 float, and register hold 16 bits, thus we want to read 2 registers
+	if (function==0x03 || function==0x04) { // read register
+		packet_size = 6; // set message size
+	} else if (function==0x10) { // write register
+		packet[6] = 4; // byte count (writing two 16 bits registers)
+		// store little endian encoded value in big endian encoded data
+		uint8_t* data = (uint8_t*)&value;
+		packet[7] = data[3];
+		packet[8] = data[2];
+		packet[9] = data[1];
+		packet[10] = data[0];
+		packet_size = 11; // set message size
+	}
+	uint16_t crc = crc_modbus(packet, packet_size); // compute error check
+	for (uint8_t i=0; i<packet_size; i++) {
+		tx_buffer[packet_size-i+1] = packet[i]; // copy packet to tx buffer in reverse order (this is how sending is implemented)
+	}
+	tx_buffer[1] = crc; // set low error check
+	tx_buffer[0] = crc>>8; // set high error check
+	tx_used = packet_size+2; // set request size
+	rx_used = 0; // reset reset buffer
+	sensor_sdm120_measurement_received = false; // reset measurement flag
+	while (TIM_CR1(TIM(SENSOR_SDM120_TIMER))&TIM_CR1_CEN) { // timer is already used
+		 __WFI(); // wait until something happens (timer is available again)
+	}	
+	gpio_set(GPIO(SENSOR_SDM120_REDE_PORT),GPIO(SENSOR_SDM120_REDE_PIN)); // enable driver output and disable receive output
+	// start timeout
+	timeout = TIMEOUT_BEGIN; // select time before sending message
+	timer_set_period(TIM(SENSOR_SDM120_TIMER), timeout_times[timeout]); // set corresponding timeout
+	timer_set_counter(TIM(SENSOR_SDM120_TIMER), 0); // reset timer counter to get preset waiting time
+	timer_enable_counter(TIM(SENSOR_SDM120_TIMER)); // wait
+
+	return true;
+}
+
+bool sensor_sdm120_measurement_request(uint8_t meter_id, enum sensor_sdm120_measurement_type_t type)
+{
+	if (type>=SENSOR_SDM120_MEASUREMENT_MAX) { // invalid type
+		return false;
+	}
+	return sensor_sdm120_transmit_request(meter_id, 0x04, register_input[type], 0);
+}
+
+bool sensor_sdm120_configuration_request(uint8_t meter_id, enum sensor_sdm120_configuration_type_t type)
+{
+	if (type>=SENSOR_SDM120_CONFIGURATION_MAX) { // invalid type
+		return false;
+	}
+	return sensor_sdm120_transmit_request(meter_id, 0x03, register_holding[type], 0);
+}
+
+bool sensor_sdm120_configuration_set(uint8_t meter_id, enum sensor_sdm120_configuration_type_t type, float value)
+{
+	if (type>=SENSOR_SDM120_CONFIGURATION_MAX) { // invalid type
+		return false;
+	}
+	return sensor_sdm120_transmit_request(meter_id, 0x10, register_holding[type], value);
+}
+
+float sensor_sdm120_measurement_decode(void)
+{
+	float measurement = NAN; // decoded measurement to return (invalid in the beginning)
+	if (!sensor_sdm120_measurement_received) { // no measurement received
+		return NAN;
+	} else {
+		sensor_sdm120_measurement_received = false; // reset flag
+	}
+	if (rx_used<5) { // not a complete response (minimum is address, function, size/error, error check low, error check high)
+		return NAN;
+	}
+	// a complete message has been received
+	if (crc_modbus(rx_buffer,rx_used)) { // checksum error, error check failed
+		measurement = NAN;
+	} else if (rx_buffer[1]&0x80) { // error condition received
+		measurement = INFINITY; // indicate we received and error
+	} else {
+		switch (rx_buffer[1]) {
+			case 0x03: // read 4xxx holding register response received
+			case 0x04: // read 3xxxx input register response received
+				if (rx_buffer[2]==0x04 && rx_used>=(4+5)) { // 2 registers received, corresponds to implemented request
+					// convert big endian received float value to little endian return value
+					uint8_t* convert = (uint8_t*)&measurement;
+					convert[0] = rx_buffer[6];
+					convert[1] = rx_buffer[5];
+					convert[2] = rx_buffer[4];
+					convert[3] = rx_buffer[3];
+				}
+				break;
+			case 0x10: // write 4xxx holding register response received
+				measurement = (rx_buffer[4]<<8)+rx_buffer[5]; // number of registers written
+				break; // not supported currently
+			default: // unknown function response received
+				measurement = INFINITY;
+				break; // nothing to do
+		}
+	}
+	rx_used = 0; // reset rx_buffer usage
+	return measurement;
+}
+	
+/** USART interrupt service routine called when data has been transmitted or received */
+void USART_ISR(SENSOR_SDM120_USART)(void)
+{
+	if (usart_get_interrupt_source(USART(SENSOR_SDM120_USART), USART_SR_TXE)) { // data has been transmitted
+		if (tx_used) { // not all bytes transmitted
+			usart_send(USART(SENSOR_SDM120_USART),tx_buffer[--tx_used]); // transmit next byte (clears flag)
+		} else { // all bytes transmitted
+			usart_disable_tx_interrupt(USART(SENSOR_SDM120_USART)); // disable transmit interrupt
+			USART_SR(USART(SENSOR_SDM120_USART)) &= ~USART_SR_TXE; // clear flag
+			USART_CR1(USART(SENSOR_SDM120_USART)) |= USART_CR1_TCIE; // enable transfer complete interrupt
+		}
+	}
+	if (usart_get_interrupt_source(USART(SENSOR_SDM120_USART), USART_SR_TC)) { // data has been completely transmitted
+		USART_CR1(USART(SENSOR_SDM120_USART)) |= USART_CR1_TCIE; // disable transfer complete interrupt
+		USART_SR(USART(SENSOR_SDM120_USART)) &= ~USART_SR_TC; // clear flag
+		timeout = TIMEOUT_END; // select wait time after sending data
+		timer_set_period(TIM(SENSOR_SDM120_TIMER), timeout_times[timeout]); // set corresponding timeout
+		timer_set_counter(TIM(SENSOR_SDM120_TIMER), 0); // reset timer counter to get preset waiting time
+		timer_enable_counter(TIM(SENSOR_SDM120_TIMER)); // wait
+	}
+	if (usart_get_interrupt_source(USART(SENSOR_SDM120_USART), USART_SR_RXNE)) { // data has been received
+		if (gpio_get(GPIO(SENSOR_SDM120_REDE_PORT),GPIO(SENSOR_SDM120_REDE_PIN))) { // not in receiver mode
+			USART_SR(USART(SENSOR_SDM120_USART)) &= ~USART_SR_RXNE; // clear flag, ignore received data
+		} else if (rx_used<LENGTH(rx_buffer)) { // receiving response
+			rx_buffer[rx_used++] = usart_recv(USART(SENSOR_SDM120_USART)); // put received byte in buffer (clears flag)
+			if (rx_used==1 && rx_buffer[0]==0) { // this is wrong decoding because the signal is going low on idle, which is misinterpreted as start bit (and the 0 broadcast device address is not supported by this device)
+				rx_used = 0; // reset buffer
+			} else if (rx_used>=5 && (rx_buffer[1]&0x80)) { // error condition response received
+				sensor_sdm120_measurement_received = true; // notify used response has been received
+			} else if (rx_used>=5 && (uint8_t)(rx_used-5)>=rx_buffer[2] && (rx_buffer[1]==0x04 || rx_buffer[1]==0x03)) { // read input or holding register response received
+				sensor_sdm120_measurement_received = true; // notify used response has been receive
+			} else if (rx_used>=8 && rx_buffer[1]==0x10) { // write holding register response received
+				sensor_sdm120_measurement_received = true; // notify used response has been receive
+			}
+		} else { // buffer full and unknown response received
+			USART_SR(USART(SENSOR_SDM120_USART)) &= ~USART_SR_RXNE; // clear flag (wait for user to read measurement, this clears the buffer)
+		}
+		timeout = TIMEOUT_END; // select time after receiving data
+		timer_set_period(TIM(SENSOR_SDM120_TIMER), timeout_times[timeout]); // set corresponding timeout
+		timer_set_counter(TIM(SENSOR_SDM120_TIMER), 0); // reset timer counter to get preset waiting time
+		timer_enable_counter(TIM(SENSOR_SDM120_TIMER)); // wait
+	}
+}
+
+/** interrupt service routine called on timeout */
+void TIM_ISR(SENSOR_SDM120_TIMER)(void)
+{
+	if (timer_get_flag(TIM(SENSOR_SDM120_TIMER), TIM_SR_UIF)) { // update event happened
+		timer_clear_flag(TIM(SENSOR_SDM120_TIMER), TIM_SR_UIF); // clear flag
+		// because of the one pulse mode the timer is stopped automatically
+		switch (timeout) { // timeout before action passed
+			case (TIMEOUT_BEGIN): // we can now send the data
+				USART_SR(USART(SENSOR_SDM120_USART)) &= USART_SR_TXE; // clear interrupt flag
+				usart_enable_tx_interrupt(USART(SENSOR_SDM120_USART)); // enable interrupt to send other bytes
+				usart_send(USART(SENSOR_SDM120_USART),tx_buffer[--tx_used]); // start transmission
+				break;
+			case (TIMEOUT_END): // we now have to wait before sending the next message
+		        gpio_clear(GPIO(SENSOR_SDM120_REDE_PORT),GPIO(SENSOR_SDM120_REDE_PIN)); // disable driver output (and enable receive output)
+				timeout = TIMEOUT_BETWEEN; // select time between sending message
+				timer_set_period(TIM(SENSOR_SDM120_TIMER), timeout_times[timeout]); // set corresponding timeout
+				timer_set_counter(TIM(SENSOR_SDM120_TIMER), 0); // reset timer counter to get preset waiting time
+				timer_enable_counter(TIM(SENSOR_SDM120_TIMER)); // wait
+			case (TIMEOUT_BETWEEN): // nothing to do, we are allowed to send the next message
+				break;
+			default:
+				break;
+		}
+	}
+}
+
diff --git a/lib/sensor_sdm120.h b/lib/sensor_sdm120.h
new file mode 100644
index 0000000..abef696
--- /dev/null
+++ b/lib/sensor_sdm120.h
@@ -0,0 +1,83 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to query measurements from eastron SDM120-ModBus electricity meter (API)
+ *  @file sensor_sdm120.h
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: USART @ref sensor_sdm120_usart , GPIO @ref sensor_sdm120_gpio , timer @ref sensor_sdm120_timer
+ */
+#pragma once
+
+/** a measurement response has been received */
+extern volatile bool sensor_sdm120_measurement_received;
+
+/** measurement types offered by electricity meter in 3xxx input registers */
+enum sensor_sdm120_measurement_type_t {
+	SENSOR_SDM120_VOLTAGE = 0,
+	SENSOR_SDM120_CURRENT,
+	SENSOR_SDM120_POWER_ACTIVE,
+	SENSOR_SDM120_POWER_APPARENT,
+	SENSOR_SDM120_POWER_REACTIVE,
+	SENSOR_SDM120_POWER_FACTOR,
+	SENSOR_SDM120_FREQUENCY,
+	SENSOR_SDM120_ENERGY_ACTIVE_IMPORT,
+	SENSOR_SDM120_ENERGY_ACTIVE_EXPORT,
+	SENSOR_SDM120_ENERGY_REACTIVE_IMPORT,
+	SENSOR_SDM120_ENERGY_REACTIVE_EXPORT,
+	SENSOR_SDM120_ENERGY_ACTIVE_TOTAL,
+	SENSOR_SDM120_ENERGY_REACTIVE_TOTAL,
+	SENSOR_SDM120_MEASUREMENT_MAX
+};
+
+/** configuration types for electricity meter in 4xxx holding registers */
+enum sensor_sdm120_configuration_type_t {
+	SENSOR_SDM120_RELAY_PULSE_WIDTH = 0,
+	SENSOR_SDM120_NETWORK_PARITY_STOP,
+	SENSOR_SDM120_METER_ID,
+	SENSOR_SDM120_BAUD_RATE,
+	SENSOR_SDM120_PULSE_1_OUTPUT_MODE,
+	SENSOR_SDM120_TIME_OF_SCROLL_DISPLAY,
+	SENSOR_SDM120_PULSE_1_OUTPUT,
+	SENSOR_SDM120_MEASUREMENT_MODE,
+	SENSOR_SDM120_CONFIGURATION_MAX
+};
+
+/** setup peripherals to communicate with electricity meter
+ *  @param[in] baudrate baud rate of RS485 serial communication
+ */
+void sensor_sdm120_setup(uint32_t baudrate);
+/** request measurement from electricity meter
+ *  @param[in] meter_id electricity meter device ID
+ *  @param[in] type measurement type to request
+ *  @return if transmission started
+ */
+bool sensor_sdm120_measurement_request(uint8_t meter_id, enum sensor_sdm120_measurement_type_t type);
+/** request configuration from electricity meter
+ *  @param[in] meter_id electricity meter device ID
+ *  @param[in] type configuration type to request
+ *  @return if transmission started
+ */
+bool sensor_sdm120_configuration_request(uint8_t meter_id, enum sensor_sdm120_configuration_type_t type);
+/** set configuration in electricity meter
+ *  @param[in] meter_id electricity meter device ID
+ *  @param[in] type configuration type to set
+ *  @param[in] value configuration value to set
+ *  @return if transmission started
+ */
+bool sensor_sdm120_configuration_set(uint8_t meter_id, enum sensor_sdm120_configuration_type_t type, float value);
+/** decode received measurement
+ *  @return decoded measurement or number of registers written, NaN if message has error or no new measurement has been received, infinity if an error or unknown message has been received
+ */
+float sensor_sdm120_measurement_decode(void);
diff --git a/lib/uart_soft.c b/lib/uart_soft.c
new file mode 100644
index 0000000..105d811
--- /dev/null
+++ b/lib/uart_soft.c
@@ -0,0 +1,414 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to control up to 4 independent receive and transmit software UART ports (code)
+ *  @file uart_soft.c
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: GPIO @ref uart_soft_gpio, timer @ref uart_soft_timer
+ */
+
+/* standard libraries */
+#include <stdint.h> // standard integer types
+#include <stdlib.h> // general utilities
+
+/* STM32 (including CM3) libraries */
+#include <libopencm3/stm32/rcc.h> // real-time control clock library
+#include <libopencm3/stm32/gpio.h> // general purpose input output library
+#include <libopencm3/stm32/timer.h> // timer library
+#include <libopencm3/cm3/nvic.h> // interrupt handler
+#include <libopencm3/stm32/exti.h> // external interrupt defines
+#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
+
+#include "uart_soft.h" // software UART library API
+#include "global.h" // common methods
+
+/** @defgroup uart_soft_gpio GPIO used for the software 4 UART ports
+ *  @note comment if unused
+ *  @warning only one port must be used per line (pin number)
+ *  @{
+ */
+#define UART_SOFT_RX_PORT0 B /**< port for receive signal for UART port 0 */
+#define UART_SOFT_RX_PIN0 9 /**< pin for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PORT1 A /**< port for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PIN1 0 /**< pin for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PORT2 A /**< port for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PIN2 0 /**< pin for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PORT3 A /**< port for receive signal for UART port 0 */
+//#define UART_SOFT_RX_PIN3 0 /**< pin for receive signal for UART port 0 */
+#define UART_SOFT_TX_PORT0 B /**< port for transmit signal for UART port 0 */
+#define UART_SOFT_TX_PIN0 8 /**< pin for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PORT1 A /**< port for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PIN1 0 /**< pin for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PORT2 A /**< port for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PIN2 0 /**< pin for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PORT3 A /**< port for transmit signal for UART port 0 */
+//#define UART_SOFT_TX_PIN3 0 /**< pin for transmit signal for UART port 0 */
+/** @} */
+
+/** buffer size for receive and transmit buffers */
+#define UART_SOFT_BUFFER 128
+/** UART receive state definition */
+struct soft_uart_rx_state {
+	uint32_t port; /**< UART receive port */
+	uint16_t pin; /**< UART receive pin */
+	uint32_t rcc; /**< UART receive port peripheral clock */
+	uint32_t exti; /**< UART receive external interrupt */
+	uint32_t irq; /**< UART receive interrupt request */
+	uint32_t baudrate; /**< UART receive baud rate */
+	volatile uint16_t state; /**< GPIO state for receive pin */
+	volatile uint8_t bit; /**< next UART frame bit to receive */
+	volatile uint8_t byte; /**< byte being received */
+	volatile uint8_t buffer[UART_SOFT_BUFFER]; /**< receive buffer */
+	volatile uint8_t buffer_i; /**< index of current data to be read out */
+	volatile uint8_t buffer_used; /**< how much data is available */
+	volatile bool lock; /**< put lock when changing buffer_i or buffer_used */
+	volatile uint8_t buffer_byte; /**< to temporary store byte while locked */
+	volatile bool buffer_byte_used; /**< signal a byte has been stored in temporary buffer */
+
+};
+/** UART transmit state definition */
+struct soft_uart_tx_state {
+	uint32_t port; /**< UART receive port */
+	uint16_t pin; /**< UART receive pin */
+	uint32_t rcc; /**< UART receive port peripheral clock */
+	uint32_t baudrate; /**< UART receive baud rate */
+	volatile uint8_t bit; /**< next UART frame bit to transmit */
+	volatile uint8_t byte; /**< byte being transmitted */
+	volatile uint8_t buffer[UART_SOFT_BUFFER]; /**< receive buffer */
+	volatile uint8_t buffer_i; /**< index of current data to be read out */
+	volatile uint8_t buffer_used; /**< how much data is available */
+	volatile bool transmit; /**< flag to know it transmission is ongoing */
+};
+
+static struct soft_uart_rx_state* uart_soft_rx_states[4] = {NULL}; /**< states of UART receive ports (up to 4) */
+static struct soft_uart_tx_state* uart_soft_tx_states[4] = {NULL}; /**< states of UART transmit ports (up to 4) */
+
+volatile bool uart_soft_received[4] = {false, false, false, false};
+
+/** @defgroup uart_soft_timer timer used to sample UART signals
+ *  @{
+ */
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN0))
+	#define UART_SOFT_RX_TIMER 3 /**< timer peripheral for receive signals */
+#endif
+#if (defined(UART_SOFT_TX_PORT0) && defined(UART_SOFT_TX_PIN0)) || (defined(UART_SOFT_TX_PORT1) && defined(UART_SOFT_TX_PIN1)) || (defined(UART_SOFT_TX_PORT2) && defined(UART_SOFT_TX_PIN2)) || (defined(UART_SOFT_TX_PORT3) && defined(UART_SOFT_TX_PIN0))
+	#define UART_SOFT_TX_TIMER 4 /**< timer peripheral for transmit signals */
+#endif
+/** @} */
+
+static const uint32_t timer_flags[4] = {TIM_SR_CC1IF,TIM_SR_CC2IF,TIM_SR_CC3IF,TIM_SR_CC4IF}; /**< the interrupt flags for the compare units */
+static const uint32_t timer_interrupt[4] = {TIM_DIER_CC1IE,TIM_DIER_CC2IE,TIM_DIER_CC3IE,TIM_DIER_CC4IE}; /**< the interrupt enable for the compare units */
+static const enum tim_oc_id timer_oc[4] = {TIM_OC1,TIM_OC2,TIM_OC3,TIM_OC4}; /**< the output compares for the compare units */
+
+bool uart_soft_setup(uint32_t *rx_baudrates, uint32_t *tx_baudrates)
+{
+	(void)rx_baudrates; // ensure compile does no complain even if no receive port is used
+	(void)tx_baudrates; // ensure compile does no complain even if no transmit port is used
+
+	// save UART receive definition
+#if defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0)
+	uart_soft_rx_states[0] = calloc(1,sizeof(struct soft_uart_rx_state)); // create state definition
+	uart_soft_rx_states[0]->port = GPIO(UART_SOFT_RX_PORT0); // save receive port
+	uart_soft_rx_states[0]->pin = GPIO(UART_SOFT_RX_PIN0); // save receive pin
+	uart_soft_rx_states[0]->rcc = RCC_GPIO(UART_SOFT_RX_PORT0); // save receive port peripheral clock
+	uart_soft_rx_states[0]->exti = EXTI(UART_SOFT_RX_PIN0); // save receive external interrupt
+	uart_soft_rx_states[0]->irq = NVIC_EXTI_IRQ(UART_SOFT_RX_PIN0); // save receive interrupt request
+#endif
+
+	// setup UART receive GPIO
+	for (uint8_t rx=0; rx<4; rx++) {
+		if (!uart_soft_rx_states[rx]) { // verify is receive UART is defined
+			continue; // skip configuration if not defined
+		}
+		if (!rx_baudrates || rx_baudrates[rx]==0) { // verify if receive baud rate has been defined
+			return false;
+		}
+		uart_soft_rx_states[rx]->baudrate = rx_baudrates[rx]; // save baud rate
+		rcc_periph_clock_enable(uart_soft_rx_states[rx]->rcc); // enable clock for GPIO peripheral
+		gpio_set_mode(uart_soft_rx_states[rx]->port, GPIO_MODE_INPUT, GPIO_CNF_INPUT_PULL_UPDOWN, uart_soft_rx_states[rx]->pin); // setup GPIO pin UART receive
+		gpio_set(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // pull up to avoid noise when not connected
+		rcc_periph_clock_enable(RCC_AFIO); // enable alternate function clock for external interrupt
+		exti_select_source(uart_soft_rx_states[rx]->exti, uart_soft_rx_states[rx]->port); // mask external interrupt of this pin only for this port	
+		exti_enable_request(uart_soft_rx_states[rx]->exti); // enable external interrupt
+		exti_set_trigger(uart_soft_rx_states[rx]->exti, EXTI_TRIGGER_BOTH); // trigger when button is pressed
+		nvic_enable_irq(uart_soft_rx_states[rx]->irq); // enable interrupt
+		uart_soft_rx_states[rx]->state = gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // save state of GPIO
+		uart_soft_rx_states[rx]->bit = 0; // reset bits received
+	}
+
+	// save UART transmit definition
+#if defined(UART_SOFT_TX_PORT0) && defined(UART_SOFT_TX_PIN0)	
+	uart_soft_tx_states[0] = calloc(1,sizeof(struct soft_uart_tx_state)); // create state definition
+	uart_soft_tx_states[0]->port = GPIO(UART_SOFT_TX_PORT0); // save receive port
+	uart_soft_tx_states[0]->pin = GPIO(UART_SOFT_TX_PIN0); // save receive pin
+	uart_soft_tx_states[0]->rcc = RCC_GPIO(UART_SOFT_TX_PORT0); // save receive port peripheral clock
+#endif
+	
+	// setup UART transmit GPIO
+	for (uint8_t tx=0; tx<4; tx++) {
+		if (!uart_soft_tx_states[tx]) { // verify is transmit UART is defined
+			continue; // skip configuration if not defined
+		}
+		if (!tx_baudrates || tx_baudrates[tx]==0) { // verify if transmit baud rate has been defined
+			return false;
+		}
+		uart_soft_tx_states[tx]->baudrate = tx_baudrates[tx]; // save baud rate
+		rcc_periph_clock_enable(uart_soft_tx_states[tx]->rcc); // enable clock for GPIO peripheral
+		gpio_set_mode(uart_soft_tx_states[tx]->port, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, uart_soft_tx_states[tx]->pin); // setup GPIO UART transmit pin
+		gpio_set(uart_soft_tx_states[tx]->port, uart_soft_tx_states[tx]->pin); // idle high
+	}
+
+	// setup timer
+#if defined(UART_SOFT_RX_TIMER)
+	rcc_periph_clock_enable(RCC_TIM(UART_SOFT_RX_TIMER)); // enable clock for timer peripheral
+	timer_reset(TIM(UART_SOFT_RX_TIMER)); // reset timer state
+	timer_set_mode(TIM(UART_SOFT_RX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
+	timer_set_prescaler(TIM(UART_SOFT_RX_TIMER), 0); // prescaler to be able to sample 2400-115200 bps (72MHz/2^16=1099<2400bps)
+	nvic_enable_irq(NVIC_TIM_IRQ(UART_SOFT_RX_TIMER)); // allow interrupt for timer
+	timer_enable_counter(TIM(UART_SOFT_RX_TIMER)); // start timer to generate interrupts for the receive pins
+#endif
+#if defined(UART_SOFT_TX_TIMER)
+	rcc_periph_clock_enable(RCC_TIM(UART_SOFT_TX_TIMER)); // enable clock for timer peripheral
+	timer_reset(TIM(UART_SOFT_TX_TIMER)); // reset timer state
+	timer_set_mode(TIM(UART_SOFT_TX_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock, edge alignment (simple count), and count up
+	timer_set_prescaler(TIM(UART_SOFT_TX_TIMER), 0); // prescaler to be able to output 2400-115200 bps (72MHz/2^16=1099<2400bps)
+	nvic_enable_irq(NVIC_TIM_IRQ(UART_SOFT_TX_TIMER)); // allow interrupt for timer
+	timer_enable_counter(TIM(UART_SOFT_TX_TIMER)); // start timer to generate interrupts for the transmit pins
+#endif
+
+	return true; // setup completed
+}
+
+#if defined(UART_SOFT_RX_TIMER)
+uint8_t uart_soft_getbyte(uint8_t uart)
+{
+	if (uart>=4 || !uart_soft_rx_states[uart]) { // ensure receive UART port is defined
+		return 0; // return
+	}
+	while (!uart_soft_rx_states[uart]->buffer_used) { // idle until data is available
+		__WFI(); // sleep until interrupt
+	}
+	uart_soft_rx_states[uart]->lock = true; // set lock
+	uint8_t to_return = uart_soft_rx_states[uart]->buffer[uart_soft_rx_states[uart]->buffer_i]; // get the next available character
+	uart_soft_rx_states[uart]->buffer_i = (uart_soft_rx_states[uart]->buffer_i+1)%LENGTH(uart_soft_rx_states[uart]->buffer); // update used buffer
+	uart_soft_rx_states[uart]->buffer_used--; // update used buffer
+	uart_soft_rx_states[uart]->lock = false; // free lock
+	if (uart_soft_rx_states[uart]->buffer_byte_used) { // temporary byte has been stored
+		uart_soft_rx_states[uart]->buffer[(uart_soft_rx_states[uart]->buffer_i+uart_soft_rx_states[uart]->buffer_used)%LENGTH(uart_soft_rx_states[uart]->buffer)] = uart_soft_rx_states[uart]->buffer_byte; // put byte in buffer
+		uart_soft_rx_states[uart]->buffer_used++; // update used buffer
+		uart_soft_rx_states[uart]->buffer_byte_used = false; // buffer byte is now in buffer
+	}
+	uart_soft_received[uart] = (uart_soft_rx_states[uart]->buffer_used!=0); // notify user if data is available
+	uart_soft_rx_states[uart]->lock = false; // free lock
+	return to_return;
+}
+
+/** timer interrupt service routine to generate UART transmit signals */
+void TIM_ISR(UART_SOFT_RX_TIMER)(void)
+{
+	for (uint8_t rx=0; rx<4; rx++) {
+		if (timer_interrupt_source(TIM(UART_SOFT_RX_TIMER),timer_flags[rx])) { // got a match on compare for receive pin
+			timer_clear_flag(TIM(UART_SOFT_RX_TIMER),timer_flags[rx]); // clear flag
+			if (!uart_soft_rx_states[rx]) { // verify if RX exists
+				continue; // skip if receive port is not defined it
+			}
+			uart_soft_rx_states[rx]->byte += ((gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin)==0 ? 0 : 1)<<(uart_soft_rx_states[rx]->bit-1)); // save bit value
+			if (uart_soft_rx_states[rx]->bit<8) { // not the last bit received
+				timer_set_oc_value(TIM(UART_SOFT_RX_TIMER),timer_oc[rx],timer_get_counter(TIM(UART_SOFT_RX_TIMER))+rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate); // set timer to next bit
+				uart_soft_rx_states[rx]->bit++; // wait for next bit
+			} else { // last bit received
+				if (uart_soft_rx_states[rx]->lock) { // someone is already reading data
+					uart_soft_rx_states[rx]->buffer_byte = uart_soft_rx_states[rx]->byte; // save byte
+					uart_soft_rx_states[rx]->buffer_byte_used = true; // notify reader there is a temporary byte
+				} else { // buffer can be updated
+					if (uart_soft_rx_states[rx]->buffer_used>=LENGTH(uart_soft_rx_states[rx]->buffer)) { // buffer is full
+						uart_soft_rx_states[rx]->buffer_i = (uart_soft_rx_states[rx]->buffer_i+1)%LENGTH(uart_soft_rx_states[rx]->buffer); // drop oldest byte
+						uart_soft_rx_states[rx]->buffer_used--; // update buffer usage
+					}
+					uart_soft_rx_states[rx]->buffer[(uart_soft_rx_states[rx]->buffer_i+uart_soft_rx_states[rx]->buffer_used)%LENGTH(uart_soft_rx_states[rx]->buffer)] = uart_soft_rx_states[rx]->byte; // put byte in buffer
+					uart_soft_rx_states[rx]->buffer_used++; // update used buffer
+					uart_soft_received[rx] = true; // notify user data is available
+				}
+				timer_disable_irq(TIM(UART_SOFT_RX_TIMER),timer_interrupt[rx]); // stop_interrupting
+				uart_soft_rx_states[rx]->bit = 0; // next bit should be first bit of next byte
+			}
+		}
+	}
+}
+#endif
+
+#if defined(UART_SOFT_TX_TIMER)
+void uart_soft_flush(uint8_t uart)
+{
+	if (uart>=4 || !uart_soft_tx_states[uart]) { // ensure transmit UART port is defined
+		return; // return
+	}
+	while (uart_soft_tx_states[uart]->buffer_used) { // idle until buffer is empty
+		__WFI(); // sleep until interrupt
+	}
+	while (uart_soft_tx_states[uart]->transmit) { // idle until transmission is complete
+		__WFI(); // sleep until interrupt
+	}
+}
+
+/** start transmitting a byte from the buffer
+ *  @param[in] uart UART port used for transmission
+ */
+static void uart_soft_transmit(uint8_t uart) {
+	if (uart>=4 || !uart_soft_tx_states[uart]) { // ensure transmit UART port is defined
+		return; // UART transmit port not defined
+	}
+	if (uart_soft_tx_states[uart]->transmit) { // already transmitting
+		return; // transmission is already ongoing
+	}
+	if (!uart_soft_tx_states[uart]->buffer_used) { // no buffered data to transmit
+		return; // nothing to transmit
+	}
+	uart_soft_tx_states[uart]->byte = uart_soft_tx_states[uart]->buffer[uart_soft_tx_states[uart]->buffer_i]; // get byte
+	uart_soft_tx_states[uart]->buffer_i = (uart_soft_tx_states[uart]->buffer_i+1)%LENGTH(uart_soft_tx_states[uart]->buffer); // update index
+	uart_soft_tx_states[uart]->buffer_used--; // update used buffer
+	uart_soft_tx_states[uart]->bit = 0; // LSb is transmitted first
+	uart_soft_tx_states[uart]->transmit = true; // start transmission
+	gpio_clear(uart_soft_tx_states[uart]->port, uart_soft_tx_states[uart]->pin); // output start bit
+	timer_set_oc_value(TIM(UART_SOFT_TX_TIMER), timer_oc[uart], timer_get_counter(TIM(UART_SOFT_TX_TIMER))+(rcc_ahb_frequency/uart_soft_tx_states[uart]->baudrate)); // set timer to output UART frame 1 (data bit 0) in 1 bit
+	timer_clear_flag(TIM(UART_SOFT_TX_TIMER), timer_flags[uart]); // clear flag before enabling interrupt
+	timer_enable_irq(TIM(UART_SOFT_TX_TIMER), timer_interrupt[uart]);// enable timer IRQ for TX for this UART
+}
+
+void uart_soft_putbyte_nonblocking(uint8_t uart, uint8_t byte)
+{
+	if (uart>=4 || !uart_soft_tx_states[uart]) { // ensure transmit UART port is defined
+		return; // return
+	}	
+	while (uart_soft_tx_states[uart]->buffer_used>=LENGTH(uart_soft_tx_states[uart]->buffer)) { // idle until there is place in the buffer
+		__WFI(); // sleep until something happened
+	}
+	uart_soft_tx_states[uart]->buffer[(uart_soft_tx_states[uart]->buffer_i+uart_soft_tx_states[uart]->buffer_used)%LENGTH(uart_soft_tx_states[uart]->buffer)] = byte; // save byte to be transmitted
+	uart_soft_tx_states[uart]->buffer_used++; // update used buffer
+	uart_soft_transmit(uart); // start transmission
+}
+
+void uart_soft_putbyte_blocking(uint8_t uart, uint8_t byte)
+{
+	uart_soft_putbyte_nonblocking(uart, byte); // put byte in queue
+	uart_soft_flush(uart); // wait for all byte to be transmitted
+}
+
+/** timer interrupt service routine to sample UART receive signals */
+void TIM_ISR(UART_SOFT_TX_TIMER)(void)
+{
+	for (uint8_t tx=0; tx<4; tx++) {
+		if (timer_interrupt_source(TIM(UART_SOFT_TX_TIMER),timer_flags[tx])) { // got a match on compare for transmit pin
+			timer_clear_flag(TIM(UART_SOFT_TX_TIMER),timer_flags[tx]); // clear flag
+			if (!uart_soft_tx_states[tx]) { // verify if transmit is defined
+				continue; // skip if transmit port is not defined it
+			}
+			if (uart_soft_tx_states[tx]->bit<8) { // there is a data bit to transmit
+				if ((uart_soft_tx_states[tx]->byte>>uart_soft_tx_states[tx]->bit)&0x01) { // bit to transmit is a 1
+					gpio_set(uart_soft_tx_states[tx]->port, uart_soft_tx_states[tx]->pin); // set output to high
+				} else { // bit to transmit is a 0
+					gpio_clear(uart_soft_tx_states[tx]->port, uart_soft_tx_states[tx]->pin); // set output to low
+				}
+				timer_set_oc_value(TIM(UART_SOFT_TX_TIMER), timer_oc[tx], timer_get_counter(TIM(UART_SOFT_TX_TIMER))+(rcc_ahb_frequency/uart_soft_tx_states[tx]->baudrate)); // wait for the next frame bit
+				uart_soft_tx_states[tx]->bit++; // go to next bit
+			} else if (uart_soft_tx_states[tx]->bit==8) { // transmit stop bit
+				gpio_set(uart_soft_tx_states[tx]->port, uart_soft_tx_states[tx]->pin); // go idle high
+				timer_set_oc_value(TIM(UART_SOFT_TX_TIMER), timer_oc[tx], timer_get_counter(TIM(UART_SOFT_TX_TIMER))+(rcc_ahb_frequency/uart_soft_tx_states[tx]->baudrate)); // wait for 1 stop bit
+				uart_soft_tx_states[tx]->bit++; // go to next bit
+			} else { // UART frame is complete
+				timer_disable_irq(TIM(UART_SOFT_TX_TIMER), timer_interrupt[tx]);// enable timer IRQ for TX for this UART
+				uart_soft_tx_states[tx]->transmit = false; // transmission finished
+				uart_soft_transmit(tx); // start next transmission (if there is)
+			}
+		} // compare match
+	} // go through UARTs
+}
+#endif
+
+/** central function handling receive signal activity */
+static void uart_soft_receive_activity(void)
+{
+	for (uint8_t rx=0; rx<4; rx++) {
+		if (!uart_soft_rx_states[rx]) { // verify if receive port is not configured
+			continue; // skip if receive port is not defined it
+		}
+		if (uart_soft_rx_states[rx]->state!=gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin)) { // only do something if state changed
+			uart_soft_rx_states[rx]->state = gpio_get(uart_soft_rx_states[rx]->port, uart_soft_rx_states[rx]->pin); // save new state
+			if (uart_soft_rx_states[rx]->bit==0) { // start bit edge detected
+				if (uart_soft_rx_states[rx]->state==0) { // start bit has to be low
+					timer_set_oc_value(TIM(UART_SOFT_RX_TIMER), timer_oc[rx], timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate)*1.5); // set timer to sample data bit 0 in 1.5 bits
+					timer_clear_flag(TIM(UART_SOFT_RX_TIMER), timer_flags[rx]); // clear flag before enabling interrupt
+					timer_enable_irq(TIM(UART_SOFT_RX_TIMER), timer_interrupt[rx]);// enable timer IRQ for RX for this UART
+					uart_soft_rx_states[rx]->byte = 0; // reset byte value
+					uart_soft_rx_states[rx]->bit++; // wait for first bit
+				}
+			} else { // data bit detected
+				timer_set_oc_value(TIM(UART_SOFT_RX_TIMER), timer_oc[rx], timer_get_counter(TIM(UART_SOFT_RX_TIMER))+(rcc_ahb_frequency/uart_soft_rx_states[rx]->baudrate)/2); // resync timer to half a bit (good for drifting transmission, bad if the line is noisy)
+			}
+		}
+	}
+}
+
+/** GPIO interrupt service routine to detect UART receive activity */
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==0) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==0) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==0) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==0)
+void exti0_isr(void)
+{
+	exti_reset_request(EXTI0); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==1) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==1) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==1) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==1)
+void exti1_isr(void)
+{
+	exti_reset_request(EXTI1); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==2) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==2) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==2) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==2)
+void exti2_isr(void)
+{
+	exti_reset_request(EXTI2); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==3) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==3) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==3) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==3)
+void exti3_isr(void)
+{
+	exti_reset_request(EXTI3); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && UART_SOFT_RX_PIN0==4) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && UART_SOFT_RX_PIN1==4) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && UART_SOFT_RX_PIN2==4) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && UART_SOFT_RX_PIN3==4)
+void exti4_isr(void)
+{
+	exti_reset_request(EXTI4); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && (UART_SOFT_RX_PIN0==5 || UART_SOFT_RX_PIN0==6 || UART_SOFT_RX_PIN0==7 || UART_SOFT_RX_PIN0==8 || UART_SOFT_RX_PIN0==9)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && (UART_SOFT_RX_PIN1==5 || UART_SOFT_RX_PIN1==6 || UART_SOFT_RX_PIN1==7 || UART_SOFT_RX_PIN1==8 || UART_SOFT_RX_PIN1==9)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && (UART_SOFT_RX_PIN2==5 || UART_SOFT_RX_PIN2==6 || UART_SOFT_RX_PIN2==7 || UART_SOFT_RX_PIN2==8 || UART_SOFT_RX_PIN2==9)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && (UART_SOFT_RX_PIN3==5 || UART_SOFT_RX_PIN3==6 || UART_SOFT_RX_PIN3==7 || UART_SOFT_RX_PIN3==8 || UART_SOFT_RX_PIN3==9))
+void exti9_5_isr(void)
+{
+	exti_reset_request(EXTI5|EXTI6|EXTI7|EXTI8|EXTI9); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+#if (defined(UART_SOFT_RX_PORT0) && defined(UART_SOFT_RX_PIN0) && (UART_SOFT_RX_PIN0==10 || UART_SOFT_RX_PIN0==11 || UART_SOFT_RX_PIN0==12 || UART_SOFT_RX_PIN0==13 || UART_SOFT_RX_PIN0==14 || UART_SOFT_RX_PIN0==15)) || (defined(UART_SOFT_RX_PORT1) && defined(UART_SOFT_RX_PIN1) && (UART_SOFT_RX_PIN1==10 || UART_SOFT_RX_PIN1==11 || UART_SOFT_RX_PIN1==12 || UART_SOFT_RX_PIN1==13 || UART_SOFT_RX_PIN1==14 || UART_SOFT_RX_PIN1==15)) || (defined(UART_SOFT_RX_PORT2) && defined(UART_SOFT_RX_PIN2) && (UART_SOFT_RX_PIN2==10 || UART_SOFT_RX_PIN2==11 || UART_SOFT_RX_PIN2==12 || UART_SOFT_RX_PIN2==13 || UART_SOFT_RX_PIN2==14 || UART_SOFT_RX_PIN2==15)) || (defined(UART_SOFT_RX_PORT3) && defined(UART_SOFT_RX_PIN3) && (UART_SOFT_RX_PIN3==10 || UART_SOFT_RX_PIN3==11 || UART_SOFT_RX_PIN3==12 || UART_SOFT_RX_PIN3==13 || UART_SOFT_RX_PIN3==14 || UART_SOFT_RX_PIN3==15))
+void exti15_10_isr(void)
+{
+	exti_reset_request(EXTI10|EXTI11|EXTI12|EXTI13|EXTI14|EXTI15); // clear interrupt flag for pin triggers this ISR (pin state will be checked independently)
+	uart_soft_receive_activity(); // check which GPIO changed
+}
+#endif
+
diff --git a/lib/uart_soft.h b/lib/uart_soft.h
new file mode 100644
index 0000000..677ea8c
--- /dev/null
+++ b/lib/uart_soft.h
@@ -0,0 +1,52 @@
+/* This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+/** library to control up to 4 independent receive and transmit software UART ports (API)
+ *  @file uart_soft.h
+ *  @author King Kévin <kingkevin@cuvoodoo.info>
+ *  @date 2016
+ *  @note peripherals used: GPIO @ref uart_soft_gpio, timer @ref uart_soft_timer
+ */
+
+/** if data has been received from UART port and is available to be read */
+extern volatile bool uart_soft_received[4];
+
+/** setup software UART ports
+ *  @param[in] rx_baudrates baud rates of the 4 UART RX ports (0 if unused)
+ *  @param[in] tx_baudrates baud rates of the 4 UART TX ports (0 if unused)
+ *  @return is setup succeeded, else the configuration is wrong
+ */
+bool uart_soft_setup(uint32_t *rx_baudrates, uint32_t *tx_baudrates);
+/** get received byte from UART port
+ *  @param[in] uart UART receive port to read byte from
+ *  @return received byte (0 if no byte is available)
+ */
+uint8_t uart_soft_getbyte(uint8_t uart);
+/** ensure all bytes are transmitted for the UART
+ *  @param[in] uart UART port to flush
+ */
+void uart_soft_flush(uint8_t uart);
+/** put byte in buffer to be transmitted on UART port
+ *  @note blocking if buffer is full
+ *  @param[in] uart UART port to transmit the byte from
+ *  @param[in] byte byte to put in transmit buffer
+ */
+void uart_soft_putbyte_nonblocking(uint8_t uart, uint8_t byte);
+/** transmit byte on UART port
+ *  @note blocks until all buffered byte and this byte are transmitted
+ *  @param[in] uart UART port to transmit the byte from
+ *  @param[in] byte byte to transmit
+ */
+void uart_soft_putbyte_blocking(uint8_t uart, uint8_t byte);
+