[This project is obsoleted and not supported]

The LTC3108  is a highly integrated DC/DC converter ideal for harvesting and managing surplus energy from extremely low input voltage sources such as TEGs (thermoelectric generators), thermopiles and small solar cells. The step-up topology operates from input voltages as low as 20mV. Using a small step-up transformer, the LTC3108 provides a complete power management solution for wireless sensing and data acquisition. The 2.2V LDO powers an external microprocessor, while the main output is programmed to one of four fixed voltages to power a wireless transmitter or sensors. The power good indicator signals that the main output voltage is within regulation. A second output can be enabled by the host. A storage capacitor provides power when the input voltage source is unavailable. Extremely low quiescent current and high efficiency design ensure the fastest possible charge times of the output reservoir capacitor.

Selecting the VOUT voltage is done by connecting the two solder jumpers on the board as follows:

For example to chose 3.3V for VOUT, the solder jumpers must be configured as shown:

Primary application of the breakout board would be to provide power for small pulsed load applications, i.e. remote sensors that will periodically wake up, make a measurement and transmission and then go in sleep mode to allow sufficient amount of energy to be accumulated for the next pulse. The VOUT capacitor should be sized to provide the necessary current when the load is pulsed on. The capacitor value required will be dictated by the load current, the duration of the load pulse, and the amount of voltage drop the circuit can tolerate. The capacitor must be rated for whatever voltage has been selected for VOUT by VS1 and VS2.

A remote node (Funky, JeeNode etc low power nodes) that utilizes a RFM12B transmitter typically makes a transmission for 5ms and uses 25mA. We can afford to drop the voltage from 3.3V to 3V (or even 2.7V) or delta VOUT=0.3V. The minimum value for COUT capacitor then calculates to 416uF or the closest standard 470uF value can be used. Of course, by assuming the voltage drop to 0.5V (perfectly acceptable for Funky and JeeNode) a smaller COUT value can be used. To be on the “safe” side, I will use 470uF tantalum capacitors for COUT. You can solder additional capacitor in addition to the on-board one to increase the pulse time. I have experimented with soldering a 0.1F supercap on top the 470uF capacitor and achieved great results.

Note that there must be enough energy available from the input voltage source for VOUT to recharge the capacitor during the interval between load pulses. Reducing the duty cycle of the load pulse will allow operation with less input energy.

CIN capacitor is fixed to 220uF as recommended in the datasheet.

The board has a footprint for a third SMD tantalum capacitor for VSTORE, but that is optional to solder. In the majority of cases, a super capacitor rated at least 5.5V would be a more appropriate storage for the excess energy. In my tests I used a 1F super capacitor. The Storage capacitor will provide power to the system in case the input voltage is lost, i.e. at nights if using a solar cell. Using storage capacitor may not be necessary, if running on TEG as these provide constant input power.

VLDO is the output of the 2.2V LDO; It is intended to power a MCU that will monitor the Power Good (PGD) pin and enable (by setting VOUT2_EN to high) the VOUT2 that in its turn will power an external RF module.

There will be two build options: one for Peltier cell and another for Solar cell. The difference is as per the datasheet recommendations:

Build A) “Peltier cell” build will have 1:100 ratio transformer, 1nF value for C1

I have used this ebay seller’s Peltier element and achieved excellent results

When using with a Peltier element, you need to find a surface where temperature difference can be utilized. I have IR thermometer that I used to look for such places around my house, no surprise to find that the best sources of heat are power supplies. I have a home entertainment network media center that is around 30-35 degrees C at its surface and by placing the Peltier on top of it with an aluminium heat sink, I get excellent results. Note that you don’t necessary need heat, what you need is temperature difference between the two plates of the element. I tested inside a fridge where the temperature on the wall where the coolant flows is -20 degrees C and the inside of the fridge is +5 degrees C; That creates excellent power output too.

This build starts up at 20mV input and is optimized for use with a Peltier element. It will work with a solar cell too, but at the cost of decreased efficiency i.e. slower recovery time, but it will start up at much lower light level, so it is a balance decision.

Build B) “Solar cell” build will have 1:20 ratio transformer, 0.01uF for C1

