## Archive for the ‘Electronics’ Category

### Measuring Rain Fall

Monday, May 9th, 2016

A new day and a new sensor to look at, the pluviometer.

The pluviometer is a mechanical sensor that looks a little like a see-saw. A small plastic bucket is placed on each side of the fulcrum. The buckets are designed so that when a critical mass of water is in one bucket it tips the see-saw and the bucket on the other side starts filling. The process continues as each bucket is filled and emptied. A picture paints a thousand words, so here is a view of the inside of the pluviometer:

Inside the Pluviometer

A small magnet is placed on the see-saw and a reed switch is behind the fulcrum. The tipping motion triggers the reed switch each time the see-saw tips, this in turn generates a single pulse.

Reading the switch becomes a seeming simple repetition of the wind speed problem, namely debouncing a switch and attaching an interrupt.

One long term goal has to take this solution off grid. This will make power consumption a critical factor in the design. Attaching an interrupt does not necessarily become an attractive option as the Oak would be running continuously and with the WiFi running this would consume a fair amount of power.

According to the specification for the pluviometer, a pulse will be generated for every 0.2794mm of rainfall.

## Offline Counting

One possible solution to the power problem would be to put the Oak to sleep and wake it up every say 5-15 minutes to take measurements and upload them to the cloud. Doing this would reduce power but would also mean that no measurements would be take during the sleep period if interrupts were used.

A cheap solution in terms of cost is to use the 74HC4040 counter. This could be put into a circuit and kept active while the Oak is sleeping. The output from the debounced switch would then be used as a clock signal for the 74HC4040. This would allow the pulses from the pluviometer to be counted while the Oak is sleeping.

The downside is that eight pins are needed to read the output from the counter. With only a small number of pins, many of which have already been used, this will require some way of adding extra pins to the system. Fortunately there are a number of digital IO expanders on the market. A common series of chips is the MCP23x17 chips. These add an additional 16 inputs/output pins with communication to the chip vis I2C (X=0) or SPI (X=S). The I2S variation will fit the bill nicely.

One final connection that is required for the counter is a reset connection. Left to itself, the rain gauge counter would continue to count pulses until the counter overflowed and started from zero once more. From a design perspective there are a few options:

1. Reset the counter each time it has been read
2. Reset the counter once a day
3. Let the counter overflow and detect the reset to zero

One consideration will be the amount of rainfall the system can detect before it resets to zero.

Maximum number of counts = 212

Which gives 4096 counts. However, for simplicity we will only consider the lower 8 bits, i.e. 0-255 counts. The system can always be expanded later should this be necessary (or if the system has the capacity).

Maximum rainfall = 255 * 0.2794 mm

Giving a maximum rainfall count of 71.247 mm per counting period. It is envisaged that the counting period would be somewhere in the region of 5-15 minutes. This would make an hourly average of 285mm assuming a steady rainfall and a 15-minute interval between counts.

This should be well within expectations for UK weather.

As an aside, the full 12-bits would allow for a rainfall of 1144mm per counting interval, or 4.5 metres of rain per hour.

## Schematic

With a little supporting hardware to be added, the schematic looks as follows:

Weather Station Partial Schematic

Note that the BME280 and TSL2561 are also on the schematic.

The rain gauge counter bit values have been labeled RXQx, RG = Rain Gauge and Q is the standard notation for a bit in a logic design.

## Software

The MCP23017 (I2C version of the IO expander) is sold by Adafruit. They have a standard Ardunio library for this component and so in the interest of code re-use, expediency and idleness this will be used.

So the first thing to do is to create an instance of the MCP23017 IO expander:

```Adafruit_MCP23017 _outputExpander;      // MCP23017, I2C controlled 16-port output.
```

Next up, the output expander needs to be setup. Looking at the schematic, the output from the counter is mapped to port B on the MCP23017. This maps to IO pins 8 to 15 inclusive. These bits should be set to inputs. One final piece of configuration is the reset pin, this needs to be set to output:

```//
//  Set up the pluviometer, zero the counts and then attached and initialise the
//  counter to the output expander.
//
void WeatherSensors::SetupRainfallSensor()
{
_pluviometerPulseCount = 0;
_pluviometerPulseCountToday = 0;
//
//  Attach the rainfall counter to the output expander.
//
int index;
for (index = 8; index < 16; index++)
{
_outputExpander.pinMode(index, INPUT);
}
//
//  Attach the counter reset pin to the output expander and reset the counter.
//
_outputExpander.pinMode(PIN_RAINFALL_RESET, OUTPUT);
ResetPluviometerPulseCounter();
}
```

As well as setting up the pulse counter, the above code resets internal counters for rainfall today and also resets the pulse count.

Reading the pulse counter is a simple matter to reading the state of each bit starting at 0:

```//
//  Read the counter from the Rainfall sensor then reset the count.
//
{

_pluviometerPulseCount = 0;
for (int index = 8; index < 15; index++)
{
{
}
}
_pluviometerPulseCountToday += _pluviometerPulseCount;
ResetPluviometerPulseCounter();
}
```

## Accuracy

The eagle-eyed amongst you will have spotted a small flaw in the above logic, namely that the pulse counter could increment whilst the system is reading the values. It turns out that this matters a great deal in some cases. Consider the following:

The pulse counter has counter 15 pulses (0b00001111). The software is processing these bit values and has processed bit 2, counter value = 7. A pulse is registered by the counter and the pulse count becomes 16 (0b00010000). The system processes bit 3 and finds it is 0 and then moves on to bit 4 and finds this is 1, i.e. 16. The counter then becomes 16 + 7 = 23 instead of 15. A little bit difficult to see, so lets put this in tabular form:

 Bit Value Decimal Value Cumulative Sum Counter 0 1 1 1 00001111 1 1 2 3 00001111 2 1 4 7 00001111 Counter increments here 00010000 3 0 0 7 00010000 4 1 16 23 00010000 5 0 0 23 00010000 6 0 0 23 00010000 7 0 0 23 00010000

The counter column contains the value in the 74HC4040 counter chip (lower 8 bits only).

The problem occurs because the reading of the pulses is not instantaneous, the software takes longer to process the data than the counter takes to register a clock pulse and update the counter.

There are two possible solutions to this, both left for later investigation:

1. Add an AND gate between the incoming rain gauge pulse and the 74HC4040 clock pin. This can be turned off when taking a reading.
2. Check the documentation for the MCP23017 to see if the values can be latched and then read. Latching the values means that they cannot be changed; once latched and the values being read would be consistent.

Both offer a solution to the problem and will be left as a later refinement.

## Conclusion

The pluviometer is a seemingly simple switch but it needs to run constantly. This presents a challenge when considering the requirement to save power where possible. This article presented a possible solution using a small number of components bringing powered on permanently.

The solution does introduce a possible error in the reading, although this should be reasonably small. A full analysis will be presented in a future article.

### Weather Station Proof of Concept Software

Sunday, April 3rd, 2016

The weather station project is still at the proof of concept stage but the last few articles have run through the concepts for connecting several sensors to the Digistump Oak microcontroller. In this article we will look at the basic (and I stress basic) software required to connect the sensors discussed so far with the microcontroller and start to collect data.

## Hardware – So Far

In the previous articles the following sensors have been discussed:

These sensors are currently connected to a piece of breadboard along with the Oak.

Now we have the sensors connected we need to add some software goodness.

## Software Requirements

The first and most obvious requirement is to be able to collect data from the above sensors. In addition the proof of concept software should also permit the following:

1. Test logging data to the cloud
2. Serial debugging
3. Setting the system time from the Internet

Data logging to the cloud will initially be to the Sparkfun Data Service as this is a simple enough service to use. One of the first things to do is to create an account / data stream in order to permit this.

## Development Environment

The Arduino development environment can be used to program the Oak and it has the advantage that it is available across multiple environments. Digistump recommend using version 1.6.5 of the Arduino environment as there are known issues with more current versions.

### Libraries

In previous articles it was noted that Sparkfun and Adafruit provide libraries for two of the I2C sensor boards being used (BME280 and TSL2561). An additional library is also required to support the third objective, setting the time from the Internet.

The additional libraries are installed from the Sketch -> Include Library -> Manage Libraries.. dialog. Open this dialog and install the following libraries:

• Sparkfun TSL2561 (1.1.0)
• NtpClientLib by German Martin (1.3.0)

The version numbers are the ones available at the time of writing.

## Software Walk Through

At this point the hardware should be in place and all of the necessary libraries installed. Let the coding begin.

This first thing we need is the includes for the libraries that are going to be used:

```#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <Time.h>
#include <NtpClientLib.h>
#include <SparkFunTSL2561.h>
#include <Wire.h>
#include <SPI.h>
```

The SPI library is not going to be used in this example but will be required in future articles.

Next up we need some definitions and global variables to support the sensors:

```//
//  Definitions used in the code for pins etc.
//
#define VERSION           "0.04"
//
#define PIN_SLEEP_OR_RUN  7
#define PIN_ONBOARD_LED   1
#define PIN_ANEMOMETER    5
#define PIN_PLUVIOMETER   8
//
#define SLEEP_PERIOD      60

//
//  Light sensor (luminosity).
//
SFE_TSL2561 light;

//
//  Create a Temperature, humidity and pressure sensor.
//
float temperature;
float pressure;
float humidity;

//
//  TLS2561 related globals.
//
boolean gain;       //  Gain setting, 0 = X1, 1 = X16;
unsigned int ms;    //  Integration ("shutter") time in milliseconds
double lux;         //  Luminosity in lux.
boolean good;       //  True if neither sensor is saturated

//
//
int ultraviolet;
#define MAXIMUM_ANALOG_VALUE  1023
#define REFERENCE_VOLTAGE     3.3
#define UV_OFFSET             1.025

//
//  Buffer for messages.
//
char buffer[256];
char number[20];

//
//  NTP class to provide system time.
//
ntpClient *ntp;

//
//  Wind Speed sensor, each pulse per second represents 1.492 miles per hour.
//
volatile int windSpeedPulseCount;
#define WINDSPEED_DURATION      5
#define WINDSPEED_PER_PULSE     1.492

//
//  We are logging to Phant and we need somewhere to store the client and keys.
//
#define PHANT_DOMAIN        "data.sparkfun.com"
#define PHANT_PAGE          "/input/---- Your stream ID goes here ----"
const int phantPort = 80;
#define PHANT_PRIVATE_KEY   "---- Your Private Key goes here ----"
```

