If you have any problems on my site, please send an email to

The main bug was that I’d forgotten to close the i2c file at the end of bmp085_ReadUP() – This shouldn’t have caused any problems if you were calling the function once per execution, but if calling it multiple times, it may crash. On the same note, if you are calling the functions multiple times, you may want to move the opening and closing of the i2c file outside of the functions so the files aren’t opened and closed multiple times. Thanks to Radu P for reporting these issues.

It looks like lm-sensors.org is back up now, but if not, you can find a locally hosted copy of smbus.c and smbus.h in this earlier blog post.

Note that I’ve written a number of posts on using this sensor. Here is a link to all posts on the topic.

Click here for the updated source (testBMP085.c).

testBMP085.c

/*
Raspberry Pi Bosch BMP085 communication code.
By:      John Burns (www.john.geek.nz)
Date:    13 February 2013
License: CC BY-SA v3.0 - http://creativecommons.org/licenses/by-sa/3.0/

This is a derivative work based on:
	BMP085 Extended Example Code
	by: Jim Lindblom
	SparkFun Electronics
	date: 1/18/11
	license: CC BY-SA v3.0 - http://creativecommons.org/licenses/by-sa/3.0/
	Source: http://www.sparkfun.com/tutorial/Barometric/BMP085_Example_Code.pde

Compile with: gcc -Wall -o testBMP085 ./smbus.c ./testBMP085.c


Circuit detail:
	Using a Spark Fun Barometric Pressure Sensor - BMP085 breakout board
	link: https://www.sparkfun.com/products/9694
	This comes with pull up resistors already on the i2c lines.
	BMP085 pins below are as marked on the Sparkfun BMP085 Breakout board

	SDA	- 	P1-03 / IC20-SDA
	SCL	- 	P1-05 / IC20_SCL
	XCLR	- 	Not Connected
	EOC	-	Not Connected
	GND	-	P1-06 / GND
	VCC	- 	P1-01 / 3.3V
	
	Note: Make sure you use P1-01 / 3.3V NOT the 5V pin.
*/

#include <stdio.h>
#include <stdint.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/i2c-dev.h>
#include <linux/i2c.h>
#include <sys/ioctl.h>
#include "smbus.h" 

#define BMP085_I2C_ADDRESS 0x77

const unsigned char BMP085_OVERSAMPLING_SETTING = 3;

// Calibration values - These are stored in the BMP085
short int ac1;
short int ac2; 
short int ac3; 
unsigned short int ac4;
unsigned short int ac5;
unsigned short int ac6;
short int b1; 
short int b2;
short int mb;
short int mc;
short int md;

int b5; 

unsigned int temperature, pressure;


// Open a connection to the bmp085
// Returns a file id
int bmp085_i2c_Begin()
{
	int fd;
	char *fileName = "/dev/i2c-0";
	
	// Open port for reading and writing
	if ((fd = open(fileName, O_RDWR)) < 0)
		exit(1);
	
	// Set the port options and set the address of the device
	if (ioctl(fd, I2C_SLAVE, BMP085_I2C_ADDRESS) < 0) {					
		close(fd);
		exit(1);
	}

	return fd;
}

// Read two words from the BMP085 and supply it as a 16 bit integer
__s32 bmp085_i2c_Read_Int(int fd, __u8 address)
{
	__s32 res = i2c_smbus_read_word_data(fd, address);
	if (res < 0) {
		close(fd);
		exit(1);
	}

	// Convert result to 16 bits and swap bytes
	res = ((res<<8) & 0xFF00) | ((res>>8) & 0xFF);

	return res;
}

//Write a byte to the BMP085
void bmp085_i2c_Write_Byte(int fd, __u8 address, __u8 value)
{
	if (i2c_smbus_write_byte_data(fd, address, value) < 0) {
		close(fd);
		exit(1);
	}
}

// Read a block of data BMP085
void bmp085_i2c_Read_Block(int fd, __u8 address, __u8 length, __u8 *values)
{
	if(i2c_smbus_read_i2c_block_data(fd, address,length,values)<0) {
		close(fd);
		exit(1);
	}
}