The LTC3108 converter can also operate from a single photovoltaic cell (also known as a PV or solar cell) at light levels too low for other low input voltage boost converters to operate. However, many variables will affect the performance in these applications. Light levels can vary  over several orders of magnitude and depend on lighting conditions (the type of lighting and indoor versus outdoor). Different types of light (sunlight, incandescent,
fluorescent) also have different color spectra, and will produce different output power levels depending on which type of photovoltaic cell is being used (monocrystalline,
polycrystalline or thin-film). Therefore, the photovoltaic cell must be chosen for the type and amount of light available. Note that the short-circuit output current from the
cell must be at least a few milliamps in order to power the LTC3108 converter.

This build starts up at 100mV input and 3-4mA current.

I haven’t tested this particular model, but these cells look excellent for the purpose.

See this post for usage with Power Good pin enabling VOUT2. To use this setup, connect the board as follows:

The advantage of the above setup is that it will only power up the attached node when voltage reaches the pre-set with jumpers level and will power off once it drops below.

See a demo video:

Some pictures:

[This project is obsoleted and not supported]

The “Funky v2” is a miniature open source/hardware cut-down clone of the Arduino Leonardo  with RFM12B radio module. It is intended as low power, battery operated remote sensing node with USB interface. Due to the miniature size, only few carefully selected pins are available at the side header, none the less that is more than sufficient to interface several sensors at a time.

Having gained experience with my Funky v1 project, I decided to create a new version. The Funky v1 project is a success, yet the areas I wanted to optimize are:

• The Attiny84 MCU that was used in the Funky v1 has limited RAM and sketch memory
• The Attiny84 requires an ISP programmer for sketch uploading
• The Attiny84 required a modified Arduino core
• Many of the available Arduino libraries are not compatible with Attiny84

So the Funky v2 was created, see my posts here , here and here

• Board size is 20×21.2mm (0.78″x0.83″) in size (same as Funky v1)
• The MCU used in an Atmega32U4, the same MCU that Arduino Leonardo uses. This makes the Funky v2 a minuature Arduino Leonardo compatible board with RFM12b transciever module
• The Funky v2 has the Caterina bootloader, so programming is done with Arduino IDE via micro USB cable
• Uses external 8Mhz crystal (can switch to internal RC clock in software as described here)
• Operates on 3.3V
• Weights only 3 grams

Funky v2 is available for sale in limited quantities in the shop.

Eagle design files and example sketches are available on my github repository.

Some of my projects involving Funky v2:

• Wearable wireless body temperature logger/monitor with DS18B20
• OLED status display
• Flood alarm
• RGB LED project
• Temperature sensor node
• Weight logger
• Frequency generator
• Using in energy harvesting project
• Soil moisture wireless node
• April fool prank
• Software I2C with Funky v2
• TCP/IP over RFM12b serial connection
• Frequency counter
• RFM12b gateway to emoncms
• Controlling RF power sockets
• IR receiver
• DHT22 
• Pulse counting

Complete list of examples: https://github.com/mharizanov/new_Funky/tree/master/examples

Funky v2 revision 2 schematic/board layout:

Note the added MOSFET to control the RFM12B’s power state; This requires explicitly powering up RFM12B transciever before initialization:

pinMode(A5,OUTPUT); // RFM12B power control pin9
digitalWrite(A5,LOW); //Make sure the RFM12B is on (LOW is on)
delay(20); // Allow for RFM12B to start
....RFM12B initalization code here.......

Setting up Arduino IDE for the board

Funky v2 r2 will have the Caterina bootloader and will identify itself as an Arduino LilyPad USB. The purpose of this is to have Arduino IDE support for the Funky v2 without the need of any additional setup.  Both Arduno LilyPad USB and Funky v2 operate on 3.3V @ 8Mhz, so it is important to select that board type and not the Arduino Leonardo that runs on 16Mhz. Simply plug in the Funky v2 and when asked for drivers (Windows), navigate to the Arduino/drivers folder.

Older Funky v2 revisions need to use the Arduino Fiov3 drivers. The ZIP file includes instructions on using them.

Powering the board

