ESP8266 SPI Spy

I came across a very useful post by Thomas Scherrer that describes how to read data from a Peacefair PZEM-021 energy meter by spying on the SPI bus with an Arduino. I decided to do the same thing with an ESP-12F WiFi module so that I could view the results remotely and plot graphs, etc. It took me a lot longer to get this working than I anticipated due to a few problems along the way.

The main hardware difference is the ESP8266 is a 3.3V device but the Arduino is 5V. The PZEM-021 is actually a mixture. The RN8208G metering chip is a 5V device. It is a SPI slave, the SPI master is an STM32 ARM processor that is 3.3V but with 5V tolerant inputs. That means the signals originating from the CPU can go straight into the ESP8266 but the data out from the RN8208G would need attenuating.

Copying Thomas, I removed the mains dropper components C1 and R1 and powered the PZEM-021 from an external supply. This allows it to measure voltages right down to zero instead of cutting out at 80V. I used this little 12V 1A supply recommended by Big Clive on YouTube.

I powered the ESP-12F from the same supply with a tiny 3.3V MP2307 buck converter module.

WARNING: when connected to PZEM-021 the 0V rail is at mains neutral potential. This has to be treated with the same precautions as live because if the mains lead happened to be be reversed or the neutral connection broke it would become live. Don't connect a USB programmer or a scope ground to the circuit unless you power it with a mains isolation transformer. Fortunately the ESP8266 can be programmed wirelessly from the Arduino IDE once a sketch with ArduinoOTA has been installed and this is much faster than USB.

During the hardware development I used a mains isolation unit that I made after watching this video by Paul Carlson, another of my favourite YouTubers. I built this originally to allow me to repair a switch mode PSU that was part of a friend's home cinema unit. It allows me to connect my scope to the live part of a circuit but then of course it is no longer isolated, so great care has to be taken not to touch the high voltage bits.

It is a DiBond box with 3D printed frame, handles and rubber feet containing an isolation transformer and a small variac. It also has two 100W light bulbs in parallel with a bypass switch for optional current limiting, a different model of power meter and some 4mm jack sockets allowing me to attach my Mooshimeter to log voltage and current.

The first task was to solder wires on to the PZEM-021 PCB to bring power in and data out to my circuit.

I didn't see a need for the chip select / word latch signal and I took the data from the other end of R9 compared to Thomas. The signals are as follows:

• Red is 12V, black is ground. 
• The word latch going to the display from chip U2 pin 7 on the left, used for synchronisation. 
• MISO data coming from the energy chip via R9.
• The SPI clock coming from U2 pin 12.

The two wires on the chip are tricky to solder due to the fine pitch, which is much smaller than a practical soldering iron bit. I used the following technique:

• Strip some wire-wrap wire and trim the end to be the length of the flat part of the pin.
• Tin it. It doesn't hold much solder due to being such a small radius.
• Add plenty of liquid flux around the pin.
• Line the wire up along the top of the pin with an Andonstar ADSM201 microscope camera.
• Put a very small amount of solder on a small chisel bit.
• Press the iron on top of the wire and leave it long enough to conduct the heat through the wire to boil the flux and melt the solder on the pad below.

The amount of solder on the iron bit is crucial. If you use too much it will bridge the pins. To remove a bridge add plenty of flux and wipe the pin with a large flat bit. Surface tension will cause some solder to wick onto the bit, wipe it off and repeat until the bridge breaks.

When I looked at the levels of the signals I got a bit of a surprise. I was expecting MISO on channel 2 to go to 5V but the other two come from the ARM and should be 3.3V signals.

They seem to have a 20kHz ripple that takes them up to 4V. I looked back at Thomas' oscilloscope pictures and see the same ripple there. It doesn't make any difference for him because he is using a 5V chip but I didn't want to stuff 4V into my ESP8266!

On further investigation I found that the whole 3.3V rail had this ripple on it. It comes from a Holtek HT7133-1 3.3V LDO regulator. The datasheet for that suggests 10uF decoupling capacitors on the input and output. The circuit has what looks like a 10uF tant on its input but the output decoupler is a tiny MLCC that looks too small to be 10uF. I added a 10uF electrolytic in parallel and that killed the oscillation. It is the blue radial cap across C1 in the photo above.

That just left the issue of the 5V signal to contend with. R9 turns out to be 1K so simply adding a 2K2 to ground drops the signal low enough.

It also changes the first eight bits from FF to 00. This is actually when the command byte is being sent to the meter chip on MOSI and MISO is tri-state, so it doesn't matter.

Hardware done, on to the firmware. Before starting the project I had seen that the ESP8266 has a spare SPI port available and I assumed it would be straightforward to just read a stream of 13 bytes, wrong! It wasn't because the SPI port it a relatively complex device with dozens of registers that doesn't just send and receive bytes. It actually works at the command level, expecting to send or receive a command and address and then send or receive status or data bytes.

