Nodo project – Nodo Ethernet Shield (NES)

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

Today the NES kit has been delivered and I got it working.

NES

After same soldering the NES seems to work. I connected it to the router configured the port forwarding and logged into the Nodo Webapp. The Nodo is recognized over the internet and I could configure some settings in the Webapp. Now the issue is to figure out what addresses my KAKU devices have so I can control and monitor them.

Hopefully I can do some domotica very soon.

Interested in this hardware then take a look at:

Nodo domotica
Nodo shop – the NES
Nodo wiki
Nodo forum

How to communicate using URLConnection in Java

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

Reading data with serial communication between Arduino and PC is one step. After the PC has received the data I want it to send the data (raw or after some calculations) to a website. The website will store the data and show the data in some nice graphs and tables.
The other way around I want to send some commands from the website to the PC where the Java app has to send it to the Arduino which on its turn will perform some actions. I will write another post on this subject some other time.

I found a nice page at Oracle describing how to use the Java URLConnection class.

Depending on the functionality of your website script/app you could start very simple with the code below.


import java.io.*;
import java.net.*;

public class Reverse {
    public static void main(String[] args) throws Exception {

	URL url = new URL("http://www.your-domain.nl/store_value.php?type=KAKU&value=1234567");
	URLConnection connection = url.openConnection();
	connection.setDoOutput(true);

	OutputStreamWriter out = new OutputStreamWriter(
                              connection.getOutputStream());
	out.close();

	BufferedReader in = new BufferedReader(
				new InputStreamReader(
				connection.getInputStream()));
	in.close();
    }
}

All we do here is opening an URL to a PHP page and provide it with two variables. These variables can be extracted from the URL by the PHP script. The snippet below shows a piece of PHP code to extract the variables from the URL. After you got the variable values they can be stored in a database, written to a file, etc..

<?php

$type = $_GET['type'];
$value = $_GET['value'];

// store it in a database or write it to a file or ...

print "TYPE = ".$type." -- VALUE =".$value."</BR>"; 

?>

I know it is very basic and not secure in the dangerous open network world (internet), but as a starting point for private network environments it might be helpful.

 

 

Serial communication between PC and Arduino

Your ads will be inserted here by

Easy Plugin for AdSense.

Please go to the plugin admin page to
Paste your ad code OR
Suppress this ad slot.

Using sensors together with the Arduino or JeeNode is cool. Using the serial monitor of the Arduino IDE lets you see the values. The data is sent from the Arduino over (in my case) a USB cable to my PC. With the serial monitor of the IDE I can receive and also send data.

To make a domotica solution I need something more than the serial monitor of the IDE. I want to be able to send and receive data from my own application and website.

I’m want to use Java to develop the application that’s going to send and receive data. Although I might also try C/C++ in a while, but for now I’ll focus on Java. The reason I want to use Java is that I’m using a Windows computer to develop, but I might want to use a Linux based device to let my application run and do its job. Hopefully it will be easier to switch between the two operating systems with an application written in Java.
(The platform I’m thinking of is the Raspberry Pi; hopefully soon to be ordered)

Searching for a good way to start writing code to communicate with an Arduino I found this page on the Arduino website and also another interesting website. (I did find this site about C and Arduino which might be useful in the future; and this one is I think about Processing and Arduino)

It turns out that by using the RXTX Java library it is possible to use serial communication to send and receive data between a PC and an Arduino. The page shows a code example of a Java app which is able to receive data from a serial port (COM port; in PC terms).

I chose Eclipse as my Java IDE (the SpringSource version to be exact). I had to download the 2.2pre version of the RXTX Library, because my Windows is a 65-bit version. In the 2.2pre package a 64-bit version of the rxtxSerial.dll is included. The 32-bit version will not work on a 64-bit OS, as I found out by trial-and-error. (I didn’t read through the entire page on Arduino.cc otherwise I would have seen the instruction)  Beware that when you use the 2.2pre .dll file you also need to use the 2.2pre RXTXcomm.jar file in your classpath. If you don’t a version mismatch error will be shown.