Note: The micro-USB connector is soldered on the board — not through it. Be gentle when plugging and unplugging your USB cable.

The board can be powered from the micro USB plug and will regulate that input to 3.3V using the the Torex XC6206 LDO regulator included on the board (Funky v2 used MCP1700 LDO prior to Aug 14th 2013, see my post here) . The VUSB line is exposed as a pin on the side header, meaning that you can power the board from there too, just do not exceed the 6V limit that the ATMega32U4 VUSB has. The XC6206 dropout voltage according to the datasheets is 250mV meaning the minimum supply voltage when powering via the VUSB should be 3.3V+0.25=3.55V, so LiPo batteries can be also used  as well.

The board carries an option for the LTC3525ESC6 (3 or 3.3V versions) boost regulator and supporting elements to be included, this is useful when you wish to power the board from a 0.8 – 5.5V source and get that regulated to 3.3V. I use that option to power the Funky v2 from a single AAA battery.

The board can also be powered from a single CR2032 battery, but unlike the Funky v1 the battery holder now can only be soldered at the side where the RFM12B module lays as the micro USB connector stands on the way on the reverse side. See example of this setup here.

Running on battery is one one of the advantages of the Funky v2 project, however it needs taking special care to reduce power usage and therefore prolong battery life. Using this example sketch  I managed to bring the power consumption down to 0.02mA @ 3V in sleep mode.

NOTE: Please remove any battery attached when plugging into USB.

The default fuse settings I use are the same as Arduino LilyPad USB:

avrdude -v -v -patmega32u4 -cusbtiny -e -Ulock:w:0x3F:m -Uefuse:w:0xce:m -Uhfuse:w:0xd8:m -Ulfuse:w:0xff:m 

avrdude -v -v -patmega32u4 -cusbtiny -Uflash:w:Caterina-lilypadusb.hex:i -Ulock:w:0x2F:m

You could disable the BOD fuse to save extra 0.02mA in sleep mode.

The bootloader also slightly differs from the  “stock” Caterina bootloader because it passes control to the sketch immediately on board power-up and will only go in bootloader mode for 8 seconds on external reset (or if no sketch is present). This is done so that no time is lost between board power-up and the sketch powering down the unused peripherals. Source code of the bootloader here.

Funky v2 header pins

The side header of the Funky v2 started as intended Jeelabs’s JeePort, but that changed slightly as I advanced with the design. The reason for that is that JeePorts are Atmega328 specific and there is no information on which pins JCW will use in a future Atmega32u4 (if ever) based JeeNode. I still kept the overall idea of having a VCC-DIO-GND-3.3V-AIO-IRQ concept. Having said that, the Ports library will probably work with minor modifications.

1. Pin 1 connects to VUSB and provides +5V if the USB cable is plugged in. It can also be used to power the board from a 3.5-6V source, given the USB cable is disconnected. Typical application of this pin would be to provide 5V for sensors attached to the header
2. Pin 2 connects to Digital 13, a special pin with timer output to drive IR LEDs for example.
3. Pin 3 connects to GND
4. Pin 4 connects to VCC (3.3V if powered via the USB or the voltage that your battery is providing if powered by a battery)
5. Pin 5 can be used both as Digital 8 or Analog 8 in Arduino IDE, it is a pin that supports pin-change interrupts: Needed for RX of SoftwareSerial (TX can be digital any pin)
6. Pin 6 is Connects to Digital 2 pin, also can be used for IRQs

The on-board LED is connected to Digital 1

Detecting USB connection

This is useful when determining weather we are running on battery power or USB power and take measures to reduce power consumption if we are running on battery. See my full post here.

void setup(){
  USBCON = USBCON | B00010000;
  pinMode(1,OUTPUT); // The on-board LED

  delay(550);  // Wait at least 550ms,may even require more on slow hosts (necessary)

  if (UDINT & B00000001){
  // USB Disconnected code here
  digitalWrite(1,HIGH);
  }
  else {
      // USB is connected code here
     digitalWrite(1,LOW);
  }
}

void loop(){
}

Power saving techniques

