Here is what they look like:

I moved the onboard DS18B20 sensor a bit farther away from the CPU. It isn’t populated on this particular board.

Here is the backside:

The silkscreen is much easier to read on this verision. It isn’t perfect, but it works. I still have the Jeenodesque ports. I like having access to both regulated and unregulated power as well as ground in lots of spots. Next to the SMA connector, I have a 0603 blue LED tied to D9. This allows me to give some feedback as to what is happening (ie flash when collecting data and sending packets). I plan on having a way for the ACK packets to turn this on for debugging or off for power saving. In the case, I can drill a small hole next to the antenna hole.

The form factor fits into the same case from New Age Enclosures.

I want to get 10 or so of these running around the house to see how the collector node handles all the chatter.

Let me know what you think of the layout. Cheers!

The board in this picture is my first attempt at an Arduino clone with built-in RF12B. There are some very Jeenodesque parts to this board (Thank you JCW for the inspirations!). For instance, the four Jeenode ports. I am not sure if I’m going to keep these or not. As the boards get more custom, then having generic ports makes less sense. Also, the 0.1″ header pins take up a ton of space on the board.

Why make this?

We’ll first, because I wanted to try to make a board in Eagle. Did that. Still lots to learn, but super fun to get a working PCB back.

I wanted to get something that fits into a case. For another project, I had cases from new age enclosures. They make relatively cheap enclosures that are not that ugly boxes that most make. The ones I chose has 3″, 4″ and 5″ versions. The board will fit into any of these so there is lots of space for extra circuitry, batteries, etc…

I also wanted to see how well the RF12B would perform with a real antenna as opposed to a relatively precise piece of wire. It also makes the system look that much more professional. I bought a bunch of 915MHZ antennas  off of Ebay for super cheap. The swivel antennas wold be nice as I could also fold them down the side of the enclosure.

Lastly, I wanted to try my hand at SMD soldering. I’m mainly using 0603 components. So far so good. It isn’t fun if you need to do a bunch of reworking the boards, but relatively easy to do once you get the hang of it. Google for tutorials. There are lots of good ones out there.

Here is the board with the components on it.

As you can see, there is some rework on there. I made the most basic of mistakes connecting TX-TX and RX-RX when I needed TX-RX and RX-TX on the FTDI connector. Easy fix, luckily. Also had a wrong trace to the reset on the ICSP connector. Otherwise worked well. The small chip to the upper-left of the ATMEGA128P is a DS18B20U+ chip. The three 0.1″ headers to the left of that chip is if you want to hang more 1-wire devices off that pin. I currently have 5 more DS18B20s coming off that pin on one of these boards.

On the other side, I wired in a micro-USB connector to provide an easy power connection. I also added a blue-LED that I will use as a status light.

Here is the board in its case:

As you can see, the board actually sits in the case upside down. I wanted to put most of the components on the bottom of the board so they don’t interfere with other circuits that might be on the top or batteries etc…

For a first stab at it, I’m thrilled. Works as expected. I’ve sent out a version 1.0b as well as one that goes into a NEMA rated outdoor enclosure. More on that soon.

Ouch. That big spike is 19 dropped packets — 19 minutes straight without new data.

Now check out this graph:

So I stopped work around 6:30. Haven’t dropped a packet since then. There have been a few retries but nothing serious and zero data lost.

Just an example how the local environment can affect your data collection.

Here  is today’s action. Pretty clear that those noisy motors wreck havoc on RF transmissions. Can you tell when I stopped working?

It lasted from 2011-06-15 3:11 PM to 2011-06-26 2:59 PM. Just under 11 days on 120mAh LiPo.It shouldn’t take much solar juice to keep that small battery charged up, but now I know I get > 1 week on a full charge without adding any energy to the battery. That should cover some dark days….

Here is a graph of the entire time period:

You can see the battery held fairly linear until the end, the dropped off quickly. Final battery voltage when it stopped: 3.461V. Which is less than I expected as it should be something like 4V if the datasheet for the LDO regulator is right (or I’m reading it right). The datasheet says it should be the output + dropout, in this case 3.3V + 750mV or around 4.050V.

I tried to charge the LiPo back up using the Ladyada charger, but it wouldn’t take the charge since the Jeenode was trying to pull from the battery at the same time as the USB was trying to charge the LiPo. Got some really bouncy voltages. More investigation required here. I’m put together a circuit board which has the MOSFET/Diode that is in the reference circuit, but left off this charger. When I get that built we can see if it solves this issue.