When in host mode it is possible to configure it to send and receive arbitrary bytes, indeed that is what the Arduino SPI class does and it works on the ESP8266 more or less the same as it does on an AVR. In slave mode though it has to receive a command and address according to the technical manual and the command defines what happens next. The relevant sections are:

4.3.2. Communication Format Supported by Slave SPISlave ESP8266SPI communication format is almost the same as that of the master mode, i.e. command+address+read/write data, but the slave read/write operation has itshardware command and undeletable address, which is,

• Command: a must; length: 3 ~ 16 bits; master output and slave input (MOSI).

• Address: a must; length: 1 ~ 32 bits; master output and slave input (MOSI).

• Read/write data: optional; length: 0 ~ 512 bits (64 Bytes); master output and slave input (MOSI) or master input and slave output (MISO).

4.3.3.Command Definition Supported by Slave SPIThe length of slave receiving command should at least be 3 bits. For low 3 bits, there are hardware reading and writing operation, which is,

• 010 (slave receiving) : Write the data sent by master into the register of slave data caching via MOSI, i.e. SPI_FLASH_C0 to SPI_FLASH_C15.

• 011 (slave sending):Send the data in the register of slave data caching (from SPI_FLASH_C0 to SPI_FLASH_C15) to master via MOSI.

• 110 (slave receiving and sending): Send slave data caching to MISO and write the master data in MOSI into data caching SPI_FLASH_C0 to SPI_FLASH_C15.

On the face of it this looks like it will not work in this application, which is unbelievable that a SPI port can't read arbitrary data as a slave and is hard coded for emulating flash chips and the like. 

I couldn't find any proper register level documentation for the ESP8266 other than various .h files on the web. The Arduino library uses shortened names which are very cryptic but some headers use longer names. While searching for these I came across the technical manual for the ESP32 and realised it has SPI ports that are nearly the same. It also has register level documentation in it's technical manual so I was able to get a slightly better understanding. After a lot of experimentation I found a solution.

The first n bits get interpreted as a command, where n is 3 or more and defaults to 8. The start of the 13 byte sequence that I want to receive is always zero now that I added the pull down resistor. So it always receives command zero. The bottom three bits normally control what happens next and zero defaults to read status. However, it is possible to override this with user definable commands by setting  SPI_SLV_CMD_DEFINE in SPI_SLAVE_REG. That makes the SPI_SLAVE3_REG define what the command values are for four different actions. By setting SPI_SLV_WRBUF_CMD_VALUE to zero and the other three values to nonzero I was able to make it interpret the command as write buffer, so the rest of the data gets written into the buffer.

Well that was the theory but I was missing two bytes at the beginning. This was because it was being interpreted as an address. The default address length is 24 bits. I changed it to 8 by setting SPI_USER1_REG and now I get the 12 bytes of data following the zero byte. Now this doesn't make sense because if the first 8 bits are being interpreted as an address where is the command coming from? The command length is set by  SPI_USER2_REG and it defaults to 8. I was expecting to have to set it to say four and set the address length to four bits so that they could share the first byte but any value between 2 and 8 seems to work and makes no difference. I don't know if it is a bug in the chip or I don't understand something but I get to read my 12 bytes of data

So in conclusion you can't read a completely arbitrary SPI data stream but you can if the first few bits are a known value.

Here is my code that sets up the HSPI:

	void hspi_slave_begin() {
	pinMode(SCK, SPECIAL); // Both inputs in slave mode
	pinMode(MOSI, SPECIAL);
	SPI1C = 0; // SPI_CTRL_REG MSB first, single bit data mode.
	SPI1S = SPISE | SPISBE | SPISCD | 0x3E0;// SPI_SLAVE_REG, set slave mode, WR/RD BUF enable, CMD define, enable interrupts
	SPI1U = SPIUSSE; // SPI_USER_REG. SPI_CK_I_EDGE
	SPI1CLK = 0; // SPI_CLOCK_REG
	SPI1U1 = 7 << SPILADDR; // SPI_USER1_REG, set address length to 8 bits
	SPI1U2 = 7 << SPILCOMMAND; // SPI_USER2_REG, set command length to 8 bits
	SPI1S1 = (length * 8 - 1) << SPIS1LBUF; // SPI_SLAVE1_REG, SPI_SLV_BUF_BITLEN = 12 bytes
	SPI1S3 = 0xF1F200F3; // SPI_SLAVE3_REG,, Define command 0 to be write buffer, others something doesn't match
	SPI1P = 1 << 19; // SPI_PIN_REG, Clock idle high, seems to cause contension on the clock pin if set to idle low.
	ETS_SPI_INTR_ATTACH(_hspi_slave_isr_handler, 0);
	ETS_SPI_INTR_ENABLE();
	}

view raw hspi_slave_begin.cpp hosted with ❤ by GitHub