When running on battery, we aim to cut power consumption down as much as possible. The following code will bring Funky v2 to about 0.03mA sleep current when running with BOD fuse disabled and at 4Mhz. Also see a complete example on GitHub.

  ADCSRA =0;
  power_adc_disable();
  power_usart0_disable();
  //power_spi_disable();  //do that a bit later, after we power RFM12b down
  power_twi_disable();
  power_timer0_disable();   // Will also kill timekeeping, so be careful if your code relies on millis(); comment out if these are needed.
  power_timer1_disable();
  power_timer3_disable();
  PRR1 |= (uint8_t)(1 << 4);  //PRTIM4
  power_usart1_disable();

  // Switch to RC Clock 
  UDINT  &= ~(1 << SUSPI); // UDINT.SUSPI = 0; Usb_ack_suspend
  USBCON |= ( 1 <<FRZCLK); // USBCON.FRZCLK = 1; Usb_freeze_clock
  PLLCSR &= ~(1 << PLLE); // PLLCSR.PLLE = 0; Disable_pll

  CLKSEL0 |= (1 << RCE); // CLKSEL0.RCE = 1; Enable_RC_clock()
  while ( (CLKSTA & (1 << RCON)) == 0){}	// while (CLKSTA.RCON != 1);  while (!RC_clock_ready())
  CLKSEL0 &= ~(1 << CLKS);  // CLKSEL0.CLKS = 0; Select_RC_clock()
  CLKSEL0 &= ~(1 << EXTE);  // CLKSEL0.EXTE = 0; Disable_external_clock

   // Datasheet says that to power off the USB interface we have to: 
   //      Detach USB interface 
   //      Disable USB interface 
   //      Disable PLL 
   //      Disable USB pad regulator 

   // Disable the USB interface 
   USBCON &= ~(1 << USBE); 

   // Disable the VBUS transition enable bit 
   USBCON &= ~(1 << VBUSTE); 

   // Disable the VUSB pad 
   USBCON &= ~(1 << OTGPADE); 

   // Freeze the USB clock 
   USBCON &= ~(1 << FRZCLK); 

   // Disable USB pad regulator 
   UHWCON &= ~(1 << UVREGE); 

   // Clear the IVBUS Transition Interrupt flag 
   USBINT &= ~(1 << VBUSTI); 

   // Physically detact USB (by disconnecting internal pull-ups on D+ and D-) 
   UDCON |= (1 << DETACH); 

   power_usb_disable();  // Keep it here, after the USB power down
   rf12_initialize(storage.myNodeID,storage.freq,storage.network); // Initialize RFM12 
   // Adjust low battery voltage to 2.2V
   rf12_control(0xC000);
   rf12_sleep(0);                          // Put the RFM12 to sleep

   power_spi_disable();

Licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

[This project is obsoleted and not supported]

The Micro Internet of Things Gateway (uIoT) is a Atmega328 + ENC28J60 solution, one of many using this combination of hardware, but still unique with its miniature size (38mm x 28 mm and 15 mm in height). The original board is designed by Simon K. and I have his permission to develop it further and sell my version to hobbyists.  My revisions so far include adding a micro USB plug for power purposes and re-shuffling the header so plain rectangular shields can be created more easily.

I have also developed a shield that plugs on top the uIoT and adds a RFM12B connectivity, a Micro SD card slot, a LED and FTDI connector option.

You can set the fuses to run on the internal RC oscillator at 8Mhz, this is my recommended setup. To achieve this, I use a modified OptiBoot Bootloader optimised for 38.4kbps baud. The modified and compiled version can be downloaded from my github repository. The full guide of how to modify and re-compile Optboot is detailed on the Arduino forums here.

In order to compile Arduino sketches to work for this modified bootloder we need to add a new entry in Arduino’s boards.txt.

atmega328_384_8.name=ATmega328 Optiboot @ 38,400baud w/ 8MHz Int. RC Osc.

atmega328_384_8.upload.protocol=arduino
atmega328_384_8.upload.maximum_size=30720
atmega328_384_8.upload.speed=38400