The steps I took for my basic serial communication test application were:

  1. copy the rxtxSerial.dll to c:\windows\sysWOW64
  2. add the c:\windows\sysWOW64 to your path
  3. added the location of the RXTXcomm.jar file to the classpath in Eclipse
  4. created a new Java project;
  5. added a new file to the \src of the project
  6. named it SerialTest.java
  7. copied the code snippet from the Arduino page (file is attached to this post)
  8. change the COM port to COM5
  9.  changed the bit-rate in the Java code (I needed 57600 for my JeeLink with RF12Demo)
  10. build en run

I saw the expected text from the RF12Demo in the console window of Eclipse.

The first step is done, data is transferred from JeeLink (Arduino) to a ‘self made’ application. The next step is, of course, to send data to an Arduino. I’ll let  you know whta my findings are.

The first of many steps to my own Java Domotica-bridge application.

Is there light? LDR sensor input

You can imagine it is helpful to know when it gets dark in or around the house. Knowing this you could turn on the lights automatically.  There are different sensors you can use to measure light intensity. At the moment I have some LDR (light dependent resistor)  elements to do some tests.

An LDR has a  high resistance when no light is sensed, the resistance will decrease when the sensor is illuminated (see also).

A basic test scenario is to connect an LDR together with a 10K Ohm resistor to your Arduino.

Together with the code snippet below you can experiment with more or less light. I don’t know whether the printed values are close to reality but you can give it a try.

/* Photocell simple testing sketch.

Connect one end of the photocell to 5V, the other end to Analog 0.
Then connect one end of a 10K resistor from Analog 0 to ground

For more information see www.ladyada.net/learn/sensors/cds.html
Modified by M.A. de Pablo. October 18, 2009.
Thanks to Grumpy_Mike for equations improvement.
*/


int photocellPin0 = 0;     // the cell and 10K pulldown are connected to a0
int photocellReading0;     // the analog reading from the analog resistor divider
float Res0=10.0;		  // Resistance in the circuit of sensor 0 (KOhms)
// depending of the Resistance used, you could measure better at dark or at bright conditions.
// you could use a double circuit (using other LDR connected to analog pin 1) to have fun testing the sensors.
// Change the value of Res0 depending of what you use in the circuit

void setup(void) {
  // We'll send debugging information via the Serial monitor
  Serial.begin(9600);  
}


void loop(void) {
  photocellReading0 = analogRead(photocellPin0);   // Read the analogue pin
  float Vout0=photocellReading0*0.0048828125;	// calculate the voltage
  int lux0=500/(Res0*((5-Vout0)/Vout0));	     // calculate the Lux
  Serial.print("Luminosidad 0: ");		     // Print the measurement (in Lux units) in the screen
  Serial.print(lux0);
  Serial.print(" Lux\t");
  Serial.print("Voltage: ");			     // Print the calculated voltage returned to pin 0
  Serial.print(Vout0);
  Serial.print(" Volts\t");
  Serial.print("Output: ");
  Serial.print(photocellReading0);		   // Print the measured level at pin 0
  Serial.print("Ligth conditions: ");		// Print an approach to ligth conditions
  if (photocellReading0 < 10) {
    Serial.println(" - Dark");
  } else if (photocellReading0 < 200) {
    Serial.println(" - Dim");
  } else if (photocellReading0 < 500) {
    Serial.println(" - Light");
  } else if (photocellReading0 < 800) {
    Serial.println(" - Bright");
  } else {
    Serial.println(" - Very bright");
  }
  delay(1000);
} 

Ladyada has a page with information about photocells, light, lux and Arduino. This page has a great sample scheme including a code example.

TMP36 – Temperature sensor

I picked the TMP36 (datasheet) to measure temperature. It’s a cheap and easy to use sensor with a broad range of temperatures it can measure. Several websites describe how to use it in combination with an Arduino, so it is easy to test it. In this post I use the information of several sources to describe how to use the TMP36. At the bottom I give the links to all sources.

The TMP36 can be used with voltages between 2.7V and 5.5V. The analog output lays between approx. 0V (ground) to 1.75V.

There are two formulas to calculate the voltages at the input pins,
one if you use 5V:

Voltage at pin in milliVolts = (reading from ADC) * (5000/1024)
This formula converts the number 0-1023 from the ADC into 0-5000mV (= 5V)

And one to use with  3.3V:

Voltage at pin in milliVolts = (reading from ADC) * (3300/1024)
This formula converts the number 0-1023 from the ADC into 0-3300mV (= 3.3V)

To convert the milliVolts to Centigrade use the formula:

Centigrade temperature = [(analog voltage in mV) – 500] / 10

Below is a code snippet that will ‘read’ the temperature in Centigrade.

/*  
*  Sample sketch to measure the temperature using a TMP36
*  The TMP36 is connected to 5V and analog pin 0
*/

// The Arduino pin the TMP36 signal pin is connected to
int tempPin = 0;    

void setup()
{
  Serial.begin(9600);  
}

void loop()
{
      //  Get the value from the sensor
      int readvalue = analogRead(tempPin);       
      float voltage = readvalue * 5.0;                     
      voltage = voltage / 1024.0;                    
      float centigrade = (voltage - 0.5) * 100 ;
      Serial.print(centigrade);
      delay(5000);
}

Ladyada.net descibes the sensor in this page.
Oomlout describes an example on its page.
Tronixstuff has also a description of how to use it.

To use the TMP36 with a JeeNode you can connect it:
TMP36 V+ (pin1) to JeeNode (+)
TMP36 Vout (pin2) to JeeNode Analog (A)
TMP36 GND (pin3) to JeeNode GND (G)

KAKU with Arduino using Nodo

The previous post was about JeeNode and receiving KAKU commands. The nodo-domotica  solution is also able to handle KAKU commands. I tried the Nodo sketch together with my Arduino Mega and an Aurel 433Mhz RX module bought from Conrad.

Aurel RX-4M50RR30SF

The module I used was the RX-4M50RR30SF (433mHz 5V – 102DBM – AM receiver). The productnumber at Conrad.nl is 190264 and it can be found here.

The Nodo schematic  shows that Arduino digital pin 2 is connected to the data-out pin of the RX module and that Arduino digital pin 12 is connected to the +5V pin of the RX module. The module’s GND pin is of course connected to a GND pin of the Arduino.
Looking at the photo above you see 8 pins instead of 3 pins; that’s because there is a pin for the antenna, 2 extra GND pins, a test pin (I don’t know how to use this) and an extra +5V pin. I connected all the three GND to the GND, the two +5V to pin 12 and the antenna pin to a approx. 17.5 cm piece of copper.
The nodo website mentions an antenna length of 15 cm but I already found some text about antenna lengths for 433Mhz signals mentioning the 17.5 cm. In close range both will work and that is what I have tested until now. It is also possible to buy a real antenna.

I was very happy to see this piece of hardware work. Before I tested this RF module I tried another module (QAM-RX4-433 from Ideetron.nl) which didn’t work in combination with the Nodo software.

 More things to sense …

 

JeeNode and OOK433 plug

Besides an Arduino Mega 2560 I can also use a JeeNode to do some experiments. The JeeNode is made based upon the Arduino but it has several differences. Like, it has fewer ports, it runs on 3.3V instead of 5V, it is smaller and has I2C support. Another great feature is the RFM12B wireless RF chipset that can be used to let JeeNodes communicate with eachother. Take a look at the JeeLabs blog for a ton of information, it is really great.

Because one of the wishes for my domotica solution is controlling KAKU devices a 433Mhz OOK RF receiver and transmitter is needed.  JeeLabs has a nice solution; the OOK 433 plug.

This plug has two 433 Mhz chipsets; one to send and one to receive signals. KAKU uses On-Off-keying (OOK) modulation for sending and receiving signals.

KAKU remote YCT-102

I assembled the plug and tested the ookDecoder.pde sketch (look at the bottom of the page), together with my KAKU YCT-102 remote. I was lucky as it worked right away; I read that some people weren’t able to get it working in combination with another KAKU remote (probably an older version).

It also works with the KAKU doorbell transmitter (ACDB-6500BC).

One thing to mention is that the sketch decodes the signals as ‘HEZ’ signals instead of ‘KAKU’ signals. Some other website also mentioned that the signals of the UCR-4285 universal KAKU remote were also recognized as ‘HEZ’ signals.

However, if you remove  ‘HezDecoder hez;’ in the ookDecoder.pde sketch the signals will show up as KAKU commands!

As for now I haven’t tried to send KAKU commands so I don’t know if that works in combination with my KAKU socket units.