When the data is received I get an interrupt where I copy it from the HSPI's dword buffer into a byte buffer in RAM.

	const int length = 12; // length of packet minus the first byte
	uint8_t data[length]; // raw data received
	volatile bool data_ready = false; // set by HSPI interrupt handler when data is received
	void ICACHE_RAM_ATTR hspi_slave_isr_handler(void *) {
	uint32_t istatus = SPIIR;
	if(istatus & (1 << SPII1)) { //SPI1 ISR
	uint32_t status = SPI1S;
	SPI1S &= ~(0x3E0); //disable interrupts
	SPI1S |= SPISSRES; //reset
	SPI1S &= ~(0x1F); //clear interrupts
	SPI1S |= (0x3E0); //enable interrupts
	if(status & SPISWBIS) {
	uint8_t *p = data;
	for(int i = 0; i < length / 4; i++) {
	uint32_t dword = SPI1W(i);
	*p++ = dword;
	*p++ = dword >> 8;
	*p++ = dword >> 16;
	*p++ = dword >> 24;
	}
	data_ready = true;
	}
	} else if(istatus & (1 << SPII0)) { //SPI0 ISR
	SPI0S &= ~(0x3ff);//clear SPI ISR
	} else if(istatus & (1 << SPII2)) {} //I2S ISR
	}

view raw hspi_slave_isr_handler.cpp hosted with ❤ by GitHub

I set up the sync pin to generate an interrupt on the falling edge. This resets the HSPI and unmarshals  the data:

	int voltint = 0, currentint = 0, wattint = 0; // raw values
	void ICACHE_RAM_ATTR sync_isr() { // Sync pin interrupt on falling edge
	SPI1S |= SPISSRES; // Reset HSPI slave
	SPI1S &= ~SPISSRES;
	SPI1CMD = SPICMDUSR; // Start HSPI slave
	static bool glitch = false;
	if(data_ready) { // If a data has been received by the HSPI
	data_ready = false;
	int volts = (data[0] << 16) + (data[1] << 8) + data[2]; // assemble 24 bits
	if(volts > 5 * voltint / 8 || glitch) { // reject samples that have been shifted right by noise on the clock line?
	glitch = false; // sample accepted
	voltint = volts;
	currentint = (data[4] << 16) + (data[5] << 8) + data[6];
	wattint = (data[8] << 16) + (data[9] << 8) + data[10];
	if(wattint > 0xFF0000) // sometimes goes slightly negative with no load
	wattint = 0;
	++samples;
	new_readings = true; // new raw readings ready
	}
	else
	glitch = true; // only reject one sample
	}
	}

view raw sync_isr.cpp hosted with ❤ by GitHub

I found that when I switched the load on and off I sometimes got a data packet shifted right one bit. That points to a spike on the SPI clock line into the ESP8266 but I could not find one with a 100MHz scope triggered on the mains switching edge. I added a snubber close to the switch but that didn't cure it, so I bodged it in the firmware and moved on. If a voltage sample is not more than half the previous one I ignore it once.

Another oddity is that when there is no load and the voltage is relatively high the power reading would go slightly negative. I detect that and set it to zero.

The foreground loop looks for the new_readings flag to be set and does the conversion to real units:

	float voltfloat = 0, currentfloat = 0, wattfloat = 0; // real unit values
	float voltscalefactor = 0.0307162746 / 256; // calibration constants vary from device to device
	float currentscalefactor = 1.553 / 256000;
	float wattscalefactor = 15.49521794871 / 2560;
	// the loop function runs over and over again forever
	void loop() {
	digitalWrite ( GREEN_LED, !!(millis() & 512) ); // flash the green LED
	server.handleClient(); // run web server
	if(new_readings) { // set by interrupt when data received
	voltfloat = voltint * voltscalefactor; // convert to real units
	currentfloat = currentint * currentscalefactor;
	wattfloat = wattint * wattscalefactor;
	Serial.printf("V%5.1f, A%4.2f, W%5.1f", voltfloat, currentfloat, wattfloat);
	for(int i = 0; i < length; ++i)
	Serial.printf(" %02X", data[i]);
	Serial.println();
	new_readings = false;
	}
	ArduinoOTA.handle();
	}

view raw loop.cpp hosted with ❤ by GitHub

The conversion constants are close to what Thomas used but slightly different, so the ARM must have some per unit factory calibration constants in it.

So it took me longer than I anticipated to follow in Thomas' footsteps because of the complexity and lack of proper documentation for the ESP8266 HSPI peripheral but I got there in the end. I hope others find this as useful as I found Thomas' work.

By now you are probably wondering what this is all for. Well, while investigating a strange line regulation problem in a power supply I got annoyed that the mains voltage in our house is constantly varying, making it hard to make measurements of input versus output. This is what it looks like logged every 10 seconds over a couple of days using my Mooshimeter.

As well as the small modern variac shown above I have a old WM5 model that I got on eBay. The only data I could find on it was from 1955. It still works fine so I decided to automate it with a small stepper motor to maintain a specified voltage. I.e. make a WiFi control IOT variac.

Another DiBond and printed part creation but the front panel had to be acrylic to let the WiFi out. Fortunately the front of my bench faces towards my router. The ESP8266 controls the motor via a Pololu stepper driver.

The control interface is a simple web form that also shows the current readings using AJAX as described here.