atmega328_384_8.bootloader.low_fuses=0xE2
atmega328_384_8.bootloader.high_fuses=0xDE
atmega328_384_8.bootloader.extended_fuses=0x05
atmega328_384_8.bootloader.path=optiboot
atmega328_384_8.bootloader.file=optiboot_atmega328_384_8.hex
atmega328_384_8.bootloader.unlock_bits=0x3F
atmega328_384_8.bootloader.lock_bits=0x0F

atmega328_384_8.build.mcu=atmega328p
atmega328_384_8.build.f_cpu=8000000L
atmega328_384_8.build.core=arduino
atmega328_384_8.build.variant=standard

Now we just need to select board > ATmega328 Optiboot @ 38,400baud w/ 8MHz Int. RC Osc in Arduino IDE when compiling sketches.

The board can be clocked via the CLKOUT pin of the ENC28J60, meaning it can run on 6.25Mhz or 12.5Mhz depending on how you set the prescaler. Upon power-up, the board always starts on 6.25Mhz and with small modification to the EtherCard library, you can run on 12.5Mhz. In this case the board requires custom entries in the boards.txt, if you plan to use it in the Arduino IDE; see here, here and here

The board uses digital 10 as CS for the ENC28J60

The shield uses non-conventional pin for selecting the RFM12B module, that also requires changing 3 lines in the Jeelib’s RFM12.cpp definitions; I would include a modified version in the examples on github to eliminate the need for change by the end user.

I have adapted optiboot and 2boots bootloaders for the uIoT, but using these only makes sense if you have the shield on (because of the FTDI connector)

The header layout is as follows:

Check all my posts on the uIoT gateway.

Eagle design files and example sketches on github

[This project is obsoleted and not supported]

Note: There is a more advanced wiki at this address: http://wiki.openenergymonitor.org/index.php?title=Raspberry_Pi

The RFM2Pi board is an Attiny84+RFM12b based expansion board that plugs on top the Raspberry Pi‘s GPIO pins and provides serial interface with the RFM12b module. The board is pre-programmed with RFDemo sketch for Attiny84 and will output to Pi’s UART the incoming packets. This revision of the board is created in collaboration with openenrgymonitor.org

Eagle Design files are available here

The interface is bi-directional, that means the board can be configured and used to send Jeelib compatible packets as well. Software running on the Raspberry Pi side can parse and decode the serial input and make further processing, like posting to emoncms or cosm. Here is an example of capturing and decoding in perl: link. The latest modular emoncms version has add-on module to support the RFM2Pi board.

Note: Prior to going any further, please backup Raspberry Pi’s SD card

By default, you Raspberry Pi will be running the console on the UART. In order to use it for the RFM2Pi board, we need to free it up from the console:

• Make sure Raspberry Pi’s UART is disconnected from the console and available for programs to use it
  • First, make a backup of the cmdline.txt file

sudo cp /boot/cmdline.txt /boot/cmdline_backup.txt

• • Next, edit it to remove references to Pi’s UART (ttyAMA0)

sudo nano /boot/cmdline.txt

• • Originally it contains this

dwc_otg.lpm_enable=0 rpitestmode=1 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait

• • Edit it to look like this

dwc_otg.lpm_enable=0 rpitestmode=1 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait

• •  Press Ctrl+O to save, then Ctrl+X to exit
  • Next, type “sudo nano /etc/inittab”  and comment (or remove) the line (towards the end of the file)

 2:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

• Restart the Raspberry Pi by typing “sudo reboot” so changes take effect
• I use minicom to view the serial data

sudo apt-get install minicom