Before we progress much further it should be acknowledged that some of the code for the BMS280 and the TSL2561 is modified from the Adafruit and Sparkfun example applications.

A key point to note from the above code is the definition of the windSpeedPulseCount variable. Note the use of the volatile keyword. This tells the compiler not to optimise the use of this variable.

Next up is some support code. Two methods are initially required, ftoa adds the limited ability to convert a floating point number to a char * for debugging. The second method outputs a debugging message. This has been abstracted to allow for possible network debug messages later in the project. At the moment the serial port will be used.

```//
//  Output a diagnostic message if debugging is turned on.
//
void DebugMessage(String message)
{
Serial.println(message);
}

//
//  Convert a float to a string for debugging.
//
char *ftoa(char *a, double f, int precision)
{
long p[] = {0, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};

char *ret = a;
long integer = (long) f;
itoa(integer, a, 10);
while (*a != '\0')
{
a++;
}
if (precision != 0)
{
*a++ = '.';
long decimal = abs((long) ((f - integer) * p[precision]));
itoa(decimal, a, 10);
}
return ret;
}
```

### TSL2561 – Luminosity Sensor

The next group of methods deal with the luminosity sensor, the TSL2561. these methods are slightly modified versions of the example code from Sparkfun. It is envisaged that future versions of these methods will deal with saturation and low light levels by dynamically changing the way the sensor works. For the proof of concept the basic code should suffice:

```//
//  Convert the error from the TSL2561 into an error that a human can understand.
//
void PrintLuminosityError(byte error)
{
switch (error)
{
case 0:
DebugMessage("TSL2561 Error: success");
break;
case 1:
DebugMessage("TSL2561 Error: data too long for transmit buffer");
break;
case 2:
break;
case 3:
DebugMessage("TSL2561 Error: received NACK on data");
break;
case 4:
DebugMessage("TSL2561 Error: other error");
break;
default:
DebugMessage("TSL2561 Error: unknown error");
}
}

//
//  Set up the luminsoity sensor.
//
void SetupLuminositySensor()
{
light.begin();

// Get factory ID from sensor:
// (Just for fun, you don't need to do this to operate the sensor)
unsigned char id;

if (light.getID(id))
{
sprintf(buffer, "Retrieved TSL2561 device ID: 0x%x", id);
DebugMessage(buffer);
}
else
{
byte error = light.getError();
PrintLuminosityError(error);
}

// The light sensor has a default integration time of 402ms,
// and a default gain of low (1X).

// If you would like to change either of these, you can
// do so using the setTiming() command.

// If gain = false (0), device is set to low gain (1X)
// If gain = high (1), device is set to high gain (16X)
gain = 0;

// If time = 0, integration will be 13.7ms
// If time = 1, integration will be 101ms
// If time = 2, integration will be 402ms
// If time = 3, use manual start / stop to perform your own integration
unsigned char time = 2;

// setTiming() will set the third parameter (ms) to the
// requested integration time in ms (this will be useful later):
light.setTiming(gain, time, ms);

// To start taking measurements, power up the sensor:

DebugMessage((char *) "Powering up the luminosity sensor.");
light.setPowerUp();
}

//
//  Read the luminosity from the TSL2561 luminosity sensor.
//
{
unsigned int data0, data1;

if (light.getData(data0, data1))
{
sprintf(buffer, "TSL2561 data: 0x%04x, 0x%04x", data0, data1);
DebugMessage(buffer);
//
//  To calculate lux, pass all your settings and readings to the getLux() function.
//
//  The getLux() function will return 1 if the calculation was successful, or 0 if one or both of the sensors was
//  saturated (too much light). If this happens, you can reduce the integration time and/or gain.
//  https://learn.sparkfun.com/tutorials/getting-started-with-the-tsl2561-luminosity-sensor
//

//
// Perform lux calculation.
//
double localLux;
good = light.getLux(gain ,ms, data0, data1, localLux);
if (good)
{
lux = localLux;
}
}
else
{
byte error = light.getError();
PrintLuminosityError(error);
}
}

//
//  Log the luminosity data to the debug stream.
//
void LogLuminosityData()
{
sprintf(buffer, "Lux: %s", ftoa(number, lux, 2));
DebugMessage(buffer);
}
```

### BME280 – Air Temperature, Pressure and Humidity Sensor

Dealing with this sensor is simpler than the luminosity sensor as can be seen from the code below:

```//
//  Setup the Adafruit BME280 Temperature, pressure and humidity sensor.
//
void SetupTemperaturePressureSensor()
{
if (!bme.begin())
{
DebugMessage("Could not find a valid BME280 sensor, check wiring!");
}
else
{
DebugMessage("BME280 sensor located on I2C bus.");
}
}

//
//  Log the data from the temperature, pressure and humidity sensor.
//
void LogTemperaturePressureData()
{
sprintf(buffer, "Temperature: %s C", ftoa(number, temperature, 2));
DebugMessage(buffer);
sprintf(buffer, "Humidity: %s %%", ftoa(number, humidity, 2));
DebugMessage(buffer);
sprintf(buffer, "Pressure: %s hPa", ftoa(number, pressure / 100, 0));
DebugMessage(buffer);
}

//
//  Read the data from the Temperature, pressure and humidity sensor.
//
{
}
```

This group of methods follows a similar line to the TSL2561 sensor methods, namely, setup, read and log methods.

### ML8511 – Ultraviolet Light Sensor

This sensor is the simplest so far as it provides a simple analog value representing the intensity of the ultraviolet light falling on the sensor.

```//
//  Read the ultraviolet light sensor.
//
{
}

//
//  Log the reading from the ultraviolet light sensor.
//
void LogUltravioletData()
{
char num[20];

sprintf(buffer, "Ultraviolet light: %s", itoa(ultraviolet, num, 10));
DebugMessage(buffer);
}
```

Note that this sensor does allow for an enable line. This can be used to disable the sensor and put it into a low power mode if necessary. This will not be used in the proof of concept will be considered when the project moves to the point where power supplies / solar power is considered.

### Wind Speed Sensor Interrupt Service Routine (ISR)

This method looks trivial and it is:

```//
//  ISR to count the number of pulses from the anemometer (wind speed sensor).
//
void IncreaseWindSpeedPulseCount()
{
windSpeedPulseCount++;
}
```

The non-trivial thing to remember about this code is that the method changes a global variable. The volatile keyword used in the variable definition is necessary to stop the compiler from optimising the global variable as this can have side effects.

### Data Logging to Sparkfun’s Data Service

Assuming that we have a WiFi connection then we can log the data collected to the Sparkfun data service (this is based upon Phant).

```//
//  Post the data to the Sparkfun web site.
//
void PostDataToPhant()
{
String url = PHANT_PAGE "?private_key=" PHANT_PRIVATE_KEY "&airpressure=";
url += ftoa(number, pressure / 100, 0);
url += "&groundmoisture=0";
url += "&groundtemperature=0";
url += "&temperature=";
url += ftoa(number, temperature, 2);
url += "&humidity=";
url += ftoa(number, humidity, 2);
url += "&luminosity=";
url += ftoa(number, lux, 2);
url += "&rainfall=0";
double uvStrength = (((double) ultraviolet) / MAXIMUM_ANALOG_VALUE) * REFERENCE_VOLTAGE;
if (uvStrength < UV_OFFSET)
{
uvStrength = 0;
}
else
{
uvStrength = (uvStrength - UV_OFFSET) / UV_GRADIENT;
}
url += "&ultravioletlight=";
url += ftoa(number, uvStrength, 2);
url += "&winddirection=0";
double windSpeed = windSpeedPulseCount / WINDSPEED_DURATION;
windSpeed *= WINDSPEED_PER_PULSE;
url += "&windspeed=";
url += ftoa(number, windSpeed, 2);
//
//  Send the data to Phant (Sparkfun's data logging service).
//
HTTPClient http;
http.begin(PHANT_DOMAIN, phantPort, url);
int httpCode = http.GET();
sprintf(buffer, "Status code: %d", httpCode);
DebugMessage(buffer);
String response = http.getString();
sprintf(buffer, "Phant response code: %c", response[3]);
DebugMessage(buffer);
if (response[3] != '1')
{
//
//  Need to put some error handling here.
//
}
http.end();
}
```

The stream has been set up to collect more data than is currently collected, for instance, ground temperature. Any parameter not measured at the moment is set to 0.

Some other things to consider following the proof of concept:

1. Error handling for network issues
2. Possible offline collection of data
3. Using a local version of Phant

Something to bear in mind after the project moved from proof of concept.

### Data Collection

The majority of the sensor have a read method to collect the data from the sensor. The only exception at the moment is the wind speed sensor. The data collection is performed inside the main method for collecting and logging the sensor readings:

```//
//  Raad the sensors and publish the data.
//
{
digitalWrite(1, HIGH);
DebugMessage("\r\nCurrent time: " + ntp->getTimeString());
LogLuminosityData();
LogTemperaturePressureData();
LogUltravioletData();
//
//  Read the current wind speed.
//
windSpeedPulseCount = 0;
attachInterrupt(PIN_ANEMOMETER, IncreaseWindSpeedPulseCount, RISING);
delay(WINDSPEED_DURATION * 1000);
detachInterrupt(PIN_ANEMOMETER);
//
PostDataToPhant();
digitalWrite(1, LOW);
}
```

Reading the wind speed is performed through the ISR described above. The algorithm is simple:

1. Clear the count of the number of revolutions (pulses) from the sensor
2. Attach an interrupt to the sensor (the interrupts increments the count every revolution of the sensor)
3. Wait for a know number of seconds (in this case 5)
4. Detach the interrupt to stop the count