The control algorithm is very simple. The motor is stepped at the specified speed by the error in voltage multiplied by the gain. The readings update every 200ms but they lag a lot. That causes overshoot if the gain is set high. It would probably benefit from a full PID controller but it works well enough for now. The deadband setting allows it to stay in a range without constantly moving because I don't want to wear out the variac. Servo control of a variac is a standard way of regulating mains but I have no idea how long the brushes last. Manual mode disables the motor.

The readings can be read and the settings changed from the command line or from a Python script using cURL. Here is an example that sweeps the voltage from 10 to 250 in 10 Volt steps and reads the current and power.

	#!/usr/bin/env python
	import pycurl
	from StringIO import StringIO
	from time import *
	import re
	def curl(url):
	buffer = StringIO()
	c = pycurl.Curl()
	c.setopt(c.URL, url)
	c.setopt(c.WRITEDATA, buffer)
	c.perform()
	c.close()
	return buffer.getvalue()
	regex = re.compile('(.*)V *(.*)A *(.*)W Pos *(.*)')
	for v in xrange(10, 251, 10):
	curl('http://variac/readings?deadband=0&set=&voltage=' + str(v))
	while True:
	sleep(0.2)
	readings = curl('http://variac/readings')
	results = regex.match(readings).groups()
	V = float(results[0])
	A = float(results[1])
	W = float(results[2])
	P = int(results[3])
	if abs(v -V) < 0.1:
	break
	print v, V, A, W, P
	curl('http://variac/readings?manual=')

view raw variac.py hosted with ❤ by GitHub

Here is a graph showing current, power and resistance versus voltage of a 60W light bulb

I plan to use this to plot a power supply line regulation graph. For that I will need a way of reading the output voltage in my script. I have two scopes that have network APIs as well as my Mooshimeter that has a BLE interface. I just need to work out which is the easiest to access in Python.