void bmp085_Calibration()
{
	int fd = bmp085_i2c_Begin();
	ac1 = bmp085_i2c_Read_Int(fd,0xAA);
	ac2 = bmp085_i2c_Read_Int(fd,0xAC);
	ac3 = bmp085_i2c_Read_Int(fd,0xAE);
	ac4 = bmp085_i2c_Read_Int(fd,0xB0);
	ac5 = bmp085_i2c_Read_Int(fd,0xB2);
	ac6 = bmp085_i2c_Read_Int(fd,0xB4);
	b1 = bmp085_i2c_Read_Int(fd,0xB6);
	b2 = bmp085_i2c_Read_Int(fd,0xB8);
	mb = bmp085_i2c_Read_Int(fd,0xBA);
	mc = bmp085_i2c_Read_Int(fd,0xBC);
	md = bmp085_i2c_Read_Int(fd,0xBE);
	close(fd);
}

// Read the uncompensated temperature value
unsigned int bmp085_ReadUT()
{
	unsigned int ut = 0;
	int fd = bmp085_i2c_Begin();

	// Write 0x2E into Register 0xF4
	// This requests a temperature reading
	bmp085_i2c_Write_Byte(fd,0xF4,0x2E);
	
	// Wait at least 4.5ms
	usleep(5000);

	// Read the two byte result from address 0xF6
	ut = bmp085_i2c_Read_Int(fd,0xF6);

	// Close the i2c file
	close (fd);
	
	return ut;
}

// Read the uncompensated pressure value
unsigned int bmp085_ReadUP()
{
	unsigned int up = 0;
	int fd = bmp085_i2c_Begin();

	// Write 0x34+(BMP085_OVERSAMPLING_SETTING<<6) into register 0xF4
	// Request a pressure reading w/ oversampling setting
	bmp085_i2c_Write_Byte(fd,0xF4,0x34 + (BMP085_OVERSAMPLING_SETTING<<6));

	// Wait for conversion, delay time dependent on oversampling setting
	usleep((2 + (3<<BMP085_OVERSAMPLING_SETTING)) * 1000);

	// Read the three byte result from 0xF6
	// 0xF6 = MSB, 0xF7 = LSB and 0xF8 = XLSB
	__u8 values[3];
	bmp085_i2c_Read_Block(fd, 0xF6, 3, values);

	up = (((unsigned int) values[0] << 16) | ((unsigned int) values[1] << 8) | (unsigned int) values[2]) >> (8-BMP085_OVERSAMPLING_SETTING);

	// Close the i2c file
	close (fd);
	
	return up;
}

// Calculate pressure given uncalibrated pressure
// Value returned will be in units of Pa
unsigned int bmp085_GetPressure(unsigned int up)
{
	int x1, x2, x3, b3, b6, p;
	unsigned int b4, b7;
  
	b6 = b5 - 4000;
	// Calculate B3
	x1 = (b2 * (b6 * b6)>>12)>>11;
	x2 = (ac2 * b6)>>11;
	x3 = x1 + x2;
	b3 = (((((int)ac1)*4 + x3)<<BMP085_OVERSAMPLING_SETTING) + 2)>>2;
  
	// Calculate B4
	x1 = (ac3 * b6)>>13;
	x2 = (b1 * ((b6 * b6)>>12))>>16;
	x3 = ((x1 + x2) + 2)>>2;
	b4 = (ac4 * (unsigned int)(x3 + 32768))>>15;
  
	b7 = ((unsigned int)(up - b3) * (50000>>BMP085_OVERSAMPLING_SETTING));
	if (b7 < 0x80000000)
		p = (b7<<1)/b4;
	else
		p = (b7/b4)<<1;
	
	x1 = (p>>8) * (p>>8);
	x1 = (x1 * 3038)>>16;
	x2 = (-7357 * p)>>16;
	p += (x1 + x2 + 3791)>>4;
  
	return p;
}

// Calculate temperature given uncalibrated temperature
// Value returned will be in units of 0.1 deg C
unsigned int bmp085_GetTemperature(unsigned int ut)
{
	int x1, x2;
  
	x1 = (((int)ut - (int)ac6)*(int)ac5) >> 15;
	x2 = ((int)mc << 11)/(x1 + md);
	b5 = x1 + x2;

	unsigned int result = ((b5 + 8)>>4);  

	return result;
}

int main(int argc, char **argv)
{
	bmp085_Calibration();
	temperature = bmp085_GetTemperature(bmp085_ReadUT());
	pressure = bmp085_GetPressure(bmp085_ReadUP());
	
	printf("Temperature\t%0.1f%cC\n", ((double)temperature)/10,0x00B0);
	printf("Pressure\t%0.2fhPa\n", ((double)pressure)/100);
	return 0;
}

