Arduino Yun – Texte aus einer sqlite3 Datenbank laden.


Das hat sicher schon jeder erlebt der mit dem Arduino zu tun hat. Gerade bei größeren Projekten ist es unerlässlich auch mal Debugmeldungen im Seriellen Monitor oder auf einem LCD Display auszugeben um zu sehen was genau gerade passiert oder an welcher Stelle es hapert. Doch dann geschehen unvorhergesehene Dinge. Einmal lässt sich das Sketch nicht auf den Arduino brennen, dann wird scheinbar die loop() Funktion nicht mehr ausgeführt. Klingt ganz nach Speicherproblemen. Der Arduino verfügt von Haus aus über sehr wenig SDRAM und Flashspeicher, da muss man schon genau aufpassen wie man Variablen deklariert oder wie viele Strings man in seinem Sketch verwendet.

Temboo SQLite3

In einem meiner letzten Projekte mit dem Arduino Yun hatte ich ebenfalls dieses Probleme. Ich wollte einen aussagekräftigen Text mit Sensorwerten per eMail versenden. Leider konnte ich in meinem Fall nicht einmal 30 Zeichen versenden denn der Speicher war erschöpft. Auch das speichern der Strings im EEPROM brachte nicht das erwünschte Resultat da es einfach zu viele waren.

Da hatte ich die Idee, alle meine Texte aus einer sqlite3 Datenbank zu laden, die ich in meinem Projekt als Debugmeldungen ausgeben wollte. Ich legte also per SSH eine SQLite3 Datenbanktabelle mit zwei Spalten an. In der ersten Zeile sollte eine Nummer stehen über die ich den zugehörigen Text auslesen wollte. In Spalte 2 steht der Text den ich im Programm ausgeben will. Also z.B. 1,Foto an Dropbox senden. Nun brauchte ich eine Möglichkeit den Arduino auch die gewünschte Statumeldung ausgeben zu lassen.

Im Arduino Sketch schreibt man normalerweise folgendes um einen Text im Seriellen Monitor auszugeben.

Serial.print("Foto an Dropbox senden");

Statt die Meldung also direkt im Arduino-Sketch zu speichern und so wertvollen Speicherplatz zu verschwenden werde ich nun eine Funktion schreiben, der ich lediglich die ID des Datenbankeintrages übergebe, dessen Text ich auslesen möchte.

Die Funktion wird anschließend wie folgt aufgerufen.

Serial.print(getStringFromSQLite(1));

Hier übergebe ich der Funktion getStringFromSQLite die ID 1 und bekomme als Rückgabewert den zugehörigen Text aus der Datenbank als String, der anschließend mit Serial.print() ausgegeben wird.

 

 

SQLite Datenbank anlegen

Es gibt einige gute Tools für Windows, Linux oder Mac Betriebssysteme, mit denen man sqlite Datenbanken anlegen und verwalten kann. Ich werde hier aber zeigen wie man das Ganze über das Terminal macht.

Öffnen Sie also ein Terminal und stellen Sie per SSH eine Verbindung zum Arduino her. Ihr Arduino muss sich dafür natürlich im selben Netzwerk wie der Rechner befinden, mit dem Sie auf diesen  zugreifen wollen.

ssh root@arduinoyun.local

Gehen Sie Ihr Passwort ein und wechseln Sie in das Verzeichnis, in dem Sie die Datenbankdatei anlegen wollen. Ich habe zuvor ein Verzeichnis mit dem Namen settingsFiles angelegt, in dem ich all meine Yun Datenbanken und Settings Files ablege.

cd /mnt/sda1/settingsFiles

Legen Sie eine Datenbank an.

sqlite3 bewegungsmelder.db

Erstellen Sie nun eine Tabelle in dieser Datenbank.

sqlite> CREATE TABLE settings (bezeichner INTEGER PRIMARY KEY, wert TEXT);

Wenn Sie wissen dass Sie keine Texte länger als z.B. 100 Zeichen benötigen, können Sie anstatt “wert TEXT” auch “wert VARCHAR(100)” schreiben.

Übrigens können Sie mit folgendem Befehl die Namen aller in der angegebenen Datenbank vorhandenen Tabellen auslesen.

sqlite> SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;

Ein paar Zeilen in die Datenbank einfügen

sqlite> INSERT INTO settings VALUES (1,'debugMode - Statusmeldungen werden ausgegeben');
sqlite> INSERT INTO settings VALUES (2,'Es werden Fotos aufgenommen und auf SD gespeichert');
sqlite> INSERT INTO settings VALUES (3,'Fotos werden an die Dropbox gesendet');

Alle Werte aus der Datenbank auslesen

sqlite> SELECT bezeichner, wert FROM settings;

Einen bestimmten Wert anhand der ID (bezeichner) auslesen.

sqlite> SELECT wert FROM settings WHERE bezeichner = 2;

Hier wird der Text “Es werden Fotos aufgenommen und auf SD gespeichert” ausgegeben.

Einen bestimmten Eintrag ändern Sie mit folgendem Befehl.

sqlite> UPDATE settings SET wert = 'das ist ein test' WHERE bezeichner = 2;

 

 

Arduino Sketch

In Zeile 12 sehen Sie, wie die Funktion aufgerufen wird.
Hier wird der Text (wert) aus der Datenbanktabelle “settings” angezeigt, bei dem der (Bezeichner) den Wert “1″ hat.

#include <Bridge.h>
#include <Temboo.h>
#include <Process.h>


Process p;

void setup() 
{
  Bridge.begin();
  Serial.begin(9600);
  Serial.println(getStringFromSQLite(1));
}


String getStringFromSQLite(int BezeichnerID)
{
  String Wert;
  p.runShellCommandAsynchronously("python "+ Path + 
            "/bewegungsmelder.py " + BezeichnerID);
  while(p.running());
  while (p.available() > 0) 
  {
    char c = p.read();  
    Wert += c;
  }
  Wert.trim();
  return Wert;
}

 

 

Python Script

bewegungsmelder.py

Dieses Script wird immer dann ausgeführt, wenn im Arduino die Funktion getStringFromSQLite aufgerufen wird. Dabei wird dem Python Script eine Ganzzahl übergeben. Es wird eine Datenbankabfrage ausgeführt bei der der Wert in Spalte “wert” zurückgegeben wird. Also praktisch in der Art. Zeige mir den Text in Spalte “wert” aus der Datenbanktabelle “settings” bei der der Bezeichner den Wert “123″ hat.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sqlite3 as lite
import sys

uBezeichner = str(sys.argv[1])


try:
  con = lite.connect('/mnt/sda1/settingsFiles/bewegungsmelder.db')

  with con:
    cur = con.cursor()    
    cur.execute("SELECT wert FROM settings WHERE bezeichner=:bezeichner",{"bezeichner":uBezeichner}) 
    con.commit()
    while True:
      row = cur.fetchone()
      if row == None:
        break
      print row[0]
except lite.Error, e:
  print "Errorrr %s:" % e.args[0]
  sys.exit(1)
finally:
  if con:
    con.close()

 

So das war es auch schon. Ich hoffe Ihnen hat dieser Beitrag gefallen.
Über Fragen und Tipps in den Kommentaren würde ich mich freuen,

The post Arduino Yun – Texte aus einer sqlite3 Datenbank laden. appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Edu-Store mit bis zu 85% Rabatt

Arduino Yun – Zugangsdaten auf SD-Karte auslagern


Zugangsdaten auf SD-Karte auslagern

Den Arduino Yun nutzt man oft in Verbindung mit einem Temboo, Google oder Twilio-Account um die volle Leistungsfähigkeit nutzen zu können, ohne viel programmieren zu müssen. Normalerweise schreibt man die Zugangsdaten zu diesen Accounts direkt in den Arduino Code.

Temboo - Zugangsdaten auf SD-Karte

 

 

Was ist aber wenn man mal das Passwort eines der Accounts ändert, was man ja aus Sicherheitsgründen sowieso des Öfteren machen sollte? Da kann man dann froh sein wenn man den Arduino Sketch noch auf seiner Festplatte findet, da man anderenfalls in die Röhre schaut wenn der Arduino Yun nicht mehr macht was er soll weil die Zugangsdaten fehlerhaft sind.

Wie praktisch wäre es da, wenn man die Zugangsdaten  in einer Datei auf der SD-Karte gespeichert hat, so dass man diese in wenigen Sekunden durch die neuen Zugangsdaten ersetzen kann, ohne dass man den Arduino neu programmieren muss?

 

Alte Version mit Nachteilen