Here is the full ESP8266 sketch.

	// ESP8266 Arduino sketch to control a variac with a stepper motor
	// GNU GPL
	// NopHead
	// hydraraptor.blogspot.com
	//
	#include <ESP8266WiFi.h> //ESP8266 Core WiFi Library (you most likely already have this in your sketch)
	#include <ArduinoOTA.h>
	#include <DNSServer.h> //Local DNS Server used for redirecting all requests to the configuration portal
	#include <ESP8266WebServer.h> //Local WebServer used to serve the configuration portal
	#include "WiFiManager.h"
	#include <ESP8266mDNS.h>
	#include "esp8266_peri.h"
	#include "ets_sys.h"
	const int RED_LED = 4; // GPIO pins
	const int GREEN_LED = 5; // Bi colour LED
	const int STEP = 0; // Stepper driver STEP pin
	const int EN = 2; // Stepper driver enable pin
	const int SYNC = 12; // Display chip CS used for synchonization
	const int DIR = 15; // Stepper driver enable
	ESP8266WebServer server ( 80 );
	int target_v = 230; // target voltage from web form
	int speed = 50; // speed in degrees per second
	int gain = 20; // feadback gain, microsteps per volt
	float deadband = 0.5; // deaband to avoid continual movement and wear
	bool manual = true; // when true the motor is disabled
	const int microsteps = 16; // configuration of the stepper driver
	const int big_teeth = 78; // teeth on the big pulley
	const int small_teeth = 16; // teeth on the motor pulley
	const float steps_per_rev = 200.0 * microsteps * big_teeth / small_teeth;
	int position = 0; // current motor postion relative to where it started
	const int length = 12; // length of packet minus the first byte
	uint8_t data[length]; // raw data received
	volatile bool data_ready = false; // set by HSPI interrupt handler when data is received
	volatile bool new_readings = false; // set by sync pin interrupt when readings are extracted from raw data
	volatile uint32_t samples = 0; // count of samples received
	int voltint = 0, currentint = 0, wattint = 0; // raw values
	float voltfloat = 0, currentfloat = 0, wattfloat = 0; // real unit values
	float voltscalefactor = 0.0307162746 / 256; // calibration constants vary from device to device
	float currentscalefactor = 1.553 / 256000;
	float wattscalefactor = 15.49521794871 / 2560;
	long speed2us(int speed) { // convert speed in degrees per second to setp delay in microseconds
	float steps_per_second = steps_per_rev * speed / 360.0;
	return 1000000 / steps_per_second;
	}
	void spin(int speed, int steps) { // step the motor
	digitalWrite(GREEN_LED, 1);
	digitalWrite(DIR, steps < 0);
	digitalWrite(EN, 0);
	delay(1);
	long uS = speed2us(speed);
	position += steps;
	steps = abs(steps);
	while(steps--) {
	digitalWrite(STEP, 1);
	ESP.wdtFeed();
	digitalWrite(STEP, 0);
	delayMicroseconds(uS);
	}
	}
	const char MAIN_page[] PROGMEM = R"=====(
	<html>
	<head>
	<meta name = "viewport" content = "width = device-width, initial-scale = 1.5, maximum-scale = 2.0, user-scalable=1", charset="UTF-8"/>
	<title>Variac control</title>
	<style>
	body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }
	</style>
	</head>
	<body>
	<h1>Variac Control</h1>
	<form action="/" method="post">
	<table>
	<tr><td>Voltage:</td> <td><input type="text" name="voltage" value="%d" size="3" maxlength="3"></td></tr>
	<tr><td>Speed:</td> <td><input type="text" name="speed" value="%d" size="3" maxlength="3"></td></tr>
	<tr><td>Gain:</td> <td><input type="text" name="gain" value="%d" size="3" maxlength="3"></td></tr>
	<tr><td>Deadband:</td><td><input type="text" name="deadband" value="%3.1f" size="3" maxlength="3"></td></tr>
	<tr><td><button type="submit" name="manual">%s</button></td><td><button type="submit" name="set">%s</button></td></tr>
	</table>
	<br/><div>Readings: <pre style="display:inline"><span id = "readings">---</span></pre></div>
	</form>
	<script>
	setInterval(function() {
	// Call a function repetatively with 2 Second interval
	getData();
	}, 200); //200ms update rate
	function getData() {
	var xhttp = new XMLHttpRequest();
	xhttp.onreadystatechange = function() {
	if (this.readyState == 4 && this.status == 200) {
	document.getElementById("readings").innerHTML =
	this.responseText;
	}
	};
	xhttp.open("GET", "readings", true);
	xhttp.send();
	}
	</script>
	</body>
	</html>
	)=====";
	void mainPage() {
	char temp[100 + sizeof MAIN_page];
	snprintf_P ( temp, sizeof temp, MAIN_page, target_v, speed, gain, deadband,
	manual ? "<strong>MANUAL</strong>" : "MANUAL",
	manual ? "SET" : "<strong>SET</strong>" );
	server.send ( 200, "text/html", temp );
	}
	int clip(int x, int low, int high) {
	if(x < low)
	return low;
	if(x > high)
	return high;
	return x;
	}
	void handleSettings() {
	if(server.hasArg("speed"))
	speed = clip(server.arg("speed").toInt(), 1, 100);
	if(server.hasArg("voltage"))
	target_v =clip(server.arg("voltage").toInt(), 1, 260);
	if(server.hasArg("gain"))
	gain = clip(server.arg("gain").toInt(), 0, 100);
	if(server.hasArg("deadband"))
	deadband = server.arg("deadband").toFloat();
	if(server.hasArg("manual")) {
	if(manual)
	position = 0;
	manual = true;
	digitalWrite(EN, 1);
	}
	if(server.hasArg("set"))
	manual = false;
	}
	void handleRoot() {
	handleSettings();
	mainPage();
	}
	void handleReadings() {
	handleSettings();
	char temp[100];
	snprintf(temp, sizeof temp, "%5.1fV %4.3fA %5.1fW Pos %5d", voltfloat, currentfloat, wattfloat, position);
	//snprintf(temp, sizeof temp, "%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", data[0], data[1],data[2], data[3], data[4], data[5], data[6], data[7],data[8], data[9], data[10], data[11]);
	server.send(200, "text/plane", temp); //Send readings to client ajax request
	}
	void handleNotFound() {
	String message = "File Not Found\n\n";
	message += "URI: ";
	message += server.uri();
	message += "\nMethod: ";
	message += ( server.method() == HTTP_GET ) ? "GET" : "POST";
	message += "\nArguments: ";
	message += server.args();
	message += "\n";
	for ( uint8_t i = 0; i < server.args(); i++ ) {
	message += " " + server.argName ( i ) + ": " + server.arg ( i ) + "\n";
	}
	server.send ( 404, "text/plain", message );
	Serial.println(message);
	}
	void ICACHE_RAM_ATTR sync_isr() { // Sync pin interrupt on falling edge
	SPI1S |= SPISSRES; // Reset HSPI slave
	SPI1S &= ~SPISSRES;
	SPI1CMD = SPICMDUSR; // Start HSPI slave
	static bool glitch = false;
	if(data_ready) { // If a data has been received by the HSPI
	data_ready = false;
	int volts = (data[0] << 16) + (data[1] << 8) + data[2]; // assemble 24 bits
	if(volts > 5 * voltint / 8 || glitch) { // reject samples that have been shifted right by noise on the clock line?
	glitch = false; // sample accepted
	voltint = volts;
	currentint = (data[4] << 16) + (data[5] << 8) + data[6];
	wattint = (data[8] << 16) + (data[9] << 8) + data[10];
	if(wattint > 0xFF0000) // sometimes goes slightly negative with no load
	wattint = 0;
	++samples;
	new_readings = true; // new raw readings ready
	}
	else
	glitch = true; // only reject one sample
	}
	}
	void ICACHE_RAM_ATTR _hspi_slave_isr_handler(void *) {
	uint32_t istatus = SPIIR;
	if(istatus & (1 << SPII1)) { //SPI1 ISR
	uint32_t status = SPI1S;
	SPI1S &= ~(0x3E0); //disable interrupts
	SPI1S |= SPISSRES; //reset
	SPI1S &= ~(0x1F); //clear interrupts
	SPI1S |= (0x3E0); //enable interrupts
	if(status & SPISWBIS) {
	uint8_t *p = data;
	for(int i = 0; i < length / 4; i++) {
	uint32_t dword = SPI1W(i);
	*p++ = dword;
	*p++ = dword >> 8;
	*p++ = dword >> 16;
	*p++ = dword >> 24;
	}
	data_ready = true;
	}
	} else if(istatus & (1 << SPII0)) { //SPI0 ISR
	SPI0S &= ~(0x3ff);//clear SPI ISR
	} else if(istatus & (1 << SPII2)) {} //I2S ISR
	}
	void hspi_slave_begin() {
	pinMode(SCK, SPECIAL); // Both inputs in slave mode
	pinMode(MOSI, SPECIAL);
	SPI1C = 0; // SPI_CTRL_REG MSB first, single bit data mode.
	SPI1S = SPISE | SPISBE | SPISCD | 0x3E0;// SPI_SLAVE_REG, set slave mode, WR/RD BUF enable, CMD define, enable interrupts
	SPI1U = SPIUSSE; // SPI_USER_REG. SPI_CK_I_EDGE
	SPI1CLK = 0; // SPI_CLOCK_REG
	SPI1U1 = 7 << SPILADDR; // SPI_USER1_REG, set address length to 8 bits
	SPI1U2 = 7 << SPILCOMMAND; // SPI_USER2_REG, set command length to 8 bits
	SPI1S1 = (length * 8 - 1) << SPIS1LBUF; // SPI_SLAVE1_REG, SPI_SLV_BUF_BITLEN = 12 bytes
	SPI1S3 = 0xF1F200F3; // SPI_SLAVE3_REG,, Define command 0 to be write buffer, others something doesn't match
	SPI1P = 1 << 19; // SPI_PIN_REG, Clock idle high, seems to cause contension on the clock pin if set to idle low.
	ETS_SPI_INTR_ATTACH(_hspi_slave_isr_handler, 0);
	ETS_SPI_INTR_ENABLE();
	}
	void hspi_slave_end() {
	SPI1S |= SPISSRES;
	SPI1CMD = 0;
	pinMode(SCK, INPUT); // Return to inputs to avoid glicthing the PZEM-021 during reset
	pinMode(MOSI, INPUT);
	digitalWrite (GREEN_LED, 1);
	digitalWrite (RED_LED, 1);
	}
	void setup() {
	Serial.begin(115200);
	Serial.println();
	Serial.println("Variac starting");
	pinMode(GREEN_LED, OUTPUT);
	pinMode(RED_LED, OUTPUT);
	pinMode(EN, OUTPUT);
	pinMode(DIR, OUTPUT);
	pinMode(STEP, OUTPUT);
	digitalWrite(RED_LED, 0);
	digitalWrite(GREEN_LED, 0);
	digitalWrite(STEP, 0);
	digitalWrite(DIR,0);
	digitalWrite(EN,1);
	//WiFi.disconnect();
	const char *hostname = "variac";
	digitalWrite ( RED_LED, 1 );
	WiFi.hostname(hostname);
	WiFiManager wifiManager;
	wifiManager.autoConnect(hostname, NULL); // Ap name same as host name
	digitalWrite( RED_LED, 0 );
	digitalWrite( GREEN_LED, 1);
	if ( MDNS.begin(hostname) )
	Serial.println ( "MDNS responder started" );
	server.on( "/", handleRoot );
	server.on("/readings", handleReadings );
	server.onNotFound( handleNotFound );
	server.begin();
	Serial.println ( "HTTP server started" );
	attachInterrupt(digitalPinToInterrupt(SYNC), sync_isr, FALLING);
	hspi_slave_begin();
	// Port defaults to 8266
	// ArduinoOTA.setPort(8266);
	// Hostname defaults to esp8266-[ChipID]
	// ArduinoOTA.setHostname("myesp8266");
	// No authentication by default
	// ArduinoOTA.setPassword("admin");
	// Password can be set with it's md5 value as well
	// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
	// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
	ArduinoOTA.onStart([]() {
	String type;
	if (ArduinoOTA.getCommand() == U_FLASH)
	type = "sketch";
	else // U_SPIFFS
	type = "filesystem";
	// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
	Serial.println("Start updating " + type);
	// Stop the interrupts
	detachInterrupt(digitalPinToInterrupt(SYNC));
	hspi_slave_end();
	});
	ArduinoOTA.onEnd([]() {
	Serial.println("\nEnd");
	});
	ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
	Serial.printf("Progress: %u%%\r", 100 * progress / total);
	static bool toggle; // toggle both leds so they flicker orange during update
	toggle = !toggle;
	digitalWrite (GREEN_LED, toggle);
	digitalWrite (RED_LED, toggle);
	});
	ArduinoOTA.onError([](ota_error_t error) {
	Serial.printf("Error[%u]: ", error);
	if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
	else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
	else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
	else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
	else if (error == OTA_END_ERROR) Serial.println("End Failed");
	});
	ArduinoOTA.begin();
	Serial.println("Ready");
	Serial.print("IP address: ");
	Serial.println(WiFi.localIP());
	}
	// the loop function runs over and over again forever
	void loop() {
	digitalWrite ( GREEN_LED, !!(millis() & 512) ); // flash the green LED
	server.handleClient(); // run web server
	if(new_readings) { // set by interrupt when data received
	voltfloat = voltint * voltscalefactor; // convert to real units
	currentfloat = currentint * currentscalefactor;
	wattfloat = wattint * wattscalefactor;
	Serial.printf("V%5.1f, A%4.2f, W%5.1f, Pos%5d", voltfloat, currentfloat, wattfloat, position);
	for(int i = 0; i < length; ++i)
	Serial.printf(" %02X", data[i]);
	Serial.println();
	new_readings = false;
	}
	if(samples > 1) { // update motor when had more than two samples since last moved
	float error = target_v - voltfloat;
	if(fabs(error) > deadband / 2 && !manual) {
	spin(speed, error * gain);
	samples = 0;
	}
	}
	ArduinoOTA.handle();
	}