I decided it was time to add a water meter into the circuit to be able to monitor our water usage.

I picked up an Elster S100 water meter complete with an electronic Pulse output.

The meter outputs one pulse per Litre of water. It’s only a two wire output so it appears to be a simple switched output such as that from a reed switch, but I’ll need to check before committing to any specific circuit design.

I’ll Probably use an Atmel AVR Microcontroller to count the pulses. The AVR will be setup as an SPI Slave to talk to a Raspberry Pi. I should have a better idea how best to implement it soon.

If you need smbus.c or smbus.h, here are copies from back in August 2012.

Note that I have made some changes to smbus.c:

• Defined NULL
• Changed the path for including smbus.h

Here are the two files:

• smbus.c
• smbus.h

Please see my previous post for general information, but use the code here.

The list of changes are:

• Added Dewpoint calculation from Page 9 of Datasheet
• Updated Humidity calculation Coefficients to recommended (12 bit) figures from Page 8 of Datasheet
• Updated Temperature calculation Coefficients to recommended (3.3 Volt Interpolated) figures from Page 9 of Datasheet

Any references to the datasheet refer to the Version 5, Dec 2011 datasheet found on Sensirions website.

Also note that the bcm2835 GPIO library has been updated and is now version 1.8 – Get the updated version from http://www.open.com.au/mikem/bcm2835/.

Here’s the source code you’re looking for: RaspberryPi_SHT1x_01November2012.zip

Here’s the source of testSHT1x.c. (RPi_SHT1x.c and RPi_SHT1x.h can be found in RaspberryPi_SHT1x_01November2012.zip)

// Compile with: gcc -lm -o testSHT1x ./../bcm2835-1.8/src/bcm2835.c ./RPi_SHT1x.c testSHT1x.c

/*
Raspberry Pi SHT1x communication library.
By:      John Burns (www.john.geek.nz)
Date:    01 November 2012
License: CC BY-SA v3.0 - http://creativecommons.org/licenses/by-sa/3.0/

This is a derivative work based on
	Name: Nice Guy SHT11 library
	By: Daesung Kim
	Date: 04/04/2011
	Source: http://www.theniceguy.net/2722
	License: Unknown - Attempts have been made to contact the author

Dependencies:
	BCM2835 Raspberry Pi GPIO Library - http://www.open.com.au/mikem/bcm2835/

Sensor:
	Sensirion SHT11 Temperature and Humidity Sensor interfaced to Raspberry Pi GPIO port

SHT pins:
	1. GND  - Connected to GPIO Port P1-06 (Ground)
	2. DATA - Connected via a 10k pullup resistor to GPIO Port P1-01 (3V3 Power)
	2. DATA - Connected to GPIO Port P1-18 (GPIO 24)
	3. SCK  - Connected to GPIO Port P1-16 (GPIO 23)
	4. VDD  - Connected to GPIO Port P1-01 (3V3 Power)

Note:
	GPIO Pins can be changed in the Defines of RPi_SHT1x.h
*/

#include <bcm2835.h>
#include <stdio.h>
#include "RPi_SHT1x.h"

void printTempAndHumidity(void)
{
	unsigned char noError = 1;  
	value humi_val,temp_val;
	
	
	// Wait at least 11ms after power-up (chapter 3.1)
	delay(20); 
	
	// Set up the SHT1x Data and Clock Pins
	SHT1x_InitPins();
	
	// Reset the SHT1x
	SHT1x_Reset();
	
	// Request Temperature measurement
	noError = SHT1x_Measure_Start( SHT1xMeaT );
	if (!noError) {
		return;
		}
		
	// Read Temperature measurement
	noError = SHT1x_Get_Measure_Value( (unsigned short int*) &temp_val.i );
	if (!noError) {
		return;
		}

	// Request Humidity Measurement
	noError = SHT1x_Measure_Start( SHT1xMeaRh );
	if (!noError) {
		return;
		}
		
	// Read Humidity measurement
	noError = SHT1x_Get_Measure_Value( (unsigned short int*) &humi_val.i );
	if (!noError) {
		return;
		}

	// Convert intergers to float and calculate true values
	temp_val.f = (float)temp_val.i;
	humi_val.f = (float)humi_val.i;
	
	// Calculate Temperature and Humidity
	SHT1x_Calc(&humi_val.f, &temp_val.f);

	//Print the Temperature to the console
	printf("Temperature: %0.2f%cC\n",temp_val.f,0x00B0);

	//Print the Humidity to the console
	printf("Humidity: %0.2f%%\n",humi_val.f);
	//Calculate and print the Dew Point
	float fDewPoint;
	SHT1x_CalcDewpoint(humi_val.f ,temp_val.f, &fDewPoint);
	printf("Dewpoint: %0.2f%cC\n",fDewPoint,0x00B0);

}

