fixed

Dockerfile

@@ -0,0 +1,36 @@
+# docker build --build-arg SENSORS="12 10000" \
+#  --build-arg MQTT_HOST=192.168.x.x --build-arg MQTT_PORT=1883 \
+#  --build-arg=MQTT_USERNAME=username --build-arg=MQTT_PASSWORD=hemligt
+
+FROM alpine:edge as BUILD_ENV
+
+COPY ./sparsnas_decode.cpp /build/
+
+RUN apk add --no-cache g++ mosquitto-dev && \
+    g++ -o /build/sparsnas_decode -O2 -Wall /build/sparsnas_decode.cpp -lmosquitto
+
+FROM alpine:edge
+
+ARG SENSORS
+ARG MQTT_HOST
+ARG MQTT_PORT
+ARG MQTT_USERNAME
+ARG MQTT_PASSWORD
+ENV MQTT_HOST=${MQTT_HOST:-localhost}
+ENV MQTT_PORT=${MQTT_PORT:-1883}
+ENV MQTT_USERNAME=$MQTT_USERNAME
+ENV MQTT_PASSWORD=$MQTT_PASSWORD
+
+RUN : "${SENSORS:?Build argument 'SENSORS' needs to be set and non-empty.}"
+
+RUN apk add --no-cache --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing/ --allow-untrusted \
+      rtl-sdr \
+      mosquitto-libs++ \
+      zsh
+
+COPY --from=BUILD_ENV /build/sparsnas_decode /usr/bin/
+COPY sparsnas.sh /
+
+RUN sed -i "s/^SENSORS=.*/SENSORS=(${SENSORS})/" /sparsnas.sh
+
+ENTRYPOINT ["/sparsnas.sh"]

README.md

