Posts by Lorenzo Farnararo

[ARDUINO + RASPBERRY PI] Switching light with NRF24l01+

[Raspberry Pi – Arduino ]Lamp Switch[/caption]
A month ago we planned to manage our Arduino irrigator (aka Irrigatorino) through the NRF24l01+ wireless module. Our little project has been subjected to a little change, since we decided to make our life easier (buahahah…) and remote control a light over a browser (yes, mobile too). Surprisingly, a lot of people liked the little demo I’ve made with some raw code and asked for a tutorial, so here we are:

Ladies and (more probably) Gentleman, I’m glad to present you the lamp driven by a browser switch!

Nothing new actually, but still exciting!

Arduino Nano 328 connected with NRF24l01+ module and Lamp (in the background)

Hardware:

To test the wiring we suggest you to use the ping/pong test you can find in the RF24 libraries (both, of the raspberry and the arduino).

Raspberry Pi

The connection between the Raspberry Pi and the NRF24l01+ module was a little bit tricky, so you have to double ( or triple) check the wiring before giving up. Here is the wiring scheme, the Raspberry Pi is a revision 2, and the module is the + (plus) version.

Raspberry Pi (rev2) – NRF24l01+ Diagram

Arduino

The setup is easy and similar to a mix of our tutorials about Irrigatorino and NRF24l01+ Tests.
Just keep in mind that you are playing with dangerous voltage, so if you get struck, it’s only your fault. I would suggest, anyway, to check if everything (especially the relay board) is working with a multimeter, before connecting to a real lamp.

Arduino Nano – NRF24l01+ – Lamp Diagram

NOTE ON PACKET LOSS:

If you are encountering problems while receiving or transmitting, like packet loss, consider adding a capacitor of 10 μF between the pin 1 and 2 of the NRF24l01+, with ground capacitor side on pin 1. You should do this on both the modules, on raspberry and arduino.

Capacitor on NRF24l01+

Software

Our plan to communicate between all this stuff is to use a Node.js application to run a binary ‘sudo ./remote -m 81‘ and ‘sudo ./remote -m 80‘ sending a message to the Arduino with the text 81 and 80 . The message is composed by pin identifier (8) and action to perform (0|1|2). After the action has been read, all the other numbers identify the pin which the action refers to.

When the arduino receive it, it then sends back an acknowledgment packet to the raspberry with the same message (yeah, like a parrot), except for action 2, which will not perform any action, but will reply with actual state of the pin. In the meantime, if the message the arduino receive is 1 it will close a relay (turning on a light, like a good parrot), 0 will open it (I doubt a parrot could be so clever).

Sketching

The sketch for the Arduino Nano is nothing more than a Getting Started demo of the RF24 library. We just modified it to switch the relay on in case it receive a message with 1 as text, or open it otherwise. Of course you’ll need the RF24 library to make it work.