By using this method we can provide an average over a number of seconds and the wind speed can be calculated as:

Wind Speed = (Revolution count / number of seconds) * 1.492

This is the calculation performed in the PostDataToPhant method.

### Setup and Loop

The final things needed by an application developed in the Arduino environment are the setup and loop methods. So let’s start looking at the setup method.

```//
//  Setup the application.
//
void setup()
{
Serial.begin(9600);
Serial.println("\r\n\r\n-----------------------------\r\nWeather Station Starting (version " VERSION ", built: " __TIME__ " on " __DATE__ ")");
Serial.println();
//
//  Connect to the WiFi.
//
Serial.print("\r\nConnecting to default network");
```

At the start of setup we need to rely upon the Serial object being available and so there are no calls to the DebugMessage method as this may be modified later to use networking for debugging. The next step is to try and connect to the network:

```    WiFi.begin();
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println(WiFi.localIP());
```

At this point the application will be either looping indefinitely until the network becomes available or we will have an IP address output to the serial port. In a more complete application this will start the logging process and periodically try to connect to the network when the network is unavailable. This is only a proof of concept after all.

There is currently no Real Time Clock (RTC) attached to the system and so we need to check the network time at startup.

```    //
//  Get the current date and time from a time server.
//
DebugMessage("Setting time.");
ntp = ntpClient::getInstance("time.nist.gov", 0);
ntp->setInterval(1, 1800);
delay(1000);
ntp->begin();
while (year(ntp->getTime()) == 1970)
{
delay(50);
}
```

This block of code loops until the network time is set correctly. At start up the year will be set to a default value of 1970, this is why the code loops until the year is something other than 1970.

Next up, setup the sensors and take our first reading:

```    //
//  Set up the sensors and digital pins.
//
SetupLuminositySensor();
SetupTemperaturePressureSensor();
pinMode(PIN_ONBOARD_LED, OUTPUT);
pinMode(PIN_ANEMOMETER, INPUT);
//
//  Read the initial data set and publish the results.
//
}
```

Everything is setup, only thing left is to continue to collect and publish the data, enter loop:

```//
//  Main program loop.
//
void loop()
{
delay(SLEEP_PERIOD * 1000);
}
```

## Example Output

