Power Plug Energy Meter - Now wireless!

This is the second post about my work on the cheap China-style energy meter hack.
My last post covered how I with a logic analyzer successfully (but not in the safest way) sniffed the SPI-transmission on the device and managed to decipher the data. And then how I used an Arduino Nano to do the sniffing for me with an interrupt driven approach. The Arduino  translated the bits and bytes to power and voltage values that it continuously printed on the PC's Serial monitor via an USB-cable.

The next obvious step in this project is to get the energy meter to transmit the data wirelessly. Not only would this mean that I could grab data from several energy meters simultaneously, but it also creates a safe way of debugging the device since my previous setup (which I abandoned after reading some of the comments on Hackaday.com) meant connecting the mains neutral to the computers ground (do not try this at home!!!)

Today's post will cover how I managed to get an Arduino pro mini (3.3V) to sniff the energy meters SPI and transmit the data wirelessly with a nRF24L01+ to an Arduino Nano connected to a computer. The neat thing with this setup is that the Arduino pro mini and the nRF fits perfectly within the casing of the energy meter, and are both driven by the internal power that charges the rechargeable battery that you'll find in the meter.

The total cost of components for each energy meter is:
Energy meter             £7.97
Arduino Mini 3.3 V       £2.58
nRF24L01+                 £0.99   (choose the black + version)
A capacitor + cables   pretty much free, say £1

which comes to a total of £12.54 per unit!

Plus one computer connected node, or a raspberry pi with a nRF24L01 to receive the transmissions from all the energy meters.

Arduino and RF24.h
As mentioned in previous blog-posts I have worked quite allot with the nRF24L01 and AVR's, writing my own libraries and so on. But since this is my first Arduino-project I wanted to learn how to import and use other peoples libraries. Since I am still a newbie in programming, I always have to learn everything from scratch, and nothing ever works as supposed to when I try to follow a tutorial...

I started out by setting up two Arduino Nanos according to this guide and running the example code at the bottom of that page, and as expected - it didn't work. 

Debugging
1. Do I have a working SPI-connection?
I had followed the explanation in the guide i linked to above, on how to install the RF24.h-library and it all seamed to work, I definitely had a working SPI-connection between the Arduino and the nRF since I could print out all the registers, and modifying them also worked...

Took me a while to figure out that I had to download and include the file "printf.h" and call "printf_begin();" to print out data from the nRF to the serial monitor... and why, why, why are they using the "protected" attribute  for many of the functions??? For example get_status is a very useful debug-function and should not be protected!

2. Am I using the correct hardware setup? 
As always I hadn't used the exact components as the instructions said, in my drawer I could only find one 47 uF 24 V  and one 100 uF 16 V capacitors. Well in the guide it sais:
"Connect a .3.3 uF to 10 uF (MicroFarad) capacitor directly on the module from +3.3V to Gnd (Watch + and - !) [Some users say 10 uF or more..]"
And I read 10 uF or more....

Anyways, I thought that this should work, since I have used these capacitors before on the nRF, but not with this library and not with Arduino...

3. I found a working code
Yay, suddenly i found a working code, the "pingpair" example that comes with the NRF.h-library worked with my setup!

4. Why does only Pingpair-code work? 
I started stripping the Pingpair-code of its components, and found that my setup was only working when it got into receiving mode in between every transmission... strange, but keeping in mind that I was using bigger capacitors I figured it had something to do with the capacitors not have time enough to recharge/discharge.

I think this is what happened:
When the Arduino calls the "Write" function, the library runs the "startWrite"-function which powers up the nRF and has a predefined delay of 150 us (wait for the nRF to power up) before it starts transmitting the data.
It turned out that this delay was not enough for my setup, so when I changed this to 1000 us (1 ms), the code worked like a charm even without the receiving functions in between! To do this modification, I opened the RF24.cpp-file (in the arduino Sketchbook libraries folder) with notepad, changed the delay, and saved the file.



Arduino Mini
Just as I managed to get a working Arduino code for the nRF, two Arduino Mini 3.3 V landed in my postbox, awesome timing!

