Friday, March 21, 2014

Installing Laravel 4 in Ubuntu Server with PHP 5.5


Today we are going to learn how to install Laravel 4 with PHP 5.5 on Ubuntu Server from cero.

1) Adding a repository

sudo apt-get install python-software-properties
sudo add-apt-repository ppa:ondrej/php5

2) Updating repositories

sudo apt-get update
sudo apt-get upgrade

3) Installing PHP 5.5

sudo apt-get install php5 php5-mcrypt
php -v

PHP 5.5.9-1+sury.org~precise+1 (cli) (built: Feb 13 2014 15:53:53)
(Optional)
sudo apt-get install php5-gd php5-curl php5-cli php5-cgi php5-dev
4) Enable Apache mod_rewrite to use Laravel pretty URL's

sudo e2enmod rewrite
sudo apache2 restart

5) Installing Composer

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

6) Installing Laravel in your desired folder (Ex. /var/www/projectname)

composer create-project laravel/laravel projectname

7) Setting up the permisions

chmod -R 775 /var/www/projectname/app/storage

8) Setting up Apache. Edit /etc/apache2/sites-available/default for example and set your configuration. 
sudo service apache2 reload

Hope help!




Thursday, March 13, 2014

How to run an script/command when a USB is connected to the port with udev in a Raspberry Pi

How to run an script/command when a USB is connected to the port.

Well, first we have to discover some information about the USB device and then we will be able to define rules to indicate the system which script we want to run.

Connect the USB device and enter the next commands

1) Get the serial number of the device

$ udevadm info -a -n /dev/ttyUSB0 | grep '{serial}' | head -n1

    ATTRS{serial}=="1234567890"
    

2) Get the Id Vendor

$ udevadm info -a -n /dev/ttyUSB0 | grep idVendor | head -n1

    ATTRS{idVendor}=="0403"


3) Get the Product Id

$ udevadm info -a -n /dev/ttyUSB0 | grep idProduct | head -n1
 
    ATTRS{idProduct}=="6001"


Now with this information we can write the UDEV rule:

4) Create a new file /etc/udev/rules.d/99-usbserial.rules and insert the line (one line):

$ sudo vi /etc/udev/rules.d/99-usbserial.rules

ACTION=="add", SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", RUN+="YOURSCRIPT_FULLPATH"


5) Save the file and reset the udev service

$ sudo /etc/init.d/udev restart

Ready, now when the USB device is connected the script YOURSCRIPT_FULLPATH will be launch. You also can see the log details of udev in /var/log/daemon.log.