@@ -1,3 +1,21 @@
+**This repository has been retired. Please use alternative forks.**
+
+*******************************************************************
+
+
+A BIG thanks to the https://www.facebook.com/groups/SHgruppen on Facebook and a special superduper thanks to the core coder @strigeus!
+https://github.com/strigeus/sparsnas_decoder
+
+This is a fork is adapted for output in JSON format to a MQTT broker.
+
+[![buy me a coffee](https://www.buymeacoffee.com/assets/img/custom_images/yellow_img.png)](https://www.buymeacoffee.com/tubalainen)
+
+If you want to implement the same thing as below into an ESP8266 please see the following project: https://github.com/bphermansson/EspSparsnasGateway
+
+If you want to get into the bits and bytes of the system please see:
+https://github.com/kodarn/Sparsnas
+
+Asif just made a HASSIO Addon based on this code, check out his repository here: https://github.com/asifma/hassio-addons
 
 This is a decoder for IKEA SPARSNÄS.
 ===================================
@@ -6,80 +24,136 @@ It uses RTL-SDR running on a Raspberry Pi to demodulate the FSK signal, and deco
 
 The packet data is encrypted using your sender's ID. The sender ID is the last 6 digits of the serial number located under the battery.
 
-How to build:
+Prerequisites:
 -------------
+Tested on a Raspberry Pi 3 with Raspbian Stretch with a NooElec Nano 3 USB SDR dongle. You should be able to use any RTL-SDR compatible dongle. If you live in Sweden/EU the NooElec Micro 3 dongle can be bought from www.amazon.de (free shipping on orders over 25 EUR).
+Of get your self the "real deal", an original RTL-SDR v3 from https://www.lohelectronics.se/kommunikation/amatorradio/radio/rtl-sdr-r820t2-rtl2832u-1ppm-tcxo-sma-sdr . Dont forget to make your self an antenna, the IKEA Sparsnäs transmits on 868 MHz so a 1/2 wave lenght wire connected to the center pin in the antenna port should do the trick. Make the wire approximently 16 cm long.
 
-First edit sparsnas_decode.cpp to setup your sender id. Then: 
-```g++ -o sparsnas_decode -O3 sparsnas_decode.cpp```
-
+An IKEA Sparsnäs unit (duuh)
 
-How to calibrate to your sender frequency:
-------------------------------------------
-```rtl_sdr -f 868000000 -s 1024000 -g 40 - > sparsnas.raw```
+An MQTT broker installed, see this video for support/help to get it going: https://www.youtube.com/watch?v=VaWdvVVYU3A
 
-Wait about 20 seconds. Press Ctrl-C.
+You can also pipe your MQTT data via node-red to InfluxDB for diplaying in for example Grafana, @naestrom have done a great job creating a node-red flow, please find more info here: https://github.com/Naesstrom/sparsnas_mqtt_nodered_influxdb
 
-```./sparsnas_decode sparsnas.raw --find-frequencies```
-
-Wait about a minute for it to finish. It prints something like:
+The installation:
+-------------
+It is highly recommended to use the [docker](https://docker.com) version described [here](docker.md).
 
-```#define FREQUENCIES {65050.000000, 105050.000000}```
+The following instructions are for you that for some reason don't want to use docker, and assumes a debian or ubuntu based environment.
 
-Edit your sparsnas_decode.cpp with those values and rebuild it according to the How to build step above.
+```sh
+sudo apt-get update && sudo apt-get install -y git g++ libmosquitto-dev libmosquitto1 rtl-sdr zsh busybox
+cd ~
+git clone https://github.com/tubalainen/sparsnas_decoder
+cd sparsnas_decoder
+git checkout dockerVersion
 
-How to run:
------------
-```rtl_sdr -f 868000000 -s 1024000 -g 40 - | ./sparsnas_decode```
+# Build sparsnas_decode and copy the binary to /usr/bin
+g++ -o sparsnas_decode -std=gnu++11  -O2 sparsnas_decode.cpp -lmosquitto
+sudo cp sparsnas_decode /usr/bin/
+```
+The decoder is now cloned, compiled and copied to `/usr/bin/sparsnas_decoder`
 
 
-Technical details:
-------------------
-SPARSNÄS uses a CC1101 chip configured for GFSK modulation at 868MHz. The two FSK symbol frequencies once downconverted to baseband are roughly 67kHz and 105kHz. (EDIT: It seems like with a different RTL-SDR the baseband frequencies are 12.5khz and 50khz. Maybe my first RTL-SDR was inaccurate). The packet length is 18 bytes, including the length byte, and a 16-bit CRC is appended to the end. The CC1101 sync word is 0xD201. The packet payload byte 5 to 17 are encrypted using a key derived from the sender device's ID.
+Using your favorite text editor, create a new file named /etc/modprobe.d/no-rtl.conf and put the following text in the file. You need to run that text editor as sudo (i.e. 'sudo vi' or 'sudo nano' etc) to write to the modprobe.d directory:
 
-The encryption key is a repeating XOR key:
-```
-      const uint32_t sensor_id_sub = SENSOR_ID - 0x5D38E8CB;
-      enc_key[0] = (uint8_t)(sensor_id_sub >> 24);
-      enc_key[1] = (uint8_t)(sensor_id_sub);
-      enc_key[2] = (uint8_t)(sensor_id_sub >> 8);
-      enc_key[3] = 0x47;
-      enc_key[4] = (uint8_t)(sensor_id_sub >> 16);
-````
-
-Packet format (big endian):
-```
-0: uint8_t length;        // Always 0x11
-1: uint8_t sender_id_lo;  // Lowest byte of sender ID
-2: uint8_t unknown;       // Not sure
-3: uint8_t major_version; // Always 0x07 - the major version number of the sender.
-4: uint8_t minor_version; // Always 0x0E - the minor version number of the sender.
-5: uint32_t sender_id;    // ID of sender
-9: uint16_t time;         // Time in units of 15 seconds.
-11:uint16_t effect;       // Current effect usage
-13:uint32_t pulses;       // Total number of pulses
-17:uint8_t battery;       // Battery level, 0-100.
+```sh
+sudo nano /etc/modprobe.d/no-rtl.conf
 ```
-This is how to convert the 'effect' field into Watt:
+
 ```
-float watt =  (float)((3600000 / PULSES_PER_KWH) * 1024) / (effect);
+blacklist dvb_usb_rtl28xxu
+blacklist rtl2832
+blacklist rtl2830
 ```
 
-Note: Due to how the encryption works, it's possible for two different SPARSNÄS with unique sender_id to confuse each other. When decrypting a packet from sender B with the A key, it's possible that the resulting packet gets a sender_id equal to A, which means A will display incorrectly decrypted data from the B device.
+Reboot with the USB dongle installed in one of the USB ports.
 
-Example usage
--------------
+Test your dongle
+```
+rtl_test
 ```
-ludde@raspberrypi ~/sparsnas $ sudo rtl_sdr -f 868000000 -s 1024000 -g 40 - | ./sparsnas_decode               
+Outcome should look something like this:
+```
+pi@raspberrypi:~ $ rtl_test
 Found 1 device(s):
   0:  Realtek, RTL2838UHIDIR, SN: 00000001
 
 Using device 0: Generic RTL2832U OEM
 Found Rafael Micro R820T tuner
+Supported gain values (29): 0.0 0.9 1.4 2.7 3.7 7.7 8.7 12.5 14.4 15.7 16.6 19.7 20.7 22.9 25.4 28.0 29.7 32.8 33.8 36.4 37.2 38.6 40.2 42.1 43.4 43.9 44.5 48.0 49.6
 [R82XX] PLL not locked!
-Sampling at 1024000 S/s.
-Tuned to 868000000 Hz.
-Tuner gain set to 40.20 dB.
+Sampling at 2048000 S/s.
+
+Info: This tool will continuously read from the device, and report if
+samples get lost. If you observe no further output, everything is fine.
+
 Reading samples in async mode...
-[2016-12-05 21:29:35] 12711:   362.3 W. 43.339 kWh. Batt 99%.
-[2016-12-05 21:29:50] 12712:   362.6 W. 43.341 kWh. Batt 99%.
+lost at least 24 bytes
 ```
+
+How to configure the decoder:
+-------------
+Take a photo/make a note of your transmitter ID number underneeth the battery lid of the transmitter (not the display. Obmit the 400 and take the remaining six numbers and make a note of them.
+
+Edit sparsnas.sh to setup your sender id. You are allowed to have unlimitied number of senders and the format is `transmitter_id pulses/kWh` followed by a space.
+
+This command will do it for you :smile: (adding the transmitters 722270 and 602064 with 1000/10000 pulses/kWh respectively).
+
+```sh
+SENSORS="722270 1000 602064 10000"; sed -i "s/^SENSORS=.*/SENSORS=(${SENSORS})/" sparsnas.sh
+```
+
+Test the script:
+```sh
+./sparsnas.sh
+```
+
+To make the decoder report values over MQTT the MQTT variables needs to be configured as follows:
+
+```sh
+MQTT_HOST=192.168.x.x MQTT_PORT=1883 MQTT_USERNAME=username MQTT_PASSWORD=password ./sparsnas.sh
+```
+
+
+To make `sparsnas_decoder` run on startup (modify the `MQTT_*` variables according to your configuration and make sure you get the right path (`/home/pi/`) to `sparsnas.sh`)
+
+```sudo nano /etc/rc.local```
+
+```sh
+#!/bin/sh -e
+#
+# rc.local
+#
+# This script is executed at the end of each multiuser runlevel.
+# Make sure that the script will "exit 0" on success or any other
+# value on error.
+#
+# In order to enable or disable this script just change the execution
+# bits.
+#
+# By default this script does nothing.
+
+# Print the IP address
+_IP=$(hostname -I) || true
+if [ "$_IP" ]; then
+  printf "My IP address is %s\n" "$_IP"
+fi
+
+MQTT_HOST=192.168.x.x MQTT_PORT=1883 MQTT_USERNAME=username MQTT_PASSWORD=password /home/pi/sparsnas_decoder/sparsnas.sh
+
+exit 0
+```
+
+Check status and traffic on your MQTT broker:
+```sh
+mosquitto_sub -v -h 192.168.x.x -u username -P password -t '#'
+```
+Example of outcome:
+```json
+core-ssh:~# mosquitto_sub -v -h 192.168.x.x -u username -P password -t '#'
+sparsnas/602064 {"Sequence": 47318,"Watt": 2424.00,"kWh": 4207.933,"battery": 100,"FreqErr": 0.70,"CRC":"ok","Sensor":602064}
+sparsnas/722270 {"Sequence":    77,"Watt": 3245.07,"kWh":    0.483,"battery": 100,"FreqErr": 0.40,"CRC":"ok","Sensor":722270}
+```
+
+To configure Home Assistant have a look in the [home-assistant](home_assistant) folder.

docker.md

@@ -0,0 +1,22 @@
+# Docker support instructions
+
+
+1.  Build docker container as follows. The `SENSORS` is required and is the unique
+    id of your sensors in the form `sensor_id pulses_per_kwh`. The various `MQTT_`args are
+    optional (but highly recommended to enable communication to your mqtt_broker).
+
+```
+docker build -t sparsnas --build-arg SENSORS="1234 1000" \
+  --build-arg MQTT_HOST=192.168.x.x --build-arg MQTT_PORT=1883 \
+  --build-arg MQTT_USERNAME=username --build-arg MQTT_PASSWORD=password \
+  https://github.com/tubalainen/sparsnas_decoder.git
+```
+
+2. Run the container (it is possible to set the arguments above at runtime as
+   `-e MQTT_HOST=192.168.1.2` if you like).
+
+```
+docker run -it --device=/dev/bus/usb --name=sparsnas --restart=always sparsnas:latest
+```
+
+3. Sit back and enjoy :smile:.

grafana/readme.md

@@ -0,0 +1,5 @@
+# Example panel for grafana
+
+The json-file will create a dashboard in grafana that expects data from indluxDB pushed by Home Assistant like the one below.
+
+<img src="sparsnas.png?raw=true" />