EDIT

Here is a bit of the schematic to answer the below comment.

Just a simple voltage divider to get the voltage from the Lipo (~4.2V) to something less than 3.3V. Since the resistors are the same value, I’m just halving the voltage.

So, I put together a small Jeenode setup with a single DS18S20 temp chip, 1 blue LED and a voltage divider circuit to measure the battery voltage. The jeenode is setup to:

1. wake-up
2. turn on LED
3. read temp
4. read voltage
5. send to receiver via RF12B
6. wait for ACK
7. resend if necc, if got ACK then,
8. go to sleep for ~1 minute

Pretty simple.

Here is the code:

#include <Ports.h>
#include <RF12.h>
#include <OneWire.h>

#define DEBUG      1

// ACK stuff
#define RETRY_LIMIT     9   // maximum number of times to retry
#define ACK_TIME        10  // number of milliseconds to wait for an ack

#define NODE_ID         9  // my Node ID
OneWire ds1(4);

#if DEBUG
// LED Setup
Port led (2);
#endif

OneWire ds(4);

typedef struct {
 int temp1;
 int lipo_mV;
 int retries;
 int failed_packets;
}
Payload_temp;
Payload_temp m;  // m = measurement

ISR(WDT_vect) {
 Sleepy::watchdogEvent();
}  // interrupt handler for watchdog