Hier sehen Sie die altbekannte Version, in der die Zugangsdaten im Arduino Sketch selber angegeben wurden.
In folgendem Code wurden die Zugangsdaten zum Temboo und zum Google Account aus Gründen der Übersichtlichkeit zwar bereits in zwei eigene Dateien ausgelagert, jedoch bleibt der oben angesprochene Nachteil bestehen.

sendAnEmail.ino

#include <Bridge.h>
#include <Temboo.h>
#include "TembooAccount.h"
#include "GmailAccount.h"

TembooChoreo SendEmailChoreo;

SendEmailChoreo.begin();

SendEmailChoreo.setAccountName(TEMBOO_ACCOUNT);
SendEmailChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
SendEmailChoreo.setAppKey(TEMBOO_APP_KEY);

SendEmailChoreo.setChoreo("/Library/Google/Gmail/SendEmail");
SendEmailChoreo.addInput("Username", GMAIL_USER_NAME);
SendEmailChoreo.addInput("Password", GMAIL_PASSWORD);
SendEmailChoreo.addInput("ToAddress", TO_EMAIL_ADDRESS);
SendEmailChoreo.addInput("Subject", "Ich bin der eMailbetreff");
SendEmailChoreo.addInput("MessageBody", "Ich bin der eMailtext");

TembooAccount.h

#define TEMBOO_ACCOUNT "myTembooAccountName"
#define TEMBOO_APP_KEY_NAME "myFirstApp"
#define TEMBOO_APP_KEY  "xxx-xxx-xxx-xx-xxx"

GmailAccount.h

#define GMAIL_USER_NAME "meineGoogleMailAdresse"
#define GMAIL_PASSWORD "meinGooglePasswort"
#define TO_EMAIL_ADDRESS "EmpfaengerAdresse"

 

temboo-logo

 

Neue Version mit vielen Vorteilen

Zugangsdaten auf der SD-Karte

In dieser Version, die ich absolut bevorzuge, habe ich die Zugangsdaten in einer normalen Textdatei in einem Ordner auf der SD-Karte im Arduino Yun abgespeichert. Temboo macht es uns in diesem Fall sehr einfach auf diese Dateien zuzugreifen. Mit nur einer einzigen Zeile ruft man diese Datei auf, worauf der Arduino alle in der Textdatei enthaltenen Daten verwendet.

sendAnEmail.ino
In Zeile 4 gibt man den Pfad zur Textdatei auf der SD-Karte an.
In Zeile 8 wird die Datei “TembooGmail”, die sich in diesem Verzeichnis befinden sollte, aufgerufen.

#include <Bridge.h>
#include <Temboo.h>

static const String Path = "/mnt/sda1/settingsFiles/";

TembooChoreo SendEmailChoreo;
SendEmailChoreo.begin();
SendEmailChoreo.setSettingsFileToRead(Path+"TembooGmail");

 

SD-Karte

In diesem Beispiel habe ich eine Textdatei mit dem Namen “TembooGmail” im Verzeichnis “/mnt/sda1/settingsFiles/” angelegt. Kopieren Sie folgende Zeilen in diese Textdatei und ersetzen Sie alle groß geschriebenen Werte durch die entsprechenden Temboo- und Gmail Accountdaten.

-c/Library/Google/Gmail/SendEmail
-aTEMBOOACCOUNTNAME
-uTEMBOOAPPKEYNAME
-pTEMBOOAPPKEY
-iUsername:GMAILUSERNAME
-iPassword:GMAILPASSWORT
-iToAddress:EMPFAENGEREMAILADRESSE
-iSubject:EMAILBETREFF
-iMessageBody:EMAILBODYTEXT

 

Hier eine Beschreibung der einzelnen Temboo Client-Parameter.
Diese und viele weitere Informationen zu diesem Thema finden Sie auch in der Technischen Dokumentation von Temboo

  • -cchoreo equivalent to setChoreo(“choreo”)
  • -aaccountName equivalent to setAccountName(“accountName”)
  • -uappKeyName equivalent to setAppKeyName(“appKeyName”)
  • -pappKey equivalent to setAppKey(“appKey”)
  • -iname:value equivalent to addInput(“name”, “value”)
  • -oname:path:variable equivalent to addOutputFilter(“name”, “path”, “variable”)
  • -ecredentialName equivalent to setCredential(“credentialName”)
  • -wfilePath equivalent to setSettingsFileToWrite(“filePath”)
  • -rfilePath equivalent to setSettingsFileToRead(“filePath”)

 

Die Vorteile dieser Version liegen klar auf der Hand. Zugangsdaten lassen sich einfach im Nachhinein ändern ohne den Arduino neu programmieren zu müssen und was genauso wichtig ist, es können längere Texte z.B. für Betreff und Bodytext verwendet werden weil diese nicht mehr im sowieso sehr knappen Speicher des Arduino gespeichert werden müssen.

An dieser Stelle noch mal ein großes Dankeschön an das freundliche, kompetente und schnelle Temboo Support Team.

 

The post Arduino Yun – Zugangsdaten auf SD-Karte auslagern appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Arduino Yun – Foto an Dropbox senden


Heute habe ich wieder einen sehr interessanten Beitrag für Sie. Ich zeige Ihnen wie man mit dem Arduino Yun ein Foto mit einer Webcam aufnehmen, dieses auf der SD Karte speichern und anschließend an seine Dropbox senden kann. Dabei lernen Sie, wie man eine Dropbox App erstellt und wie man vom Arduino Yun aus Befehle auf dem integrierten Linux ausführen kann. Also doch eine ganze Menge interessanter Informationen die Sie hier finden werden. Los gehts also mit dem Beitrag “Foto an Dropbox senden”

ArduinoTembooWebCamDropboxPreview

 

Was benötige ich?

  • Arduino Yun
  • Einen Button oder einen Sensor
  • Einen Dropbox Account
  • Einen Temboo Account

 

Dropbox App erstellen

Um eine Dropbox App zu erstellen loggt man sich zunächst in seinen Dropbox Account ein und ruft anschließend die Seite https://www.dropbox.com/developers/apps auf.

Auf dieser Seite klickt man zunächst oben rechts auf den Button “Create App”. Auf der nächsten Seite wählt man aus dass man eine Dropbox API app erstellen möchte. Setzen Sie ein Häkchen bei “Files and datastores”. Jetzt noch ein Häkchen bei “Yes” setzen. Damit bestimmen Sie dass die App nur auf Daten innerhalb der App zugreifen darf. Zum Schluss vergeben Sie einen aussagekräftigen Namen für Ihre App.

Im nächsten Fenster können Sie Einstellungen für die neue App vornehmen. Außerdem sehen Sie hier schon den App Key und den App Secret Key, die wir im weiteren Verlauf noch brauchen.

Klicken Sie im Feld “OAuth2″ unter “Generated access token” auf “Generate”um einen access token zu generieren, den wir im weiteren Verlauf ebenfalls noch benötigen werden.

Im Tab “Details” können noch Angaben unter Publisher und Description gemacht, sowie eine Website und ein Programmsymbol angegeben werden. Diese Daten werden z.B. auf der Seite Sicherheitseinstellungen/Apps verknüpft in der Dropbox angezeigt. Speichern Sie Ihre Einstellungen.

 

Zugriff auf die App durch Temboo autorisieren

Melden Sie sich auf der Seite temboo.com an.
Klicken Sie links in der Liste der unterstützten Webanbieter auf “Dropbox
Klicken Sie rechts im Fenster unter Bundles auf “OAuth
Klicken Sie auf “InitializeOAuth

 

InitializeOAuth

Temboo - Dropbox - InitializeOAuth

 

Geben Sie oben im Fenster den zuvor in der Dropbox erzeugten DropboxAppKey und Ihren DropboxAppSecret Key ein und klicken Sie auf den Button “Run”. Anschließend wird eine Ausgabe generiert die alles weitere erklärt.

 

Temboo - Dropbox - InitializeOAuth - Output

 

Als erstes muss Temboo dazu autorisiert werden auf den erzeugten Dropboxordner zuzugreifen. Klicken Sie dazu auf “this URL” im ersten blau umrandeten Feld. Aber Achtung: Wenn Sie sich zu viel Zeit lassen, werden Sie die Meldung erhalten dass die Session abgelaufen ist. Klicken Sie dann einfach noch einmal auf den Button “Run”. Sie sollten nun dieses Fenster zu sehen bekommen. Klicken Sie auf Zulassen und schließen Sie das Fenster das höchstwahrscheinlich sowieso nur aus einer leeren weißen Seite bestehen wird.

Temboo - Dropbox - OAuth - App zulassen

Notieren Sie sich noch die CallbackID und den OAuthTokenSecret und klicken Sie in einem der Ausgabefenster auf den Link “FinalizeOAuth“.

 

FinalizeOAuth

Temboo - Dropbox - FinalizeOAuth