Running the above code results in the following output in the serial monitor (note that some data (IP addresses has been modified):

```
-----------------------------
Weather Station Starting (version 0.04, built: 06:46:39 on Apr  3 2016)

Connecting to default network...........
Setting time.
Retrieved TSL2561 device ID: 0x50
Powering up the luminosity sensor.
BME280 sensor located on I2C bus.

Current time: 06:48:45 03/04/2016
TSL2561 data: 0x0373, 0x004f
Lux: 399.65
Temperature: 18.89 C
Humidity: 52.86 %
Pressure: 1006 hPa
Ultraviolet light: 307
Status code: 200
Phant response code: 1
```

The current public data stream for this service should be viewable here.

Checking this stream you can see the resulting data that was sent to Sparkfun for the above serial output:

Phant Data From Weather Station Proof of Concept

One thing to remember when comparing the above data is that the Sparkfun data stream logs data using UTC and the application above was running during British Summer Time.

## Conclusion

The code above is a proof of concept, it is not error proof nor does it take into account power usage or optimisation, it is merely meant to prove that the sensors can be read and the data output to a cloud service.

Next steps for the proof of concept:

1. How to handle two sensors requiring an analog conversion
2. The project is running out of digital pins
3. Real time clocks
4. Offline data logging

All of this before even looking at the location and powering the project in the wild (OK, my garden).

Back right after this break…

### Wind Speed and Ultraviolet Light Sensors

Saturday, April 2nd, 2016

Last time we looked at the I2C Sensors that are part of the weather station. At the end of the article it was noted that these were working and able to log data to the Particle ecosystem.

Now it is time for the analog sensors:

1. Wind speed
2. Wind direction
3. Rainfall
4. Ultraviolet light

The Ultraviolet light and wind direction sensor will present us with a problem as they are both analog sensors and the Oak only has one Analog-to-Digital Convertor (ADC).

The rainfall gauge and the wind speed sensor both use a similar technology to generate a signal, namely a magnet that will trigger a reed switch. These two sensors also present an issue; while they are simple enough there are a finite number of pins on the Oak and they are being consumed at a fair rate.

## ML8511 – Ultraviolet Light Sensor

The ML8511 measures ultraviolet light at a wavelength of 365nM. This is at the top end of the UVB band, the band which is harmful to living tissue. The sensor generates a voltage that is linear and proportional to the intensity of the UV light. The intensity of the light measured is on the scale 0 to 15 mW/cm2. The following chart is taken from the data sheet:

ML8511 UV Plot

The chart above is generated when the supply voltage is 3.0V but the system under development will be using a 3.3V supply. Some investigation is required to determine the output voltage when there is no UV present. After running the sensor under constant temperature conditions with no UV light present the ADC was generating a reading in the 316 – 320 range. This gives out output voltage for the sensor in the range 1.02V – 1.03V.

If we assume that the output characteristics of the sensor remain linear at 3.3V and the gradient remains the same then we can generate a formula for calculating the intensity of the UV light based upon the sensor output.

All linear graphs can be represented by the following formula:

y = mx + c

Where:

• y is the y coordinate (in our case the voltage output of the sensor)
• x is the x coordinate (in our case the intensity of the UV light)
• m is the gradient of the line
• c is a constant offset of the y coordinate

If we set x to 0 then the equation becomes y = c This represents the output of the sensor when there is no UV light present. As we have seen from the above experiment, this is in the range 1.02V – 1.03V. So as an approximation we will use the value c = 1.025V.

The gradient of any line is represented by the following formula:

m = deltaY / deltaX

When given two points on a line (x1, y1) and (x2, y2), then the gradient becomes:

m = (y2 – y1) / (x2 – x1)

Luckily the data sheet gives us two points on the line at 25C, namely the output voltage in shade and the output voltage at 10mW/cm2. So assuming shade represents no ultraviolet light then the gradient of the line becomes:

m = (2.2 – 1.0) / (10 – 0)

So m is 0.12. Plugging m and c back into the original equation gives:

y = 0.12x + 1.025

Solving for x gives:

x = (y – 1.025) / 0.12

Or to put it in context:

UV Intensity = (Sensor output in volts – 1.025) / 0.12 mW / cm2

There are some assumptions in the above work and the data sheet shows that the output voltage can vary but we have a method for calculating the intensity of UV light; accurate enough for a home project anyway.

## Wind Speed

Wind speed is measured by an anemometer. The anemometer in the Weather Sensor kit is a cup anemometer:

Cup Anemometer

This has a magnet on the spindle connected to the cups. The magnet closes (and opens) a reed switch each time it passes the switch. So one pulse is generated per full revolution of the spindle. Each full revolution of the spindle (per second) represents a wind speed of 1.492 miles per hour (mph) or 2.4 km/h.

For the experienced, this sounds simple but we all know there could be a nasty shock in store for us, namely switch bounce. An easy way to find out, hook the output up to an oscilloscope.

The circuit is simple enough, connect one switch contact to 3.3V, one to a resistor and the other end of the resistor to ground. Connect the scope to the resistor / switch junction.

The scope was set up to have a trigger voltage of about 1.5V and to trigger on the falling edge of a signal. The cups on the anemometer were then position so that the reed switch was closed (a high output on the scope) and the scope setup in single shot mode (to capture and hold the trace when triggered). Spinning the anemometer gave the following output:

Anemometer Switch Bounce

As you can see, the switch does bounce. Switch debouncing is a well known and documented problem, in fact I have written about it here so we will not go too deep into the problem in this article. The solution that will be used is a simple RC circuit:

The principle is that the RC circuit resists change and so filters out the glitch in the above trace. So we need a filter that is resistive enough to filter out the glitch but fast enough to respond in the minimum time between pulses.

The weather station is going to be located in the mainland UK, about 30 miles from the coast. In this location the wind speed is unlikely to rise above 60-80 mph unless in extreme conditions (tornadoes are known to occur in the UK). So assuming the maximum wind speed in 149.2 mph (this number is based upon the fact that 1.492 mph gives one revolution per second) then we have a maximum number of rotations of 100 per second. This gives a revolution time of 10 milliseconds.

So we have a 10 millisecond window for the pulse from the sensor. The pulse will be low for the majority of the time as the switch can only close when the magnet is above the switch, so for most of the 10ms we will have a low pulse. You can see this in the following trace:

Anemometer Duty Cycle

The signal appears to be high for 30% of the time. An accurate measurement could be made using the scope but it does not appear to be necessary. In our case, 10 milliseconds per rotation, the signal would be low for approximately 70% of the time, i.e. 7 milliseconds.

Going back to the first trace should the switch bounce it is observed that the switch bounce lasts for approximately 50-60 microseconds. Several observations of both the rising and falling edges showed this to be reasonable consistent. This final piece of information helps to define the parameters for this problem:

• The frequency of the pulses should be 100Hz maximum (i.e. 10 milliseconds between pulses)
• Duty cycle is 30% (high for 3 milliseconds, low for 7 milliseconds)
• Switch bounce can last 50-60 microseconds (assume 100 microseconds as a worst case)
• Trigger voltage is 2.3V with a supply voltage of 3.3V

There are plenty of online calculators for this type of circuit, Layada has one here that covers this type of scenario. We know the supply voltage (3.3V) and the trigger voltage (2.3V) so the only thing to do is look at the components available and calculate the delay time. After a few tries a 10K resistor and a 100nF capacitor were found to give a delay of 1.1939 milliseconds. This covers our case with plenty of margin for error.

Putting together the circuit above where the anemometer is the switch and triggering on the rising edge gives the following output on the oscilloscope:

The rise time looks to be acceptable, smooth and slow enough to iron out the glitches but fast enough to allow a 10 millisecond duration with a 30% duty cycle.

## Conclusion

At the start of the article it was noted that four analog sensors are present in the kit. This article has concentrated on just two, the UV and Wind Speed sensors. The Rainfall and Wind Direction sensors will be covered in future articles.

The two sensors here will require one digital pin and one analog pin. As there is only one analog pin on the Oak then some creative thinking will be required in order to connect the Wind Direction sensor.

Assuming a maximum wind velocity of 149.2 mph then we will have 100 rotations of the anemometer per second. This should be something that could be measured by the Oak using an interrupt on one of the digital pins

At this point the hardware for six measurements can be put together on breadboard and some prototype software put together. This is the subject of the next article, Proof of Concept Software

### Reading I2C Sensor Data with the Oak

Friday, April 1st, 2016

The weather station project will be bringing together a number of sensors, light, ultraviolet light, air pressure, humidity, wind speed, wind direction and rain fall. This collection of sensors falls into three groups:

• Electronic sensors on an I2C bus
• Mechanical sensors using switches
• Analog sensors

The current plan is for the weather station to use the Oak as the microcontroller running the show. The data from the sensors can then be uploaded to the cloud, destination to be determined, but let’s start with Sparkfun’s data service.

The I2C sensors will require the least amount of work to get up and running so let’s start with those. The two sensors operating on the I2C bus are:

Oak and 2C Sensors on Breadboard

One of the great things about working with these two sensors is the fact that there are prebuilt drivers and example code for both breakout boards available from Github. What could be simpler, well head over to the Sketch – Include Library – Board Manager… menu in the Arduino IDE and you can download the library and have the IDE install it for you.

## TSL2561 – Luminosity Sensor

This sensor allows the radiance of the light to be calculated in a way that approximates the response of the human eye. It does this by combining the input from two photodiodes, one infra-red only and one visible light and infra-red light combined. The output from the two sensors can be used to luminous emittance in lux (lumens per square metre).

The following table gives an idea of the lux values for typical scenarios:

 Lux Typical Environment 0.0001 Moonless, overcast night sky 0.002 Moonless clear night sky 0.27–1.0 Full moon on a clear night 80 Office building hallway 320–500 Office lighting 1000 Overcast day 10000–25000 Daylight

As you can see from the table above, the lux values for a “normal” human day can vary dramatically. The sensor copes with this by allowing the use of a variable time window and sensitivity when taking a reading. Effectively the sensor accumulates the readings over the time window (integration interval) into a single 16-bit number which can then be used to calculate the lux reading.

## BME280 – Air Pressure, Temperature and Humidity Sensor

This sensor is produced by Bosch and is packaged in both I2C and SPI configuration on the same board. The accuracy of the sensor appears good, pressure and temperature both to 1% and humidity to 3%.

## Libraries

Both Sparkfun and Adafruit have provided libraries and example code for the boards. These were easy to add to the development environment.

One caveat, the BME280 requires the addition of the Adafruit sensor library as well as the BME280 library.

Once added it was a simple case of wiring up the sensor to 3.3V and the I2C bus and running the example code.

They both worked first time.

## Some Code Modifications (for later)

The light sensor has been show to work in low light conditions but not to any degree of precision. A possible modification to the example code is to look at the sensitivity and integration window settings to see if the precision can be adjusted to make the sensor return better readings in low light.

Some of the values when calculated use the fractional part of a floating-point number, temperature and humidity spring to mind. This meant adding a method to convert a double into it’s string representation for debugging purposes. Trivially solved but an annoying omission from the implementation of sprintf.

## Posting to Particle Dashboard

The Oak can also post to the Particle dashboard providing a second method of debugging your application. Statements such as Particle.publish(“Debug”, “Temperature data…”); will cause the string Temperature data… to be posted in a group/attribute Debug

So the readings from the office look like this:

Some Weather Data

## Conclusion

Two simple to use sensors with good supported class libraries make these sensors quick and easy to hook up to the Oak. Merging the two examples was simple and sensor data is now appearing over the serial output from the Arduino.

Compiling the code gives some warnings about the I2C library being compiled for the ESP8266 whilst the target board is defined as an Oak. This can be ignored as the Oak is really a convenient wrapper around an ESP8266 module.

### Setting Up the Oak – Flashing LED

Sunday, March 27th, 2016

The Oak microcontroller is new, Digistump only shipped version 1 firmware a few days ago (20th Match 2016). The hardware I have was shipped sometime in January. So the first thing to do is to upgrade the firmware and then try blinking an LED.

The Digistump Wiki contains a number of tutorials and troubleshooting guides. First stop the Connecting Your Oak for the First Time page. This shows how the Oak can be connected to your WiFi network and the firmware updated.

The initial over the air firmware update was problematic to say the least. Reading through the Digitsump forums it seems that I am not the only one having a problem with the first update. There are three methods for upgrading the firmware:

• Over the Air using firmware from the internet
• Over the air with a local server
• Serial using pyserial or esptool

I started at the top of the list and slowly worked my way down. In the end the only method that worked for me was the serial update.

## Flashing an LED

With the latest version of the firmware installed it is time to test the development environment. What could be simpler than flashing and LED. The on board LED is connected to pin 1 so lets try and use that.

Digistump offer two development environments:

At the time of writing there was a known issue with the Particle development environment which prevented an application being built and flashed successfully. This is an early release and so issues are expected.

This only leaves the Arduino environment, an IDE I really hate.

There are two methods for flashing an application to the Oak using the Arduino environment:

• Over The Air (OTA)
• Serial (requires Python)

Despite the earlier problems with the firmware update I decided to try the OTA method first. DigitStump have provided compehensive instructions in their WiKi on how to achieve this.

Following the example was easy and after only 15 minutes I have the LED on the Oak flashing at 1Hz. Just to prove it was not a fluke I then tried changing the frequency and reflashing the Oak.

Success!

## Conclusion

My initial frustration with the firmware update was soon forgotten once I had an application successfully running on the Oak. I am hoping that the issues were caused by the fact I have an early release of the board with the original firmware installed.

Programming is easy enough and can be done over the air which is convenient.

### Weather Station

Friday, March 25th, 2016

The first part of this year has seen me working on some photography projects, now time to get the soldering iron out. I have three projects I’m hoping to complete this year and one long term project that may take me a while, so pay attention 007.

## Weather Station

A few weeks ago I received a couple of Oaks. These boards are based around the ESP12 module, a Kickstarter project I backed at the end of 2015. The project aimed to make working with the ESP12 easier by providing integration with particle.io. The latest firmware was release a few days ago so I think it is time to give this little device a go.

At the start of the year we came across a weather meter which allowed the measurement of rainfall, wind speed and wind direction. My wife mentioned that it might be nice to use one of these to record the weather in the garden.

And so the idea was born, weather meter, meet the Oak.

## Mapping Out The Project

After a few hours the project started to become larger than just a couple of sensors, it currently looks something like the following:

Weather Station Mind Map

I have coloured each block of concepts the same colour in order to give the project some structure. Let’s look at each block in turn and see how we can approach the problem.

### Temperature, Pressure and Humidity

Starting with the green block and five o’clock on the diagram.

Temperature, Presure and Humidity Mind Map

There are two temperatures we can measure here, air temperature and soil or ground level temperature. The air temperature will give an indication of how pleasant a day it is at the moment and the ground level sensor will give an indication of the progress of the seasons from the plants perspective. For this reason we are interested in both of these measurements.

Air pressure has long been used as a predictor for upcoming weather events.

Luckily we can get the air temperature, pressure and humidity sensor in one convenient package, the BME280. Ground level temperature will need a waterproof sensor. I think this would be best purchased as a unit rather than made so the DS18B20 with a 6 foot cable looks like it might be ideal.

### Wind and Rain

Working clockwise, the next block are the wind and rain sensors:

Wind and Rain Sensor Mind Map

All of these measurements come from the weather meter. The wind speed and rainfall sensors are simple switches that generate pulses whilst the wind direction is a resistor network.

### Light Sensor

The next block shows the two light sensors:

Light Sensor Mind Map

The two light measurements are the overall light intensity (luminosity) and ultraviolet light intensity. Luckily there are a couple of sensors for these two measurements, the TSL2561 and the ML8511.

The ultraviolet light sensor is an analogue sensor and so we will have to consider the stability of the supply voltage when making the reading.

The luminosity sensor uses a measurement window and a sensitivity setting to take a reading. This means that for given settings the sensor may be overwhelmed and simply give a maximum reading. The work around for this is to make the measurement window and sensitivity dynamic. So long, sensitive windows at night and short less sensitive windows on bright sunny days.

### Cases and Location

The next things we need to consider are cases and locations:

Case and Location Mind Map

The microcontroller and power etc. will need to be located in a case of some form. This will need to be weather proof as water and electricity are not the best of friends. It would also be a good idea to keep any batteries in an environment with a reasonably stable temperature. A little research into how the professionals house weather Stations.

The sensors on the other hand need to be outdoors in a suitable location for the measurements being taken.

### Power Supply

All of this equipment will need a stable power supply:

Power Supply Mind Map

The initial work can be done using a bench power supply but when the project moves outdoors it will need to either be mains or battery powered. The long term aim is to use a solar cell and rechargeable battery, as they say on Kickstarter, a stretch goal.

### Data Logging and Real Time Clock

Now we have collected all of this information we need to do store it somewhere:

Data Logging Mind Map

The Oak is a WiFi enabled board so the most obvious place to put the data is the cloud. It might be an idea to also provide some local storage in case the WiFi network is unavailable.

The Real Time Clock (RTC) could have two uses, to wake the microcontroller and also provide a timestamp for the data items.

## Conclusion

What started out as a simple wind and rain logging project has grown a little. The current specification is to measure and log the following readings:

1. Rainfall
2. Wind speed
3. Wind direction
4. Luminosity
5. Ultraviolet light

The measurements should be collected and reliably logged either locally or preferably to the cloud.

There are several challenges with a number of interesting problems to overcome.

Let’s get this show on the road.

### LED Board Has Arrived

Sunday, November 1st, 2015

A few weeks ago I started to work with KiCAD and put together a small LED board as a project to become familiar with the application. The boards were sent to manufacture and the the postman delivered the manufactured PCBs yesterday.

LED Board Front

LED Board Front

Time to add the components and test the boards.

Everthing looks good, the boards work OK so time to move on to the big board for the cube.

Sunday, October 25th, 2015

I have been a long time supporter of DesignSpark PCB for laying out my PCBs. Moving to the Mac meant that I had to look for an alternative or to use the PC emulator. Enter KiCad.

I needed a project in order to evaluate KiCAD, something small and inexpensive to manufacture will fit the bill. One project that needs completing is the LED cube. The 74HC595s in this project were always going to restrict the power of the cube. They have a limit of 125mW which limits either the number of LEDs that can be illuminated or the brightness of the LEDs. This can be easily overcome by either using a higher power 74HC595 or by connecting each of the LEDs to a transistor wired as a switch. The transistor as a switch idea gives some flexibility for future experimentation and so this is the direction we will take. Making this board for the cube would be expensive as it would be large, over 15cm x 15cm. A smaller version would prove the concept as well as the software.

## 8 LED Indicator Board

The 8 LED Indicator Board is a simple PCB containing all of the components that would be used in a large powered board. The board is simple, it takes a signal for each of the 8 LEDs, power and ground. Any high signals turn the transistor on and illuminates the appropriate LED. The schematic for a single switch is as follows:

Simple Transistor Switch

The board contains 8 of these switches along with connectors for the power and signals, adding seven more and some connectors gives the following:

8 Transistor Switches

The next step in the process is to convert this design to a PCB layout. Normally (with DesignSpark) I would just jump from the schematic straight to the PCB layout. With KiCAD it is necessary to perform two additional (for me) actions. The first is to annotate the components in the schematic. The second is to associate a footprint to each of the components. PCB layout can commence once this has been completed.

A few hours later:

8 LED Transistor Switch PCB Layout

There is even a 3D viewer with an impressive set of models built in:

8 LED Switch in 3D

So far, so good, the final step is to generate the gerbers, send for manufacture and wait.

## Conclusion

Moving from one software suite to another is always an interesting process. Old habits such as key strokes, menu locations etc are difficult to break. I certainly found some aspects of KiCAD a little frustrating but as ever, there is always Google.

The gerber files have been sent to manufacture. The good news is that they were accepted straight away and have been through the manufacturing process. They are currently somewhere between China and the UK. I expect to see them in about 1 week (assuming the usual delay between ordering and shipping).

There are some issues I have found with the software:

• The PCB Designer drains the battery on the Mac significantly faster than the Schematic layout tool.
• Every now and then the PCB layout tool will start to zoom in (or out) seemingly at random.
• Creating a new, empty component library is not as intuitive as it could be.

In fairness though there are some thing which I really did like:

• Schematic editor is simple to use
• Large component library
• 3D Viewer
• Easy to create new components
• It only took a week to go from nothing to gerbers

All in all, this has been a positive experience although painful at times. The only thing remaining is to see how the boards turn out.

### UDP on the ESP01 (ESP8266 Development Board)

Monday, June 1st, 2015

ESP8266 boards offer an amazing opportunity to explore the IoT world at a low cost. The boards start for as little as £5 here in the UK and come in a variety of form factors from one with only two GPIO pins to larger boards containing more GPIOs, PWM, I2C, SPI and analog capability. The boards started to become noticed around the middle of 2014 and have become more popular as the tools and documentation have matured.

Support for the boards is mainly through the online community forum. The latest documentation and SDKs can be found through the same forums.

The boards make low cost networks of sensors a possibility with the ESP8266 modules acting as either small servers or clients on your WiFi network.

The ESP8266 module is often supplied with one of two firmware version burned into the module:

1. nodeMCU – Lua interpreter
2. AT command interpreter

For the purposes of this exercise we will look at replacing the default firmware supplied with a custom application.

The SDK available from Expressif allows the developer to program the module using C. First thing to do is to install the tool chain for the module. The ESP8266 Wiki contains a host of information including instructions on setting up the tools on a variety of platforms. This whole process took about 2-3 hours on my Windows PC with another few hours to put together a template for a makefile application for Visual Studio.

Now that the development tools are in place we can start to think about the sensor network. Security is a major concern for Internet of Things (IoT) projects but this proof of concept will ignore this for the moment and rely on the WiFi encryption as the only mean of securing the data. This is a proof of concept afterall.

The applications developed here will allow data to be transmitted using UDL over the local area network.

Before starting on the ESP8266 application we should put together a simple application to receive the data from the local network. A simple .NET application on a Windows PC should do the trick:

```using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;

namespace UDPConsoleClient
{
class Program
{
static UdpClient _udpClient = new UdpClient(11000);

static void Main(string[] args)
{
Console.WriteLine("UDP Client listening on port 11000");
IPEndPoint _remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
while (true)
{
string message = Encoding.ASCII.GetString(data);
}
}
}
}
```

Create a new Windows console application on the PC and add the above code to the program.cs file. When run, this application will listen to the local network and display any UDP packets as a string to the console. Nothing special but good enough for the purposes of this experiment.

## Basic ESP8266 Application

The basic ESP8266 application works in a similar way to an Arduino application, there is an initialisation method user_init and a loop method. The loop method is slightly different from the Arduino loop in that it is added to a task queue and the developer is free to select the name of the method. A basic application looks something like this:

```#include "at_custom.h"
#include "ets_sys.h"
#include "osapi.h"
#include "gpio.h"
#include "os_type.h"
#include "mem.h"
#include "user_config.h"
#include "espconn.h"
#include "user_interface.h"

//
//  Callbacks for the OS task queue.
//

//
//
{
os_delay_us(10);
}

//
//
void ICACHE_FLASH_ATTR user_init()
{
//
//
}
```

Compiling and deploying this application will result in a module which does nothing much other than wait.

## Debugging

Unlike some of the other modules and boards discussed on this blog, the ESP8266 does not have much available in the way of debugging. Code will need to be added to the application to output debug information on GPIO pins in order to get feedback on what is going on inside the application.

The ESP01 module being used has two GPIO pins available, GPIO0 and GPIO2. We can use these to output serial data akin to SPI and then use a logic analyser to examine the application state. Adding the code below will allow us to do this.

```#define BB_DATA                     BIT0
#define BB_CLOCK                    BIT2

//
//  Initialise the GPIO pins.
//
void InitialiseGPIO()
{
gpio_init();
//
//  Set GPIO2 and GPIO0 to output mode.
//
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
}

//
//  Bit bang the data out as serial (SPI) data.
//
void BitBang(uint8 byte)
{
//
//  Set the clock and data bits to be low.
//
gpio_output_set(0, BB_DATA, BB_DATA, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
//
//  Output the data.
//
short bit;
for (bit = 7; bit >= 0; bit--)
{
if (byte & (1 << bit))
{
gpio_output_set(BB_DATA, 0, BB_DATA, 0);
}
else
{
gpio_output_set(0, BB_DATA, BB_DATA, 0);
}
gpio_output_set(BB_CLOCK, 0, BB_CLOCK, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
}
//
//  Set the clock and data bits to be low.
//
gpio_output_set(0, BB_DATA, BB_DATA, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
}
```

## Timers

For the proof of concept the application can simply generate a regular packet of data emulating the presence of sensor data. The most cost effective (in terms of power) way of doing this will be to use a timer of some sort.

```//
//  OS Timer structure holding information about the timer.
//
static volatile os_timer_t timerInformation;

//
//  Timer function called periodically - try communicating with the world.
//
void TimerCallback(void *arg)
{
BitBang(0x01);
}

//
//
void ICACHE_FLASH_ATTR user_init()
{
InitialiseGPIO();
//
//  Disarm timer.
//
os_timer_disarm(&timerInformation);
//
//  Set up timer to call the timer function.
//
os_timer_setfn(&timerInformation, (os_timer_func_t *) TimerCallback, NULL);
//
//  Arm the timer:
//      - timerInformation is the pointer to the OS Timer data structure.
//      - 1000 is the timer duration in milliseconds.
//      - 0 fire once and 1 for repeating
//
os_timer_arm(&timerInformation, 1000, 1);
//
//
}
```

Adding the above code to the basic application should generate data on GPIO0 and GPIO2 every second.

## UDP Communication & WiFi Connectivity

The last part of the puzzle is to connect the board to the local WiFi network and to start to send data across the network.

### WiFi Connection

For a basic WiFi connection where the router is providing a DHCP service then we need to let the firmware know the SSID of the network we wish to connect to and the password for the network:

```const char ssid[32] = "--- Your SSID Here ---";
struct station_config stationConf;

wifi_set_opmode(STATION_MODE);
os_memcpy(&stationConf.ssid, ssid, 32);
wifi_station_set_config(&stationConf);
```

Executing the above code will set the network parameters. The network connection is not established immediately but can take some time to become active. Network connectivity can be detected by the following code snippet:

```struct ip_info info;

wifi_get_ip_info(STATION_IF, &info);
if (wifi_station_get_connect_status() != STATION_GOT_IP || info.ip.addr == 0)
{
// Not connected yet !!!
}
```

### UDP Communication

Network communication needs a connection structure to be set up. This holds information about the network connection type, IP addresses and ports. For this exercise we are using the UDP protocol and will broadcast the data to any UDP listener on the network. The UDP broadcast address is x.y.z.255, in this case 192.168.1.255. The code to set this up is as follows:

```struct espconn *_ptrUDPServer;
uint8 udpServerIP[] = { 192, 168, 1, 255 };

//
//  Allocate an "espconn" for the UDP connection.
///
_ptrUDPServer = (struct espconn *) os_zalloc(sizeof(struct espconn));
_ptrUDPServer->type = ESPCONN_UDP;
_ptrUDPServer->state = ESPCONN_NONE;
_ptrUDPServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
_ptrUDPServer->proto.udp->local_port = espconn_port();
_ptrUDPServer->proto.udp->remote_port = 11000;
os_memcpy(_ptrUDPServer->proto.udp->remote_ip, udpServerIP, 4);
```

The application can now start to send data over the network:

```#define USER_DATA                   "ESP8266 - Data"

espconn_create(_ptrUDPServer);
espconn_sent(_ptrUDPServer, (uint8 *) USER_DATA, (uint16) strlen(USER_DATA));
espconn_delete(_ptrUDPServer);
```

The application should really perform some diagnostics in the above code in order to detect any errors and clean up where necessary.

## Putting it all Together

A little rearrangement of the snippets above is necessary in order to put together a mode elegant solution, namely:

1. Output the results of function calls to the network to the GPIO pins
2. check for network connectivity before calling the network functions

Adding these modifications to the code gives the following final solution:

```// ***************************************************************************
//
//  Basic UDP broadcast application for the ESP8266.
//
#include "at_custom.h"
#include "ets_sys.h"
#include "osapi.h"
#include "gpio.h"
#include "os_type.h"
#include "mem.h"
#include "user_config.h"
#include "espconn.h"
#include "user_interface.h"

#define USER_DATA                   "ESP8266 - Data"
#define BB_DATA                     BIT0
#define BB_CLOCK                    BIT2

//
//  Callbacks for the OS task queue.
//
struct espconn *_ptrUDPServer;
uint8 udpServerIP[] = { 192, 168, 1, 255 };

// ***************************************************************************
//
//  Forward declarations.
//

//
//  OS Timer structure holding information about the timer.
//
static volatile os_timer_t timerInformation;

//
//  Initialise the GPIO subsystem.
//
void InitialiseGPIO()
{
gpio_init();
//
//  Set GPIO2 and GPIO0 to output mode.
//
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
}

//
//  Bit bang the data out as serial (SPI-like) data.
//
void BitBang(uint8 byte)
{
//
//  Set the clock and data bits to be low.
//
gpio_output_set(0, BB_DATA, BB_DATA, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
//
//  Output the data.
//
short bit;
for (bit = 7; bit >= 0; bit--)
{
if (byte & (1 << bit))
{
gpio_output_set(BB_DATA, 0, BB_DATA, 0);
}
else
{
gpio_output_set(0, BB_DATA, BB_DATA, 0);
}
gpio_output_set(BB_CLOCK, 0, BB_CLOCK, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
}
//
//  Set the clock and data bits to be low.
//
gpio_output_set(0, BB_DATA, BB_DATA, 0);
gpio_output_set(0, BB_CLOCK, BB_CLOCK, 0);
}

//
//  Timer function called periodically - try communicating with the world.
//
void TimerCallback(void *arg)
{
struct ip_info info;

wifi_get_ip_info(STATION_IF, &info);
if (wifi_station_get_connect_status() != STATION_GOT_IP || info.ip.addr == 0)
{
BitBang(0x01);
}
else
{
BitBang(0x02);
BitBang(espconn_create(_ptrUDPServer));
BitBang(0x03);
BitBang(espconn_sent(_ptrUDPServer, (uint8 *) USER_DATA, (uint16) strlen(USER_DATA)));
BitBang(0x04);
BitBang(espconn_delete(_ptrUDPServer));
BitBang(0x05);
}
}

//
//
{
os_delay_us(10);
}

//
//
void ICACHE_FLASH_ATTR user_init()
{
at_init();
InitialiseGPIO();
//
//  Disarm timer.
//
os_timer_disarm(&timerInformation);
//
//  Start the network connection.
//
const char ssid[32] = "--- Your SSID Here ---";
struct station_config stationConf;

wifi_set_opmode(STATION_MODE);
os_memcpy(&stationConf.ssid, ssid, 32);
wifi_station_set_config(&stationConf);
//
//  Allocate an "espconn" for the UDP connection.
///
_ptrUDPServer = (struct espconn *) os_zalloc(sizeof(struct espconn));
_ptrUDPServer->type = ESPCONN_UDP;
_ptrUDPServer->state = ESPCONN_NONE;
_ptrUDPServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
_ptrUDPServer->proto.udp->local_port = espconn_port();
_ptrUDPServer->proto.udp->remote_port = 11000;
os_memcpy(_ptrUDPServer->proto.udp->remote_ip, udpServerIP, 4);
//
//  Setup timer to call the timer function.
//
os_timer_setfn(&timerInformation, (os_timer_func_t *) TimerCallback, NULL);
//
//  Arm the timer:
//      - timerInformation is the pointer to the OS Timer data structure.
//      - 1000 is the timer duration in milliseconds.
//      - 0 fire once and 1 for repeating
//
os_timer_arm(&timerInformation, 1000, 1);
//
//
}
```

Compiling and deploying this application to the ESP01 generates regular (1 second intervals) messages on the console application at the start of this post.

## Conclusion

The journey with the ESP8266 has just started but it looks promising. The initial set up was not a simple as I would have liked as there are a number of parts all of which need to be brought together in order for the development cycle to start. Once these are all in place then coding is relatively easy even though there is little documentation. The community which is developing is certainly helping in this process.

On the whole this chipset offers an interesting opportunity especially with the like of Adafruit developing the Huzzah DIP friendly ESP12 board which has now received the appropriate certification for commercial WiFi use.

### STM8S I2C Slave Device

Sunday, May 24th, 2015

Having succeeded at getting a basic I2C master working on the STM8S it is not time to start to look at I2C slave devices on the STM8S.

The project will be a simple one, the STM8S will take a stream of bytes and perform simple addition. When requested, the STM8S will return the total as a 16-bit integer. Each new write request will clear the current total and start the whole process again.

Simple enough so let’s get started.

This post is a fairly long as it contains a lot of code so it might be a good time to grab a beer and settle down.

The slave adder is a simple device running over I2C. The devices has the following properties:

1. Acts as an I2C slave device with address 0x50
2. I2C bus speed is 50 KHz
3. Upon receiving a valid start condition and address for a write operation the device will clear the current total.
4. Bytes written to the device will be summed and a running total kept.
5. A start condition with a valid address for a read operation will return the current total as a 16-bit integer, MSB first.

A Netduino 3 will be used as the I2C bus master device. This runs the .NET Microframework and has an implementation of the I2C protocol built into the framework. This gives a good reference point for the master device i.e. someone else has debugged that so we can assume that the device is working as per the protocol specification.

As mentioned in the previous article on I2C Master devices, there is a really good article about the I2C protocol on Wikipedia. If you want more information about the protocol then I suggest you head over there.

### Netduino Code

The initial version of the I2C master device will simply send two bytes of data for the I2C slave device to sum. The code is simple enough:

```using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

namespace I2CMaster
{
public class Program
{
public static void Main()
{
//
//  Create a new I2C object on address 0x50 with the clock running at 50 KHz.
//
I2CDevice i2cBus = new I2CDevice(new I2CDevice.Configuration(0x50, 50));
//
//  Create a transaction to write two bytes of data to the I2C bus.
//
byte[] buffer = { 1, 2 };
I2CDevice.I2CTransaction[] transactions = new I2CDevice.I2CTransaction[1];
transactions[0] = I2CDevice.CreateWriteTransaction(buffer);
while (true)
{
}
}
}
}
```

The above application creates a new instance of the I2CDevice with a device address of )x50 and a clock frequency of 50 KHz. A single transaction is created and the master writes the same two bytes to the I2C bus every second.