/*

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */
 /*
  Hack.lenotta.com
  Modified code of Getting Started RF24 Library
  It will switch a relay on if receive a message with text 1, 
  turn it off otherwise.
  Edo
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

int relay = 8;

//
// Hardware conf
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };


char * convertNumberIntoArray(unsigned short number, unsigned short length) {
    
    char * arr = (char *) malloc(length * sizeof(char)), * curr = arr;
    do {
        *curr++ = number % 10;
      number /= 10;
    } while (number != 0);
    return arr;
}

unsigned short getId(char * rawMessage, unsigned short length){
    unsigned short i = 0;
    unsigned short id = 0;
    for( i=1; i< length; i++){
        id += rawMessage[i]*pow( 10, i-1 );
    }
    return id;
}

unsigned short getMessage( char * rawMessage){
    unsigned short message = rawMessage[0];
    return (unsigned short)message;
}
unsigned short getLength( unsigned int rudeMessage){
    unsigned short length = (unsigned short)(log10((float)rudeMessage)) + 1;
    return length;
}

void setup(void)
{
  //
  // Print preamble
  //

  Serial.begin(57600);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, HIGH);
  printf_begin();
  printf("\nRemote Switch Arduino\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();
//  radio.setAutoAck(1);                    // Ensure autoACK is enabled
  radio.setRetries(15,15);

  radio.openWritingPipe(pipes[1]);
  radio.openReadingPipe(1,pipes[0]);
  radio.startListening();
  radio.printDetails();
}

int getState(unsigned short pin){
  boolean state = digitalRead(pin);
  return state == true ? 0 : 1;
}

void doAction(unsigned short id, unsigned short action){

    
    if( action == 0 ){
        digitalWrite(id, HIGH);
    }else{
        digitalWrite(id, LOW);
    }
  


}
void sendCallback(unsigned short callback){
   // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &callback, sizeof(unsigned short) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
}

void performAction(unsigned short rawMessage){
  unsigned short action, id, length, callback;
  char * castedMessage;
  
  length = getLength(rawMessage);
  castedMessage = convertNumberIntoArray(rawMessage, length);
  action = getMessage(castedMessage);
  id = getId(castedMessage, length);

  if (action == 0 || action ==1){
      callback = action;
      doAction(id, action);
  }else if(action == 2){
      callback = getState(id);
  }
  sendCallback(callback);


 
}
void loop(void)
{

    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned short message;
      bool done;
//      char * new;
      unsigned short rawMessage; 
      done = false;
      while ( radio.available() )
      {
        // Fetch the payload, and see if this was the last one.
        radio.read( &rawMessage, sizeof(unsigned long) );

        // Spew it
        printf("Got message %d...",rawMessage); 

        performAction(rawMessage);

        delay(10);
      }

     
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

version 2 as published by the Free Software Foundation.

Hack.lenotta.com

Modified code of Getting Started RF24 Library

It will switch a relay on if receive a message with text 1,

turn it off otherwise.

Edo

#include <SPI.h>

#include "nRF24L01.h"

#include "RF24.h"

#include "printf.h"

int relay = 8;

// Hardware conf

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10

RF24 radio(9,10);

// Topology

// Radio pipe addresses for the 2 nodes to communicate.

const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

char * convertNumberIntoArray(unsigned short number, unsigned short length) {

char * arr = (char *) malloc(length * sizeof(char)), * curr = arr;

do {

*curr++ = number % 10;

number /= 10;

} while (number != 0);

return arr;

}

unsigned short getId(char * rawMessage, unsigned short length){

unsigned short i = 0;

unsigned short id = 0;

for( i=1; i< length; i++){

id += rawMessage[i]*pow( 10, i-1 );

}

return id;

}

unsigned short getMessage( char * rawMessage){

unsigned short message = rawMessage[0];

return (unsigned short)message;

}

unsigned short getLength( unsigned int rudeMessage){

unsigned short length = (unsigned short)(log10((float)rudeMessage)) + 1;

return length;

}

void setup(void)

{

// Print preamble

Serial.begin(57600);

pinMode(relay, OUTPUT);

digitalWrite(relay, HIGH);

printf_begin();

printf("\nRemote Switch Arduino\n\r");

// Setup and configure rf radio

radio.begin();

// radio.setAutoAck(1); // Ensure autoACK is enabled

radio.setRetries(15,15);

radio.openWritingPipe(pipes[1]);

radio.openReadingPipe(1,pipes[0]);

radio.startListening();

radio.printDetails();

}

int getState(unsigned short pin){

boolean state = digitalRead(pin);

return state == true ? 0 : 1;

}

void doAction(unsigned short id, unsigned short action){

if( action == 0 ){

digitalWrite(id, HIGH);

}else{

digitalWrite(id, LOW);

}

void sendCallback(unsigned short callback){

// First, stop listening so we can talk

radio.stopListening();

// Send the final one back.

radio.write( &callback, sizeof(unsigned short) );

printf("Sent response.\n\r");

// Now, resume listening so we catch the next packets.

radio.startListening();

}

void performAction(unsigned short rawMessage){

unsigned short action, id, length, callback;

char * castedMessage;

length = getLength(rawMessage);

castedMessage = convertNumberIntoArray(rawMessage, length);

action = getMessage(castedMessage);

id = getId(castedMessage, length);

if (action == 0 || action ==1){

callback = action;

doAction(id, action);

}else if(action == 2){

callback = getState(id);

}

sendCallback(callback);

}

void loop(void)

{

// if there is data ready

if ( radio.available() )

{

// Dump the payloads until we've gotten everything

unsigned short message;

bool done;

// char * new;

unsigned short rawMessage;

done = false;

while ( radio.available() )

{

// Fetch the payload, and see if this was the last one.

radio.read( &rawMessage, sizeof(unsigned long) );

// Spew it

printf("Got message %d...",rawMessage);

performAction(rawMessage);

delay(10);

}

Enabling Raspberry Pi GPIO and Installing Node.js

First we enable the Raspy GPIO:

sudo apt-get install python-dev

#make sure to COMMENT the lines with spi-bcm2708 and i2c-bcm2708 modules
sudo vim /etc/modprobe.d/raspi-blacklist.conf

#be sure to have i2c-dev module in the /etc/module
sudo vim /etc/modules

sudo adduser pi i2c
sudo apt-get update

#reboot:
sudo shutdown -r now

#get the GPIO software
wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.3a.tar.gz

#untar it and install it
tar -xzvf RPi.GPIO-0.5.3a.tar.gz
cd RPi.GPIO-0.5.3a/
sudo python setup.py install
sudo apt-get install i2c-tools

sudo apt-get install python-dev

#make sure to COMMENT the lines with spi-bcm2708 and i2c-bcm2708 modules

sudo vim /etc/modprobe.d/raspi-blacklist.conf

#be sure to have i2c-dev module in the /etc/module

sudo vim /etc/modules

sudo adduser pi i2c

sudo apt-get update

#reboot:

sudo shutdown -r now

#get the GPIO software

wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.3a.tar.gz

#untar it and install it

tar -xzvf RPi.GPIO-0.5.3a.tar.gz

cd RPi.GPIO-0.5.3a/

sudo python setup.py install

sudo apt-get install i2c-tools

Method 2 (not tested, but should work):

#
#Pretty similar except for the python-dev package taken from the repos.
#source: Adafruit.com

sudo apt-get update

sudo apt-get install python-dev

sudo apt-get install python-rpi.gpio

#add this two modules: i2c-bcm2708 i2c-dev
sudo nano /etc/modules 

sudo apt-get install python-smbus
sudo apt-get install i2c-tools

# do COMMENT the lines with spi and i2c modules
sudo nano /etc/modprobe.d/raspi-blacklist.conf

#Pretty similar except for the python-dev package taken from the repos.

#source: Adafruit.com

sudo apt-get update

sudo apt-get install python-dev

sudo apt-get install python-rpi.gpio

#add this two modules: i2c-bcm2708 i2c-dev

sudo nano /etc/modules

sudo apt-get install python-smbus

sudo apt-get install i2c-tools

# do COMMENT the lines with spi and i2c modules

sudo nano /etc/modprobe.d/raspi-blacklist.conf

Let’s install node.js.
If you don’t need the latest version you can install it from the repos:

sudo apt-get install nodejs

1	sudo apt-get install nodejs

Otherwise you can follow this instructions (under Ubuntu, Mint… section) to compile the latest version.

The Lamp Switch Application

For Raspberry Pi 2 users: some of our readers pointed out that this library is a bit outdated for the Raspberry 2 and it’s encountering some problems. Until we have time to update the article, please refer to this post on the Raspberry Official Forum to solve the “Preparing interface” stuck problem (kudos to Andrei).

What we need now is to write an application that will send a message to the arduino using the NRF24l01+ and the Raspi. So the first thing to do is download the RF24 library ported for Raspberry Pi. I would suggest to use git.

#install git
sudo apt-get install git
#move to home
cd ~
#clone the RF24 repos from edoardoo's github fork
git clone https://github.com/edoardoo/RF24RaspberryCommunicator.git

#retrieve the RF24 libs
cd ~/RF24RaspberryCommunicator/
git submodule init
git submodule update

#install git

sudo apt-get install git

#move to home

cd ~

#clone the RF24 repos from edoardoo's github fork

git clone https://github.com/edoardoo/RF24RaspberryCommunicator.git

#retrieve the RF24 libs

cd ~/RF24RaspberryCommunicator/

git submodule init

git submodule update

Now let’s install the library:

#install the library
cd ~/RF24RaspberryCommunicator/RF24
sudo make install

#install the library

cd ~/RF24RaspberryCommunicator/RF24

sudo make install

At this point, with the RF24 library installed, you can use the compiled remote application or compile it yourself with make command:

cd ~/RF24RaspberryCommunicator

#optional: compile the remote application:
make clean && make

# Use remote command to send message to arduino (use sudo!)
# Message should be in this format: [id pin number][action to do]
# We've set relay at pin 8 and actions are:
# 0: turn off
# 1: turn on
# 2: get the actual state

#this message will turn the light on:
sudo ./remote -m 81

cd ~/RF24RaspberryCommunicator

#optional: compile the remote application:

make clean && make

# Use remote command to send message to arduino (use sudo!)

# Message should be in this format: [id pin number][action to do]

# We've set relay at pin 8 and actions are:

# 0: turn off

# 1: turn on

# 2: get the actual state

#this message will turn the light on:

sudo ./remote -m 81

If everything went well you should be able to turn on (and off) the relay at this point using the sudo ./remote -m 81 application, hearing the famous ‘click’ from the relay board.

The Node.js Lamp Application

At this point the only thing left is to build a little node.js server and bind a click on a client browser to an exec function on the raspberry server.

Since it’s more than just a file, we’ve placed a link to the repository on github. All the code is commented, so I hope everything is clear.

We are using git submodule to add the base node application RemoteRaspberry. So here is a list of commands to clone the repo:

cd ~/RF24RaspberryCommunicator
git clone https://github.com/edoardoo/LightSwitchInNode.git
cd LightSwitchInNode/
git submodule init
git submodule update

cd ~/RF24RaspberryCommunicator

git clone https://github.com/edoardoo/LightSwitchInNode.git

cd LightSwitchInNode/

git submodule init

git submodule update

Anyway, since we were a little bit confused on our first node application we’ve decided to write down a little note to help you understand:

– lightSwitch.js => is a link to the application (remote.js) you need to run with “sudo node lightSwitch.js” (the sudo is NEEDED). This is the web server and will launch the client interface too.

views (folder) => contains the main layout and the basic template.

– routes.js => contains the route to the template.

RemoteRaspberry (folder) => the basic node app, which contains:
package.json => required modules (with version) you need to run the application
node_modules (folder) => it’s an auto generated folder which contains the modules
public (folder) => contains remoteClient.js, the javascript code loaded on the client and bootstrap folder for styling
remote.js => the actual node app

To run the application you need to:

#install the dependencies
cd ~/RF24RaspberryCommunicator/LightSwitchInNode/RemoteRaspberry

#but first clean the npm cache
sudo npm cache clean
npm install

#nom nom nom installing stuff

#run the application
cd ../
sudo node lightSwitch.js

#install the dependencies

cd ~/RF24RaspberryCommunicator/LightSwitchInNode/RemoteRaspberry

#but first clean the npm cache

sudo npm cache clean

npm install

#nom nom nom installing stuff

#run the application

cd ../

sudo node lightSwitch.js

Authors note (31/3/2014)

We love the way you support each other in the comments! It’s really a satisfaction for us.
We can’t be always here to answer your questions or doubts, and all your contributions are a really great value you add to this website.
Thank you all!

Update (10/5/2014)

We’ve refined a bit the code, making it more clean and definitely more readable. All you have to do now to add new buttons, is to create a new button in the node app views giving it a data-command tag. The value of that tag will be automagically passed to the old switch -f binary (now called remote -m). Of course you still need to tell arduino how to interpret the message. No more c++ recompiling. Plus, we’ve made the web interface give you a visual feedback when the raspberry receive the ack package from arduino.

Update (27/8/2014)

Looks like the Rf24 library author has changed the folder’s name. I’ve tried to fix the article with the new names. Didn’t have time to check it yet. Let me know if everything is ok. Edo.

Update (2/12/2014)

I’ve cleaned and updated the code to the latest RF24 libraries from TMRh20. I’ve managed to submit a bug (issue #46)of the RF24 lib to the TMRh20 github account, and apply the workaround he proposed. Unfortunately it looks like the modules needs time between communications, it’s a known bug that right now we don’t have time to fix. If you would like to fork the RF24RaspberryCommunicator project, magically fix it and make a pull request, we would love it. Right now, since we do it for free, we don’t have time to fix it. Hope you like it. Edo.

Update (17/01/2016)

For the Raspberry Pi 2 users who got stucked at “Preparing interface” message, please refer tothis post on the Raspberry Official Forum .

Have Fun!

[Arduino] DIY (stupid and cheap) Plants Irrigator

Arduino Gardening

It’s a burning summer in Florence and I needed a solution to watering my little plants I have around the house.

Of course I had a look at some shops for a ready solution, but where is the joy of experimenting with an arduino?

First thing to do in this case is to know what you want, and where your project could drive you. It’s nice to fly high with ideas, but to make them affordable you have to take off first.

So here we are with our project/tutorial: a time programmed irrigator which will water my plants for 1 minute, once a day, on alternate days.

The whole thing costs around 25$ (we’ve bought almost everything from china).

What we’ve used

– an Arduino (we used a Nano 328)
– an RTC (Real Time Clock)
– Water Control NC Solenoid Valve
– a relay board

Wiring

Wiring Diagram

Sketching

I wanted to make arduino water my plants on alternate days, so we had to add a little function ‘dayOfYear’ which will tell us (guess what?) the day of the year it is. Example: February 1st is the 32nd day of the year, and our function will return ’32’.

Maybe there was a better solution, or it was already implemented, but this way was faster for our purpose.

If the day number it’s even and the time correspond to what I’ve set, it will close the relay (and the valve will open).

We’ve used the RTClib (with the little edit I mentioned about ‘dayOfYear’) to control and read the RTC.

The Sketch

//
//Sketch for a little (stupid) plants irrigator
//Baldarn and Edo
//http://hack.lenotta.com
//
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 RTC;
int relay = 8;

void setup () {
  //Initialize the serial port, wire library and RTC module
    Serial.begin(9600);
    Wire.begin();
    RTC.begin();
    pinMode(relay, OUTPUT);
    digitalWrite(relay, HIGH);
    //IF YOU USE RTC FOR THE FIRST TIME: If we remove the comment from the following line, we will set up the module time and date with the computer one
    //RTC.adjust(DateTime(__DATE__, __TIME__));
}

void loop () {
    DateTime now = RTC.now();
    //We print the day
    Serial.print(now.day(), DEC);
    Serial.print('/');
    //We print the month
    Serial.print(now.month(), DEC);
    Serial.print('/');
    //We print the year
    Serial.print(now.year(), DEC);
    Serial.print(' ');
    //We print the hour
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    //We print the minutes
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    //We print the seconds
    Serial.print(now.second(), DEC);
    Serial.println();
    //We check the time and sent through the serial port every 3s
    if(now.dayOfYear() % 2 == 0){
      if(now.hour() == 20){
        if(now.minute() == 54){
          digitalWrite(relay, LOW);
        }
        else{
          digitalWrite(relay, HIGH);
        }
      }
    }

    //Serial.println(digitalRead(relay));
    //Serial.println();
    delay(3000);
}

//Sketch for a little (stupid) plants irrigator

//Baldarn and Edo

//http://hack.lenotta.com

#include <Wire.h>

#include "RTClib.h"

RTC_DS1307 RTC;

int relay = 8;

void setup () {

//Initialize the serial port, wire library and RTC module

Serial.begin(9600);

Wire.begin();

RTC.begin();

pinMode(relay, OUTPUT);

digitalWrite(relay, HIGH);

//IF YOU USE RTC FOR THE FIRST TIME: If we remove the comment from the following line, we will set up the module time and date with the computer one

//RTC.adjust(DateTime(__DATE__, __TIME__));

}

void loop () {

DateTime now = RTC.now();

//We print the day

Serial.print(now.day(), DEC);

Serial.print('/');

//We print the month

Serial.print(now.month(), DEC);

Serial.print('/');

//We print the year

Serial.print(now.year(), DEC);

Serial.print(' ');

//We print the hour

Serial.print(now.hour(), DEC);

Serial.print(':');

//We print the minutes

Serial.print(now.minute(), DEC);

Serial.print(':');

//We print the seconds

Serial.print(now.second(), DEC);

Serial.println();

//We check the time and sent through the serial port every 3s

if(now.dayOfYear() % 2 == 0){

if(now.hour() == 20){

if(now.minute() == 54){

digitalWrite(relay, LOW);

}

else{

digitalWrite(relay, HIGH);

}

//Serial.println(digitalRead(relay));

//Serial.println();

delay(3000);

}

The Function We Added

We have modified the class DateTime in RTClib.h as follow:

//
//Baldarn and Edo
//http://hack.lenotta.com
//
class DateTime {
public:
    DateTime (uint32_t t =0);
    DateTime (uint16_t year, uint8_t month, uint8_t day,
                uint8_t hour =0, uint8_t min =0, uint8_t sec =0);
    DateTime (const char* date, const char* time);
    uint16_t year() const       { return 2000 + yOff; }
    uint8_t month() const       { return m; }
    uint8_t day() const         { return d; }
    uint8_t hour() const        { return hh; }
    uint8_t minute() const      { return mm; }
    uint8_t second() const      { return ss; }
    uint8_t dayOfWeek() const;

    //This is the function to calculate which day of the year it is:

    uint8_t dayOfYear() const;

    // 32-bit times as seconds since 1/1/2000
    long secondstime() const;   
    // 32-bit times as seconds since 1/1/1970
    uint32_t unixtime(void) const;

protected:
    uint8_t yOff, m, d, hh, mm, ss;
};

//Baldarn and Edo

//http://hack.lenotta.com

class DateTime {

public:

DateTime (uint32_t t =0);

DateTime (uint16_t year, uint8_t month, uint8_t day,

uint8_t hour =0, uint8_t min =0, uint8_t sec =0);

DateTime (const char* date, const char* time);

uint16_t year() const { return 2000 + yOff; }

uint8_t month() const { return m; }

uint8_t day() const { return d; }

uint8_t hour() const { return hh; }

uint8_t minute() const { return mm; }

uint8_t second() const { return ss; }

uint8_t dayOfWeek() const;

//This is the function to calculate which day of the year it is:

uint8_t dayOfYear() const;

// 32-bit times as seconds since 1/1/2000

long secondstime() const;

// 32-bit times as seconds since 1/1/1970

uint32_t unixtime(void) const;

protected:

uint8_t yOff, m, d, hh, mm, ss;

};

and added the following function to RTClib.cpp:

//
//Baldarn and Edo
//http://hack.lenotta.com
//
uint8_t DateTime::dayOfYear() const {    
    uint16_t days = d;
    for (uint8_t i = 1; i < m; ++i)
        days += pgm_read_byte(daysInMonth + i - 1);
    if (m > 2 && yOff % 4 == 0)
        ++days;

    return days;
}

//Baldarn and Edo

//http://hack.lenotta.com

uint8_t DateTime::dayOfYear() const {

uint16_t days = d;

for (uint8_t i = 1; i < m; ++i)

days += pgm_read_byte(daysInMonth + i - 1);

if (m > 2 && yOff % 4 == 0)

++days;

return days;

}

Possible Developments

As you’ve seen this is a really stupid implementation, but it was on our purpose to make it stupid and not including any sort of display.
In fact, the main project is a little bit bigger than just a programmable Garduino (as someone calls it).

What we have in mind is to make the Garduino just an interpreter for our garden architect “Mr Rasp Gardner”, a raspberry pi which will communicate with the arduino using the NRF24l01+ module we tested here. As you can imagine, this drive us to an intelligent gardener, a nice web interface, statistics and much (much) more.

One of the first thing to implement, apart wireless communication, could be a simple hygrometer which will tell us if the plants have actually been watered. Maybe next week.

Tp-link wr841nd debricking session [Success]

We made it!

After thousand of tests, passing by a serial tftp boot, trying jtag reprogramming we finally get back the wr841nd (ver.8.1) to life!

How?

We followed an OpenWRT guide that you can find over here

Well… we disassembled the flash of another working router with a very small soldering iron tip (all the merit goes to Edo).

Then we connected to the serial of the router via an arduino adapter. Doing this we cuold connect to uboot (remember the “tpl” keys for getting to the uboot console!!).

From the console we dumped all the files of the flash into the ram with the command:

C

cp.b 0x9f000000 0x81000000 0x3effff

1

cp.b 0x9f000000 0x81000000 0x3effff

The command is: copy the content of the flash (0x9f000000) to the ram (0x81000000) for the lenght (0x3effff)

Then we reassembled the old broken flash and copied all back in that one with the command:

C

cp.b 0x81000000 0x9f000000 0x3effff

1

cp.b 0x81000000 0x9f000000 0x3effff

And doing this we restored uboot in the broken flash. After this we reinstalled OpenWRT via the tftp server mode with the following commands:

C

erase 0x9f020000 +0x3c0000

1

erase 0x9f020000 +0x3c0000

C

tftpboot 0x81000000 openwrt.bin

1

tftpboot 0x81000000 openwrt.bin

C

cp.b 0x81000000 0x9f020000 0x3c0000

1

cp.b 0x81000000 0x9f020000 0x3c0000

C

bootm 0x9f020000

1

bootm 0x9f020000

Finally we had a working router!

[Ninux] Installing Baldarn’s Ninux node

The first link of Ninux Firenze is now online! I am now connected to Leonardo via a radio link in the 5GHz bandwith. Let’s summarize the installation, I’ve needed:

Ubiquity NanoBrige M5 25dBi
IP56 waterproof container
20 m of corrugated pipe
20m of STP cat 5e cable
2 shielded 5e plugs

The first thing to do was making a hole from a room in the top of the house for the cat 5e cable and the current. I used a 40 cm drill for this dirty job. Luckily I already had an antenna of a wisp.

Hole inside the house

Hole from outside the house

The next step was mounting the waterproof container. I drilled four holes and mounted the container on the wall outside the room. Inside I’ve mounted 4 sockets for the current.

Later I’ve isolated the holes for the screws with some silicone and drilled some little holes in the bottom of the container for letting water goes out in case of condensation.

Container with sockets

Next the roof part. I’ve passed the cat 5e cable in the corrugated pipe, attached the pipe to the container and the antenna on the roof.

The route of the corrugated pipe

Preparing the antenna on the roof

The node is now up and running! May the wireless be with you!

Hack | Lenotta

Recent Posts

Posts by Lorenzo Farnararo

[ARDUINO + RASPBERRY PI] Switching light with NRF24l01+

Hardware:

Raspberry Pi

Arduino

NOTE ON PACKET LOSS:

Software

Sketching

Enabling Raspberry Pi GPIO and Installing Node.js

The Lamp Switch Application

The Node.js Lamp Application

Authors note (31/3/2014)

Update (10/5/2014)

Update (27/8/2014)

Update (2/12/2014)

Update (17/01/2016)

[Arduino] DIY (stupid and cheap) Plants Irrigator

What we’ve used

Wiring

Sketching

The Sketch

The Function We Added

Possible Developments

Tp-link wr841nd debricking session [Success]

[Ninux] Installing Baldarn’s Ninux node