Geben Sie nun oben erneut den DropboxAppKey und den DropboxAppSecret Key ein. Geben Sie die CallbackID und den OAuthTokenSecret Key, die auf der “InitializeOAuth” Seite generiert wurden ein.
Klicken die auf den Button “Run”.

Auch hier gilt, wenn Sie sich zu viel Zeit lassen läuft die Session ab und die Eingabe wird ungültig. Wenn das passieren sollte (Fehlermeldung nachdem Sie auf “Run” geklickt haben), gehen Sie noch einmal auf das Fenster “InitializeOAuth” und klicken Sie dort einfach noch einmal auf den Button “Run” um eine neue CallbackID, sowie einen neuen OAuthTokenSecret Key zu erzeugen.

Wenn alles geklappt hat, sollten Sie jetzt eine Ausgabe mit einem AccessToken, einem AccessTokenSecret und einer UserID sehen.

FinalizeOAuth - Dropbox - OUTPUT

 

Die folgende Ausgabe ist besonders wichtig da wir diese Angaben für das Python Script benötigen das die Fotos erst auf die SDKarte und anschließend in den Dropboxordner unserer eigenen zuvor erstellten App lädt. Notieren Sie sich also den AccessToken, den AccessTockenSecret und die UserID. In dem Pythonscript benötigen wir außerdem noch den Accountnamen, den Applicationnamen und den Key der in Temboo angelegten Application. Diese finden Sie in Ihrem Temboo Account unter Applications.

 

Python Script anlegen

Das Python Script wird auf der SD Karte auf dem Arduino abgelegt. Aufgerufen wird es durch den Arduino selber wenn ein Button gedrückt oder z.B. ein Bewegungssensor ausgelöst wird. Dem Python Script wird der Pfad und der Dateiname des zuvor durch den Arduino auf der SD Karte gespeicherten Fotos übergeben. Anschließend wird das Foto an die Dropbox gesendet und in unserem App Verzeichnis gespeichert.

upload_picture.py

Hier fügen wir jetzt folgendes in die jeweilige Zeile ein.

Hier kommen die Daten aus dem Temboo Applications Fenster rein.
Zeile 17 = Accountnamen, Appnamen, Key

Hier kommen die Daten aus dem FinalizeOAuth Fenster rein
Zeile 24 = DropboxAppSecret
Zeile 25 = AccessToken
Zeile 27 = AccessTokenSecret
Zeile 28 =  DropboxAppKey

# coding=utf-8
# Script to upload files to Dropbox

# Import correct libraries
import base64
import sys
from temboo.core.session import TembooSession
from temboo.Library.Dropbox.FilesAndMetadata import UploadFile

print str(sys.argv[1])

# Encode image
with open(str(sys.argv[1]), "rb") as image_file:
    encoded_string = base64.b64encode(image_file.read())

# Declare Temboo session and Choreo to upload files
session = TembooSession('TEMBOOACCOUNTNAME', 'TEMBOOAPPNAME', 'TEMBOOKEY')
uploadFileChoreo = UploadFile(session)

# Get an InputSet object for the choreo
uploadFileInputs = uploadFileChoreo.new_input_set()

# Set inputs
uploadFileInputs.set_AppSecret("DROPBOXAPPSECRET")
uploadFileInputs.set_AccessToken("ACCESSTOKEN")
uploadFileInputs.set_FileName(str(sys.argv[1]))
uploadFileInputs.set_AccessTokenSecret("ACCESSTOKENSECRET")
uploadFileInputs.set_AppKey("DROPBOXAPPKEY")
uploadFileInputs.set_FileContents(encoded_string)
uploadFileInputs.set_Root("sandbox")

# Execute choreo
uploadFileResults = uploadFileChoreo.execute_with_results(uploadFileInputs)

Die Datei upload_picture.py muss nun auf die SD Karte gespeichert werden. Dazu müssen wir die SD Karte gar nicht erst aus dem Arduino entfernen und am Rechner anschließen. Das geht auch komfortabler mittels ssh Zugriff.

Öffnen Sie auf Ihrem Rechner ein Terminalfenster und gehen Sie in das Verzeichnis, in dem Sie die Datei upload_picture.py liegen haben. Ich habe die Datei auf dem Dektop liegen, also springe ich mit folgendem Befehl zum Desktop.

cd Desktop

 

Mit folgendem Befehl kopieren Sie die Datei schließlich auf die SD Karte auf dem Arduino. Die SD Karte wird bei mir übrigens als “sda1″ im Verzeichnis “/mnt” gemountet.

scp upload_picture.py root@arduinoyun.local:/mnt/sda1/

 

Da wir gerade dabei sind Daten auf die SDKarte zu übertragen können wir uns noch um einen weiteren, ganz wichtigen Schritt kümmern. Damit das Script funktioniert benötigen wir nämlich noch die temboo-python-sdk auf unserer SD Karte. Laden Sei diese Datei also herunter und speichern Sie diese am besten gleich wieder auf dem Desktop. Danach entpacken Sie das Verzeichnis. Auf dem Desktop sollte sich im Anschluss ein Verzeichnis mit dem Namen temboo befinden.

Öffnen Sie erneut das Terminal und geben Sie folgenden Befehl ein um den kompletten Ordner temboo auf die SDKarte zu übertragen.

scp -r temboo root@arduinoyun.local:/mnt/sda1/

 

Arduino Sketch

Kommen wir zum letzten Schritt.
Ich habe das Sketch so geschrieben, dass jedes Mal wenn ich einen Button drücke, ein Bild von der am Arduino Yun angeschlossenen Webcam, aufgenommen und auf der SD Karte gespeichert wird. Anschließend wird das Bild an die Dropbox gesendet.

Ich habe ein paar Variablen angelegt mit denen sich der Programmablauf beeinflussen lässt.

testMode
true = Das Bild wird nur auf der SD Karte gespeichert jedoch nicht an die Dropbox gesendet.
false = Das Bild wird auf der SD Karte gespeichert und anschließend an die Dropbox gesendet

debugMode
true = Es werden Statusmeldungen in der Console ausgegeben. Wenn Sie nicht über WLAN auf den Arduino zugreifen müssen Sie Console durch Serial ersetzen
false = Es werden keine Statusmeldungen ausgegeben

delFromSD
true = das Foto wird auf der SD Karte gespeichert und zum Schluss gelöscht.
false = das Foto bleibt auf der SD Karte und wird nicht gelöscht.

 

#include <Bridge.h>
#include <Process.h>

Process picture;


// Anpassen
const boolean testMode   = false;        // true = Bilder werden aufgenommen aber nicht zur Dropbox gesendet         
const boolean debugMode  = false;        // true = Debugmessages ausgeben (Serieller Monitor oder Console)
const boolean delFromSD  = false;        // true = Bild nach der Übertragung zur Dropbox von der SDKarte löschen
String path = "/mnt/sda1/";              // Pfad zum Verzeichnis in dem die Bilder gespeichert werden sollen
static const int triggerPin = 8;         // Pin für Auslöser (Button, Bewegungsmelder, etc)
static const int ledPin     = 13;        // DigitalPin - LED

//Ab hier nichts mehr anpassen
String filename;                         // Dateiname
int state;
int lastState;





void setup() 
{
  Bridge.begin();
  
  pinMode(triggerPin,INPUT);
  pinMode(ledPin, OUTPUT);
  
  if(debugMode == true) 
  {
    Console.begin();
    Console.println(F("debugMode - Statusmeldungen werden ausgegeben"));
    if(testMode == true) Console.println(F("testMode - Fotos werden nicht an Dropbox gesendet"));
    if(delFromSD == true) Console.println(F("Fotos werden autom. von SD-Karte entfernt."));
  } 
}





void loop() 
{
  state = digitalRead(triggerPin);
  
  if (state != lastState) 
  {
    if (state == HIGH) 
    {
      digitalWrite(ledPin, HIGH);
      
      // timestamp als Dateiname für das Bild benutzen
      filename = "";
      picture.runShellCommand("date +%d%m%Y%H%M%S");
      if(debugMode == true) Console.println(F("Dateiname erzeugen..."));
      
      while(picture.running());
  
      while (picture.available() > 0) 
      {
        char c = picture.read();
        filename += c;
      } 
      filename.trim();
      filename += ".png";
      
      if(debugMode == true) Console.println(filename);
   
      // Bild aufnehmen
      if(debugMode == true) Console.println(F("Foto aufnehmen"));
      picture.runShellCommand("fswebcam " + path + filename + " -r 1280x720 --flip h --delay 5");

      while(picture.running());
      
      if(testMode == false) 
      {
        if(debugMode == true) Console.println(F("Foto an Dropbox senden"));
        picture.runShellCommand("python " + path + "upload_picture.py " + path + filename);
      } else if(debugMode == true) Console.println(F("testMode - Foto wird nicht an Dropbox gesendet"));
      
      while(picture.running());
      
      //Bild von SD Karte entfernen nachdem dieses auf die Dropbox geladen wurde
      if(delFromSD == true)
      {
        if(debugMode == true) Console.println(F("Foto von SD-Karte entfernen"));
        picture.runShellCommand("rm " + path + filename);
        while(picture.running()); 
      }
      digitalWrite(ledPin, LOW);
    }
    lastState = state;
  }
}

 

So das war mal ein hartes Stück Arbeit.
Ich hoffe dass Ihnen auch dieser Beitrag gefallen hat und würde mich über Fragen oder Anregungen in den Kommentaren sehr freuen.

 

The post Arduino Yun – Foto an Dropbox senden appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Arduino Yun – Werte in Google Drive Tabelle schreiben


In diesem Beitrag zeige ich Ihnen, wie man mit dem neuen Arduino Yun oder einem anderen Arduino mit Internet Shield, sowie mit Hilfe von Temboo, Sensorwerte in eine Google Drive Tabelle schreiben kann. 

Was ist Temboo?

Kurz zusammengefasst handelt es sich bei Temboo um eine Plattform, auf der die APIs von mehr als 100 der verschiedensten webbasierten Dienste wie Dropbox, Twitter, FitBit, PayPal, LastFM und vielen, vielen Weiteren unter einer gemeinsamen Abstraktionsschicht zusammengefasst sind.

temboo-logo

 

Dank Temboo haben Sie die Möglichkeit mit dem Arduino oder auch aus eigenen Programmen heraus, auf diese Dienste zuzugreifen. Um Temboo nutzen zu können ist ein kostenloser Temboo Account Vorraussetzung.

Die Möglichkeiten mit Temboo sind fast grenzenlos. So könnte man sich z.B. eine eMail schicken lassen wenn jemand an der Haustür klingelt während man nicht zu Hause ist. Vielleicht noch ein Foto der Person aufnehmen und zusammen mit der eMail verschicken? ;-)

 

 

Welche Hardware?

Für dieses Beispiel verwende ich neben dem Arduino Yun einen DHT22, eine LDR Sensor, 2 Widerständen und ein paar Kabeln nichts weiter. Wie gesagt können Sie, wenn Sie keinen Arduino Yun besitzen, jeden anderen Arduino mit InternetShield auch benutzen.
Arduino Yun

 

Arduino Yun bei Voelkner.de
Der Ardunio Yún ist das erste Mitglied einer neuen, bahnbrechenden Reihe von WLAN -Boards, die die Power von Linux mit der Einfachheit von Arduino verbinden. Auf der Arduino Seite kommt ein klassischer Arduino Leonardo (basierend auf dem Atmega32u4 Controller) zum Einsatz, während die WLAN-Seite von einem speziellen Linux-Ableger namens Linino (MIPS GNU/Linux basierend auf OpenWRT) gesteuert wird.

 

 

Arduino Sketch

Öffnen Sie Arduino und legen Sie ein neues Projekt an. Fügen Sie nachstehenden Code ein und speichern Sie das Sketch unter “YunWriteGoogleDocs”.

YunWriteGoogleDocs.ino

/****************************************************************************************************************************
  Projekt: YunWriteGoogleDocs                                                                                               *
  Autor: Enrico Sadlowski                                                                                                   *
  Erstellungsdatum: 26.06.2014                                                                                              *
  Letzte Aktualisierung: 27.06.2014                                                                                         *
                                                                                                                            *
  Es werden ständig die Werte eines DHT22 und eines LDR Sensors ermittelt.                                                  *
  "productiveMode" == true, Die Werte werden an eine Google Drive Tabelle gesendet.                                         *
  "debugMode" == true, Es werden Meldungen über den Seriellen Port ausgegeben.                                              *
  Außer Helligkeit, Temperatur und Luftfeuchte wird noch das aktuelle Datum und die aktuelle Zeit.                          * 
  vom embedded Linux ausgelesen und mit in die Google Tabelle gespeichert.                                                  *
                                                                                                                            *
  Vorraussetzungen                                                                                                          *
  Google Account, temboo.com Account, Google Tabelle mit dem Namen "Yun" im Google Drive Account, Arduino Yun               *                                                                                                                                                                            *
****************************************************************************************************************************/

#include <DHT.h>
#include <Bridge.h>
#include <Temboo.h>
#include <Process.h>

#include "TembooAccount.h"                // Temboo Account Zugangsdaten
#include "GoogleAccount.h"                // Google Account Zugangsdaten


// Diese Daten anpassen
const boolean productiveMode    = true;   // Nur wenn productivMode == true werden Daten an Google Drive und eMails gesendet
const boolean debugMode         = true;   // debugMode == true, es werden Messages über den seriellen Monitor ausgegeben
static const int DHTPin         = 9;      // DigitalPin - DHT22 Sensor    
static const int ledPin         = 13;     // DigitalPin - LED
static const int lightPin       = A0;     // Analoger Pin an dem der Lichtsensor angeschlossen ist
unsigned const long interval    = 3600;   // Interval in Sekunden wie oft die Daten abgefragt und gesendet werden sollen



// Ab hier nichts mehr anpassen
unsigned long previousMillis  =  0;       // Delay Ersatz
Process date;                             // Datum 
int day, month, year;                     // Tag Monat und Jahr trennen
int h, t, l;                              // Humidity, Temperature und Helligkeit
#define DHTTYPE DHT22                     // DHT11, DHT21, DHT22
DHT dht(DHTPin, DHTTYPE);





void setup()
{
  Bridge.begin();
  dht.begin();
  pinMode(ledPin, OUTPUT);
  
  if (debugMode == true)
  {
    Serial.begin(115200);
    while (!Serial);
    
    Serial.println(F("DebugMode..."));
    if(productiveMode) Serial.println(F("Produktivemode...")); else Serial.println(F("Testmode..."));
    
    if(productiveMode == true)
    {
      Serial.print(F("Daten werden alle "));
      Serial.print(interval);
      Serial.println(F(" Sekunden an Google Drive Tabelle gesendet..."));
    }
    
    Serial.println(F("Setup komplett...n"));
  }
}





void loop()
{ 
  unsigned long currentMillis = millis();
   
  getSensorValues(); //Ständig Sensorwerte ermitteln
  
  if(currentMillis - previousMillis >= (interval*1000)) 
  {
    digitalWrite(ledPin, HIGH);
        
    previousMillis = currentMillis;
    
    if(productiveMode == true) 
    {
      if(debugMode == true) { Serial.println(F("Aufruf von /Library/Google/Spreadsheets/AppendRow Choreo...")); }
      runAppendRow(l, t, h); 
    } else { if(debugMode == true) Serial.println(F("Testmodus - Es werden keine Daten gesendet")); }
  }
  digitalWrite(ledPin, LOW);
}





/*****************************************************
                                                     *
  Daten in Google Tabelle auf Google Docs schreiben  *
                                                     *
*****************************************************/
void runAppendRow(int lightLevel, int temperature, int humidity)
{
  TembooChoreo AppendRowChoreo;

  AppendRowChoreo.begin();
  AppendRowChoreo.setAccountName(TEMBOO_ACCOUNT);
  AppendRowChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
  AppendRowChoreo.setAppKey(TEMBOO_APP_KEY);
  AppendRowChoreo.setChoreo("/Library/Google/Spreadsheets/AppendRow");
  AppendRowChoreo.addInput("Username", GOOGLE_USERNAME);
  AppendRowChoreo.addInput("Password", GOOGLE_PASSWORD);
  AppendRowChoreo.addInput("SpreadsheetTitle", SPREADSHEET_TITLE);

  String data = parseDateTime()+","+String(lightLevel)+","+String(temperature)+","+String(humidity);
  AppendRowChoreo.addInput("RowData", data);

  unsigned int returnCode = AppendRowChoreo.run();

  if (returnCode == 0) {
    if (debugMode == true) { Serial.println(F("Ausfuehrung von /Library/Google/Spreadsheets/AppendRow Choreo komplett.n")); }
  } else {
    while (AppendRowChoreo.available()) {
      char c = AppendRowChoreo.read();
      if (debugMode == true) { Serial.print(c); }
    }
    if (debugMode == true) { Serial.println(); }
  }
  AppendRowChoreo.close();
  if (debugMode == true) { Serial.print(data); Serial.println(F(" an Google Docs gesendet"));  }
}





/*************************************************************************************************
                                                                                                 *
  Datum und Zeit von (mm/dd/yy hh:ii:ss) zerlegen in Tag, Monat, Jahr, Stunde, Minute, Sekunde   *
  Empfang  = 06/26/14 16:15:42                                                                   *
  Rückgabe = 26.06.14, 16:15:42                                                                  *
                                                                                                 *
*************************************************************************************************/
String parseDateTime()
{
  String result;
  
  if (!date.running()) 
  {
    date.begin("date");
    date.addParameter("+%D-%T-");
    date.run();
  }
  
  if (date.available() > 0) 
  {
    String timeString = date.readString();
    
     //TimeStamp zerlegen in Datum und Zeit
    int dateColumn = timeString.indexOf("-");
    int timeColumn = timeString.lastIndexOf("-");
    
    String dateStr = timeString.substring(0, dateColumn);
    String timeStr = timeString.substring(dateColumn+1, timeColumn);
 
    // Datum zerlegen und daraus deutsche Schreibweise machen
    int firstColon = timeString.indexOf("/");
    int secondColon = timeString.lastIndexOf("/");
    
    String monthString = timeString.substring(0, firstColon);
    String dayString   = timeString.substring(firstColon + 1, secondColon);
    String yearString  = timeString.substring(secondColon + 1);
    
    day   = dayString.toInt();
    month = monthString.toInt();
    year  = yearString.toInt();
    
    if (day <= 9) result += "0";
    result += String(day);
    result += ".";
    if (month <= 9) result += "0";
    result += String(month);
    result += ".";
    result += String(year);
    result += ",";
    result += timeStr;
  }
  return result;
}




/*******************************************************
                                                       *
  Sensorwerte des DHT22 und des LDR Sensors ermitteln  *
                                                       *
*******************************************************/
void getSensorValues()
{
  h = dht.readHumidity();    // Luftfeuchte auslesen
  t = dht.readTemperature(); // Temperatur auslesen
  l = analogRead(lightPin);  // Lichtstärke auslesen
  
  
  if(debugMode == true)
  {
    if (isnan(t) || isnan(h)) 
    {
      Serial.println(F("DHT22 konnte nicht ausgelesen werden"));
    } 
    else
    {          
      Serial.print(F("Luftfeuchte: ")); 
      Serial.print(h);
      Serial.print(F("%t"));
      Serial.print(F("Temperatur: ")); 
      Serial.print(t);
      Serial.println(F("C"));
    }
  }
}

 

Um die Zugangsdaten zum Google- und zum Temboo Account nicht direkt im HauptSketch stehen zu haben, legen wir uns nun ein neues Tab an und nennen dieses GoogleAccount.h

Die Zugangsdaten zu Ihrem Google Account sollten Ihnen ja hoffentlich bekannt sein. Nur so viel. Wenn Sie die Bestätigung in zwei Schritten aktiviert haben, sollten Sie unter dem Link  ein neues App Passwort für Ihren Arduino generieren. Dieses Passwort geben Sie anschließend in unten stehenden Code ein!

GoogleAccount.h

#define GOOGLE_USERNAME "EINFÜGEN"
#define GOOGLE_PASSWORD "EINFÜGEN"
#define SPREADSHEET_TITLE "EINFÜGEN"
#define TO_EMAIL_ADDRESS "EINFÜGEN"

 

Da das so einfach war legen wir gleich noch ein Tab mit dem Namen TembooAccount.h an und fügen folgende Daten ein.

Die benötigten Daten finden Sie in Ihrem Temboo Account
unter Account->Applications

TembooAccount.h

#define TEMBOO_ACCOUNT "EINFÜGEN"
#define TEMBOO_APP_KEY_NAME "EINFÜGEN"
#define TEMBOO_APP_KEY "EINFÜGEN"

 

Ergebnis

So sieht das ganze aus wenn ein paar Werte durch den Arduino in die Google Drive Tabelle eingetragen wurden.

ArduinoYunGoogleDriveTable

 

Den kompletten Quellcode finden Sie auch auf GitHub.
YunWriteGoogleDocs

Ich hoffe dass Ihnen auch dieser Beitrag gefallen hat und würde mich über Kommentare freuen.

 

The post Arduino Yun – Werte in Google Drive Tabelle schreiben appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Smart App Lock – Die beste App zum Sperren deiner Apps


Ständig installiert man neue, vermeintlich interessante oder nützliche Apps auf seinem Android Smartphone. In vielen Fällen sieht es dann allerdings so aus, dass die App nur Platz im Speicher verschwendet, weil man diese nie wieder oder nur selten nutzt.

Heute möchte ich euch eine Android App vorstellen, die definitiv nicht zu den Apps zählt, die nach der Installation mit Nichtachtung gestraft werden.

 

Smart App Lock (App Protector)

Die App “Smart App Lock (App Protector)” von SPSOFT ist eine App die ich mehrmals täglich unbewusst nutze. Die App bietet drei Funktionen von denen ich zwei regelmäßig nutze. Funktion 1 ist der Schutz ausgewählter Apps vor unberechtigtem Öffnen, indem diese mit einem Passwort, einer Pin oder einer Geste geschützt werden. Funktion 2 sorgt dafür dass bei zuvor festgelegten Apps der Bildschirm aktiviert bleibt so lang die App aktiv auf dem Bildschirm angezeigt wird. Sehr praktisch bei der Verwendung von Newsreadern während dem lesen längerer Texte.

Ich selber nutze diese Funktion bei sportlichen Aktivitäten z.B. beim Radfahren, wo ich nicht ständig die Tastensperre entfernen kann um meine Erfolge auf dem Bildschirm sehen zu können. Funktion 3 ist die Funktion die ich eher weniger benutze, da bei den aktuellen Android Versionen ein Swipe von oben und ein Klick genügen um die Bildschirmrotation zu deaktivieren. Bei dieser Funktion kann man, wie bereits angedeutet, dafür sorgen, dass die automatische Bildschirmrotation bei festgelegten Apps deaktiviert wird.

Smart App Lock funktioniert so, dass man einige Grundeinstellungen vornimmt, die App aktiviert und die Apps, die man mit einem Passwort schützen will oder bei denen während des Betriebs das Display eingeschaltet oder die automatische Rotation deaktiviert werden soll, auf den verschiedenen Screens hinzufügt werden. Alles weitere läuft im Hintergrund so dass man die App selbst nur noch dann öffnen muss wenn man mal eine neue App zu einer der Listen hinzufügen möchte.

Der Aufbau von Smart App Lock ist sehr intuitiv. So verfügt diese gerade einmal über die 3 Screens “App Lock”, “Screen” und “Rotation”, sowie einen Screen auf dem man die verschiedenen Einstellungen des Programms vornehmen kann.

Einstellungen

Wenn Sie die App das erste mal nach der Installation öffnen, sehen Sie ein Login Fenster mit dem Hinweistext. “Initialpasswort ist 7777″. Geben Sie also dieses Passwort ein um die App zu öffnen.

SmartAppLock-FirstStart SmartAppLock-Settings

Wechseln Sie als nächstes auf das erste Tab “Settings” um die Grundeinstellungen für den Betrieb der App vorzunehmen.

Passwort und Muster Einstellungen

Wählen Sie zunächst die gewünschte Sperrart. Sie können wählen zwischen Passwort (Nummer), Muster, Passwort (Buchstaben) und Geste. Ich selber entscheide mich hier für Passwort (Nummer) Da dieses auch bei vielen Stellen, schnell eingegeben ist. Klicken Sie anschließend auf Passwort und ändern Sie das vorgegebene Passwort 7777 durch Ihr eigenes, sicheres Passwort.

Unter Passworthinweis können Sie einen eigenen Hinweistext angeben der gezeigt werden soll wenn Sie eine App, die Sie mit einem Passwort sichern wollen, gezeigt werden soll. Ich habe den Hinweistext hier entfernt da ich diesen nicht benötige. Alle weiteren Punkte in dieser Kategorie haben eher einen kosmetischen Effekt weshalb ich nicht näher darauf eingehen werde.

 

Standard Einstellungen

Das setzen des Häkchens hinter “Dienst aktivieren” aktiviert die App. Dies können Sie auch durch ein Symbol in der Statusleiste anzeigen lassen. In den Standard Einstellungen gibt es noch einiges zu entdecken. Testen Sie einfach mal die verschiedenen Einstellungsmöglichkeiten. Ich selbst habe die App zusätzlich zum Geräteadministrator hinzugefügt und die Passwortinitialisierung eingeschaltet.

 

Speer-Bildschirm Einstellungen

SmartAppLock-SperrBildschirmHier sieht man den Bildschirm der gezeigt wird wenn man eine App öffnen will, die durch ein Passwort geschützt wurde. Sie können hier den Hintergrund ändern, die Anzeige des Hinweistextes deaktivieren, die App-Information, also den Namen der App die Sie öffnen wollen, anzeigen oder verbergen lassen.

 

 

Apps vor unbefugtem öffnen schützen

SmartAppLock-AppLockUm eine oder mehrere Apps mit einem Passwort vor unberechtigtem Öffnen zu schützen, klicken Sie unten auf das Plus und wählen Sie die gewünschten Apps aus.

Eine sehr  interessante Funktion verbirgt sich hinter dem “FAKE Symbol”. Wenn Sie diese Funktion für eine App aktivieren dann wird beim öffnen der App eine Fehlermeldung anstatt des normalen Sperr-Bildschirms angezeigt. Das lässt normale Benutzer denken, dass die App abgestürzt ist. Drücken Sie etwas länger auf den OK-Button um den Sperr-Bildschirm, über den Sie die App mit Ihrem Passwort öffnen können, anzuzeigen.

Wichtig ist nur, dass Sie das Häkchen bei “Diese Meldung nicht noch einmal anzeigen” setzen da sonst nicht die Fehlermeldung sondern ein Hinweistext auf diese Funktion angezeigt wird.

 

Bei der Nutzung von Apps das Abschalten des Bildschirms oder das aktivieren der automatischen Bildschirmrotation verhindern

Verfahren Sie bei diesen zwei Screens genauso wie bei dem Screen “App-Lock”. Also einfach unten auf das Plus klicken und die gewünschten Apps zur Liste hinzufügen

SmartAppLock-ScreenSmartAppLock-Rotation

 

 

Wie gesagt, Smart App Lock ist eine der wenigen Apps die ich ständig nutze.
Leicht einzurichten, läuft im Hintergrund und bietet einen echten Mehrwert.
Wie finden Sie diese App? Kennen Sie Alternativen die Sie womöglich besser finden? Anregungen in den Kommentaren sind immer gern gesehen.

The post Smart App Lock – Die beste App zum Sperren deiner Apps appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Automator – Ein verschlüsseltes Image erstellen

In diesem Beitrag möchte ich anhand eines kleinen Beispiels zeigen, wie man das Programm “Automator”, das standardmäßig auf jedem Intel Mac installiert sein sollte, dazu nutzen kann um sich die alltägliche Arbeit mit dem Mac zu erleichtern.

Auf die Idee für diesen Beitrag kam ich weil ich feststellen musste, dass das Programm RedButton, mit dem ich lange Zeit meine Verzeichnisse verschlüsselt habe, einfach nicht mehr funktioniert. Jedes Mal wenn dieses Programm anfängt den Ordner zu verschlüsseln verabschiedet sich mein Mac und startet neu. Das war eine gute Gelegenheit eine eigene Lösung für das Problem zu finden.

Ich werde in diesem Beispiel zeigen, wie man einen Dienst anlegt mit dem man Dateien oder Ordner im Finder als ein, mit einem Passwort verschlüsseltes, Image speichern kann. Dazu muss man im Finder lediglich die gewünschte zu verschlüsselnde Datei oder Ordner mit der rechten Maustaste anklicken und anschließend den Dienst “verschlüsseltes Image erzeugen” auswählen.

Dienst erstellen

Rufen Sie zunächst das Programm “Automator” auf. Den Automator können Sie wahlweise über Spotlight mit der Tastenkombination cmd + Leertaste und der anschließenden Eingabe des Wortes “Automator” öffnen oder Sie gehen im Launchpad in den Ordner “Andere” und öffnen den Automator von dort aus. Wählen Sie als Art für das neu zu erstellende Dokument den Eintrag “Dienst” aus.

Automator - Auswahlfenster

Als erstes muss man angeben was genau der Dienst empfangen soll. In unserem Beispiel wollen wir Dateien und Ordner an den Dienst übergeben die dieser anschließend verschlüsseln soll. Wählen Sie also den Eintrag “Dateien oder Ordner”. Rechts daneben wählen Sie, welches Programm den Dienst anbieten soll. Wir wollen den Dienst im Finder nutzen, also wählen wir hier den Eintrag “Finder”.

Wählen Sie nun aus der Bibliothek ganz links im Programmfenster den Eintrag “Dateien & Ordner” und klicken Sie rechts daneben doppelt auf den Eintrag “Neues Image”.  Das Ganze sollte jetzt so aussehen.

Automator - Neues Image

Ich möchte, wenn ich einen Ordner mit einem Passwort verschlüsselt als Image speichere, dass die Imagegröße automatisch an die Größe des vorhandenen Ordners angepasst wird. Außerdem soll der Ort wo das verschlüsselte Image gespeichert wird, der Ort sein in dem ich mich gerade befinde. Es soll sich lediglich ein Fenster öffnen, in dem ich das Passwort für das zu verschlüsselnde Image zweimal eingeben kann. Alles andere soll im Hintergrund passieren. Sie können optional natürlich auch angeben dass Sie jedes mal nach dem Zielordner oder nach der Größe des zu erzeugenden Images usw. gefragt werden.

Volumenname lasse ich leer, das bewirkt dass der Volumenname gleich dem Namen des gewählten Ordners sein wird. als Größe gebe ich an, dass die Image-Größe an den Inhalt angepasst werden soll. Ich mache ein Häkchen bei “Verschlüsseln”. “Sichern unter” lasse ich ebenfalls leer, so wird das zu erzeugende Image wiederum unter dem Namen des gewählten Ordners abgespeichert. Hinter “Ort” wähle ich “Der selbe Name wie die Eingabe”. Das bedeutet, dass das image im selben Verzeichnis abgespeichert wird in dem wir uns gerade befinden. Geben Sie zum Schluss an, was geschehen soll wenn das Image erzeugt wurde. Ich für meinen Teil möchte dass das image nicht sofort eingehängt wird sondern dass dieses nur erstellt wird. Also gebe ich an “Auswerfen und die Image-Datei zurückliefern”.

Das Ganze sieht bei mir nun so aus.

Automator - Neues Image fertig

Speichern Sie den Dienst nun ab indem Sie auf “Ablage->Sichern” klicken und geben Sie z.B. den Namen “Verschlüsseltes Image erzeugen” ein.

Wenn Sie jetzt in den Finder gehen und einen rechtsklick auf einen Ordner oder eine Datei machen, sehen Sie im erscheinenden Context-Menü ganz unten den Eintrag “Dienste”. Wenn Sie jetzt mit dem Mauszeiger über “Dienste” fahren müssten Sie bereits den neuen Eintrag “Verschlüsseltes Image erzeugen” sehen können. Klicken Sie auf diesen Eintrag um den gewählten Ordner zu verschlüsseln und ein Image zu erstellen.

Es öffnet sich folgendes Fenster in dem Sie nun zweimal Ihr Passwort eingeben können mit dem das Image verschlüsselt werden soll. Entfernen Sie das Häkchen bei “Kennwort im Schlüsselbund sichern” wenn Sie nicht wollen dass das Passwort im Schlüsselbund gespeichert wird.

Automator - Passworteingabe

Der Dienst wird übrigens im Homeverzeichnis des jeweiligen Users im Verzeichnis “Library->Services” abgelegt.

Ich hoffe ich konnte Ihnen einen kleinen Einblick in den Umgang mit dem Programm Automator gewähren und Ihnen zeigen was auf dem Mac doch so alles möglich ist um sich die Arbeit noch weiter zu erleichtern und Arbeitsprozesse zu automatisieren.

The post Automator – Ein verschlüsseltes Image erstellen appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

Erfahrungsbericht Smart Pedelec 2014

Nach zwei Jahren Elektroroller fahren, war ich mal wieder auf der Suche nach einer neuen, innovativen Art der Fortbewegung. Es sollte ein Fahrzeug sein, mit dem man leicht durch jeden Stau kommt. Ein Fahrzeug dessen Akku man ohne Probleme und ohne großes Aufsehen auch mal schnell an jeder handelsüblichen 220V Steckdose nachladen kann. Eins mit dem man auch noch fahren kann wenn der Akku dann doch mal leer gefahren wurde und eins mit dem man sich auch sportlich betätigen kann. Die laufenden Kosten sollten sich außerdem in Grenzen halten. Entschieden habe ich mich für das Smart Pedelec 2014 von Daimler.

Smart Pedelec

Ich finde das Design des Smart Pedelec einfach nur grandios. Der Akku sitzt nicht wie bei den meisten anderen eBikes und Pedelecs auf dem Rahmen oder unter dem Gepäckträger sondern ist absolut perfekt in den Rahmen integriert. Daimler setzt bei seinem Smart Pedelec auf die bewehrte BionX-Technik, die aus den drei Baugruppen Elektromotor, Akku und Steuer-Bedieneinheit besteht. Die bei Dunkelheit blau beleuchtete und wasserdichte Bedieneinheit lässt sich mit einem leichten Druck auf die Entriegelung nach unten wegschieben und entfernen. Setzt man die Steuerung ein und betätigt den Powerbutton, findet man sich im normalen Fahrradmodus wieder und die LED-Beleuchtung wird eingeschaltet. Die Leistung der Motorunterstützung lässt sich in vier Stufen einstellen. In der höchsten Unterstützungsstufe steuert der Motor 300% zur selbst aufgebrachten Kraft bei. Wenn es mal bergab geht oder man sich so richtig auspowern will, kann man eine der vier Generatorstufen einstellen, in denen der Elektromotor  als Generator genutzt und die erzeugte Energie zurück in den Akku eingespeist wird.

Smart Pedelec

Im Internet habe ich viel über die schlechte Ausleuchtung der Strasse direkt vor dem Pedelec oder die gefährliche Bedienung der Steuereinheit während der Fahrt gelesen, da man dabei immer eine Hand vom Lenker nehmen musste. Daimler hört seinen Käufern offensichtlich zu und hat beim Smart Pedelec 2014 diese Dinge sehr zufriedenstellend gelöst. Die Ausleuchtung der Strasse ist nun auch direkt vor dem Pedelec mehr als ausreichend. Das Bedienteil lässt sich nun über eine Fernbedienung, die am linken Griff befestigt ist und sich ganz leicht und ohne Verrenkungen mit dem Daumen über 3 Buttons bedienen lässt, steuern. Die Bedienung ist auch mit der Fernbedienung äußerst intuitiv zu bedienen. Es gibt lediglich zwei Knöpfe zum umschalten der Unterstützungs- und Generatorstufen und einen Button zum umschalten zwischen den einzelnen Displayanzeigen.

 

Cockpit und Bedienteil

Das Bedienteil wird oben auf dem Cockpit eingeklipst und lässt sich genauso einfach mit leichtem Druck auf den Halteklip wieder entfernen. Das ist wichtig da man das Bedienteil sowieso jedes Mal wenn man das Pedelec irgendwo abstellt mitnehmen sollte, denn das wäre sicher das erste Teil was fehlen dürfte wenn man zurück kommt. Das Cockpit verfügt an der Unterseite über einen USB Anschluss an dem sich z.B. ein Smartphone anschließen und mit Strom versorgen lässt.  Das ist äußerst praktisch wenn man die Smartphonehalterung dazu bestellt hat und man sein Smartphone als Navigationssystem nutzt.

Smart Pedelec - Fernbedienung Smart Pedelec - Bedienteil

Das Bedienteil ist sehr übersichtlich gestaltet und man kommt sofort und auch ohne vorher die Bedienungsanleitung gelesen zu haben damit zurecht. Beim einschalten des Bedienteils befindet man sich im normalen Fahrradmodus, in dem der Motor des Pedelec weder unterstützt noch als Generator fungiert. Man benutzt das Pedelec also wie ein normales Fahrrad. Ein kurzer Klick auf die obere linke Taste schaltet das Bedienteil ein oder aus. Drückt man bei eingeschaltetem Bedienteil länger auf diesen Knopf, lässt sich die LED-Beleuchtung des Pedelec ein- bzw. ausschalten. Die linke, untere Taste nutzt man zum umschalten der Anzeige zwischen Tageskilometerstand, Gesamtkilometerstand, Durchschnittsgeschwindigkeit, Uhrzeit und der vergangenen Zeit seit dem einschalten des Bedienteils.  Mit den beiden Tasten auf der rechten Seite des Bedienteils wählt man die gewünschte Unterstützungs- oder Rekuperationsstufe (Generator, Energierückgewinnung).

Smart Pedelec - USB-Anschluss

 

Der Motor

Das Smart Pedelec verfügt über einen leistungsstarken, bürstenlosen, 250W BionX Hinterradnaben-Elektromotor mit einem maximalen Drehmoment von 35Nm. Er verfügt über jeweils vier Generator und vier Unterstützungsstufen. Die Kraft des Motors wird über den Carbon Zahnriemen auf das Hinterrad übertragen. Dieser soll besonders wartungsarm, sauber und langlebig sein.

Smart Pedelec - Elektromotor Smart Pedelec - Zahnriemenantrieb

 

Der Akku

Der entnehmbare Lithium-Ionen Akku verfügt über eine Kapazität von 423 Wh nominal und eine Spannung von 48V. Er hat ein Gewicht von 3,3Kg. Je nach Gewicht des Fahrers, der Topographie und der gewählten Unterstützungs- und Generatorstufen reicht der Akku für eine Entfernung von bis zu 100km.  Die Ladezeit von 0% bis 100% beträgt 5 Stunden. Der Akku lässt sich über das mitgelieferte Netzteil, das die Größe und das Aussehen eines normalen Laptop Netzteils hat, im ausgebauten wie im eingebauten Zustand laden. Daimler gibt eine Ladezyklenzahl von 500 an. Das bedeutet, dass der Akku nach 500 mal vollständigem Ent- und wieder vollständigem aufladen noch über eine Restkapazität von 80% verfügt. Aus Erfahrung mit meinem Elektroroller kann ich sagen dass diese Werte absolut realistisch sind. Nach zwei Jahren und 11.000 gefahrenen km scheint die Leistung des Akkus meines Elektrorollers absolut nicht nachgelassen zu haben.

Auch beim Akku hat sich Daimler etwas besonderes einfallen lassen. Streicht man nämlich mit dem Finger über die Ladebuchse am Akku dann wird diese je nach Ladezustand rot, orange oder grün beleuchtet, wobei rot für eine Akku-Kapazität von unter 25% und grün für einen voll aufgeladenen Akku steht.

Smart Pedelec - Akkuverriegelung Smart Pedelec - Akku

 

Bremsen

Die Vorderradbremse MT4 von Magura ist eine hydraulische Scheibenbremse mit einem Durchmesser von 180mm und verfügt über eine Rekuperationsfunktion. Bei Betätigung der Vorderradbremse wird der Motor als Generator benutzt und die erzeugte Energie zurück in den Akku gespeist. Der Motor übernimmt also die Funktion eines großen Dynamos um Energie zurück zu gewinnen.

Die Hinterradbremse  MT4 ist wie die Vorderradbremse eine hydraulische Scheibenbremse von Magura.

Smart Pedelec - Bremshebel Smart Pedelec - Scheibenbremse

 

Federung

Das Smart Pedelec wird standardmäßig mit einer starren Gabel geliefert. Als ich mich für dieses Pedelec entschied kalkulierte ich schon ein dass ich das Rad nur im Stadtverkehr nutzen und ich dieses nicht wie ein Mountainbike auf Feld- und Waldwegen fahren würde. Leider musste ich die Erfahrung machen, dass Münchens Radwege stellenweise in einem so schlechten Zustand sind dass man das Gefühl hat auf einem Feldweg unterwegs zu sein. Mit meinem voll gefederten Mountainbike sind mir diese schlechten Strassenverhältnisse vorher nie so gravierend aufgefallen. Wenn Sie am Abend nach getaner Arbeit total müde mit dem Pedelec nach Hause radeln dann fahren Sie doch die ersten Meter mal über Kopfsteinpflaster. Sie werden sehen, das Pedelec schüttelt die Müdigkeit schlagartig aus Ihrem Körper und Sie kommen hellwach zu Hause an. ;-) Daimler hat auch hier auf die Wünsche der Käufer reagiert und bringt nun eine gefederte Gabel als Zubehörteil auf den Markt. Nun muss jeder für sich selbst entscheiden ob ihm die starre Gabel genügt oder er vielleicht doch zur gefederten Gabel greift.

 

Schaltung

Die Schaltung des Smart Pedelec ist recht einfach gehalten und verfügt lediglich über drei Gänge. Bei der Schaltung handelt es sich um eine integrierte 3-Gang SRAM I-Motion 3 – Nabenschaltung. Zuerst dachte ich dass dies, gerade im Vergleich zu anderen Pedelecs doch sehr wenig wäre. Wie ich jedoch feststellen musste ist dies doch mehr als ausreichend, da man mit dem Pedelec sowieso kaum mehr als 30km/h fahren wird. Den ersten Gang habe ich bis jetzt noch nicht gebraucht. Ich denke dieser wird nur nützlich sein wenn man an einem sehr steilen Berg anfahren will oder man sehr unsportlich ist. Da ich ein schneller Fahrer bin und die meiste Zeit mit ca. 27km/h dahin gleite, nutze ich meist nur den dritten Gang und ich hatte noch nie das Gefühl dass ein weiterer Gang schön wäre.

Smart Pedelec - Schaltung

 

Fazit

Daimler hat hier wirklich eine tolle Arbeit geleistet und sich viele Gedanken zu Design und Funktionalität gemacht. Das Pedelec ist für die Stadt gemacht und dort sollte man es auch nutzen. Wer es zweckentfremdet auch auf Feld und Waldwegen nutzen will der hat die Möglichkeit das Fahrverhalten durch eine nachrüstbare Federgabel zu optimieren.

Des Weiteren bietet Daimler eine breite Palette an Zubehörteilen wie einen höheren Lenker, eine gekröpfte Sattelstange, eine Halterung für Smartphones zwischen 3,5″ und 4,3″ einen Gepäckträger mit den passenden Satteltaschen und einigem mehr.

Alles in Allem muss ich sagen dass ich mehr als überzeugt vom Konzept des Pedelec und von der Umsetzung des Smart Pedelec durch Daimler bin. Mit diesem Fahrzeug überwinde ich auch am Morgen um 04:30 Uhr, wenn ich zur Arbeit fahren muss, den Schweinehund und nutze das Bike anstatt dem Auto oder dem Elektroroller. Man kommt entspannt und nicht schweißgebadet am Ziel an und hat trotzdem noch etwas für die Gesundheit und die Umwelt getan.

Ein großes Dankeschön geht an Herrn Kurreck von der Firma bike-angebot für die schnelle und freundliche Abwicklung und an Herrn Fröhlich von der Firma shokes in Frankfurt am Main, der mir stets mit Rat und Tat zur Seite stand.

Weitere Informationen zum Smart Pedelec finden Sie hier

 

The post Erfahrungsbericht Smart Pedelec 2014 appeared first on Fluuux – TechBlog.

Zum Blog Fluuux

PCF8574 – Ein LCD Display mit nur zwei Pins am Arduino betreiben.

Wie man ein LCD Display am Arduino anschließt habe ich ja nun schon mehrfach gezeigt. Nachteil war immer dass ein Display gleich einen Großteil der verfügbaren Pins des Arduino belegt hat. In diesem Beitrag erfahren Sie, wie man per I2C und mittels Portexpander PCF8574 – ein LCD Display mit nur zwei Pins am Arduino betreiben kann. Letztendlich zeige ich wie man mehrere Displays ebenfalls mit nur zwei Pins am Arduino betreiben kann.

Bauteile für dieses Beispiel

1 x Arduino Uno Rev.3
1 x Drehpoti
1 x PCF8574 Portexpander
1 x 16×2 LCD Display
und eine Menge Steckbrücken

16x2 PCF8574 I2C Breadboard Foto

 

Der Portexpander PCF8574

Da die Anzahl der digitalen Ports am Arduino begrenzt sind und man oft mehr Ports braucht als eigentlich verfügbar sind, kann man sich behelfen indem man einen Schieberegister benutzt. Man kann aber auch mittels I2C Bus den I/O Portexpander PCF8574 von Phillips ansteuern. Dieser Baustein bietet ganze 8 bidirektionale Portleitungen die man einzeln über den I2C Bus setzen und auch abfragen kann.

PCF8574 Belegung

 

Belegung des PCF8574

  • A0 – A2 = Auswahl der I2C Bus Adresse
  • P0 – P7 = Digitale I/O Ports
  • SDA = Datenleitung – Verbindung zum I2C Bus
  • SCL = Taktleitung – Verbindung zum I2C Bus
  • INT = Interrupt Ausgang
  • VDD = +5V
  • VSS = GND

Über die Ports A0, A1 und A2 lässt sich die Adresse einstellen. indem man diese Ports auf LOW oder HIGH setzt. Es lassen sich bis zu 16 PCF8574 am I2C Port des Arduino anschließen. Darauf, wie man diese Adressen nun genau einstellt möchte ich hier nicht näher eingehen. Sie sollten sich bei Interesse die Wiki Seite zu I2C und das DataSheet des PCF8574 anschauen.

 

Verbinden des Displays mit dem Portexpander

16x2 PCF8574 I2C Steckplatine

ACHTUNG
Je nach genutztem Arduino müssen Sie die Ports SDA und SCL des Portexpanders an unterschiedlichen Ports am Arduino anschließen. In der Liste sehen Sie wo bei den verschiedenen Arduinos SDA und SCL liegen.

Arduino               SDA          SCL
Arduino UNO           A0           A1 
Arduino Mega 2560     20           21
Arduino Leonardo      2             3

 

PCF8574                Arduino              Display
Port 16 (VDD)          +5V                  -
Port 15 (SDA)          A4 (SDA)             - 
Port 14 (SCL)          A5 (SCL)             -
Port 13 (INT)          -                    -
Port 12 (P7)           -                    -
Port 11 (P6)           -                    Port 4 (RS)
Port 10 (P5)           -                    Port 5 (R/W)
Port 9  (P4)           -                    Port 6 (E)
Port 8  (VSS)          GND                  -
Port 7  (P3)           -                    Port 14 (DB7)
Port 6  (P2)           -                    Port 13 (DB6)
Port 5  (P1)           -                    Port 12 (DB5)
Port 4  (P0)           -                    Port 11 (DB4)
Port 3  (A2)           GND                  -
Port 2  (A1)           GND                  - 
Port 1  (A0)           GND                  -

 

Library

Um nun bequem mit dem Display per I2C kommunizieren zu können, behelfe ich mir einer fantastischen Library, die Sie hier herunterladen können.

Beispiel Sketch

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x20,16,2);

void setup()
{
    lcd.init();
    lcd.setCursor(0,0);
    lcd.print("Hello, world!");
}

void loop()
{
  lcd.setCursor(0,0);
  lcd.print("Sek. seit Start");
  lcd.setCursor(0,1);
  lcd.print(millis()/1000);
}

 

Mehrere Displays am Arduino anschließen

Ein Display mit nur zwei Pins betreiben lief ja schon mal ganz gut. Aber die Vorteile von I2C sind ja, dass man bis zu 18 Portexpander gleichzeitig betreiben kann. Hier also ein Beispiel mit zwei Portexpandern und zwei Displays. Wie Sie sehen ist der Aufbau weiterer Portexpander kongruent zum ersten. Lediglich die Ports SDA und SCL  weiterer Portexpander müssen mit den Ports SDA und SCL des ersten Portexpanders verbunden werden. Der wichtigste Punkt hier sind jedoch die Verbindungen an A0 – A1. Am ersten Portexpander haben wir A0, A1 und A2 jeweils auf GND gelegt. Laut Datenblatt steht dies für die Adresse 0×20. Im oben angegebenen Sketch sehen Sie in Zeile 3, dass die Adresse 0×20 beim Aufruf des Displays mit übergeben wurde. Um nun zwei oder noch mehr Displays ansteuern zu können, müssen sich natürlich die Adressen aller Portexpander unterscheiden.

In diesem Ausschnitt aus dem Data Sheet des PCF8574 sehen Sie wie Sie die verschiedenen Adressen übergeben können. Ich habe für Portexpander 1 die Adresse 20h, also hexadezimal 20 oder auch 0×20 gewählt indem ich A0, A1 und A2 jeweils auf GND gelegt habe. Für den zweiten Portexpander werde ich die Adresse 21h, also 0×21 wählen. Dazu lege ich A0 auf +5V und A1, sowie A2 auf GND.

PCF8574 Address Map

 

 

Steckplatine mit zwei Portexpandern und zwei Displays

16x2 PCF8574 I2C 2 Displays Steckplatine

 

 

Beispiel Sketch

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd1(0x20,16,2); // Display 1 mit 16 Spalten und 2 Zeilen an Adresse 20h
LiquidCrystal_I2C lcd2(0x21,16,2); // Display 2 mit 16 Spalten und 2 Zeilen an Adresse 21h

void setup()
{
    lcd1.init(); // Display 1 initialisieren
    lcd2.init(); // Display 2 initialisieren 

    lcd1.setCursor(0,0);
    lcd1.print("DISPLAY 1");

    lcd2.setCursor(0,0);
    lcd2.print("DISPLAY 2");

    delay(1000);

    lcd1.clear();
    lcd2.clear();
}

void loop()
{
  lcd1.setCursor(0,0);
  lcd1.print("Sek. seit Start");
  lcd1.setCursor(0,1);
  lcd1.print(millis()/1000);

  lcd2.setCursor(0,0);
  lcd2.print("Zeile 1");
  lcd2.setCursor(0,1);
  lcd2.print("Zeile 2");
}

16x2 PCF8574 I2C 2 Displays Breadboard

The post PCF8574 – Ein LCD Display mit nur zwei Pins am Arduino betreiben. appeared first on Fluuux – TechBlog.

Zum Blog Fluuux