kiwi/Ardiuno
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added git ignore and initial work for WS3

Browse Source
This commit is contained in:
Xavier Beaudouin
2020-12-15 16:21:21 +01:00
parent 8ade410293
commit 3a4369d18d
5 changed files with 1926 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

514
WS3/Serial/Serial.ino Normal file
View File

@ -0,0 +1,514 @@
// Weather Station 3 from AliExpress / TaoBao
//
// Highly inspired by https://github.com/kquinsland/ws3-to-esphome-bridge/
//
// Maybe the code is not optimal but it works.
//
// Configuration of WS3 :
//
// JP1 toggle betwen ARS inch mode and professional metric mode
// short : inch
// open : metric
//
// JP2 baud rate
// short : 2400
// open : 9600
//
// Configuration used for this code :
// JP1 : open
// JP2 : closed
//
// Data is in the form :
//
// A4095B000C0000D0000E0000F0000G0000H0000I0000J0000K0000L0218M515N09654O.....*52
//
//
// Serial connection used there (hardcoded using AltSoftSerial) :
// Only TX has to be connected, RX is not used by WS3.
//
// Board Receive
// ----- -------
// Teensy 3.0 & 3.1 20
// Teensy 2.0 10
// Teensy++ 2.0 4
// Arduino Uno 8
// EtherTen 8
// Arduino Leonardo 13
// Arduino Mega 48
// Wiring-S 6
// Sanguino 14
//
// This code was tested and developped on EtherTen board which
// is Arduino Uno compatible with some additions.
//
// Use following libraries:
// - AltSoftSerial
// - Adafruit_MQTT
//
// soft or alt
// AltSerial takes more global variables.
#define ALTSERIAL
#ifdef ALTSERIAL
#include <AltSoftSerial.h>
#else
#include <SoftwareSerial.h>
#endif
// Ethernet
#include <SPI.h>
#include <Ethernet.h>
// MQTT
#include <PubSubClient.h>
// Define the mac address.
const byte mac[] PROGMEM = {
0xDE, 0xAA, 0xBE, 0xEC, 0xAF, 0x02
};
// Domoticz MQTT configuration
#define mqtt_server "192.168.20.253"
#define mqtt_port 1883
// Domoticz Indexes (virtual devices has to be created)
#define domoticz_windir 160
#define domoticz_temp 161
#define domoticz_hum 162
#define domoticz_rain 163
#define domoticz_pres 164
// Definitions
const char* Mqtt_clientid = "51WS3Wether";
const char* dom_in = "domoticz/in";
// Defines
#define DEBUG
#ifdef DEBUG
#define debug(x) Serial.print(x)
#define debugln(x) Serial.println(x)
#else /* DEBUG */
#define debug(x)
#define debugln(x)
#endif /* DEBUG */
// Baud used to read see JP2
#define WS3_BAUD 2400
// Toggle support for PM2.5 sensor
//#define SUPPORT_PM25_SENSOR
// Define the length of data
#ifdef SUPPORT_PM25_SENSOR
// There is 88 bytes per packets
#define WS3_PKT_LEN 78
// And the checksum is the last 2 bytes
#define WS3_CHK_LEN 2
#define CHK_SUM_DELINEATOR 75
#else /* SUPPORT_PM25_SENSOR */
// There is 88 bytes per packets
#define WS3_PKT_LEN 78
// And the checksum is the last 2 bytes
#define WS3_CHK_LEN 2
#define CHK_SUM_DELINEATOR 75
#endif /* SUPPRT_PM25_SENSOR */
// Seems the Metric format does not have a correct checksum
// In this case we should not test the checksum, just see
// if we have a correct dataline
#define DONT_CHKSUM
// Place holder for the packet received
String pkt_str = "";
// Flag for packet OK
bool pkt_ok = false;
#ifdef ALTSERIAL
AltSoftSerial WS3;
#else
SoftwareSerial WS3(8,9);
#endif
EthernetClient ethClient;
//PubSubClient client(ethClient);
// After parsing the string of bytes, we'll have an easier to use struct
// TODO: this should be it's own file?
struct WS3Packet {
// The 1st field is "A0000" - Wind direction AD value in real time (0-4096)
int wind_dir;
// The 2nd field is "B000" - Wind direct angle value (16 direction)
int wind_angle; // new
// The 3rd field is "C0000" - Real time wind speed frequency 1Hz
int wind_freq; // New
// The 4th field is "D0000" - Real time wind speed, unit: 0.1 m/s
float wind_speed;
// The 5th field is "E0000" - Avg wind speed in the previous minute, unit: 0.1m/s
float wind_speed_1m;
// The 6th field is "F0000" - the highest wind speed in the last 5 minutes, unit: 0.1m/s
float wind_speed_5m;
// The 7th field is "G0000" - Real time rain bucket (0-9999), loop-count
int rain_bucket_cnt; // New
// The 8th field is "H0000" - Number of rain bucket in the last minute, (0-9999)
int rt_rain_bucket;
// The 9th field is "I0000" - Rain fall in 1 minute, unit: 0.1mm
float rain_1m;
// The 10th field is "J0000" - the previous hour's rainfall ( 0.1 mm)
float rain_1h;
// The 11th field is "K0000" - rainfall during the first 24 hours ( 0.1 mm)
float rain_24h;
// The 12th field is "L0000" - temperature, unit: degree C (unit 0.1 Degree)
float temp_f;
// The 13th field is "M000" - humidity ( 00 % - 99 %), unit 0.1%
float humidity;
// The 14th field is "M10020" - air pressure ( 0.1 hpa )
float air_pressure;
};
// Setup the stuff.
void setup() {
// You can use Ethernet.init(pin) to configure the CS pin
//Ethernet.init(10); // Most Arduino shields
//Ethernet.init(5); // MKR ETH shield
//Ethernet.init(0); // Teensy 2.0
//Ethernet.init(20); // Teensy++ 2.0
//Ethernet.init(15); // ESP8266 with Adafruit Featherwing Ethernet
//Ethernet.init(33); // ESP32 with Adafruit Featherwing Ethernet
Serial.begin(57600);
while (!Serial) ; // wait for Arduino Serial Monitor to open
Serial.println("Weather Station 3 Adapter by Kiwi");
// Wait for eternet to initialize
// start the Ethernet connection:
Serial.println("Initialize Ethernet with DHCP:");
if (Ethernet.begin(mac) == 0) {
Serial.println("Failed to configure Ethernet using DHCP");
if (Ethernet.hardwareStatus() == EthernetNoHardware) {
Serial.println("Ethernet shield was not found. Sorry, can't run without hardware. :(");
} else if (Ethernet.linkStatus() == LinkOFF) {
Serial.println("Ethernet cable is not connected.");
}
// no point in carrying on, so do nothing forevermore:
while (true) {
delay(1);
}
}
// print your local IP address:
Serial.print("My IP address: ");
Serial.println(Ethernet.localIP());
// Start the Software Serial for WS3
WS3.begin(WS3_BAUD);
debugln("WS3 UART is ready...");
// Allocate memory for packet
pkt_str.reserve(WS3_PKT_LEN);
//payload.reserve(WS3_PKT_LEN-WS3_CHK_LEN);
debugln(" -> Packet memory allocated!");
}
#ifdef DONT_CHKSUM
// Validate packet using the checksum.
// Work only APRS data on this 51W3 board.
// Maybe the code on the board does not make the correct checksum ?
bool validate_packet(String pay, unsigned long chk) {
// Print the payload and the checksum we want
debugln("validate_packet:");
debug(pay);
debug(" * ");
debugln(chk);
// TEST DATA (actual packets)
// c000s000g000t075r000p019h43b09940*32
// String pay = "c000s000g000t075r000p019h43b09940";
// byte chk = 0x32; // this will be in HEX)
// c000s000g000t075r000p019h42b09940*33
// String pay = "c000s000g000t075r000p019h42b09940";
// byte chk = 0x33; // this will be in HEX)
// c000s000g000t075r000p019h42b09939*3D
// String pay = "c000s000g000t075r000p019h42b09939";
// byte chk = 0x3D; // this will be in HEX)
// SUPER grateful for the helpful https://toolslick.com/math/bitwise/xor-calculator to validate my
// code!
// Current byte
byte i1=0;
// the intermediate checksum
byte tmp = 0;
// starting from the second character, we begin XORing
for (int x = 0; x < pay.length() ; x++) {
i1=pay[x];
// Do the xOR
tmp = tmp^i1;
}
// do the check
if(tmp == chk){
return true;
} else {
debugln("INVALID!");
debug("calculated:");
debugln(tmp);
return false;
}
}
#endif /* DONT_CHKSUM */
// Parse the packet and fill the structure with data
void parse_packet(String payload, WS3Packet* p) {
// E.G.: A4095 B000 C0000 D0000 E0000 F0000 G0000 H0000 I0000 J0000 K0000 L0237 M502 N09810 O.....
// Parse in order, starting with A0000 (wind dir real time, 0-4096)
int wind_dir_idx = payload.indexOf('A');
p->wind_dir = payload.substring(wind_dir_idx+1, wind_dir_idx+5).toInt();
// Then move on to B000 - wind direction angle (16 direction)
int wind_angle_idx = payload.indexOf('B');
p->wind_angle = payload.substring(wind_angle_idx+1, wind_angle_idx+4).toInt();
// Then move on to C0000 - wind speed frequency (1 Hz)
int wind_freq_idx = payload.indexOf('C');
p->wind_freq = payload.substring(wind_freq_idx+1, wind_freq_idx+5).toInt();
// Then move on to D0000 - wind speed real time (unit 0.1 m/s)
int wind_speed_idx = payload.indexOf('D');
p->wind_speed = payload.substring(wind_speed_idx+1, wind_speed_idx+5).toInt() / 10;
// Then move on to E0000 - wind speed avg in the last minute (unit 0.1 m/s)
int wind_speed_1m_idx = payload.indexOf('D');
p->wind_speed_1m = payload.substring(wind_speed_1m_idx+1, wind_speed_1m_idx+5).toInt() / 10;
// Then move on to F0000 - wind speed over the last 5 min
int wind_speed_5_idx = payload.indexOf('F');
p->wind_speed_5m = payload.substring(wind_speed_5_idx+1, wind_speed_5_idx+5).toInt() / 10;
// Then move on to G0000 - Rain in Realtime (0-9999 counter) bucket
int rain_bucket_cnt_idx = payload.indexOf('G');
p->rain_bucket_cnt = payload.substring(rain_bucket_cnt_idx+1, rain_bucket_cnt_idx+5).toInt();
// Then move on to H0000 - Rain bucket in the last 1 minute (0-9999 counter)
int rt_rain_bucket_idx = payload.indexOf('H');
p->rt_rain_bucket = payload.substring(rt_rain_bucket_idx+1, rt_rain_bucket_idx+5).toInt();
// Then move on to I0000 - rain last minute (0.1mm)
int rain1m_idx = payload.indexOf('I');
p->rain_1m = payload.substring(rain1m_idx+1, rain1m_idx+5).toInt() *.1;
// Then move on to J0000 - rain last hour (0.1mm)
int rain1h_idx = payload.indexOf('J');
p->rain_1h = payload.substring(rain1h_idx+1, rain1h_idx+5).toInt() *.1;
// Then move on to K0000 - rain last 24h (0.1mm)
int rain24h_idx = payload.indexOf('K');
p->rain_24h = payload.substring(rain24h_idx+1, rain24h_idx+5).toInt()*.1;
// Then move on to L0200 - temp (0.1°C)
// XXX: Check with minus zero temperatures
int temp_idx = payload.indexOf('L');
p->temp_f = payload.substring(temp_idx+1, temp_idx+5).toInt()*.1;
// Then move on to M611 - Humidity
int humidity_idx = payload.indexOf('M');
// p->humidity = payload.substring(humidity_idx+1, humidity_idx+3).toInt()*.1;
p->humidity = payload.substring(humidity_idx+1, humidity_idx+3).toInt();
// Then move on to N10020 - air pressure
int pressure_idx = payload.indexOf('N');
p->air_pressure = payload.substring(pressure_idx+1, pressure_idx+6).toInt()*.1;
}
// Clear the packet before working on the next
void clear_pkt(WS3Packet* p) {
p->wind_dir = 0;
p->wind_angle = 0;
p->wind_freq = 0;
p->wind_speed = 0;
p->wind_speed_1m = 0;
p->wind_speed_5m = 0;
p->rain_bucket_cnt = 0;
p->rt_rain_bucket = 0;
p->rain_1m = 0;
p->rain_1h = 0;
p->rain_24h = 0;
p->temp_f = 0;
p->humidity = 0;
p->air_pressure = 0;
}
// Print the data
void print_weather(WS3Packet* p){
Serial.print("Wind Direction (realtime): ");
Serial.println(p->wind_dir, DEC);
//Serial.println(" degrees");
Serial.print("Wind direction angle : ");
Serial.print(p->wind_angle, DEC);
Serial.println(" degree");
Serial.print("Wind speed Frequency: ");
Serial.print(p->wind_freq, DEC);
Serial.println(" Hz");
Serial.print("Wind speed: ");
Serial.print(p->wind_speed, DEC);
Serial.println(" m/s");
Serial.print("Wind speed 1m: ");
Serial.print(p->wind_speed_1m, DEC);
Serial.println(" m/s");
Serial.print("Wind speed 5m: ");
Serial.print(p->wind_speed_5m, DEC);
Serial.println(" m/s");
Serial.print("temp_f: ");
Serial.print(p->temp_f, DEC);
Serial.println(" deg. C.");
Serial.print("Rain buckets / buckets 1m: ");
Serial.print(p->rain_bucket_cnt, DEC);
Serial.print(" / ");
Serial.println(p->rt_rain_bucket, DEC);
Serial.print("Rain 1m / 1H / 24H: ");
Serial.print(p->rain_1m, DEC);
Serial.print(" / ");
Serial.print(p->rain_1h, DEC);
Serial.print(" / ");
Serial.print(p->rain_24h, DEC);
Serial.println(" mm");
Serial.print("humidity: ");
Serial.print(p->humidity, DEC);
Serial.println(" %");
Serial.print("air_pressure: ");
Serial.print(p->air_pressure, DEC);
Serial.println(" hpa");
}
// Processing the packet.
bool process_packet(String pkt, WS3Packet* p) {
debugln("[D] process_packet - ALive!");
debugln(pkt);
// Allocate bytes for the payload
String payload;
payload.reserve(WS3_PKT_LEN-WS3_CHK_LEN);
#ifdef DONT_CHKSUM
// everything after the * is checksum (2 char long)
unsigned long chksum;
#endif /* DONT_CHKSUM */
// Check if the 75rd character is *
if (pkt.charAt(CHK_SUM_DELINEATOR) != '*') {
debugln("Packed invalid; no * character at position 75!");
return false;
#ifdef DONT_CHKSUM
} else {
// The character indicating the checksum is coming is in the correct place. Yay.
// Now, we need to pull the two ascii characters that are transmitted to us
// and turn them into a single byte. E.G. Char 3, Char D should convert to 0x3D.
//
// We can do this with the strtoul() function; we indicate that we wante base 16
chksum = strtoul(pkt.substring(CHK_SUM_DELINEATOR+1, CHK_SUM_DELINEATOR+2).c_str(),NULL,16);
//Serial.print("Checksum :");
//Serial.println(pkt.substring(CHK_SUM_DELINEATOR+1, CHK_SUM_DELINEATOR+2).c_str());
}
#endif /* DONT_CHKSUM */
// We have the checksum, Now we can bother to get the payload
payload = pkt.substring(0, CHK_SUM_DELINEATOR);
// And try to validate...
#ifndef DONT_CHKSUM
if(!validate_packet(payload, chksum)){
debugln("invalid packet! :(");
return false;
} else {
debugln("Valid packet!");
}
#endif /* DONT_CHKSUM */
parse_packet(payload, p);
return true;
}
void loop() {
// While data comes in and we don't have a pending packet to process...
while (WS3.available() && pkt_ok !=true) {
// Pull the bytes off the stream
char inChar = (char)WS3.read();
// And build up the packet
pkt_str += inChar;
// Until we hit the end
if (inChar == '\n') {
pkt_ok = true;
}
}
// Yay, we now have a packet!
// Now, we attempt to parse out the string into a packet that we can work with
if (pkt_ok) {
debugln("pkt_ok!");
// At this point, we have a string of characters that was probably a valid packet
// We set get some memory and attempt to parse the string into the struct
WS3Packet p = {};
// Validate the payload, then parse it.
if (process_packet(pkt_str, &p)) {
// print results if parse OK
print_weather(&p);
debugln("processed");
} else {
debugln("unable to parse packet :(");
}
// clear so we can start again
pkt_str = "";
pkt_ok = false;
clear_pkt(&p);
}
}
// MQTT Stuff
#ifdef MQTT
void callback(char* topic, byte* payload, unsigned int length) {
debug("Message arrived [");
Serial.print(topic);
debug("] ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
debug(" ");
}
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
debug("Attempting MQTT connection...");
// Attempt to connect
if (client.connect(Mqtt_clientid)) {
debugln("connected");
// ... and resubscribe
client.subscribe(dom_in);
} else {
debug("failed, rc=");
debug(client.state());
debugln(" try again in 5 seconds");
// Wait 5 seconds before retrying
for(int i = 0; i<5000; i++){
delay(1);
}
}
}
}
#endif