view raw variac.ino hosted with ❤ by GitHub

ESP8266 contention during programming

To put the ESP8266 into serial programming mode it needs to be reset with GPIO 2 held high, GPIO 15 low and GPIO 0 low. On the other hand to start it executing flash GPIO 0 needs to be high during reset. I have seen lots of circuits on the web, for example the NodeMCU board and Adafruit's  Huzzah board that pull GPIO 0 to ground with a switch and / or with DTR from a USB to serial adapter.  Reset can be driven from RTS to automate programming with the Arduino IDE.

A lesser known fact is that when the ESP8266 goes into programming mode it outputs a 26 MHz clock on GPIO 0 with considerable drive strength and fast edges. Shorting this to ground or DTR is not good at all as it causes massive contention and generates a lot of noise. This can cause programming to fail unless there is some hefty decoupling on the supply rail. The simple solution is to put a resistor between GPIO 0 and whatever is pulling it low. Here is what the signals look like with 10K between GPIO 0 and DTR from an FTD1232.

The oscillation doesn't show up at full amplitude with a slow time base but I can assure you it is full swing with plenty of overshoot due to not being terminated. You can see a bit of it coupled onto the TX line and this is when it is through 10K. Imagine how noisy things get when it is fighting with the FTD1232 DTR line and winning.