And to run it at 9600 baud (or change that to whaterver baud you used on TinySensor’s side:

minicom -b 9600 -o -D /dev/ttyAMA0

Tip: you may use “sudo minicom -s” to store these settings as permanent

The board plugs on-top the Raspberry Pi and utilizes the following pins:

[This project is obsoleted and not supported]

The ‘Funky’ Sensor is a miniature ATTiny84 based node with a RFM12b module for wireless communications.  It was originally created by Tobias Floery, and inspired by Jeelab’s JeeNode Micro. I was quite impressed by the small size and usability of the device and asked Tobias for permission to copy and develop further a version of my own.

My revisions include

• Added voltage step-up circuit based on the LTC3525 boost regulator chip , the exact same as the one found on Jeelab’s AA power board.
• Removed the battery voltage sensing circuitry as it can be achieved using the bandgap method
• Added micro-USB plug, so that the node can be powered from there (only power function, no USB communication). The voltage regulator is retained, so alternatively the Funky can be powered from a source up to 7.5V
• I added provision for a 4.7K or 10K between pads 4 and 5 on the Funky, that will allow directly soldering DHT22 humidity+temperature or DS18B20 temperature sensors (or any other sensor that uses three pins and requires pull-up on the data line).
• The RFM12b clock out pin is connected to ATTiny’s CLKI pin, providing possibility for using RFM’s 10Mhz crystal for clocking. This required changing the LED pin.

The board measures 23 x 23.4 mm in size. I use the “flat crystal” version of the RFM12b module to keep it low-profile and to allow the optional CR2032 battery holder to be soldered on either side.

The latest Eagle design files are available here.

Building it

Because of its miniature size, I only offer pre-built Funky sensors in the store.

Programming the Funky

You need to set-up the Arduino IDE for use with ATTiny processors. I have shared my experience in this post. My already configured Arduino IDE 1.0.1 for Windows is available for download here.

You need a six pin ISP programmer to program the Funky. I own a clone of the USBTiny programmer, these are widely available on ebay and cost less than 10 dollars delivered.

Note: The Funky is a 3.3V device, and the RFM12b module cannot withstand more than 3.6V. When programming the Funky, make sure you don’t supply 5V thru the ISP programmer, or the RFM12b module will most likely be burned. The USBTiny programmer has a jumper on it that when removed, does not provide power to the ISP connector. You still have to provide 3.3V from other source so that the Funky can be programmed.

You need 6 pin ISP connector to program the Funky. The PCB is 1.60mm thick, while a 2×3 pin header has 2mm spacing. It requires a small bending to make better contact, use pliers to apply minimal pressure to the pins so they make better contact:

Prior to uploading a sketch, make sure you have set the correct fuses. I recommend running the Funky on the Internal Oscillator at 8 Mhz, because 1Mhz is not enough for sending/receiving  RFM12B packets. Setting the fuses is done by selecting the appropriate desired option and then pressing “burn bootloader”. This doesn’t really burn a bootloader, only sets the correct fuses for this type of board. You only need to to this once, fuse settings are then “remembered”; Since I ship the Funkys already pre-programmed with a test sketch, I have already set the fuses to 8Mhz BOD disabled for you.

You can run the Funky on RFM12b’s crystal @ 10Mhz as described here, but only do this if you absolutely know what you are doing because you may end up with unresponsive Funky.

I ship the Funky Sensors with the “Internal Temperature sensor” sketch uploaded, it allows me to test the MCU and RFM module easily.

Example usage

Examples on github

Pads on the Funky:

[This project is obsoleted and not supported]

TinySensor Documentation

The TinySensor is a ATTiny84 based multi-purpose board. It is designed to primary serve as a low power, battery operated wireless remote sensor that will measure and transmit data to a remote base at regular intervals. For the purpose, there is a dedicated temperature sensor port (intended for DS18B20 one-wire temperature sensor bus) and a configurable voltage divider.

Schematic and board TinySensor v1.4_rev3

Numerous applications and hardware configurations are possible, some examples include

• Temperature sensing
• Air Humidity Sensing
• Light Intensity sensing
• Current sensing (for power monitoring)
• Soil Moisture sensing
• Water flow sensing
• Switch position sensing

..and many more, limited by your imagination only. See my projects tagged with Attiny84

The module has on-board RFM12B transceiver module, so it is able to communicate with other modules in the wireless network.

Additionally, there is a SD card pin connector, that allows storing measurement data on a SD card, in really remote locations that may be useful option.

There is a Jeelabs JeePort, so you can benefit from all JeePorr compatible sensors /libraries out there

A 3.3V FTDI connector can be used to power the board and serial bi-directional debugging (no programming yet)

A CR2032 battery slot can be used to power the board when the application permits ultra-low power mode and long intervals between transmissions of data.

A Raspberry Pi connector allows plugging the TinySensor directly on a Raspberry Pi and using UART to communicate between the two modules. A good example usage is the RFM12b to Raspberry Pi serial gateway project.

Building it

Building the TinySensor is pretty much trivial. Start with the lowest profile components and gradually add them in the order of height, this way the taller components won’t stand in the way.

I usually start with the 10K resistors that keep the ATtiny84 reset and RFM12B’s Slave Select lines pulled up. If you will not use the ISP for programming, these two resistors may be omitted.

If you intend to use the DS18B20 temperature sensor, you need to solder the 4K7 resistor that keeps the data line pulled up. I prefer to add headers instead of soldering the other resistors, so that I can change configurations on the run.

Next, solder in the two decoupling capacitors. These are ceramic and orientation doesn’t matter.

I then solder the RFM12B module on the bottom of the PCB. The orientation of the RFM may be a bit tricky to figure at first. The crystal needs to go on the inner side of the pcb. Apply a small amount of solder on one of the pins so that it affixes the whole module. Adjust if necessary so it is in the middle of the footprint. Once positioned, solder carefully all connections. I hold the soldering iron a bit longer when soldering the RFM12Bs so that solder falls in the bottom of the module as well. Make sure there is solder on the top of the pad as well, I have had issues where I didn’t have enough solder applied. The antenna needs to be 82mm for 868Mhz modules.

You can now solder a 14 pin socket (or the ATTiny84 directly, if you need low-profile, but the socket is recommended for most uses) and the ATTiny84. The silk screen shows the correct orientation of the socket and the chip.

Next is the 6-pin ISP connector, if you will use it to program the ATtiny.

This is the basic configuration to get you started

Programming it

Check this post on how to setup Arduino IDE for working with ATTiny84.

Using it

Check the code repository for TinySensor on github.

Using the TinySensor with a Raspberry Pi

Note: Prior to doing any further work, please backup Raspberry Pi’s SD card.

The TinySensor has a dedicated port sized 2×5 pins, that allows it to be plugged on  a Raspberry Pi. It will get its power from the 3.3V line and will connect Pi’s UART TX  and RX TinySensor’s PA3 and PA7 respectively.

When plugging the TinySensor on the Raspberry Pi, make sure of the following:

• The TinySensor board is held on the Pi by the 2×5 pin header only. If pressed, it may contact the Pi’s other components. I apply a small amount of hot glue silicon on two points, where potential contact between the TinySensor and the Raspberry Pi may occur, you can use isolation band as well. These points are the FTDI connector (if soldered, the connections are close to Pi’s GPIOs) and between the ISP connector and DS18B20 port, so that the board doesn’t touch the large capacitor on the Pi:

• The TinySensor should not be powered from another source.
  • Don’t plug FTDI cable directly in the FTDI port as it provides 3.3V too. You may use FTDI for serial debugging by connecting it with jumper wires, you need only GNS, TX and RX lines. Leave the FTDI power unconnected
  • If you have the CR2032 battery installed, please remove it. If you have other batteries installed at the external battery connector, make sure they are disconnected
  • If you have ISP programmer connected, please make sure it does not power the TinySensor. There is a jumper on most ISP programmers that disconnects the power line
• Make sure Raspberry Pi’s UART is disconnected from the console and available for programs to use it
  • First, make a backup of the cmdline.txt file

sudo cp /boot/cmdline.txt /boot/cmdline_backup.txt

• • Next, edit it to remove references to Pi’s UART (ttyAMA0)

sudo nano /boot/cmdline.txt

• • Originally it contains this

dwc_otg.lpm_enable=0 rpitestmode=1 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait

• • Edit it to look like this

dwc_otg.lpm_enable=0 rpitestmode=1 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 rootwait

• •  Press Ctrl+O to save, then Ctrl+X to exit
  • Next, type “sudo nano /etc/inittab”  and comment (or remove) the line (towards the end of the file)

 2:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

• Restart the Raspberry Pi by typing “sudo reboot” so changes take effect
• I use minicom to view the serial data

sudo apt-get install minicom

And to run it at 9600 baud (or change that to whaterver baud you used on TinySensor’s side:

minicom -b 9600 -o -D /dev/ttyAMA0

Tip: you may use “sudo minicom -s” to store these settings as permanent