static int readDS18S20() {
 ds1.reset();
 ds1.skip();
 ds1.write(0x4E); // write to scratchpad
 ds1.write(0);
 ds1.write(0);
 ds1.write(0x1F); // 12-bits is enough, measurement takes 750 msec
 ds1.reset();                               // Reset device
 ds1.skip();
 ds1.write(CONVERT,1);                      // Issue Convert command
 delay(1000);                             // maybe 750ms is enough, maybe not
 ds1.reset();                    // Reset device
 ds1.skip();
 ds1.write(READSCRATCH);                   // Read Scratchpad
 byte data[12];
 for (uint8_t j = 0; j < 9; j++) {               // we need 9 bytes
 data[j] = ds1.read();
 }
 ds1.reset();

 if(OneWire::crc8(data,8) != data[8]) {
#if DEBUG
 Serial.println(" crc?");
#endif
 return 0;
 }
 int16_t raw = ((int16_t)data[1] <<  | data[0];
 float celsius = ((float)(raw >> 1) - 0.25 +((float)(data[7] - data[6]) / (float)data[7]));
 return int(((celsius*1.8)+32)*100);
}

//------------------------------------------------------------------------------
// SETUP
//------------------------------------------------------------------------------
void setup () {
#if DEBUG
 Serial.begin(57600);
 Serial.println("\n[120mAh Test]");
 led.mode(OUTPUT);               // setup DIO pin as output
 led.mode2(INPUT);              // setup AIO pin as output
 led.digiWrite(HIGH);                // turn on BLUE led
#endif 
 m.temp1 = 0;
 rf12_initialize(NODE_ID, RF12_915MHZ, 212);  //nodeID //freqBand //netGroup
 //rf12_config();

}

//------------------------------------------------------------------------------
// LOOP
//------------------------------------------------------------------------------
void loop () {
 m.retries = 0;
 byte i;

#if DEBUG
 led.digiWrite(1);               // turn on GREEN led
#endif
 m.temp1 = readDS18S20();
 m.lipo_mV = (map(led.anaRead(),0,1023,0,3300))/0.68;

 rf12_sleep(RF12_WAKEUP);  // turn on radio
 for (i = 0; i < RETRY_LIMIT; ++i) {
 m.retries = (int)i;
 while(!rf12_canSend())
 rf12_recvDone();
 rf12_sendStart(RF12_HDR_ACK,&m,sizeof m);
 rf12_sendWait(0);
 byte acked = wait_for_ACK(); // from roomNode.pde
 //rf12_recvDone();

#if DEBUG
 Serial.print("Sending Attempt #");
 Serial.print(m.retries);
 Serial.print("  Failed Packets: ");
 Serial.print(m.failed_packets);
 Serial.print("  Temp: ");
 Serial.print(m.temp1);
 Serial.print("  Lipo mV: ");
 Serial.println(m.lipo_mV);
 delay(2);
#endif

 if(acked) {
 m.failed_packets = 0;
 # if DEBUG
 Serial.print(" --> Got ACK  Failed Packets: ");
 Serial.println(m.failed_packets);
 delay(2);
 #endif
 break;
 }
 }

 if(i >= RETRY_LIMIT) {
 ++m.failed_packets;
 #if DEBUG
 Serial.print("Incrementing Failed Packets  -- Failed Packets: ");
 Serial.println(m.failed_packets);
 delay(2);
 #endif
 }

#if DEBUG
 Serial.println("\n\n");
 led.digiWrite(0);               // turn off led 
#endif

 rf12_sleep(RF12_SLEEP);  // turn off radio
 Sleepy::loseSomeTime(60000);  // power down AVR for ~ 1 minute // 2000 for getting the temps etc...
}

//------------------------------------------------------------------------------
// wait a few milliseconds for proper ACK to me, return true if indeed received
// see http://talk.jeelabs.net/topic/811#post-4712
static byte wait_for_ACK() {
 MilliTimer ackTimer;
 while (!ackTimer.poll(ACK_TIME)) {
 if (rf12_recvDone() && rf12_crc == 0 && rf12_hdr == (RF12_HDR_DST | RF12_HDR_CTL | NODE_ID))
 return 1;
 }
 return 0;
}

So far the node has been running for about 36 hours. The LiPo started at 4.197V according to the ADC (the voltage divider is using 5% resistors, so this may be off a bit, but good enough for this test).

Here is a graph after the first 36 hours:

I find it interesting that the slope isn’t linear. The current voltage is 4.06V. So it burned through ~137mV. Pretty good. The hope is that this can run for at least a week. That should get through any dark periods between solar recharging. Of course, the LED probably sucks the most juice. The final product won’t have the LED or at least will have the option to turn it off (you can do so with the DEBUG var in the sketch). I may have that as an option to turn on/off the indicators remotely.

Here is a graph of a 5 hour  period:

You can clearly see how the battery steps down. Pretty cool. More to come as the experiment progresses.

UPDATE:

So its been a week. Here is the graph:

Current voltage reading is 3.87V, therefore we have used ~ .327V over 7 days. 10,080 data transmissions! I think this is a tribute to JCW @ Jeelabs for developing a sleep setup that really limits the current draw. The MCP1702 says it wants about ~525mA above V_REG which should equal3.825V. Hmmm. Curious to see when the system goes down….

It is listed as a 3.7V, 120mAh 1S 14C LiPo battery. It is mainly used in mini RC helicopters.

It appears to have a JST-XH series connector which mates with a JST micro male.

I want to read the voltage of the battery as it runs the sketch.

Connecting a voltage divider to an analog pin allows me to read the voltage of the LiPo. Since:

Vin might be as high as 4.5V. So if R1=4.7k and R2=10k, we get a divider that should give us a range below 3.3V for the analog read. Vin of 4.5V would give a Vo of 3.06V.

To get voltage out we would then need to take the analog read of the pin, map it to 3.3V and divide it by the 0.68 from the resistor dividor. Or:

int volts = (map(led.anaRead(),0,1023,0,3300))/0.68;

The 3300 comes from the 3.3V analog internal reference voltage of the Jeenode.

Fully charged, according to the LiPo charger results in a reading of 4202 or 4.2V. Perfect.

Update: It appears the connector is a micro min JST connector. I can’t find a matching connector from JST, but there are cables on Ebay. JST website isn’t the best to find products…

There has been a bunch written about this signal. You can read about it here (German, with photo), here and here. There is work to translate this signal to an OOK scheme.

You need to attach a small capacitor to PIN 15. The datasheet recommends a value of 1nF or larger. I contacted Silicon Labs’ tech support and they recommend a 10nF for a 1ms sampling time. They also said that the signal will be relatively noisy as the cap charges/discharges (~10/15 mV) so it is best to smooth the readings over several samples. They said you could use as small as a 1nF cap, for faster sampling, but the noise will be greater. Just to make it clear, the HopeRF datasheet recommends a 4.7nF cap.

The ARSSI value will change from chip to chip so for absolute measurements, you’ll need to do some characterization. For relative signal strength, it should be fine as the signal stays linear.

I was sent the following graph:

As you can see, the voltage is going to range between 300-1300mV. Interestingly, the graph in the datasheet is slightly different:

where the range is 450-1150mV over the same -100dbm to -65dbm.

I connected a wire to the side of the 4.7uF cap that is on the RF12B module to an analog pin. I got around the range expected when receiving packets (I had the node set as 31 so it was looking for all packets for its group). I seems not to be so useful as you would need to poll it constantly when receiving packets and who knows, it might get in the way of getting that packet or ACK.

Andy has created a new library for Arduino that includes DHCP. JCW has got it working on Jeenodes it appears.

Follow it here.

Code is available on Github here.

Will give it a go shortly on my Jeenode/EtherCard setup.

The HopeRF modules use chips from Silicon Labs. The RF12B uses the  Si4421 (datasheet). Jeenodes from Jeelabs uses these modules and they work well. These chips are from Silicon Labs’ EasyRadio set of chips. I believe Silicon Labs purchased Integration which made the original chips, in June 2008.

Silicon Labs also makes several other interesting modules which HopeRF have turned into modules. Mainly, the RF22B which has up to +20db output power @ 89 mA TX. These come from the EasyRadio PRO chips. The Si4430/31/32 chips looks very interesting. Some people have done some work on drivers for the Arduino, but they may not be as used as Jeelabs RF12 library. Specifically, mikem seems to have done a lot of work getting a good driver for the RF22B. Read about it here.

Silicon Labs has the RFM23B HopeRF modules listed on their website here — one interesting aspect is that they are pre-certified which would help in getting any product certified. As with a lot of wireless technologies they are aiming at the green energy market (smart meters, solar, etc…) These use the Si4431 chipset. (Press Release)

It seems the chips can do a wide range of frequencies, but the 433MHZ need different supporting resistors and capacitors. The 833MHZ and 915MHZ use the same supporting parts.

Digikey sells the Si4421-A1-FT for $2.88/each, $2.77/25s or $2.69/100s. Mouser has the Si4421-A1-FT for $5.03/1 or $3.97/25s or $2.94/100s. Interesting that digikey has the price of 1 less than the price for when buying a 100 from Mouser. Pays to comparison shop. The crystal is about $1. That already puts it above what the module costs direct from HopeRF.

That said, it would be neat to make a small board with all the necessary components and with a SMA or RP-SMA connector for a more robust antenna. (I’ve had 3 of the 4 Jeenodes’ antennas break-off since I’ve had them and I’m relatively careful with them — the antenna that comes from Modern Devices is stranded and seems to be relatively weak. I replaced them with a solid core wire and it seems a bit better. Not sure which is better for RX/TX but they are working fine with the replacement antennas.

Of course, the downside to building the chips onto the same board is that the supporting caps and resistors are tuned for the frequencies so you’d have to keep 2 versions stuffed with different chips instead of just shipping out a different module.

The above is an older version of the module. It has 9 components and the crystal, plus the main chip of course. Interestingly, the newer version below has 8 components as well as the different main chip format. You can see the area at the bottom center that was left unstuffed. (Note: I rotated the image so it aligns with the pinout diagram below).

Here is the pinout for the module:

The datasheet shows a typical application shown below:

The Si4221 needs:

• X1 – 10MHZ Crystal (can share with the microprocessor – but that would make it not a normal Arduino I think)
• C1 – 2.2μF
• C2 – 10nF
• C3 – different for each ISM band (433MHZ – 220pF, 868MHZ – 47pF, 915MHZ – 33pF)
• C2 & C3 should be 0603 ceramic capacitors
• C4 is listed as optional and is connected to the ARSSI pin

The rest of the components on the RF12B chip must be for the matching network for the antenna. From what I can understand, from my non-existent knowledge of antenna design, the matching network transforms the high impedance of the antenna to the low impedance needed for the transceiver to limit any power loss/reflectance.

In the Si4421′s datasheet it shows a schematic of their evaluation board (page 39) with a 50 ohm matching network. The parts of the matching network are:

• 4 ceramic inductors  (L1-L4) in nH (nanoHenrys)
• 4 capacitors (C8-C11) C11 listed as optional

different values for each depending on what frequency band you are after. The three RF inductors’s SRF (self resonant frequency), DCR (DC resistance) and Q should be similar. A high Q has low insertion loss which minimized power consumption.

Hmmm, on the HopeRF board there are 8 or 9 small components where as the reference design has 10 or 12, depending if you include the optional parts. Guess the reference design’s matching network is more complex.

The Jeenode connects only the 5 required connections: SCL, SCK, MOSI, MISO and IRQ. There is not a connection to the ARSSI or any of the other optional pins such as FFS and FFIT.