int main ()
{
	//Initialise the Raspberry Pi GPIO
	if(!bcm2835_init())
		return 1;
	
	printTempAndHumidity();

	return 1;
}

Unfortunately, my Raspberry Pi is still unstable (I’ve tried both Raspian and ARCH Linux), so I’m playing around a lot with increasing the USB power capability.

The next option, which will definitely void the warranty is to completely remove the Polyfuses and run power direct from the DC input to the USB ports. This bypasses all the fuses on the board and replaces the thin PCB traces with a heavier gauge wire.

Without fuses, you could get into trouble if you don’t know what you’re doing. Consider yourself warned!

Here’s how to do it.

First, remove the USB Polyfuses from the Raspberry Pi.

Raspberry Pi with USB Polyfuses removed

Close-up view of the board with the USB polyfuses removed

Now take two pieces of hookup wire (Red and Black is recommended!), and run them from the USB header to the DC Input of the board.

Here are some close-ups of where they go.

USB end. Note that each wire is soldered to the power pins of both USB ports. You may find it easier to make a solder “bridge” first.

DC Power end. +ve is connected to the polyfuse (F3), while negative is connected to the diode (D17). Be careful not to overheat the polyfuse or diode.

If everything has gone well, you should end up with a board looking like this.

The end result.

Your USB Ports are now unrestricted (within reason) with regards to their maximum current draw.

For me this power problem affects my network connection. It seems that the Network adapter is very picky when it comes to it’s supply voltage.

The Webcam seems to draw about 240mA at 5 volts when it focuses, while the Raspberry Pi is limited to 140mA per USB port and 1.1A total current draw.

The Raspberry Pi limits these currents by way of Polyfuses which are a fuse made of a special polymer. They “blow” like a fuse if too much current goes through them, but then over time “heal” and conduct again. Unfortunately due to their inherit design, before they “blow” their resistance increases as the current increases. This can cause a drop in voltage, commonly referred to as voltage droop.

Without going into too much more detail, this basically means that as a USB device approaches a 140mA current draw, the voltage going to the device will drop and in much that same way, if the total current approaches 1.1 Amps, the system voltage will drop.

I decided the best way to fix this problem is to bypass the Polyfuses on the USB port with wire links. This would mean that the 140mA limit was bypassed, but the total 1.1 Amp limit would still apply. Note that this more than likely voids the warranty on your Raspberry Pi.

You first need to find the PolyFuses on your Raspberry Pi. They are easy to find, they’re the two green “blocks” on the board between the USB port header and the activity LEDs.

Photo showing the Polyfuses (Green blocks) protecting the USB ports.

Photo showing wire links soldered to the USB port Polyfuses

And that’s it. Your USB ports are no longer limited to 140mA. The total board however is still limited to 1.1 Amps.

Remember that there are two easy to access test points on the Raspberry Pi to measure the system voltage. These points are labelled TP1 and TP2.

The La Crosse TX23U Anemometer is almost half the price of the TX20, so I decided to buy one and see if I could decode the protocol.

The big difference between the TX20 and the TX23U is that the TX20 will send a datagram every two seconds (when the DTR line is pulled low), while the TX23U won’t send anything until triggered by briefly pulling the Data line low.

Here’s everything you’ll ever want to know about the pin out and the communications protocol of the La Crosse TX23.

Wiring Pinout:

I’m unsure of what Voltage the TX23U is normally driven with (when connected to a La Crosse Weather Station), but it seems happy running from 3.3 Volts.

TxD should be pulled high to Vcc with a 10k (or similar) pull up resistor.

If you connect the GND and TxD to a oscilloscope (with the pullup resistor from TxD to Vcc) and trigger it by pulling TxD to GND briefly, you’ll see a waveform similar to the following.

The datagram from a La Crosse TX23U Anemometer

The datagram starts high due to the pull up resistor. The TX23U then pulls the data line low for approximately 20 mSec while it (I assume) performs internal calculations. It then sends a 41 bit datagram. Each Bit is approximately 1200uSec long, resulting in a bit rate of around 833 bits per second.