Another lesser know fact is that when the ESP8266 is in reset its GPIO lines get pulled up internally. You can see with 10K pulling it down the GPIO line only goes down to about 0.7V during reset.

Before reset my application is driving GPIO 0 low. RTS goes low a short time before DTR, so it briefly becomes an input and gets pulled to 3.3V by DTR before it pulls it low again. This explains the spike on the left.

I haven't seen any circuits published that avoid this contention.

Printed ESP-12 module breakout adapter

I plan to make a few projects based around ESP-12F WiFi modules. These are postage stamp sized modules containing an ESP8266 chip plus 4MB of flash. The ESP8266 chip is a 32 bit MCU with an integrated WiFi transceiver and TCP/IP stack. They come programmed as a WiFi modem but they can be reprogrammed with the Arduino IDE to do other things in addition to the WiFi. Great for IOT applications because they are so small and cheap (less than £2) but reasonably powerful. A lot more powerful than an Arduino, for example, but with less I/O.

The solder pads are on a 2mm pitch, so they are often used with a breakout board to adapt them to 0.1" pitch for breadboard or perfboard, etc.  That adds cost and increases the size somewhat because the through hole pins need to be outside the perimeter of the module. I solved the problem another way, by using a 3D printed wire guide that routes wires from the 0.2mm pitch holes to the nearest 0.1" hole, minimising the space used and costing virtually nothing.

The holes in the module are quite small so I use stripped wire wrap wire. I push it through the module, down through the guide, which routes it to the correct hole in the perfboard. I fold the top over, solder it to the module and trim it. I do the four corners first and pull them tight and solder underneath to secure the module.

Here is a module mounted on perboard.

It doesn't use any extra board space outside the 0.1" holes it uses. I.e. the adjacent holes are all usable.

I didn't break out the end connections because they are not very useful. They are all GPIO lines used internally for the flash. I read it is possible to free up two by removing the can and re-configuring the flash chip to use a two bit interface instead of four bits, but that is too much hassle for me.