Because I cannot find the webpage to download the ookDecoder.pde sketch I include it below. All credits go to Jean-Claude (owner of JeeLabs and creator of the JeeNode hardware) see the comments in the code.

 

// New code to decode OOK signals from weather sensors, etc.
// 2010-04-11 <jcw@equi4.com> http://opensource.org/licenses/mit-license.php
// $Id: ookDecoder.pde 7527 2011-04-11 01:57:48Z jcw $

#include "decoders.h"

#define USE_433 1
#define USE_868 0

#if USE_433
OregonDecoder orsc;
CrestaDecoder cres;
KakuDecoder kaku;
XrfDecoder xrf;
HezDecoder hez;
#endif

#if USE_868
VisonicDecoder viso;
EMxDecoder emx;
KSxDecoder ksx;
FSxDecoder fsx;
#endif

#define PORT 1

volatile word pulse;

ISR(ANALOG_COMP_vect) {
    static word last;
    // determine the pulse length in microseconds, for either polarity
    pulse = micros() - last;
    last += pulse;
}

void reportSerial (const char* s, DecodeOOK& decoder) {
    byte pos;
    const byte* data = decoder.getData(pos);
    Serial.print(s);
    Serial.print(' ');
    for (byte i = 0; i < pos; ++i) {
        byte d = data[i];
        Serial.print(d & 0x0F, HEX);
        Serial.print(d >> 4, HEX);
    }
    // Serial.print(' ');
    // Serial.print(millis() / 1000);
    Serial.println();
    
    decoder.resetDecoder();
}

void setup () {
    Serial.begin(57600);
    Serial.println("\n[ookDecoder]");
    
    pinMode(13 + PORT, INPUT);  // use the AIO pin
    digitalWrite(13 + PORT, 1); // enable pull-up

    // use analog comparator to switch at 1.1V bandgap transition
    ACSR = _BV(ACBG) | _BV(ACI) | _BV(ACIE);

    // set ADC mux to the proper port
    ADCSRA &= ~ bit(ADEN);
    ADCSRB |= bit(ACME);
    ADMUX = PORT - 1;
}

void loop () {
    cli();
    word p = pulse;
    pulse = 0;
    sei();

#if USE_433
    if (p != 0) {
        if (orsc.nextPulse(p))
            reportSerial("ORSC", orsc);        
        if (cres.nextPulse(p))
            reportSerial("CRES", cres);        
        if (kaku.nextPulse(p))
            reportSerial("KAKU", kaku);        
        if (xrf.nextPulse(p))
            reportSerial("XRF", xrf);        
        if (hez.nextPulse(p))
            reportSerial("HEZ", hez);        
    }
#endif

#if USE_868
    if (p != 0) {
        if (viso.nextPulse(p))
            reportSerial("VISO", viso);        
        if (emx.nextPulse(p))
            reportSerial("EMX", emx);        
        if (ksx.nextPulse(p))
            reportSerial("KSX", ksx);        
        if (fsx.nextPulse(p))
            reportSerial("FSX", fsx);        
    }
#endif
}

Nodo can do KAKU too …

Domotica

Since a month or so I’m working on a domotica implementation. Based on Arduino and Arduino like hardware. For now it is just browsing the internet to look for the right hardware. What sensors are available and how can they be used together with the Arduino development tools (IDE and available sketches).
I like to start with known solutions to learn more about the way Arduino works and how the connected hardware can be controlled.

For now I’m playing with an Arduino Mega 2560 and some JeeNode (JeeLabs) hardware. The JeeNode is a Arduino compatible platform with several interesting features. First of all it has a great community. Second, it has several nice out-of-the box features which are great for a domotica solution. It comes with a wireless RF chip that is configured to communicate with other JeeNodes. This is a real plus for a wireless domotica implementation. It is possible, with the pre-installed demo-sketch, to make a mesh-like network of JeeNodes.

For the Arduino I found the Nodo project as a great starting point for a Arduino based domotica solution. A new version is being made at this time which aims at the Arduino Mega and the new Arduino 1.0 IDE.

In this blog I want to share my experience in the quest for a great domotica implementation. Examples of sensors, sketches and links to interesting websites.

That’s it for the first post.