### STM8S Code

As with the I2C Master article, much of the action happens in two places:

1. I2C device initialisation method
2. I2C Interrupt Service Routine (ISR)

The initialisation method sets up the I2C peripheral on the STM8S and enters the waiting state, waiting for the master to put data onto the I2C bus.

The ISR will deal with the actual data processing and in a full application it will also deal with any error conditions that may arise.

### I2C Initialisation

The initialisation method sets up the I2C bus by performing the following tasks:

1. Setting the expected clock frequency
3. Turning the interrupts on

The I2C peripheral must be disabled before configuring certain aspects of the peripheral, namely clock speeds:

```I2C_CR1_PE = 0;
```

The peripheral needs to know the current master clock frequency, the I2C mode (Standard or Fast) and the clock divider values. These must all be configured whilst the peripheral is disabled.

```I2C_FREQR = 16;                     //  Set the internal clock frequency (MHz).
I2C_CCRH_F_S = 0;                   //  I2C running is standard mode.
I2C_CCRL = 0xa0;                    //  SCL clock speed is 50 KHz.
I2C_CCRH_CCR = 0x00;
```

The device assumes that we will be using the standard 16 MHz clock speed which has been used in the other tutorials in this series. This is indicated by the I2C_FREQR register.

The values for the clock control register (I2C_CCRL and I2C_CCRH_CCR were simply taken from the STM8S programming reference manual. There is no coincidence that a bus speed of 50 KHz was chose, it is simply one of the reference values in the table. No point in creating work if you do not have to. If you want different speeds then you can either use one of the defined values in the remainder of the table or use the formulae provided.

The next step is to define the device address and addressing mode. I2C allows both 7 and 10 bit addressing modes. For simplicity this device will use a 7-bit device address:

```I2C_OARH_ADDMODE = 0;               //  7 bit address mode.
I2C_OARH_ADDCONF = 1;               //  Docs say this must always be 1.
```

The device also allows for the maximum rise time to be configured. This example uses 17uS as the maximum time:

```I2C_TRISER = 17;
```

The I2C peripheral allows for three different interrupt conditions to be defined, buffer interrupts, event interrupts (start condition etc.) and error interrupts. For convenience we will turn all of these on:

```I2C_ITR_ITBUFEN = 1;                //  Buffer interrupt enabled.
I2C_ITR_ITEVTEN = 1;                //  Event interrupt enabled.
I2C_ITR_ITERREN = 1;
```

Now that the peripheral is configured we need to re-enable it:

```I2C_CR1_PE = 1;
```

The last bit of initialisation is to configure the device to return an ACK after each byte:

```I2C_CR2_ACK = 1;
```

At this point the I2C peripheral should be listening to the I2C bus for a start condition and the address 0x50.

### I2C Interrupt Service Routine (ISR)

The ISR contains the code which processes the data and error conditions for the I2C peripheral. All of the I2C events share the same ISR and the ISR will need to interrogate the status registers in order to determine the exact reason for the interrupt.

Starting with an empty ISR we have the following code:

```#pragma vector = I2C_RXNE_vector
__interrupt void I2C_IRQHandler()
{
}
```

There are several other vector names we could have chosen, they all contain the same value and the value I2C_RXNE_vector was chosen arbitrarily.

Assuming that there are no errors on the bus, the I2C master code above will cause the following events to be generated:

This initial simple implementation can use these two events to clear the total when a new Start condition is received and add the current byte to the total when data is received.

```if (I2C_SR1_ADDR)
{
//
//  In master mode, the address has been sent to the slave.
//  Clear the status registers and wait for some data from the salve.
//
reg = I2C_SR1;
reg = I2C_SR3;
_total = 0;                 // New addition so clear the total.
return;
}
```

I2C_SR1_ADDR should be set when an address is detected on the bus which matches the address currently in the address registers. As a starter application the code can simply assume that any address is going to be a write condition. The code can clear the totals and get ready to receive data. Note that this will be expanded later to take into consideration the fact that the master can perform both read and write operations.

The next event we need to consider is the receipt of data from the master. This will trigger the Receive Buffer Not Empty interrupt. This simple application should just read the buffer and add the current byte to the running total:

```if (I2C_SR1_RXNE)
{
//
//  Received a new byte of data so add to the running total.
//
_total += I2C_DR;
return;
}
```

As indicated earlier, the I2C ISR is a generic ISRT and is triggered for all I2C events. The initialisation code above has turned on the error interrupts as well as the data capture interrupts. Whilst none of the code in this article will handle error conditions, the ISR will output the status registers for diagnostic purposes:

```PIN_ERROR = 1;
__no_operation();
PIN_ERROR = 0;
reg = I2C_SR1;
BitBang(reg);
reg = I2C_SR3;
BitBang(reg);
```

This will of course require suitable definitions and support methods.

Putting this all together gives an initial implementation of a slave device as:

```//
//  This application demonstrates the principles behind developing an
//  I2C slave device on the STM8S microcontroller.  The application
//  will total the byte values written to it and then send the total
//  to the master when the device is read.
//
//  This software is provided under the CC BY-SA 3.0 licence.  A
//  copy of this licence can be found at:
//
//
#if defined DISCOVERY
#include <iostm8S105c6.h>
#else
#include <iostm8s103f3.h>
#endif
#include <intrinsics.h>

//
//  Define some pins to output diagnostic data.
//
#define PIN_BIT_BANG_DATA       PD_ODR_ODR4
#define PIN_BIT_BANG_CLOCK      PD_ODR_ODR5
#define PIN_ERROR               PD_ODR_ODR6

//
//  Somewhere to hold the sum.
//
int _total;

//
//  Bit bang data on the diagnostic pins.
//
void BitBang(unsigned char byte)
{
for (short bit = 7; bit >= 0; bit--)
{
if (byte & (1 << bit))
{
PIN_BIT_BANG_DATA = 1;
}
else
{
PIN_BIT_BANG_DATA = 0;
}
PIN_BIT_BANG_CLOCK = 1;
__no_operation();
PIN_BIT_BANG_CLOCK = 0;
}
PIN_BIT_BANG_DATA = 0;
}

//
//  Set up the system clock to run at 16MHz using the internal oscillator.
//
void InitialiseSystemClock()
{
CLK_ICKR = 0;                       //  Reset the Internal Clock Register.
CLK_ICKR_HSIEN = 1;                 //  Enable the HSI.
CLK_ECKR = 0;                       //  Disable the external clock.
while (CLK_ICKR_HSIRDY == 0);       //  Wait for the HSI to be ready for use.
CLK_CKDIVR = 0;                     //  Ensure the clocks are running at full speed.
CLK_PCKENR1 = 0xff;                 //  Enable all peripheral clocks.
CLK_PCKENR2 = 0xff;                 //  Ditto.
CLK_CCOR = 0;                       //  Turn off CCO.
CLK_HSITRIMR = 0;                   //  Turn off any HSIU trimming.
CLK_SWIMCCR = 0;                    //  Set SWIM to run at clock / 2.
CLK_SWR = 0xe1;                     //  Use HSI as the clock source.
CLK_SWCR = 0;                       //  Reset the clock switch control register.
CLK_SWCR_SWEN = 1;                  //  Enable switching.
while (CLK_SWCR_SWBSY != 0);        //  Pause while the clock switch is busy.
}

//
//  Initialise the I2C system.
//
void InitialiseI2C()
{
I2C_CR1_PE = 0;                     //  Disable I2C before configuration starts.
//
//  Set up the clock information.
//
I2C_FREQR = 16;                     //  Set the internal clock frequency (MHz).
I2C_CCRH_F_S = 0;                   //  I2C running is standard mode.
I2C_CCRL = 0xa0;                    //  SCL clock speed is 50 KHz.
I2C_CCRH_CCR = 0x00;
//
//  Set the address of this device.
//
I2C_OARH_ADDCONF = 1;               //  Docs say this must always be 1.
//
//  Set up the bus characteristics.
//
I2C_TRISER = 17;
//
//  Turn on the interrupts.
//
I2C_ITR_ITBUFEN = 1;                //  Buffer interrupt enabled.
I2C_ITR_ITEVTEN = 1;                //  Event interrupt enabled.
I2C_ITR_ITERREN = 1;
//
//  Configuration complete so turn the peripheral on.
//
I2C_CR1_PE = 1;
//
//  Acknowledge each byte with an ACK signal.
//
I2C_CR2_ACK = 1;
}

//
//  I2C interrupts all share the same handler.
//
#pragma vector = I2C_RXNE_vector
__interrupt void I2C_IRQHandler()
{
unsigned char reg;

{
//
//  Clear the status registers and wait for some data from the salve.
//
reg = I2C_SR1;
reg = I2C_SR3;
_total = 0;                 // New addition so clear the total.
return;
}
if (I2C_SR1_RXNE)
{
//
//  Received a new byte of data so add to the running total.
//
_total += I2C_DR;
return;
}
//
//  Send a diagnostic signal to indicate we have cleared
//  the error condition.
//
PIN_ERROR = 1;
__no_operation();
PIN_ERROR = 0;
//
//  If we get here then we have an error so clear
//  the error, output the status registers and continue.
//
reg = I2C_SR1;
BitBang(reg);
reg = I2C_SR3;
BitBang(reg);
}

//
//  Main program loop.
//
int main()
{
_total = 0;
__disable_interrupt();
//
//  Initialise Port D.
//
PD_ODR = 0;             //  All pins are turned off.
PD_DDR_DDR4 = 1;        //  Port D, bit 4 is output.
PD_CR1_C14 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C24 = 1;         //  Pin can run up to 10 MHz.
//
PD_DDR_DDR5 = 1;        //  Port D, bit 5 is output.
PD_CR1_C15 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C25 = 1;         //  Pin can run up to 10 MHz.
//
PD_DDR_DDR6 = 1;        //  Port D, bit 6 is output.
PD_CR1_C16 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C26 = 1;         //  Pin can run up to 10 MHz.
//
InitialiseSystemClock();
InitialiseI2C();
__enable_interrupt();
while (1)
{
__wait_for_interrupt();
}
}
```

### Executing the Applications

At this stage a quick test with the two devices connected and the logic analyser will show the master device outputting data to the I2C bus. The correct operation of the I2C salve device can be verified by setting break points with in the two if statements in the ISR. Note that this will generate some errors but it is good enough to verify that the ISRs are being triggered correctly.

STM8 I2C Write Condition

The above shows the output from the Saleae Logic Analyser when the write transaction is sent to the bus by the Netduino.

## Reading and Writing with I2C Slaves

At this point the above code should be accepting data from the Netduino 3. It is now time to expand the code to take into account the requirement to read back data from the slave device.

### Netduino Code

The Netduino code will need to be modified to generate both a write transaction to send data to the I2C slave device and a read transaction to retrieve the results from the calculation.

```using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

namespace I2CMaster
{
public class Program
{
public static void Main()
{
//
//  Create a new I2C object on address 0x50 with the clock running at 50 KHz.
//
I2CDevice i2cBus = new I2CDevice(new I2CDevice.Configuration(0x50, 50));
//
//  Create a transaction to write two bytes of data to the I2C bus.
//
byte[] buffer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
byte[] resultBuffer = new byte[2];
I2CDevice.I2CTransaction[] transactions = new I2CDevice.I2CTransaction[2];
transactions[0] = I2CDevice.CreateWriteTransaction(buffer);
while (true)
{
}
}
}
}
```

The transaction array has been expanded to contain a second transaction to read the data from the device. The data to be summed has also been expanded to include a further eight elements.

### STM8S Code

A state machine will be used to allow the STM8S to work out what action should be taken within the ISR. This is required as the i”c peripheral will generate an event for the address detection for both the write transaction and the read transaction. The application will need to be able to differentiate between the two conditions as one requires the total to be cleared, the other requires that the total is sent back to the master device.

The state machine contains the following states:

1. Waiting for a write condition to start
2. Adding data to the running total
3. Sending the MSB of the total
4. Sending the LSB of the total

This is represented in code by an enum and a global variable:

```typedef enum
{
ISWaiting,                    //  Waiting for comms to start.
ISSendingMSB,                 //  Sending MSB of total.
ISSendingLSB                  //  Sending LSB of total.
} I2CStateType;
I2CStateType _i2cState;
```

The ISR will need to be changed in order to deal with the state machine and also handle the slave transmitting data to the master device. The first change is to the address detection. This assumes that the main program loop initialises the state to ISWaiting:

```if (I2C_SR1_ADDR)
{
//
//
if (_i2cState == ISWaiting)
{
_total = 0;             // New addition so clear the total.
}
reg = I2C_SR1;
reg = I2C_SR3;
return;
}
```

The code above works out if the application is waiting for the first write condition (IsWaiting) or if the address detection has been triggered by a read condition (any other state).

Next, any other data reception is assumed to be data to be added to the total. The state is changed to IsAdding just in case:

```if (I2C_SR1_RXNE)
{
//
//  Receiving data from the master so we must be adding.
//
_total += I2C_DR;
return;
}
```

Next we have two new conditions we have not considered so far, the first is the fact that we need to transmit the result to the master. The request from the client will trigger a Transmit Buffer Empty event:

```if (I2C_SR1_TXE)
{
{
I2C_DR = (_total >> 8) & 0xff;
_i2cState = ISSendingMSB;
}
else
{
I2C_DR = _total & 0xff;
_i2cState = ISSendingLSB;
}
return;
}
```

The master is asking for two bytes and the application needs to track if we are transmitting the most significant byte (MSB) or least significant byte (LSB).

The next new condition is the acknowledge event. This is generated at the end of the master read operation. This will set the system back into a waiting condition:

```if (I2C_SR2_AF)
{
I2C_SR2_AF = 0;             //  End of slave transmission.
_i2cState = ISWaiting;
return;
}
```

The full application becomes:

```//
//  This application demonstrates the principles behind developing an
//  I2C slave device on the STM8S microcontroller.  The application
//  will total the byte values written to it and then send the total
//  to the master when the device is read.
//
//  This software is provided under the CC BY-SA 3.0 licence.  A
//  copy of this licence can be found at:
//
//
#if defined DISCOVERY
#include <iostm8S105c6.h>
#else
#include <iostm8s103f3.h>
#endif
#include <intrinsics.h>

//
//  Define some pins to output diagnostic data.
//
#define PIN_BIT_BANG_DATA       PD_ODR_ODR4
#define PIN_BIT_BANG_CLOCK      PD_ODR_ODR5
#define PIN_ERROR               PD_ODR_ODR6

//
//  State machine for the I2C communications.
//
typedef enum
{
ISWaiting,                    //  Waiting for comms to start.
ISSendingMSB,                 //  Sending MSB of total.
ISSendingLSB                  //  Sending LSB of total.
} I2CStateType;
I2CStateType _i2cState;

//
//  Somewhere to hold the sum.
//
int _total;

//
//  Bit bang data on the diagnostic pins.
//
void BitBang(unsigned char byte)
{
for (short bit = 7; bit >= 0; bit--)
{
if (byte & (1 << bit))
{
PIN_BIT_BANG_DATA = 1;
}
else
{
PIN_BIT_BANG_DATA = 0;
}
PIN_BIT_BANG_CLOCK = 1;
__no_operation();
PIN_BIT_BANG_CLOCK = 0;
}
PIN_BIT_BANG_DATA = 0;
}

//
//  Set up the system clock to run at 16MHz using the internal oscillator.
//
void InitialiseSystemClock()
{
CLK_ICKR = 0;                       //  Reset the Internal Clock Register.
CLK_ICKR_HSIEN = 1;                 //  Enable the HSI.
CLK_ECKR = 0;                       //  Disable the external clock.
while (CLK_ICKR_HSIRDY == 0);       //  Wait for the HSI to be ready for use.
CLK_CKDIVR = 0;                     //  Ensure the clocks are running at full speed.
CLK_PCKENR1 = 0xff;                 //  Enable all peripheral clocks.
CLK_PCKENR2 = 0xff;                 //  Ditto.
CLK_CCOR = 0;                       //  Turn off CCO.
CLK_HSITRIMR = 0;                   //  Turn off any HSIU trimming.
CLK_SWIMCCR = 0;                    //  Set SWIM to run at clock / 2.
CLK_SWR = 0xe1;                     //  Use HSI as the clock source.
CLK_SWCR = 0;                       //  Reset the clock switch control register.
CLK_SWCR_SWEN = 1;                  //  Enable switching.
while (CLK_SWCR_SWBSY != 0);        //  Pause while the clock switch is busy.
}

//
//  Set up Port D GPIO for diagnostics.
//
void InitialisePortD()
{
PD_ODR = 0;             //  All pins are turned off.
PD_DDR_DDR4 = 1;        //  Port D, bit 4 is output.
PD_CR1_C14 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C24 = 1;         //  Pin can run up to 10 MHz.
//
PD_DDR_DDR5 = 1;        //  Port D, bit 5 is output.
PD_CR1_C15 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C25 = 1;         //  Pin can run up to 10 MHz.
//
PD_DDR_DDR6 = 1;        //  Port D, bit 6 is output.
PD_CR1_C16 = 1;         //  Pin is set to Push-Pull mode.
PD_CR2_C26 = 1;         //  Pin can run up to 10 MHz.
}

//
//  Initialise the I2C system.
//
void InitialiseI2C()
{
I2C_CR1_PE = 0;                     //  Disable I2C before configuration starts.
//
//  Set up the clock information.
//
I2C_FREQR = 16;                     //  Set the internal clock frequency (MHz).
I2C_CCRH_F_S = 0;                   //  I2C running is standard mode.
I2C_CCRL = 0xa0;                    //  SCL clock speed is 50 KHz.
I2C_CCRH_CCR = 0x00;
//
//  Set the address of this device.
//
I2C_OARH_ADDCONF = 1;               //  Docs say this must always be 1.
//
//  Set up the bus characteristics.
//
I2C_TRISER = 17;
//
//  Turn on the interrupts.
//
I2C_ITR_ITBUFEN = 1;                //  Buffer interrupt enabled.
I2C_ITR_ITEVTEN = 1;                //  Event interrupt enabled.
I2C_ITR_ITERREN = 1;
//
//  Configuration complete so turn the peripheral on.
//
I2C_CR1_PE = 1;
//
//  Set the acknowledge to be ACK.
//
I2C_CR2_ACK = 1;
}

//
//  I2C interrupts all share the same handler.
//
#pragma vector = I2C_RXNE_vector
__interrupt void I2C_IRQHandler()
{
unsigned char reg;

{
//
//
if (_i2cState == ISWaiting)
{
_total = 0;             // New addition so clear the total.
}
reg = I2C_SR1;
reg = I2C_SR3;
return;
}
if (I2C_SR1_RXNE)
{
//
//  Receiving data from the master so we must be adding.
//
_total += I2C_DR;
return;
}
if (I2C_SR1_TXE)
{
{
I2C_DR = (_total >> 8) & 0xff;
_i2cState = ISSendingMSB;
}
else
{
I2C_DR = _total & 0xff;
_i2cState = ISSendingLSB;
}
return;
}
if (I2C_SR2_AF)
{
I2C_SR2_AF = 0;             //  End of slave transmission.
_i2cState = ISWaiting;
return;
}
//
//  Send a diagnostic signal to indicate we have cleared
//  the error condition.
//
PIN_ERROR = 1;
__no_operation();
PIN_ERROR = 0;
//
//  If we get here then we have an error so clear
//  the error, output the status registers and continue.
//
reg = I2C_SR1;
BitBang(reg);
BitBang(I2C_SR2);
reg = I2C_SR3;
BitBang(reg);
}

//
//  Main program loop.
//
int main()
{
_total = 0;
_i2cState = ISWaiting;
__disable_interrupt();
InitialisePortD();
InitialiseSystemClock();
InitialiseI2C();
__enable_interrupt();
while (1)
{
__wait_for_interrupt();
}
}
```

The above two pieces of code are fuller applications and if we execute these and hook up the logic anayser to the I2C bus we see the following output:

The I2C protocol allows for one or more devices with different slave addresses to be connected to the same I2C bus. The previous article used the TMP102 temperature sensor with slave address 0x48 and this article has created a slave device with address 0x50. It should therefore be possible to connect the two devices to the same bus and talk to each selectively.

### Netduino Application

As with the previous examples, the Netduino 3 will be used as the I2C bus master. The applicaiton above will need to be merged with the code in the previous article.

```using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

namespace I2CMaster
{
public class Program
{
public static void Main()
{
//
//  Create a new I2C object and the configurations for the STM8S and the TMP102.
//
I2CDevice.Configuration stm8s = new I2CDevice.Configuration(0x50, 50);
I2CDevice.Configuration tmp102 = new I2CDevice.Configuration(0x48, 50);
I2CDevice i2cBus = new I2CDevice(stm8s);
//
//  Create a transaction to write several bytes of data to the I2C bus.
//
byte[] buffer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
byte[] resultBuffer = new byte[2];
I2CDevice.I2CTransaction[] transactions = new I2CDevice.I2CTransaction[2];
transactions[0] = I2CDevice.CreateWriteTransaction(buffer);
//
//  Create a transaction to read two bytes of data from the TMP102 sensor.
//
byte[] temperatureBuffer = new byte[2];
while (true)
{
//
//  Read data from the I2C bus.
//
i2cBus.Config = stm8s;
i2cBus.Config = tmp102;
//
//
int sensorReading = ((temperatureBuffer[0] << 8) | temperatureBuffer[1]) >> 4;
double fahrenheit = centigrade * 1.8 + 32;
//
//  Display the readings in the debug window and pause before repeating.
//
Debug.Print(centigrade.ToString() + " C / " + fahrenheit.ToString() + " F");
//
//  Now display the results of the addition.
//
string message = "";
for (int index = 0; index < buffer.Length; index++)
{
message += buffer[index].ToString();
if (index == (buffer.Length - 1))
{
message += " = " + ((resultBuffer[0] * 256) + resultBuffer[1]).ToString();
}
else
{
message += " + ";
}
}
Debug.Print(message);
}
}
}
}
```

The above code creates two I2C configuration object, one for the TMP102 and one for the STM8S device. The I2C bus object has the configuration changed depending upon which device is required.

### Wiring up the Devices

Firstly, wire up the TMP102 sensor as described in the article on I2C master devices. The SDA and SCK lines should be connected to 3.3V via 4K7 resistors. Next connect the SDA and SCK lines from the STM8S device to the same point as SDA and SCK lines from the TMP102 sensor. Throw in the logic analyser connections and you get something like this:

TMP102 and STM8S I2C slave devices

### Running the Application

Running the above two applications and starting the logic analyser generated the following output: