Sonntag, 3. Mai 2015

AngularJS a Startup guide


Einen kleinen Einblick in AngularJS und NodeJS


Mit wenigen Schritten könnt ihr euren eigenen NodeJS Testserver erstellen und Daten an der Oberfläche anzeigen.

Unser Ziel:

  1. Node installieren
  2. Node verwenden
  3. Server selbst programmieren
  4. HTML und JavaScript Dateien ausliefern
  5. Kommunikation Server ====== Client

Dann lasst uns mal starten.

Server

Mit AngularJS und NodeJS können wir mit wenigen Zeilen Code und Node Paketen einen funktionierenden Testserver erstellen.

Schritt 1:

NodeJS installieren https://nodejs.org/

Schritt 2:
Ordner erstellen in dem ihr eure Erste Testapplikation erstellen wollt.
In dem Ordner eine Datei package.json erstellen.

Diese zeigt dem Node Package Manager (der Paketverwaltung) an welche Pakete für euer Projekt heruntergeladen und installiert werden müssen.
 {  
  "name": "nodeSeed",  
  "version": "0.1.0",  
  "description": "",  
  "main": "server.js",  
  "scripts": {  
   "test": "echo \"Error: no test specified\" && exit 1",  
   "start": "node server.js"  
  },  
  "author": "",  
  "license": "ISC",  
  "dependencies": {  
   "body-parser": "~1.10.2",  
   "express": "~4.11.1"  
  }  
 }  

Perfekt, jetzt rufen wir aus der Kommandozeile den Befehl
 npm install  
auf. Hierdurch installiert der Node Package Manager alle benötigten Pakete, in unserem Fall body-parser und express. Das ganze sollte dann ungefähr so aussehen
Quelle: eigene Darstellung
Schritt 3:
Erstellt eine Datei server.js in eurem Ordner und fügt folgenden Inhalt ein
 var express = require('express');  
 var bodyParser = require('body-parser')  
 var app = express();  
 var port = 7000;  
 http = require('http'),  
 path = require('path'),  
 app.use(express.static(path.join(__dirname, 'public')));  
 app.use( bodyParser.json() );    // to support JSON-encoded bodies  
 app.use(bodyParser.urlencoded({  
  extended: true  
 })); // to support URL-encoded bodies  
 http.createServer(app).listen(port);  
 console.log('Server listen on port : ' + port);  

Super! Jetzt haben wir unseren ersten eigenen Server programmiert :)
Sieht wenig aus, oder?

Wenn ihr jetzt in der Kommandozeile in eurem Ordner node server.js aufruft lauscht euer Server auf dem Port 7000.

Schritt 4 (Der Client Code):
Jetzt müssen wir nur noch einen Ordner public erstellen in dem wir eine Datei app.js erstellen.
App.js wird unseren Client Code enthalten. Ist also für alles was dem User angezeigt wird verantwortlich.

 angular.module('testApp', [])  
  .controller('ArticlesCtrl', function($scope){  
   $scope.articles = [  
    { id: 1, name: "Pizza Vegetaria", price: 5 },  
    { id: 2, name: "Pizza Salami",  price: 5.5 },  
    { id: 3, name: "Pizza Thunfisch", price: 6 }  
   ];  
  });  

Zeile 1 definiert den Namen unseres Moduls, dieser kann natürlich von euch frei gewählt werden. testApp passt aber erstmal für unsere Zwecke.
Zeile 2 zeigt, was unser Controller, also die Verarbeitungsschicht alles kann. Javascript Kenner werden sich hier schon wie zu hause fühlen.
Die restlichen Zeilen enthalten unsere Testdaten. Alles in JSON, also einfach zu lesen und zu verstehen.

Schritt 5:
Zum Clientcode gehört neben dem Javascript Teil natürlich auch noch HTML.
Denn was wäre eine Webseite ohne HTML? :)
Legt direkt neben der app.js Datei eine index.html Datei mit folgendem Inhalt an.

 <html lang="de" ng-app="testApp">  
 <head>  
       <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.28/angular.min.js"></script>  
       <script src="/app.js"></script>  
      <title>Mein erster Angular Test</title>  
 </head>  
 <body>  
 Mein erste Angular JS Test Applikation :)  
 <table class="table" ng-controller="ArticlesCtrl">  
  <tr ng-repeat="article in articles | filter:search">  
   <td>{{article.id}}</td>  
   <td>{{article.name}}</td>  
   <td>{{article.price}}</td>  
  </tr>  
 </table>  
 </body>  
 </html>  


Im Head definieren wird die JavaScript importe, also  AngularJS und unsere app.js.
Im Body können wir die Funktionen (im Angular-Jargon Direktiven) ng-repeat verwenden.

So, jetzt können uns im Browser unter http://localhost:7000/ unser Ergebnis anschauen
Das Ergebnis sieht noch nicht wirklich hübsch aus, aber es wird angezeigt:




Ich hoffe euch hat das erste Tutorial - AngularJS Startup guide gefallen. Wenn ihr Fragen oder Anregungen habt, schreibt mir oder hinterlasst einen Kommentar.
Im nächsten Tutorial hübschen wir unsere Webseite dann auf!


Freitag, 1. Mai 2015

Raspberry Pi - Java

Java auf dem Raspberry Pi


Wie gehts und was sollte man beachten?

Wichtig ist erstmal, die Installation von Java. Perfekt, im Raspian ist Java bereits enthalten.
Wenn ihr also das Image von https://www.raspberrypi.org/downloads/ bereits auf eurem Raspi installiert habt ist in diesem Schritt nichts mehr zu tun :)

Installationsschritte:
  1. Pi4J Download
  2. Windows/ Linux Entwicklungsumgebung
  3. Erstes Programm schreiben
  4. Publishen auf den Pi
  5. Ausführen des Java Programms

1 Pi4J

Bei dem Projekt pi4J handelt es sich um eine freundliche und objektorientierte I/O API für die Steuerung der GPIOs des Raspberry Pi. 

Für die Installation auf dem Pi braucht ihr nur einige wenige Befehle:
 curl -s get.pi4j.com | sudo bash  

Hier werden alle benötigten Pakete für den Pi heruntergeladen und installiert.
Wer sich die Details anschauen möchte kann diese unter http://pi4j.com/install.html finden.

Auf dem Pi können jetzt Java Programme dei GPIOs ansteuern.

2 Entwicklungsumgebung

Ob Windows, MacOS oder Linux, als kostenfreie Entwicklungsumgebung für Java bietet sich Eclipse an. Herunterladen könnt ihr Eclipse unter eclipse-ide-java-developers
Nach dem Download einfach die ZIP Datei entpacken und die Eclipse.exe starten.

Um in Eclipse auch die benötigten Bibliotheken verwenden zu können, müsst ihr die JAR Dateien runterladen http://pi4j.com/download.html dort pi4j-1.0.zip  anklicken und runterladen.

  1. Neues Java Projekt erstellen 
    Quelle: Eigene Darstellung Eclipse
  2. Zip Datei entpacken und die JAR Dateien zu eurem Java Projekt hinzufügen. Am besten in einen Ordner mit dem Namen "lib".
    Quelle: Eigene Darstellung Eclipse
  3. Rechtsklick auf euer Projekt > build path > configure build path. Dort mit Add JARs  euer Projekt auswählen und den Inhalt des lib Ordners hinzufügen
    Quelle: Eigene Darstellung Eclipse
Jetzt ist eure Entwicklungsumgebung aufgesetzt :)

3 Erstes Programm

Für einen ersten Test wird nicht viel benötigt. Eine kleine LED reicht aus.
Folgender Code aktiviert eure LED sowie keine Internetverbindung bei dem Raspberry möglich ist.

Die LED muss an den GPIO_0 (Null) angeschlossen werden. Zusätzlich die Stromversorgung (in meinem Fall 3,3V) und GND (-).
Das Ganze sollte jetzt so aussehen

Quelle: Eigene Darstellung


 import java.io.IOException;  
 import java.net.Socket;  
 import java.net.UnknownHostException;  
 import com.pi4j.io.gpio.GpioController;  
 import com.pi4j.io.gpio.GpioFactory;  
 import com.pi4j.io.gpio.GpioPinDigitalOutput;  
 import com.pi4j.io.gpio.PinState;  
 import com.pi4j.io.gpio.RaspiPin;  
 /**  
  * This example code demonstrates how to perform simple state control of a GPIO  
  * pin on the Raspberry Pi.  
  *   
  */  
 public class ControlGpioExample {  
      public static void main(String[] args) throws InterruptedException {  
           ControlGpioExample controller = new ControlGpioExample();  
           System.out.println("<--Pi4J--> GPIO Control Example ... started.");  
           // create gpio controller  
           final GpioController gpio = GpioFactory.getInstance();  
           // provision gpio pin #01 as an output pin and turn on  
           final GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(  
                     RaspiPin.GPIO_00, "MyLED", PinState.HIGH);  
           int i = 3;  
           while (i > 0) {  
                i--;  
                controller.alarm(pin);  
                Thread.sleep(3000);  
           }  
           gpio.shutdown();  
      }  
      private void alarm(GpioPinDigitalOutput pin) {  
           boolean inetAvailable = this.isInternetAvailable();  
           System.out.println("Internet is : " + inetAvailable);  
           if (inetAvailable) {  
                // turn off gpio pin #01  
                pin.high();  
                System.out.println("--> GPIO state should be: OFF");  
           } else {  
                // set shutdown state for this pin  
                pin.setShutdownOptions(true, PinState.LOW);  
                pin.low();  
                System.out.println("--> GPIO state should be: ON");  
           }  
      }  
      private boolean isInternetAvailable() {  
           Socket socket = null;  
           boolean reachable = false;  
           try {  
                String host = "google.de";  
                System.out.println("try to ping " + host);  
                socket = new Socket(host, 80);  
                reachable = true;  
           } catch (UnknownHostException e) {  
                e.printStackTrace();  
           } catch (IOException e) {  
                e.printStackTrace();  
           } finally {  
                if (socket != null)  
                     try {  
                          socket.close();  
                     } catch (IOException e) {  
                     }  
           }  
           return reachable;  
      }  
 }  
In Anlehnung an: http://pi4j.com/example/control.html 

Das Programm könnt ihr in Eclipse mit Rechtsklick auf euer Projekt und EXPORT als runnable JAR File exportieren.
Quelle: Eigene Darstellung

4 Publishen auf den Pi

Jetzt könnt ihr es mit Hilfe von WinSCP (WinSCP) auf euren Raspi übertragen.

5 Programm ausführen

In der Konsole in den Ordner navigieren in dem ihr die JAR Datei abgelegt habt.
und dann wie folgt aufrufen
 java -jar  DATEINAME.jar


Als Ergebnis solltet so aussehen. Die Exception ist an dieser Stelle absichtlich, weil wir sehen wollen ob wir eine Internetverbindung haben.

Quelle: Eigene Darstellung

Wenn wir keine Internetverbindung haben, leuchtet die LED Leuchte.

Das wars auch schon :) Ich hoffe euch hat das kleine Tutorial gefallen



Raspberry Pi Sensor Kit

Das Sensorkit für den Raspberry Pi 

Mit insgesamt 37 verschiedenen Modulen ist das Sensorkit ein echt guter Start in die Rasperry Pi Entwicklung.

Was ihr benötigt

  1. Euren Raspberry Pi (kann auch das alte Modell sein) http://tinyurl.com/oaex9j2 
  2. Das Sensorkit (http://tinyurl.com/myam7tj)
  3. Und etwas Motivation
Wenn ihr noch nicht die GPIO Library installiert habt, folgt bitte diesem Artikel raspberry-pi-gpio-setup.html

Wenn ihr keine Programmiersprache könnt, ist das kein Problem. In dem Kit sind viele Beispiele auf der mitgelieferten CD enthalten. Zudem gibt es viele Videos, welche die verwendeten Sensoren in Aktion zeigen.

Folgende Module sind enthalten:
Quelle Sunfounder/ Amazon
Es sind bspw. Module wie ein Temperatursensor, welcher auch die Luftfeuchtigkeit misst.


Erste Schritte

Um eine angeschlossene LED Lampe am Raspberry zum Leuchten zu blinken benötigt ihr folgende Zeilen Code:
 /*  
  *  dht11.c:  
  *  Testing the humidity and temperature sensor  
  *  DHT11 test  
  */  
 #include <wiringPi.h>  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <stdint.h>  
 #define MAXTIMINGS 85  
 #define DHTPIN 1  
 //#define DHTPIN 7  
 int dht11_dat[5] = {0,0,0,0,0};  
 void read_dht11_dat()  
 {  
      uint8_t laststate = HIGH;  
      uint8_t counter = 0;  
      uint8_t j = 0, i;  
      float f; // fahrenheit  
      dht11_dat[0] = dht11_dat[1] = dht11_dat[2] = dht11_dat[3] = dht11_dat[4] = 0;  
      // pull pin down for 18 milliseconds  
      pinMode(DHTPIN, OUTPUT);  
      digitalWrite(DHTPIN, LOW);  
      delay(18);  
      // then pull it up for 40 microseconds  
      digitalWrite(DHTPIN, HIGH);  
      delayMicroseconds(40);   
      // prepare to read the pin  
      pinMode(DHTPIN, INPUT);  
      // detect change and read data  
      for ( i=0; i< MAXTIMINGS; i++) {  
           counter = 0;  
           while (digitalRead(DHTPIN) == laststate) {  
                counter++;  
                delayMicroseconds(1);  
                if (counter == 255) {  
                     break;  
                }  
           }  
           laststate = digitalRead(DHTPIN);  
           if (counter == 255) break;  
           // ignore first 3 transitions  
           if ((i >= 4) && (i%2 == 0)) {  
                // shove each bit into the storage bytes  
                dht11_dat[j/8] <<= 1;  
                if (counter > 16)  
                     dht11_dat[j/8] |= 1;  
                j++;  
           }  
      }  
      // check we read 40 bits (8bit x 5 ) + verify checksum in the last byte  
      // print it out if data is good  
      if ((j >= 4) &&   
                (dht11_dat[4] == ((dht11_dat[0] + dht11_dat[1] + dht11_dat[2] + dht11_dat[3]) & 0xFF)) ) {  
           f = dht11_dat[2] * 9. / 5. + 32;  
           printf("Humidity = %d.%d %% Temperature = %d.%d *C (%.1f *F)\n",   
                     dht11_dat[0], dht11_dat[1], dht11_dat[2], dht11_dat[3], f);  
      }  
      else  
      {  
      // if the data is bad we don't print it  
           printf("Data not good, skip. Reason: \n");  
      }  
 }  
 int main (void)  
 {  
      printf ("Raspberry Pi wiringPi DHT11 Temperature test program\n") ;  
      if (wiringPiSetup () == -1)  
           exit (1) ;  
      while (1)   
      {  
           read_dht11_dat();  
           delay(1000); // wait 1sec to refresh  
      }  
      return 0 ;  
 }  

Und der Sensor muss angeschlossen werden

Quelle: eigene Darstellung

Perfekt, jetzt könnt ihr das Programm kompilieren und Starten:
 gcc NAME_EURES_PROGRAMMS.c -lwiringPi  


viel Spaß mit eurem Sensor!

Raspberry Pi - GPIO Setup

Um die GPIOs eures Raspberry Pi zu verwenden müssen folgende Schritte durchgeführt werden


Den Artikel http://echtetestberichte.blogspot.de/2015/05/raspberry-pi-setup.html solltet ihr schon durchgearbeitet haben


Installation der GPIO C Library

Im Terminal des Raspberry Pi:
 sudo apt-get update  
 sudo apt-get upgrade  
 apt-get install git-core  
 git clone git://git.drogon.net/wiringPi  
 cd wiringPi  
 git pull origin  
 cd wiringPi  
 ./build  



Zum Testen ob eure GPIO Pins funktionieren:
 gpio readall  

Jetzt bekommt ihr eure Pins angezeigt, es sollte so aussehen


Den Raspi könnt ihr jetzt zur Entwicklung von Programmen für Sensoren verwenden.

Raspberry Pi - Setup

Um den Raspberry Pi auf die Verwendung der GPIO Pins vorzubereiten sind einige Schritte durchzuführen. (Dies ist eien Beschreibung der Vorgehensweise, welche aber keinerlei Gewährleistung auf eure Hard oder Software gibt.)

Setup


1) Download der Image Datei, also das Betriebssystem.         
http://www.raspberrypi.org/downloads
ich empfehle Raspbian für Anfänger.

2) Wenn ihr Windows verwendet ladet euch Win32DiskImager runter

3) Enzippt die heruntergeladene Datei
4) öffent den Win32DiskImager und fügt die .img Datei hinzu
Quelle Win32DiskImager



5) Wichtig, jetzt die SD Karte in ein SD Karten Lesegerät welches mit eurem Rechner verbunden ist einlegen
6) erst wenn ihr euch sicher seid, dass unter "Device" auch eure SD Karte und kein anderes Laufwerk ausgewählt ist klickt auf "write" 

7) perfekt jetzt habt ihr euren Raspberry Pi vorbereitet.

Betrieb

Jetzt müsst ihr euren Raspberry nur noch mit einem HDMI Kabel, Stromkabel und Netzwerkkabel anschließen.
Zusätzlich sind jetzt Maus und Tastatur anzuschließen. Ihr werdet von eurem Raspberry jetzt durch das Setup geleitet.