It’s best to calculate the bit rate based on the pin state changes of the start frame as the bit rate seems very dependent on temperature.

Note that all of the values are LSB (Least Significant Bit) First, so you will need to reverse them for standard (MSB First) Integer arithmetic.

A – Host pulls TxD low
You need to pull TxD low (To GND) to signal to the TX23U that you want a measurement. Holding it low for 500mSec seems to give reliable results.

B – TxD released
When the Host releases TxD, it will go high briefly (about 1.2mSec) due to the Pull up resistor.

C – TX23U pulls TxD low
The TX23U then takes control of the TxD line and pulls it low. This lasts for about 20mSec while (I assume) the TX23U is taking measurements and calculating values.

D – Start Frame and Triggering / Detecting start of data
The start frame is always 11011, and due to section C pulling the line low, you can use a rising edge trigger / interrupt to detect the Start Frame.

E – Wind Direction
The wind direction is supplied as a 4 bit value. It requires it’s endianness to be reversed. Once this is done it’s a value of 16th’s of a revolution from North. Thus it can be multiplied by 22.5 to get a direction in Degrees, or a 16 value array can be used to return the direction.

In the example image above, the Wind direction is read as 1101, and then it’s endianness is reversed to 1011, which is decimal 11, WSW or 247.5 degrees.

Table of the directions is below.

F – Wind Speed
The wind speed is a 12 bit value. It requires it’s endianness to be reversed.
I’m unsure of the exact units, but it appears to be a factory calibrated value in units of 0.1 metre/sec. The 3 MSB’s are always 000, so only 9 bits are used. With a max value of 511, this relates to 51.1 metres per second, or 183.96 km/h (114.31 miles per hour).

From the example image above, the wind speed is read as 101010100000, then endianness reversed to 000001010101, which is decimal 85, or 8.5 metres per second.

G – Checksum
The checksum is a 4 bit value. It requires it’s endianness to be reversed.
This is a 4 bit value of the four least significant bits of the SUM of the wind direction and the three nibbles of the 12 bit windspeed.
The checksum in the datagram above is read as 1010, then endianness swapped to 0101.

For the datagram image above, the checksum would be calculated by:

As the Checksum received matches the calculated Checksum, the received data is likely to be correct.

H – Wind Direction (Inverted)
The wind direction (Inverted) is supplied as a 4 bit value. It requires inverting and it’s endianness to be reversed. It can then be interpreted like section “E” above.

In the example image above, the Wind direction is read as 0010, Inverted to 1101 and it’s endianness is reversed to 1011, which is decimal 11, WSW or 247.5 degrees.

I – Wind Speed (Inverted)
The wind speed (Inverted) is a 12 bit value. It requires inverting and it’s endianness to be reversed. It can then be interpreted like section “F” above.

From the example image above, the wind speed is read as 010101011111, Inverted to 101010100000 and it’s endianness is reversed to 000001010101, which is decimal 85, or 8.5 metres per second.

Suggestions
The checksum calculation is very simple and could easily be prone to errors where noise in the line results in invalid data which still matches the checksum.
As both the wind direction and the wind speed are sent twice, I suggest the following checks before a result is considered to be read correctly:

• Check that the start frame is 11011 (0x1B)
• Check received checksum matches calculated checksum
• Check that Wind Direction matches Wind Direction (Inverted)
• Check that Wind Speed matches Wind Speed (Inverted)

I definitely need to slow it down!

The incubator will include:

• Temperature Control
• Humidity Control
• Automatic Egg Turning

The first step was to find a suitable enclosure so that the size of the Egg Turner could be determined. I decided to use a plastic storage box as this should be easy to clean after use. The plastic box will end up inside a plywood box for insulation.

I determined that based on the size of the box, I should have the space to turn 30 eggs in three rows of 5×2 eggs.

A few quick tests of Radio Control Servos quickly proved that they had enough torque and stroke to turn the eggs so an old Hitec servo was chosen as the drive system.

I got hold of some aluminium corner, a rivet gun and a few other essentials and in no time (actually about 20 hours) had it working.

I didn’t take any photos of it prior to completion, but here are some photos of it completed.

The plan is that each “rack” will hold a 5×2 egg section cardboard egg carton. These can be replaced each time the incubator is used.

After powering it up, it turns out it’s too fast to turn the eggs from one extreme to the other, so I’ll have to use some smarts in the microcontroller to allow it to turn them gradually.