One little problem; the Arduino Mini does not come fitted with an USB to Serial-chip to enable programming over USB.... luckily for me I had an USB to Serial adapter laying around (used for debugging AVR's, as I wrote about in this tutorial-post) that I could use to program the Arduino.

Here's a pic of when I have soldered an nRF to the Arduino and uploading code with the USB to COM adapter via a breadboard (out of sight) so the colored cables does not match the pins...

Off course this didn't work straight away either, I found out that when using this kind of FTDI-adapter you have to press the reset-button on the Arduino Mini just when the Arduino-IDE starts to upload the code to get it working! A better buy would be one of these which comes with an automatic reset-pin ("DTR").

I soldered the nRF to the Arduino, and glued them together with some hot-glue, which was also used to attach the unit to the power meter. Plenty of unoccupied room in the meter behind the LCD, and perfect position for a wireless transmitter!

Here you have the wire diagram: 

I started off by just uploading a simple transmission code on the Arduino mini, that would send a dummy byte once a second to confirm a working setup. I  soldered everything together,  plugged the meter into an outlet and kept my fingers crossed as I watched the Arduino-Serial monitor connected to the receiving unit, and.... noting (of course!)

After several hours of debugging, (I thought I had burnt the nRF by hooking it up directly to the power-meters VCC-pin)  It turned out had I accidentally  uploaded a non-working code to the Arduino Mini.... FAIL!!!

I had cleaned up my working code, and shifted some parts around, it seems like you can't open the writing/reading-pipes on the nRF before you set the datarate/payloadsize/PALevel...

Anyway, the setup I found working is grabbing the power directly from the battery (3.6 V soldered to the underside of the PCB) rather than the VCC-cable (which i think is a bit flaky, and is connected to the RAW-pin on the Arduino, which has a built in 3,3 V regulator. I'm not sure this modification is necessary, but it ensures that the nRF and the Arduino gets 3.3 V. (The pictures above are not connected to RAW, but the Arduino's 3.3 V)

Here's whats transmitted to the computer connected Arduino and printed in the Serial monitor:

I have spent some time looking at ways to store and plot this data in the cloud. One interesting approach is to send the data to a website like http://emoncms.org/ and use there ready to use energy-viewing graphs. With the help of a small python-script I wrote, I can easily send the data from my raspberry pi-server to my account on there website where I have the option of making graphs.

I have also been working in the program called "Processing" which is pretty much the same as Arduino-IDE but for graphing and doing stuff with the data.
I have so far programmed a working graph that shows the data output from up to 6 wireless energy meters, it  also logs the data with timestamp to a csv-file. See the processing-code at the bottom.

Above you see a screenshot of when I have plugged in two energy meters (1 and 2). Nr 1 shows a soldering station which i obviously changed the power on allot during the readings. Nr 2 is a 4-step lamp that i flickered from 3 to 0 to 1 to 2 to 3. as you see i didn't stop at 0 for a very long time, so the graphed mean value stopped at ~10W.

You might wounder why the red and green line (nr 1) sometimes differ? That's because I have the meter to transmit the average=red and the maximum=green power readings on every third power reading. This interval is easily changed by typing 1:1 or 1:4 to change the interval on meter 1 from to 1 or to 4 readings in between transmissions.

I had a hard time figuring out how to transmit this new interval from the computer nrf to the meter, because if I in between every transmission changed the nRF to a receiver, the power consumption would cause the whole meter to stop working.

This time I had to do some serious thinking, and I ended up using the possibility to alter the autoAck-payload. A function that normally sends an "OK" from the receiving nrf back to the transmitting nRF to confirm the transmission. I found out how to alter this value to send something like a "2" instead, or some other integer that would be a new interval. This was exactly what I needed, See the code at the bottom!

Her's the working Arduino code, first for the Energy Meter then for the computer connected receiver-Arduino. At the very bottom you have the processing code:

	/*
	Reads voltage and power from China-style energy meter and sends it to nRF24L01+.
	Collecting data from meter by eavesdropping on the MOSI-line (master in slave out)
	between the energy monitoring chip (ECH1560) and the main processor
	Meter Arduino
	GND (Brown) GND (2nd from the end of the meter-board)
	VCC (3.6V) RAW (Connect to battery "+" under meter-board)
	CLK (Green) D2 (INT0) (5th from the end of the meter-board)
	SDO (Blue-white) D5 (6th from the end of the meter-board)
	nRF24L01+ Ardiono
	GND (square) GND
	VCC 3,3V (mini = VCC)
	CE 9
	CSV 10
	SCK 13
	MOSI 11
	MISO 12
	*/
	#include <SPI.h>
	#include "nRF24L01.h"
	#include "RF24.h"
	#include "printf.h"
	//NRF-setup:
	#define CE_PIN 9
	#define CSN_PIN 10
	//Energy meter setup:
	const int CLKPin = 2; // Pin connected to CLK (D2 & INT0)
	const int MISOPin = 5; // Pin connected to MISO (D5)
	// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
	RF24 radio(CE_PIN, CSN_PIN); // Create a Radio
	// Radio pipe addresses for 1 node to communicate.
	//const uint64_t PipeAddress = 0xAABBCCDD11LL; //5-byte address "LL" is for long
	const uint64_t pipes[] = { 0xAABBCCDD11LL}; //Transmitting address (Last 2 numbers are number on energy-meter)
	//EnergyMeter-variables
	//All variables that are changed in the interrupt function must be volatile to make sure changes are saved.
	volatile int Ba = 0; //Store MISO-byte 1
	volatile int Bb = 0; //Store MISO-byte 2
	volatile int Bc = 0; //Store MISO-byte 2
	float U = 0; //voltage
	float P = 0; //power
	float ReadData[3] = {0, 0, 0}; //Array to hold mean values of [U,I,P]
	int AverageMax = 5;
	volatile long CountBits = 0; //Count read bits
	volatile int Antal = 0; //number of read values (to calculate mean)
	volatile long ClkHighCount = 0; //Number of CLK-highs (find start of a Byte)
	volatile boolean inSync = false; //as long as we ar in SPI-sync
	volatile boolean NextBit = true; //A new bit is detected
	void SendToComputer(void); //initiate transmitt-function
	void setup(void)
	{
	//debug over Serial
	Serial.begin(57600);
	//Setting up interrupt ISR on D2 (INT0), trigger function "CLK_ISR()" when INT0 (CLK)is rising
	attachInterrupt(0, CLK_ISR, RISING);
	//Set the CLK-pin (D5) to input
	pinMode(CLKPin, INPUT);
	//Set the MISO-pin (D5) to input
	pinMode(MISOPin, INPUT);
	// Setup and configure nrf radio see: http://maniacbug.github.io/RF24/classRF24.html
	radio.begin();
	//
	//********* Optional settings for nrf below see: http://maniacbug.github.io/RF24/classRF24.html
	//
	// increase the delay between retries & # of retries
	radio.setRetries(15,15);
	// reduce the payload size. (3 floates = 3*4=12 Bytes)
	radio.setPayloadSize(12);
	//Set speed of transmission (250kbps only works on the "+"-version!!! slower increases range!
	radio.setDataRate(RF24_250KBPS);
	//Set Power Amplifier (PA) level to high to increase range!
	radio.setPALevel(RF24_PA_HIGH);
	//Automatically receive data when sending something
	radio.enableAckPayload();
	//
	//********* End of optional settings*********
	//
	//Addresses has to be set last!
	//Transmitter address
	radio.openWritingPipe(pipes[0]);
	//I don't have to set an receiver address, because the auto ack will automatically receive an payload if i need to send anything to this meter!
	}
	void loop(void)
	{
	//do nothing until the CLK-interrupt occures and sets inSync=true
	if(inSync == true){
	CountBits = 0; //CLK-interrupt increments CountBits when new bit is received
	while(CountBits<40){} //skip the uninteresting 5 first bytes
	CountBits=0;
	Ba=0;
	Bb=0;
	while(CountBits<24){ //Loop through the next 3 Bytes (6-8) and save byte 6 and 7 in Ba and Bb
	if(NextBit == true){ //when rising edge on CLK is detected, NextBit = true in in interrupt.
	if(CountBits < 9){ //first Byte/8 bits in Ba
	Ba = (Ba << 1); //Shift Ba one bit to left and store MISO-value (0 or 1) (see http://arduino.cc/en/Reference/Bitshift)
	//read MISO-pin, if high: make Ba[0] = 1
	if(digitalRead(MISOPin)==HIGH){
	Ba |= (1<<0); //changes first bit of Ba to "1"
	} //doesn't need "else" because BaBb[0] is zero if not changed.
	NextBit=false; //reset NextBit in wait for next CLK-interrupt
	}
	else if(CountBits < 17){ //bit 9-16 is byte 7, stor in Bb
	Bb = Bb << 1; //Shift Ba one bit to left and store MISO-value (0 or 1)
	//read MISO-pin, if high: make Ba[0] = 1
	if(digitalRead(MISOPin)==HIGH){
	Bb |= (1<<0); //changes first bit of Bb to "1"
	}
	NextBit=false; //reset NextBit in wait for next CLK-interrupt
	}
	}
	}
	if(Bb!=3){ //if bit Bb is not 3, we have reached the important part, U is allready in Ba and Bb and next 8 Bytes will give us the Power.
	Antal += 1; //increment for mean value calculations
	//Voltage = 2*Ba+Bb/255
	U=2.0*((float)Ba+(float)Bb/255.0);
	//Power:
	CountBits=0;
	while(CountBits<40){}//Start reading the next 8 Bytes by skipping the first 5 uninteresting ones
	CountBits=0;
	Ba=0;
	Bb=0;
	Bc=0;
	while(CountBits<24){ //store byte 6, 7 and 8 in Ba and Bb & Bc.
	if(NextBit == true){
	if(CountBits < 9){
	Ba = (Ba << 1); //Shift Ba one bit to left and store MISO-value (0 or 1)
	//read MISO-pin, if high: make Ba[0] = 1
	if(digitalRead(MISOPin)==HIGH){
	Ba |= (1<<0); //changes first bit of Ba to "1"
	}
	NextBit=false;
	}
	else if(CountBits < 17){
	Bb = Bb << 1; //Shift Ba one bit to left and store MISO-value (0 or 1)
	//read MISO-pin, if high: make Ba[0] = 1
	if(digitalRead(MISOPin)==HIGH){
	Bb |= (1<<0); //changes first bit of Bb to "1"
	}
	NextBit=false;
	}
	else{
	Bc = Bc << 1; //Shift Bc one bit to left and store MISO-value (0 or 1)
	//read MISO-pin, if high: make Bc[0] = 1
	if(digitalRead(MISOPin)==HIGH){
	Bc |= (1<<0); //changes first bit of Bc to "1"
	}
	NextBit=false;
	}
	}
	}
	//Power = (Ba*255+Bb)/2
	P=((float)Ba*255+(float)Bb+(float)Bc/255.0)/2;
	//Voltage mean
	ReadData[0] = (U+ReadData[0]*((float)Antal-1))/(float)Antal;
	//Power mean
	ReadData[1] = (P+ReadData[2]*((float)Antal-1))/(float)Antal;
	//Power max
	if(P>ReadData[2]){
	ReadData[2] = P;
	}
	//every 5th read-out ~every 5th second, we send the mean value data to the nrf24l01-transmitter
	if(Antal>=AverageMax){
	//Send the data to the computer
	bool ok = radio.write( ReadData, sizeof(ReadData) );
	if (ok){
	Antal=0; //reset mean-value counter after successfull transmission ~10s
	ReadData[0]=0;
	ReadData[1]=0;
	ReadData[2]=0;
	//This is an awesome feature, if "radio.enableAckPayload()" is enabled, then we may have got somethig in return that we can use:
	//did we get any data in return when sending the bytes??
	if ( radio.isAckPayloadAvailable() )
	{
	radio.read(&AverageMax,sizeof(AverageMax));
	}
	}
	}
	inSync=false; //reset sync variable to make sure next reading is in sync.
	}
	if(Bb==0){ //If Bb is not 3 or something else than 0, something is wrong!
	inSync=false;
	Serial.println("Disconnected");
	}
	}
	}
	//Function that triggers whenever CLK-pin is rising (goes high)
	void CLK_ISR(){
	//if we are trying to find the sync-time (CLK goes high for 1-2ms)
	if(inSync==false){
	ClkHighCount = 0;
	//Register how long the ClkHigh is high to evaluate if we are at the part wher clk goes high for 1-2 ms
	while(digitalRead(CLKPin)==HIGH){
	ClkHighCount += 1;
	delayMicroseconds(30); //can only use delayMicroseconds in an interrupt.
	}
	//if the Clk was high between 1 and 2 ms than, its a start of a SPI-transmission
	if(ClkHighCount >= 33 && ClkHighCount <= 67){
	inSync = true;
	}
	}
	else{ //we are in sync and logging CLK-highs
	//increment an integer to keep track of how many bits we have read.
	CountBits += 1;
	NextBit = true;
	}
	}
	// vim:cin:ai:sts=2 sw=2 ft=cpp

view raw Energy Meter Wireless.cpp hosted with ❤ by GitHub

Here's the code for the receiving Arduino (connected to computer via USB)

	#include <SPI.h>
	#include "nRF24L01.h"
	#include "RF24.h"
	#include "printf.h" //Activate for NRF-debug (printf_begin(); in setup() followed by radio.printDetails();)
	#define CE_PIN 9
	#define CSN_PIN 10
	//
	// Hardware configuration
	//
	// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
	RF24 radio(CE_PIN, CSN_PIN); // Create a Radio
	// Radio pipe addresses 1 node to communicate.
	//const uint64_t Address = 0xAABBCC22LL; //5-byte address "LL" is for long (if more than one node:)
	//const uint64_t pipes[2] = { 0xAABBCC11LL, 0xAABBCC22LL }; //Pipes 1-5 must share the first 4 bytes. Only the least significant byte should be unique!
	const uint64_t pipes[3] = { 0xBABBCCDD00LL, //Writing pipe (not used)
	0xAABBCCDD11LL, //Meter A's writing pipe
	0xAABBCCDD22LL //Meter B's writing pipe
	}; //First letter is address to energ-meter
	float ReadData[3] = {0, 0, 0};
	uint8_t TempStatus;
	uint8_t CH;
	uint8_t data[2];
	void setup(void)
	{
	Serial.begin(57600);
	//printf_begin();
	Serial.println("Start: ");
	//
	// Setup and configure rf radio
	radio.begin();
	//
	//********* Optional settings for nrf below see: http://maniacbug.github.io/RF24/classRF24.html
	//
	// increase the delay between retries & # of retries
	radio.setRetries(15,15);
	// reduce the payload size. (3 floates = 3*4=12 Bytes)
	radio.setPayloadSize(12);
	//Set speed of transmission (250kbps only works on the "+"-version!!! slower increases range!
	radio.setDataRate(RF24_250KBPS);
	//Set Power Amplifier (PA) level to high to increase range!
	radio.setPALevel(RF24_PA_HIGH);
	//Awesome feature that lets us send a package in return when receiving something without changing to transmitter!
	radio.enableAckPayload();
	//
	//********* End of optional settings*********
	//
	//Addresses has to be set last!
	//radio.openWritingPipe(pipes[0]);
	radio.openReadingPipe(1,pipes[1]);
	radio.openReadingPipe(2,pipes[2]);
	//Start listening for incoming data
	radio.startListening();
	//
	// Dump the configuration of the rf unit for debugging
	//
	//read_register(CONFI); //read out the status register to decide which channel that's transmitting data //change RF24.h in libraries (remove "public:", "protected:" and change "private:" to "public:) to use this function!
	//Serial.println(radio.get_status(),BIN);
	//Serial.println(radio.read_register(RF_SETUP),BIN);
	Serial.println("Type: 2:3 to change the intervall of meter 2 to ~3s");
	//radio.writeAckPayload( 1, &AverageMax, sizeof(AverageMax) );
	//radio.writeAckPayload( 2, &AverageMax, sizeof(AverageMax) );
	}
	void loop(void)
	{
	// if data is received to the nRF
	if ( radio.available() )
	{
	// Dump the payloads until we've gotten everything
	bool done = false;
	while (!done)
	{
	Serial.println(" ");
	//Serial.println(radio.get_status(),BIN);
	// read out the status register to decide which channel that's transmitting data
	//change RF24.h in libraries (remove "public:", "protected:" and change "private:" to "public:) to use this function!
	CH = 0;
	CH = ((radio.get_status() & 0b00001110) >> 1); //extract bit 1-3 (the channels) to CH and move them one step to right to get it in decimal
	// Fetch the payload, and see if this was the last one.
	done = radio.read( ReadData, sizeof(ReadData) );
	//Print out details
	Serial.print("Energy meter: ");
	Serial.println(CH);
	//When meter reads 0W it sometimes shows ~6000W
	if(ReadData[2]<4000){
	Serial.print(ReadData[0],0);
	Serial.println(" V");
	Serial.print(ReadData[1],1);
	Serial.println(" W");
	Serial.print(ReadData[2],2);
	Serial.println(" W-Max");
	}
	else{
	Serial.print(ReadData[0],0);
	Serial.println(" V");
	Serial.print(0.0,0);
	Serial.println(" W");
	}
	delay(20);
	//Reset STATUS-register:
	//radio.write_register(STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
	}
	}
	}
	//Interrupt ocures whenever you type anything in the serial-monitor.
	//To change the data sending interval of an energy meter, in the serial monitor type:
	//2:3
	//to change the channel 2-energy meter to ~3s interval.
	void serialEvent() {
	while (Serial.available()) {
	// Reads the the bytes until it reaches an non-integer value ":"
	int CH = Serial.parseInt();
	byte skipp = Serial.read();
	int AverageMax = Serial.parseInt();
	if(Serial.available()==false && CH >0 && CH < 6 && AverageMax >0 && AverageMax <10000){
	// Add an ack packet for the next time around
	radio.writeAckPayload( CH, &AverageMax, sizeof(AverageMax) );
	Serial.print("Intervall on meter: ");
	Serial.print(CH);
	Serial.print(" will change to: ~");
	Serial.print(AverageMax);
	Serial.println("s on next transmission!");
	}
	else{
	while (Serial.available()) {
	skipp = Serial.read();
	}
	Serial.println("Wrong format! Type: 2:3 to change the intervall of meter 2 to ~3s");
	}
	}
	}
	// vim:cin:ai:sts=2 sw=2 ft=cpp

view raw Energy Meter Computer.cpp hosted with ❤ by GitHub

And finally the Processing code that can be used to read and write to the computer connected Arduino through its serial connection (over USB)

	import processing.serial.*;
	Serial myPort; // Create object from Serial class
	String val; // Data received from the serial port
	//print to csv-file
	PrintWriter output;
	long xPos = 1; // horizontal position of the graph
	//int xLast[] = new int[6];
	int yPos = 0;
	int xMax = 600;
	int yMax = 600;
	int vmax = 250;
	int pmax = 500;
	int newPmax=0;
	long lastupdatedXvalue = 0;
	int pmmax = pmax;
	int Meter = 1;
	int IntValue=0;
	float Last_V = 0.0;
	float Last_P = 0.0;
	float Last_Pmax = 0.0;
	boolean Error = false;
	float curVal=0;
	int curElevation=0;
	String SerialString = "";
	String typing = "";
	int RGB[][] = new int[][] {
	{
	255, 0, 0,
	255, 0, 0,
	0, 150, 0,
	}
	,
	{
	255, 220, 230,
	255, 0, 0,
	170, 25, 255,
	}
	};
	//ArrayList<ArrayList<Float>> V = new ArrayList<ArrayList<Float>>(6);
	TwoDArrayList V;
	TwoDArrayList P;
	TwoDArrayList PMax;
	TwoDArrayList xVals = new TwoDArrayList();
	movingLabels Label[][] = new movingLabels[2][6];
	//ArrayList<ArrayList<Float>> P = new ArrayList<ArrayList<Float>>(5);
	//ArrayList<ArrayList<Float>> PMax = new ArrayList<ArrayList<Float>>(5);
	//ArrayList P = new ArrayList();
	//ArrayList PMax = new ArrayList();
	String label;
	float[] markers;
	String portName = "";
	void setup()
	{
	// List all the available serial ports
	println(Serial.list());
	//Sets current Serial-port to the arduino port (the last in the list!?)
	portName = Serial.list()[Serial.list().length-1]; //change the "Serial.list().length-1" to a 1 or 2 etc. to match your port
	//Create Serial object to use for comunication with the Arduino with the correct baudrate (Energy meter=57600)
	myPort = new Serial(this, portName, 57600);
	//create a csv-file and folder with timestamp-name to stop it from overwriting files...
	output = createWriter("Logged Data/EnergyMeter_" + year() + "-" +month() + "-" + day() + "_" + hour() + "." + minute() + ".csv");
	//create new instances of a nested arraylist-object (see tab "Arraylist")
	V = new TwoDArrayList();
	P = new TwoDArrayList();
	PMax = new TwoDArrayList();
	// set the window size:
	size(xMax, yMax);
	// set inital background to gray
	background(0);
	//A serialEvent() is generated when a newline character is received :
	myPort.bufferUntil('\n');
	xPos=0;
	drawTitle();
	//Label[2]=new movingLabels(xPos, 200.0, Integer.toString(xPos) + " V");
	}
	void draw()
	{
	//Wait for a serial event to trigger...
	}
	//Interrupt that triggers whenever data is received on the serial port.
	void serialEvent (Serial myPort) {
	//if error occures, do not stop code...
	try {
	// get the Serial-ASCII string:
	String inString= myPort.readStringUntil('\n');
	println(inString); //debug
	if (inString != null) {
	// trim off any whitespace before and after the data (if exists)
	inString = trim(inString);
	//The data comes in 4 separate transmissions, first energy meter number, then V then W than W-Max
	//now check which one we are receiving:
	if (inString.indexOf("Energy")>=0) //If the String "Energy" is found, its the Energy meter number "Energy Meter: x"
	{
	//Remove the "Energy Meter: " to get the float containing the number
	//print("Mätare: ");
	inString = inString.replaceAll("Energy meter: ", "");
	Meter = Integer.parseInt(inString.trim());//Float.parseFloat(inString);
	//increment x-value
	xPos=millis()/100; //10 lines per second
	//Setts the actual value, before fitting it into the graph.
	} else if (inString.indexOf(" V")>=0 && V.getSize(Meter)==PMax.getSize(Meter) && Meter<7 && Meter>0) //If the String " V" is found, its the voltage string: "xxx V"
	{
	//Remove the " V" to get the float containing the data
	inString = inString.replaceAll(" V", "");
	IntValue = Integer.parseInt(inString.trim());
	if (IntValue>0) {
	Last_V = float(inString);
	ReDraw();
	//If we've allready filled 3/4th of the plot-window, start removing data so we dont crash into the wall.
	if (xPos >= xMax-100)
	{
	//ReDraw();
	}
	xVals.addArr(Meter, (float)xPos);
	stroke(RGB[Meter-1][0], RGB[Meter-1][1], RGB[Meter-1][2]);
	Error=false;
	//If this is a valid reading IntValue>200 (~230 expected) to skip error-values
	if (IntValue>200)
	{
	//voltage converted to a scale from (0 to vmax) as (0 to height of the graph*0,8)
	curVal=map(IntValue, 0, vmax, 0, height*0.8);
	//Add the value to the V-object
	V.addArr(Meter, curVal);
	} else if (V.getSize(Meter)>0) //Error and not first valueA
	{
	Error=true;
	curVal=V.getLast(Meter);
	V.addArr(Meter, V.getLast(Meter));
	} else //Error and first value =>put a zero as first recorded value
	{
	curVal=0;
	V.addArr(Meter, curVal);
	}
	//Check if this is the first added value?
	if (V.getSize(Meter)==1)
	{
	//Draw the starting line from current xPos and y=V(0) to itself (make a dot)
	line(xPos, height-V.getArr(Meter, 0), xPos, height-V.getArr(Meter, 0));
	//Create a label-object for the line that hoovers 10px over line (first index of "Label" is 0=V,1=Pmax,2=P, secound index is Meter)
	Label[0][Meter]=new movingLabels(xPos, height-V.getArr(Meter, 0)-10, inString + " V");
	} else {
	//Draw a line from the second last xVals-value to the new xPos-value (last xVals-value)
	line(xVals.getLast(Meter, 1), height-V.getLast(Meter, 1), xVals.getLast(Meter), height-V.getLast(Meter));
	//print the label:
	Label[0][Meter].drawText(xPos-10, height-curVal-10, Meter + String.format(": %.0f", Last_V)+"V");
	}
	//output.println("V");
	}
	}
	//now do the same with W-Max and W (note the "" for string and '' for char!
	else if (inString.indexOf("W-Max")>=0 && PMax.getSize(Meter)<P.getSize(Meter)) // Max power "xx.x W-Max"
	{
	inString = inString.replaceAll(" W-Max", "");
	Last_Pmax = float(inString);
	stroke(RGB[Meter-1][6], RGB[Meter-1][7], RGB[Meter-1][8]);
	//skip error-values
	if (Last_Pmax<4000 && Error == false)
	{
	curVal= map(Last_Pmax, 0, pmmax, 0, height*0.8);
	//Add the voltage-float converted to a scale from 0 to vmax as 0 to height of the graph*0,8
	PMax.addArr(Meter, curVal);
	} else if (PMax.getSize(Meter)>0) {
	Error=true;
	curVal=PMax.getLast(Meter);
	PMax.addArr(Meter, PMax.getLast(Meter));
	} else {
	Error=true;
	curVal=0;
	PMax.addArr(Meter, curVal);
	}
	//Check if this is the first added value?
	if (PMax.getSize(Meter)==1) {
	//Draw the starting line from x=10 and y=V(0) to itself (make a dot)
	line(xPos, height-PMax.getArr(Meter, 0), xPos, height-curVal);
	} else {
	//Draw a line from the last value to the new value
	line(xVals.getLast(Meter, 1), height-PMax.getLast(Meter, 1), xVals.getLast(Meter), height-PMax.getLast(Meter));
	}
	//output.println("Wmax");
	//Print all the values to a csv-file (see output-tab)
	PrintToCSVFile();
	} else if (inString.indexOf(" W")>=0 && inString.indexOf("Max")<0 && P.getSize(Meter)<V.getSize(Meter)) //Average Power "xx.x W"
	{
	inString = inString.replaceAll(" W", "");
	Last_P = float(inString);
	stroke(RGB[Meter-1][3], RGB[Meter-1][4], RGB[Meter-1][5]);
	//skip error-values either caught here, or by the voltage-readings.
	if (Last_P<=4000 && Error == false)
	{
	curVal=map(Last_P, 0, pmax, 0, height*0.8);
	//Add the voltage-float converted to a scale from 0 to vmax as 0 to height of the graph*0,8
	P.addArr(Meter, curVal);
	//Add kWh
	P.addkWh(Meter, Last_P);
	} else if (P.getSize(Meter)>0)
	{
	Error=true;
	curVal=P.getLast(Meter);
	P.addArr(Meter, P.getLast(Meter));
	} else //this is the first reading, and it is wiered.
	{
	Error=true;
	curVal=0;
	P.addArr(Meter, curVal);
	}
	//Check if this is the first added value?
	if (P.getSize(Meter)==1) {
	//Draw the starting line from x=10 and y=V(0) to itself (make a dot)
	line(xPos, height-P.getArr(Meter, 0), xPos, height-curVal);
	Label[1][Meter]=new movingLabels(xPos, height-curVal-10, "W");//Float.toString(P.getLast(Meter)) + " V");
	} else {
	//Draw a line from the last value to the new value
	line(xVals.getLast(Meter, 1), height-P.getLast(Meter, 1), xVals.getLast(Meter), height-P.getLast(Meter));
	Label[1][Meter].drawText(xPos+5, height-curVal-10, Meter + String.format(".\n%.1f", Last_P)+"W\n" + String.format("%.4f", P.getkWh(Meter)) + "kWh");//Float.toString(P.getLast(Meter)) + " W");
	}
	//output.println("W");
	}
	}
	}
	catch(RuntimeException e) {
	print("Här: ");
	println(e);
	delay(1000);
	myPort = new Serial(this, portName, 57600);
	}
	}
	//Function that triggers when a key is pressed, that sends data to the Arduino over serial.
	void keyPressed() {
	// If the return key is pressed, save the String, do something with it, clear it
	if (key == '\n' ) {
	//type eg: 2:1 to set the transmission intervall to 1s on the 2'nd meter.
	if (SerialString.indexOf(":")>=0) { //see if the string contained ":"
	//Send string to Arduino:
	myPort.write(SerialString);
	} else if (SerialString.indexOf("z")>=0) { //if you want to change the zoom on the power-readings, type
	//example: type "z1800" to set it to pmax=1800W => screen height
	try {
	//extract the number-part from the string and try and convert it to an integer:
	newPmax=int(SerialString.replaceAll("z", ""));
	ReDraw();
	}
	catch(Exception e) {
	//newPmax=0;
	}
	}
	//redraws the whole graph.
	//ReDraw();
	// clear the string
	SerialString = "";
	} else {
	// Each character typed by the user is added to the end of the String variable.
	SerialString = SerialString + key;
	drawTitle();
	//The string is printed on the screen everytime the Label is uated...
	}
	//ReDraw();
	}
	//******************************************************New Tab here****************************************************//
	/*This class is creating nested arraylists
	Theloat in my case, but can be used by all objects
	To create an nested arraylist:
	//Create a public variable-list
	TwoDArrayList = X;
	//In code, make a new instance of the list
	X = new TwoDArrayList();
	//Then
	X.addArr(2,34); //Adds "34" to the last position of array 2
	X.setArr(2,3,34); //Sets "34" to array 2, position 3.
	X.getArr(2,3); //Returns value from array 2, position 3.
	*/
	class TwoDArrayList<T> extends ArrayList<ArrayList<T>> {
	long lastX[] = new long[6];
	float kWh[][]= new float[6][2];
	public void setLastX(int index, long _lastX) {
	lastX[index]=_lastX;
	}
	public long getLastX(int index) {
	if (lastX[index]==0) {
	lastX[index]= xMax-100;
	}
	return lastX[index];
	}
	public void addkWh(int index, float Pmedel) {
	//E=P*dt
	kWh[index][0]+=Pmedel*(millis()-kWh[index][1])/(1000*3600)/1000; // /ms /s per h /kW in W
	kWh[index][1]=millis();
	}
	public float getkWh(int index) {
	return kWh[index][0];
	}
	//Add element on last position of inner list "index"
	public void addArr(int index, T element) {
	while (index >= this.size ()) {
	this.add(new ArrayList<T>());
	}
	this.get(index).add(element);
	}
	//Add element on specific position of index and index2
	public void setArr(int index, int index2, T element) {
	while (index >= this.size ()) {
	this.add(new ArrayList<T>());
	}
	ArrayList<T> inner = this.get(index);
	while (index2 >= inner.size ()) {
	inner.add(null);
	}
	inner.set(index2, element);
	}
	//return value from index position
	public float getArr(int index, int index2) {
	return (Float)this.get(index).get(index2);
	}
	//return size from index position
	public int getSize(int index) {
	if (this.isEmpty()) {
	return 0;
	} else if (index>this.size()-1) {
	return 0;
	} else if (this.get(index).isEmpty()) {
	return 0;
	} else {
	return (Integer)this.get(index).size();
	}
	}
	//return last value without offset
	public float getLast(int index) {
	return (Float)this.get(index).get(this.get(index).size() -1);
	}
	//return last value with offset
	public float getLast(int index, int offset) {
	return (Float)this.get(index).get(this.get(index).size() -1 -offset);
	}
	//
	public void Remove(int index, int index2) {
	if (this.get(index).isEmpty()==false) {
	this.get(index).remove(index2);
	}
	}
	}
	//******************************************************New Tab here****************************************************//
	void drawTitle() {
	//background(0);
	fill(255, 255, 255);
	textAlign(LEFT);
	String title = "Energy Meter";
	textSize(20);
	text(title, 20, 20);
	textSize(15);
	text("Zoom: " + pmax + " W", 20, 50);
	text(SerialString, 250, 20);
	}
	void drawLabel(int x, int y, String val, String unit) {
	fill(255, 255, 255);
	textSize(10);
	textAlign(LEFT);
	String title = val + ' ' + unit;
	text(title, x, y);
	}
	class movingLabels {
	float x, y, xOld, yOld;
	String s;
	String sOld="";
	movingLabels (float _x, float _y, String _text) {
	//This function is the 'constructor'.
	//It will get called when you create a new
	//movingText object
	x = _x; //Set x to the first argument
	y = _y; //Set y to the second argument
	s = _text; //Set our string to the 3rd argument
	}
	public void drawText(float _x, float _y, String _text) {
	s=_text;
	x=_x;
	y=_y;
	textSize(10);
	textAlign(LEFT);
	//Start by writing over the old text with black:
	fill(0);
	for (int i=0; i<10; i++) {
	//text(sOld, xOld, yOld);
	}
	textSize(10);
	//Now print the new text in white
	fill(255, 255, 255);
	textLeading(10); //enable new line '\n'
	text(s, x, y);
	sOld=s;
	xOld=x;
	yOld=y;
	drawTitle();
	}
	}
	void YLabel() {
	fill(255, 255, 255);
	textSize(10);
	textAlign(RIGHT);
	stroke(255,255,255);
	strokeWeight(1);
	int Intervall = pmax/20;
	int HuvudLinje = Intervall*5;
	for (float v = 0; v <= pmax; v += Intervall) {
	if (v % Intervall == 0) { // If a tick mark
	float y = map(v, 0, pmax, height,height*0.2);
	//=map(Last_P, 0, pmax, 0, height*0.8);
	if (v % HuvudLinje == 0) { // If a major tick mark
	float textOffset = textAscent()/2; // Center vertically
	if (v == 0) {
	textOffset = 0; // Align by the bottom
	} else if (v == height*0.8) {
	//textOffset = textAscent(); // Align by the top
	}
	text(floor(v), 20, y + textOffset);
	line(35, y, width, y); // Draw major tick
	//line(plotX1-2, y+9, plotX1, y+9); //line to draw midle lines
	} else {
	line(40, y, 45, y); // Draw minor tick
	}
	}
	}
	}
	//******************************************************New Tab here****************************************************//
	void PrintToCSVFile() {
	//String to export to csv-file with timestamp:
	//csv-files opened in Swedish Excel automatically separate colums by: ';', in english version it's: ','
	String Temp = year() + "-" + month() + "-" + day() + ";";
	Temp += hour() + ":" + minute() + ":" + second() + ";";
	//jump some colums to separate the different meters:
	for (int i=1; i<Meter; i++) {
	Temp += ";;;;;;;";
	}
	Temp += "Energy Meter: " + Meter + ";";
	Temp += String.format("%.0f", Last_V) + ";V;";
	Temp += String.format("%.1f", Last_P) + ";W;";
	Temp += String.format("%.1f", Last_Pmax) + ";W";
	//put the string in output-buffer
	output.println(Temp);
	//Execute the writing to the file...
	output.flush();
	}
	//Not used, but a way of adding separators.
	String PrintData(float Data, int Col) {
	String TempStr = "";
	for (int i=0; i<Col; i++) {
	TempStr = TempStr + ";";
	}
	return TempStr + String.format("%.1f", Data);
	}
	//******************************************************New Tab here****************************************************//
	void ReDraw() {
	//if a secound meter starts after we've hit the wall, its empty!
	if (V.getSize(Meter)>0) {
	// set inital background=clear screen
	background(0);
	//save current meter to remember which one to add data to later.
	int currMeter = Meter;
	//put the string in output-buffer
	//output.println("getlastX: ;" + xVals.getLastX(Meter) + ";Xpos: ;" + xPos);
	//find the offset from last recorded value:
	long Xoffset=xPos-lastupdatedXvalue;//xVals.getLastX(Meter);
	lastupdatedXvalue=xPos;
	//loop through all the meters and if they contain data; meve them back one dX
	for (int j=1; j<7; j++) {
	Meter=j;
	//Check if Meter is not empty
	if (V.getSize(Meter)>0) {
	//Remove values that have passed the screen on the rest of the meters
	while (xVals.getArr (Meter, 0)<-100) {
	V.Remove(Meter, 0);
	P.Remove(Meter, 0);
	PMax.Remove(Meter, 0);
	xVals.Remove(Meter, 0);
	}
	if (xPos>= xMax-100 && newPmax==0) {
	//Uppdate all the xVals on j-meter.
	for (int i=0; i<xVals.getSize (Meter); i++)
	{
	xVals.setArr(Meter, i, xVals.getArr(Meter, i) - Xoffset);
	}
	}
	if (newPmax>0) {
	for (int i=0; i<P.getSize (Meter); i++)
	{ // curVal=map(P, 0, pmax, 0, height*0.8);
	P.setArr(Meter, i, P.getArr(Meter, i)*pmax/newPmax);
	PMax.setArr(Meter, i, PMax.getArr(Meter, i)*pmmax/newPmax);
	}
	}
	//Set line-color to pink for plotting "V"
	stroke(RGB[Meter-1][0], RGB[Meter-1][1], RGB[Meter-1][2]);
	//Uppdate all the V-values
	for (int i=0; i<V.getSize (Meter)-1; i++)
	{
	line(xVals.getArr(Meter, i), height-V.getArr(Meter, i), xVals.getArr(Meter, i+1), height-V.getArr(Meter, i+1));
	}
	//Set line-color to pink for plotting "W-Max"
	stroke(RGB[Meter-1][3], RGB[Meter-1][4], RGB[Meter-1][5]);
	for (int i=0; i<P.getSize (Meter)-1; i++)
	{
	line(xVals.getArr(Meter, i), height-P.getArr(Meter, i), xVals.getArr(Meter, i+1), height-P.getArr(Meter, i+1));
	}
	//Set line-color to pink for plotting "W"
	stroke(RGB[Meter-1][6], RGB[Meter-1][7], RGB[Meter-1][8]);
	for (int i=0; i<PMax.getSize (Meter)-1; i++)
	{
	line(xVals.getArr(Meter, i), height-PMax.getArr(Meter, i), xVals.getArr(Meter, i+1), height-PMax.getArr(Meter, i+1));
	}
	//If this isn't the meter that'll get a new value, draw the lables
	if (Meter!=currMeter) {
	//Label[0][Meter].drawText(xVals.getLast(Meter), height-V.getLast(Meter)-10, Meter + String.format(": %.0f", map(V.getLast(Meter), 0, height*0.8, 0, vmax))+"V");
	Label[1][Meter].drawText(xVals.getLast(Meter)+5, height-P.getLast(Meter)-10, Meter + String.format(".\n%.1f",
	map(P.getLast(Meter), 0, height*0.8, 0, pmax))+"W\n" + String.format("%.4f",P.getkWh(Meter)) + "kWh");
	}
	}
	}
	Meter=currMeter;
	if (newPmax>0) {
	pmax=newPmax;
	pmmax=newPmax;
	newPmax=0;
	}
	}
	//Save the current time
	xVals.setLastX(Meter, xPos);
	if (xPos> xMax-100) {
	//X-value for newest value that'll be added bellow!
	xPos = xMax-100;
	}
	YLabel();
	}

view raw EnergyMeter.pde hosted with ❤ by GitHub