Here is the OpenSCAD that produced the adapter: -

	//
	// GNU GPL v2
	// nop.head@gmail.com
	// hydraraptor.blogspot.com
	//
	// Adapts ESP12 module to 0.1" grid.
	//
	eps = 1/128; // small fudge factor to stop CSG barfing on coincident faces.
	layer_height = 0.25; // slicer layer height
	extrusion_width = 0.5; // slicer extrusion width
	nozzle = 0.45; // extruder nozzle aperture
	squeezed_wall = extrusion_width - layer_height / 2 + nozzle / 2 + extrusion_width / 2;
	module ESP12F_carrier_stl() {
	pins = 8;
	pitch1 = 2;
	pitch2 = 2.54;
	hole = pitch1 - squeezed_wall;
	hole2 = pitch2 - 3 * extrusion_width;
	length1 = (pins - 1) * pitch1 + hole + squeezed_wall * 2;
	length2 = (pins - 1) * pitch2 + hole + squeezed_wall * 2;
	height = 3;
	wpitch1 = (pins - 1) * pitch1;
	wpitch2 = ceil(wpitch1 / 2.54) * 2.54;
	width1 = wpitch1 + hole + squeezed_wall * 2;
	width2 = wpitch2 + hole2 + squeezed_wall * 2;
	difference() {
	hull() {
	translate([0, 0, height - eps / 2])
	cube([width1, length1, eps], center = true);
	translate([0, 0, eps / 2])
	cube([width2, length2, eps], center = true);
	}
	for(side = [-1, 1])
	for(i = [0 : pins - 1])
	hull() {
	translate([side * wpitch1 / 2, i * pitch1 - (pins - 1) * pitch1 / 2, height])
	cube([hole, hole, eps], center = true);
	translate([side * wpitch2 / 2, i * pitch2 - (pins - 1) * pitch2 / 2, 0])
	cube([hole2, hole2, eps], center = true);
	}
	}
	}
	ESP12F_carrier_stl();

view raw esp12_carrier.scad hosted with ❤ by GitHub

The only notable thing is the squeezed wall definition, see my previous post.

Avoiding voids

The thinnest practical wall you can print, (with Skeinforge at least), is two extrusion widths wide. Any bigger leaves a gap, until you get to three extrusions wide, and then you get infill in between them.

If the wall is exactly two extrusions wide then they only touch tangentially and have a weak bond because the edges of the filament are rounded.

I discovered that if you make a wall even thinner then Skeinforge still lays down two paths equal to the extrusion width but places them closer together. This is because it always offsets inwards by half the extrusion width, even if the resulting paths overlap. I found I can make use of this to squash the plastic together, making a stronger wall with less voids.

An optimum amount of squeeze is to place the nozzle aperture just free of the flat part of the first path when extruding the second. The width to make this happen is $extrusion\_width - layer\_height / 2 + nozzle\_aperture / 2 + extrusion\_width / 2$.

Of course, despite what Skeinforge thinks, the plastic volume can't overlap, so regardless of where the nozzle is the minimum width the wall can be is $2 * extrusion\_width - layer\_height * (1 - π/4)$ due to the volume of plastic extruded, i.e. if it manages to completely fill the voids. This is shown below: -

The grey area is where the edge would have been with the wall two extrusion widths wide. There isn't much difference, and depending on the viscosity of the plastic, the real width should be somewhere in between. But the big difference is the walls are strongly fused together. The top void should be completely filled because it is right under the nozzle, leading to a smoother top surface. And the bottom void has more chance of being filled due to the back pressure caused by the filament having to flow more to the right.

To put some numbers to the diagrams, these have been drawn to scale for 0.25mm layer height and 0.5mm extrusion width, 0.4mm nozzle. The requested wall width is 0.825mm but the volume of plastic means it must be at least 0.946mm, only 0.054mm less than the original 1mm wall.

I made a test script that makes a box with two 1mm walls and two 0.825mm walls.

	layer_height = 0.25; // slicer layer height
	extrusion_width = 0.5; // slicer extrusion width
	nozzle = 0.45; // extruder nozzle aperture
	squeezed_wall = extrusion_width - layer_height / 2 + nozzle / 2 + extrusion_width / 2;
	wall = 2 * extrusion_width;
	w = 20;
	h = 10;
	base = 1;
	difference() {
	cube([w, w, h]);
	translate([wall, wall, base])
	cube([w - wall - squeezed_wall, w - wall - squeezed_wall, h]);
	}

view raw void_test.scad hosted with ❤ by GitHub

Here is a corner of the box under a microscope. The wall on the left is seamlessly fused and the wall on the right clearly has a void.

The wall comes out a bit thinner than the theory predicts, I am not sure why, maybe the increased pressure causes the plastic to feed a bit slower.

I used this technique to make the Mendel90 fan guards a lot stronger part way through production because I had some fall apart one day when my filament was a bit undersized.

It would be nice if the slicer could do this automatically, so you can keep a 1mm wall in the design, but it would make it by extruding one side of the wall as normal but the other side it would offset the nozzle to fill the voids and then extrude a little more plastic to make it still 1mm thick.

In fact it should really do this anytime it is extruding against another extrusion path. E.g. when doing multiple outlines and when doing infill. I.e. the only time the tool path of the nozzle should be down the centre of the extrusion path is when there is nothing either side, or it is enclosed on both sides. And in each of these three cases a slightly different flow rate would be needed to get the new exposed edge in the correct place.