(Note: In my rule I didn't use the serial number :))

Hope help!

Wednesday, March 12, 2014

HTTP POST request with JSON String in JAVA for Raspberry Pi - libhttpclient-java

Hi there,
Continuing with the last project I want to send the data collected by the Raspberry Pi to my API service. I need to do that using JAVA, so I decided to use libcommons-httpclient-java , a Java library for creating HTTP clients.

Let's install it:

pi@raspberrypi ~ $ sudo apt-get install libhttpclient-java
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following extra packages will be installed:
  libhttpcore-java
The following NEW packages will be installed:
  libhttpclient-java libhttpcore-java
0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.
Need to get 671 kB of archives.
After this operation, 892 kB of additional disk space will be used.
Do you want to continue [Y/n]? 

...


We can compile using this library (javac -cp ...) or include the new library in ore CLASSPATH variable:

$ export CLASSPATH=$CLASSPATH:/usr/share/java/httpclient.jar
$ export CLASSPATH=$CLASSPATH:/usr/share/java/httpcore.jar
$ export CLASSPATH=$CLASSPATH:/usr/share/java/commons-logging-1.1.1.jar


Now, it's time to code the java http client which post the data to the server (not explained in this post).

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.message.BasicNameValuePair;

import java.util.List;
import java.util.ArrayList;

public class ApacheHttpClientPost {
    public static final int HTTP_OK = 200;
    private String restUrl="http://192.168.188.20/arest/serverside.php";
   
    public void setRestUrl(String url) {
        this.restUrl = url;
    }
   
   
    public int sendJson(String jsonString) {

        int responseStatusCode = -1;
       
        try {

            HttpClient httpClient = new DefaultHttpClient();
            HttpPost post = new HttpPost(this.restUrl);

            List nameValuePairs = new ArrayList(1);
            nameValuePairs.add(new BasicNameValuePair("tel", jsonString));

            post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
            HttpResponse response = httpClient.execute(post);


            responseStatusCode = response.getStatusLine().getStatusCode();
            System.out.println(responseStatusCode);
            if (responseStatusCode > 200 && responseStatusCode < 300) {
                throw new RuntimeException("Failed : HTTP error code : "
                    + response.getStatusLine().getStatusCode());
            }
   
            BufferedReader br = new BufferedReader(
                new InputStreamReader((response.getEntity().getContent())));
   
            String output;
            System.out.println("Output from Server .... \n");
            while ((output = br.readLine()) != null) {
                System.out.println(output);
            }
   
            httpClient.getConnectionManager().shutdown();
           
        } catch (MalformedURLException e) {
            e.printStackTrace();

        } catch (IOException e) {
            e.printStackTrace();
        }

        return responseStatusCode;
    }
   
    public static void main(String[] args) {
        ApacheHttpClientPost me = new ApacheHttpClientPost();
       
        me.sendJson("{data: \"data content\"}");
    }
}


Don't forget to set up a server and change the "restUrl" URL. To compile and execute the code run the next commands:

pi@raspberrypi ~/java $ javac ApacheHttpClientPost.java
pi@raspberrypi ~/java $ java ApacheHttpClientPost

200
Output from Server ....

Array
(
    [tel] => {data: "data content"}
)


Of course, the code works but it is an extract from the project. I recomment you to use it as a reference.

Hope help!





Tuesday, March 11, 2014

Encoding JSON in Java with libjson-simple


Before start to encoding/decoding JSON using Java, we will need to install a JSON library. In this example I will use libjson-simple as follow:

pi@raspberrypi ~/$ sudo apt-get install libjson-simple-java

Once we have installed the library we need to update our CLASSPATH system variable:


pi@raspberrypi ~/$ export CLASSPATH=$CLASSPATH:/usr/share/java/json_simple-1.1.jar
Now we are ready to coding. Let use the next code:

import org.json.simple.JSONObject;

class JsonEncodeDemo
{
   public static void main(String[] args)
   {
      JSONObject obj = new JSONObject();

      obj.put("protocol", "mbus");
      obj.put("length", new Integer(168));
      obj.put("manufacturer", new Integer(4897));
      obj.put("valid", new Boolean(true));

      System.out.print(obj);
   }
}

To execute the code we can use:

pi@raspberrypi ~/java $ javac JsonEncodeDemo.java
pi@raspberrypi ~/$ java JsonEncodeDemo{"valid":true,"protocol":"mbus","manufacturer":4897,"length":168}

Hope help!!

Raspberry Pi. Read data from USB Serial Port using Java and Python.


Hello,

Recently I bought my first Raspberry Pi, and as a first project I decided to implement a wireless package filter.. Here I'm going to show how to read the USB (serial port) using Linux on a Raspberri Pi.

Using Python

First, you have to install the basic packages to read serial port

pi@raspberrypi ~ $ sudo apt-get install python-serial

In my case I am using FTDI wireless USB device, connected to the port /dev/ttyUSB0. You can check the state of your USB stick and the kernel modules associted to it using the command:

pi@raspberrypi ~ $ dmesg
...
[    5.822444] usbcore: registered new interface driver usbserial
[    5.988161] usbcore: registered new interface driver usbserial_generic
[    6.169752] usbserial: USB Serial support registered for generic
[    6.594175] usbcore: registered new interface driver ftdi_sio
[    6.683308] bcm2708-i2s bcm2708-i2s.0: Failed to create debugfs directory
[    6.870064] usbserial: USB Serial support registered for FTDI USB Serial Device
[    7.198032] ftdi_sio 1-1.2:1.0: FTDI USB Serial Device converter detected
[    7.336725] usb 1-1.2: Detected FT232RL
[    7.533758] usb 1-1.2: Number of endpoints 2
[    7.639343] usb 1-1.2: Endpoint 1 MaxPacketSize 64
[    7.729645] usb 1-1.2: Endpoint 2 MaxPacketSize 64
[    7.808760] usb 1-1.2: Setting MaxPacketSize 64
[    7.879211] usb 1-1.2: FTDI USB Serial Device converter now attached to ttyUSB0
...


The loaded modules for my devices are shown with the command:

pi@raspberrypi ~ $ lsmod
Module                  Size       Used by

...
ftdi_sio               29846       0
usbserial              26929       1 ftdi_sio
...


You can get more information about your USB devices as follow:

pi@raspberrypi ~ $ lsusb
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.
Bus 001 Device 004: ID 0403:6001 Future Technology Devices International, Ltd FT232 USB-Serial 


Once we know that the device is connected and has beed detected we can start coding. In my case the parameters to fetch the device are: 9600 8N1.

import serial
import sys

# configure the serial connections (the parameters differs on the device you are connecting to)
ser = serial.Serial(
    port='/dev/ttyUSB0',
    baudrate=9600,
    parity=serial.PARITY_ODD,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
)
 
# Print the bytes feched 
while True:
    n = ser.inWaiting()

    if n>0:

            ch=ser.read(size=1)
            print("%02x" % ord(ch),  end='')

This is a very basic code that read data from /dev/ttyUSB0 and print it hexadecimal pair format.

Now you can include your code to detect different telegrams or patterns, por example using:

            if '0x68' == hex(ord(ch)):
                    data="blablabla"

Using Java

If we want to do the same using Java, we need to install first the RXTX library (and of course Java SDK)

pi@raspberrypi ~ $ sudo apt-get install librxtx-java
Then you need to update your local varibles: CLASSPATH and LD_LIBRARY_PATH, for example as follow:

pi@raspberrypi ~ $ export CLASSPATH=$CLASSPATH:/usr/share/java/RXTXcomm.jar
pi@raspberrypi ~ $ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/jni


Now you are ready to code. A basic example is here presented:

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;

import java.io.IOException;
import java.io.InputStream;

public class TestSerialComm {
    private CommPortIdentifier portIdentifier;
    private SerialPort serialPort;
    private InputStream in;

    public static final boolean DEV_MODE = true;
   
    void connect( String portName ) throws Exception {
        this.portIdentifier = CommPortIdentifier.getPortIdentifier( portName );

        if( portIdentifier.isCurrentlyOwned() ) {
       
          System.out.println( "Error: Port is currently in use" );
         
        } else {
       
            if(DEV_MODE) System.out.println("Starting...");
           
            int timeout = 2000;
            CommPort commPort = portIdentifier.open( this.getClass().getName(), timeout );

            if( commPort instanceof SerialPort ) {
                this.serialPort = ( SerialPort )commPort;
                serialPort.setSerialPortParams( 9600 ,
                                            SerialPort.DATABITS_8,
                                            SerialPort.STOPBITS_1,
                                            SerialPort.FLOWCONTROL_NONE );

                this.in = serialPort.getInputStream();

            } else {
                System.out.println( "Error: Only serial ports are handled by this example." );
            }
        }
    }

    public void fetchTelegrams() throws Exception {
        int b = -1;

        if(DEV_MODE) System.out.println("Inside loop...");

        while (true) {

            // Read new byte
            b = this.in.read();        


            // Negative value means no-data
            while(b<0 br="" nbsp="">                             b = this.in.read();


            // We have data
            System.out.print(this.hexify(b));             

             // Your code is here
             // ....
        }

    }
   
    /*
     * Convert received byte (int form) to HEX couples.
     */
    public String hexify(int input){
        String output = Integer.toHexString(input).toUpperCase();
        if(output.length() == 1)
            output = "0"+output;
        return output;
    }

    public static void main( String[] args ) {
        try {
            TestSerialComm test = new TestSerialComm();
            test.connect( "/dev/ttyUSB0" );
                                       
            // Infinity loop
            test.fetchTelegrams();
            System.exit(0);
               
        } catch( Exception e ) {
          e.printStackTrace();
        }
    }
}


To compile this example, you can for example do this:

pi@raspberrypi ~/java $ javac TestSerialComm.java
pi@raspberrypi ~/java $ java TestSerialComm
Starting...
Running...

74495041919473055087219194730...

I hope help!!