Monthly Archives: March 2014

Verbinden und Steuern eines Arduino Boards mit Cascades, Teil II

IMG_20140220_124315Im zweiten Teil will ich erklären, wie es möglich ist einen Arduino über ein Z30 zu steuern. Bevor das getan werden kann muss der Arduino vom Gerät erkannt werden. Die notwendigen Schritte sind hier im ersten Teil dokumentiert.

Nachdem der Arduino verbunden ist, muss zunächst der Pfad geöffnet werden, der in der Klasse Peripheral gespeichert ist (Siehe blog Teil I). Ich benutze einen Button um die Kommunikation zu öffnen, weil der Arduino etwas Zeit zum Starten braucht und ich es einfach halten möchte :-) Falls versucht wird den Pfad zu früh zu öffnen, kann es sein, dass es nicht funktionieren.

Wenn der Button gedrückt wird, wird eine Funktionen aufgerufen, die die Kommunikation beginnt. Die Variable m_serial wird dazu genutzt um zu überprüfen, ob bereits eine serielle Kommunikation geöffnet ist und verhindert, dass der Pfad jedesmal geöffnet wird, wenn der Button gedrückt wird. In diesem Fall wird die Funktion beendet. Anderenfalls wird der Pfad ausgelesen und im read/write Modus mit open() geöffnet. Vergiss nicht zu überprüfen, ob der Pfad gültig ist.

Die nächsten Zeilen sind dazu nötig, die Attribute für die Kommunikation festzulegen: Die Bauderrate und der Mode, die im struct termios gespeichert sind. Die Bauderate legt die Übertragungsgeschwindigkeit fest und muss die selbe sein wie für den Arduino. Schau nach welche im Arduinoprogramm verwendet wurde (hier 9600). Anderenfalls wird es nicht funktionieren. Der TRANSNOW Modus ist dafür da, die Nachricht sofort zu senden:

Um zu sehen, ob wir erfolgreich waren wird der erste Befehl zum einschalten der LED gesendet:

Die Variable m_value legt die Intensität fest und sollte zwischen 0 und 255 liegen (0 bedeutet aus). m_lastWrite beinhaltet den letzten Wert, der an den Arduino gesendeten wurde. Auf diese Weise vermeiden wir unnötige neue Sendungen mit dem selben Wert.

Jetzt benötigen wir etwas mehr UI (außer den Button), um die Intensität der LED zu ändern. Ich habe dafür eine Radio Group verwendet, um verschiedene Helligkeiten wählen zu können (an, halb an, aus). Erstelle diese in der qml-Datei und benutzte eine invoke Funktion wenn das Signal onSelectedIndexChanged() empfangen wird:

Jedes mal wenn der Nutzer die Auswahl ändert, wird  writeSerial() aufgerufen. In dieser Funktion muss zunächst überprüft werden welcher Index gewählt wurde und die Intensität dementsprechend eingestellt werden. Ich habe das über eine switch-case-Anweisung getan und die Helligkeit manuell geändert.

Da wir den Wert nur an den Arduino senden wollen, wenn dieser verbunden ist und der Pfad geöffnet ist, muss die Variable m_serial überprüft werden. In Teil I dieses Blogs wird die Variable im Konstruktor auf -1 gesetzt. Ebenso wenn der Arduino getrennt wird. Wenn der Arduino verbunden ist senden wir den neuen Wert indem wir write() aufrufen.

Jetzt hast du gelernt, wie man einen Arduino an ein BlackBerry 10 Gerät anschließen und steuern kann. Damit kann ein eigenes kleines Protokoll geschrieben werden, was der Arduino interpretiert. Weiter Informationen können hier auf der Website gefunden werden.

Hier ist das gesamte Projekt.

Verbinden und Steuern eines Arduino Boards mit Cascades

IMG_20140228_094623Hallo, hier ist @leaschnherr und heute will ich im Rahmen von Mobile Computing Plattformen erklären, wie man den USB Host Mode des Z30 nutzen kann um ein Arduino Uno Board zu steuern. Um es einfach zu halten, war zunächst mein Ziel die Intensität einer LED zu kontrollieren.

Der Code für den Arduino kann unverändert aus dem Dimmer Beispiel von Arduino übernommen werden, das du hier mit hilfreichen Erklärungen findest.

Wenn du das erste mal mit einen Arduino arbeitest, lese die Anweisungen auf der Website hier. Stelle sicher, dass das Programm korrekt läuft und teste einige Beispiele, um dich an die Umgebung zu gewöhnen.

Der Code für die BlackBerry 10 App ist etwas komplexer und im ersten Teil will ich nur erklären, wie USB Geräte erkannt werden und wie man auf diese zugreift.

Nachdem ein neues Cascades Projekt erstellt worden ist, muss zunächst die Peripheral Discovery Library hinzugefügt werden. Wenn Momentics verwendet wird, kann diese einfach durch einen Rechtsklick auf den Projektordner hinzugefügt werden. Dann wähle aus: configure->Add Library->Standard BlackBerry platform library und auf ‘next’. In der Suche libperipheral_discovery eingeben und diese anschließend auswählen und auf ‘finish’ klicken. Dann wird die Library automtaisch in der config.pri Datei hinzugefügt, die in die .pro Datei eingebunden wird.

Im ersten Teil wird noch keine GUI benötigt, so das wir uns nicht darum kümmern brauchen. Ich werde diese dann im zweiten Teil erklären. Das einzige was getan werden muss, ist eine Instanz einer Klasse zu erstellen, die ich Discover genannt habe. Hier ist der Konstruktor dieser Klasse:

Die Funkion bps_initialize() muss aufgerufen werden, wenn irgendein Service der BPS Schicht verwendet wird. Für unser Projekt brauchen wir den Peripheral Discovery Service. Dann muss dieser Service selbst initialisiert werden, indem pd_initialize(0) aufgerufen wird. Um zu erkennen wenn der Arduino verbunden oder getrennt wird, wird im nächsten Schritt ein Signal Handler (m_sigEvent) und eine dazugehörige Funktion (signalHandler()) mittels bps_add_sigevent_handler() verbunden. signalHandler() wird nun jedes mal aufgerufen, wenn zuvor definierte Ereignisse auftreten.

Danach muss überprüft werden, ob der USB Host Mode unterstützt wird:

Das kann über die Funktion pd_is_bus_supported() getestet werden. Die App wird auch auf anderen Geräten laufen, allerdings wird es nicht möglich sein ein externes USB Gerät zu steuern. Wenn die Anfrage erfolgreich war und das BlackBerry 10 Gerät den USB Host Mode unterstützt, ist der nächste Schritt, die benötigten Events zu registrieren:

Bevor irgendeine Funktion mit pd_class_t als Parameter aufgerufen wird, muss die Methode pd_is_class_supported() aufgerufen werden. In diesem Fall mit PD_CLASS_SERIAL als Parameter, für Serielle Kommunikation. Wenn kein Fehler zurück gegeben wird, ist es möglich, m_sigEvent mit PD_CLASS_SERIAL zu registrieren. Die Variable m_sigEvent ist vom Typ struct sigevent und der Signal Handler (siehe Konstruktor). Nach diesen Schritten wird jedes mal wenn ein USB Gerät angeschlossen oder getrennt wird, die im Konstruktor definierte Funktion signalHandler() aufgerufen:

Da die signalHandler() Funktion static sein muss und es somit nicht möglich ist nicht-static Variablen zu nutzen, wird einfach ein Funktionspointer zu einer anderen Funktion verwendet. Diese überprüft, ob der Arduino angeschlossen oder getrennt wurde:

Wenn das Gerät angeschlossen wurde, wird eine Peripherie mit der erkannten pd_peripheral_t allokiert (Weiter Erklärungen, siehe unten). Im anderen Fall, wenn das Gerät getrennt wurde, wird die pd_free_peripheral() Methode aufgerufen und andere Vorbereitungen für die nächste Verbindung getroffen (Die Variable m_serial, welche für die spätere Kommunikation benötigt wird, wird auf -1 gesetzt).

Unser angeschlossenes Gerät wird in einer Klasse Peripheral gespeichert. Diese einfache Klasse beinhaltet den Pfad, welcher von der zuvor allokierten  pd_peripheral_t Variable ausgelesen werden kann. Später ist es möglich, diese Klasse auch für weiter Informationen zu verwenden. Im Konstruktor werden eine Reihe von Anweisungen aufgerufen, die nötig sind um den Pfad herauszufiltern.

Der Pfad ist eine Eigenschaft aus einer Liste von Eigenschaften. Also ist das erste was getan werden muss die gesamte Liste zu lesen. Anschließend wird jede Eigenschaft angeschaut und nach Variablentyp gefiltert: Der Pfad ist der einzige String, so sehen wir wenn es sich um die richtige Eigenschaft handelt. Gute Programmierer würden natürlich noch den String überprüfen, z. B. ob er “/dev” beinhaltet :-)

Jetzt ist es möglich den Arduino zu Verbinden und zu erkennen. Wie diese Schnittstelle verwendet wird um Anweisungen an den Arduino zu senden wird in Teil II erklärt.

How to Connect and Control an Arduino Board with Cascades, Part II

IMG_20140220_124315

In this second part I want to explain, how to control a connected Arduino via a Z30 device. Before you can do this, the Arduino has to be discovered by the device. The necessary steps are documented here in the first part.

After setting up a successful connection between Z30 and Arduino the path, which is saved in our Peripheral class (see blog part I) needs to be opened to perform any communication. I use a button to open the communication, because the Arduino needs some time to boot and I like to do it simple :-) If you try to open the path too early it might not work.

When the button is pressed, a method is called, which starts the communication. The variable m_serial is used to check, if a serial connection is already open and avoid us to open the path on each button click. In this case, the function returns immediately. Otherwise the path is read out and opened for read/write mode with open(). Don’t forget to check if the path is valid and return if it is not.

The next lines are to set the attributes for communication: The baude rate and the mode, which are saved in the  struct termios. The baude rate sets the communication rate and must be the same as for the Arduino. Look up which one you used for your Arduino program (here 9600), otherwise it won’t work. The TRANSNOW mode is used to transmit the message immediately:

To check if the steps above were successful, we write the first command, to switch the LED on:

The variable m_value sets the intensity and should be between 0 and 255 (0 is off). m_lastWrite contains the last value which was send to the Arduino. This way we avoid useless re-sending of the same value again and again .

Now we need a little more UI beside the button to be able to change the LED intensity. I decided to use a radio group to select different brightnesses (off, middle, full). Create them in the qml File an use an invoked method, when the onSelectedIndexChanged signal is received:

Each time the user select a different button writeSerial() is called. In this method the first thing is to verify which index was selected and set the intensity accordingly. I checked it with a switch-case-instruction and changed the intensity manually.

Because we only want to send the value to the Arduino, when it is connected and the path is open, the variable m_serial need to be checked. As you might remember from the part I of this blog m_serial is set to -1 in the constructor and after each disconnection. If the Arduino is connected, we send the new brightness value by calling write().

Now you learned how to connect the Arduino to your BlackBerry 10 device and how to control it. With that you can write an own little protocol which the Arduino can interpret. Further information can be found here at the website.

Download the whole project here.

How to Connect and Control an Arduino Board with Cascades

IMG_20140228_094623Hey, here is @leaschnherr and today in the context of mobile computing platform I want to explain to you how can use the USB host mode of a Z30 device to control an Arduino Uno Board. To keep it simple, my aim was just to manipulate the intensity of an external LED connected to a GPIO.

The code running on the Arduino can be used unchanged from the Dimmer example of Arduino, which you can find here with helpful explanation.

If you work with an Arduino for the first time, read the introduction at the website here. Be sure the program is running correctly and try out some examples to get used to the environment.

The Code for the BlackBerry 10 App  is a little more complex and in the first part I only want to explain, how to recognize and handle a connected USB device:

After creating a new Cascades project the first thing which has to be done is to add the Peripheral Discovery Library. In the Momentics environment just click right on the Project folder. Then choose configure->Add Library->Standard BlackBerry platform library and click ‘next’. Search for libperipheral_discovery, select it and click ‘finish’. The Library is now added automatically to the config.pri file, which gets included to the .pro file.

In the first part no GUI is needed, so you don’t have to care about it during the recognition and I’m going to explain it in the second part. The only thing which has to be done is to create an instance of a class which I called Disvover. Here is the constructor of this class:

The function bps_initialize() has to be called as once you need any services from the BPS layer. For our project we need with the Peripheral Discovery Service. Then we need to initialize the Peripheral Discovery Service themselves by calling pd_initialize(0). Then to detect connection and disconnection of the Arduino board, we need to register for the m_sigEvent and a corresponding handler (signalHandler()) via the bps_add_sigevent_handler() function. signalHandler() is now called each time, when defined events occur.

After that it is necessary to check, if the USB host mode is supported:

This could be done with a simple function called  pd_is_bus_supported()The app will run on other devices, too, but it won’t be possible to control an external USB device. If the request was successful, and the Blackberry 10 Device supports the USB host mode, the next step is to register the necessary events:

Before any method with pd_class_t as parameter is used, the function pd_is_class_supported() should be called.  In this case with PD_CLASS_SERIAL as Parameter, this is for serial communication. When this call doesn’t return an error, we go ahead and register m_sigEvent with PD_CLASS_SERIAL. Now every time, when a USB device is connected or disconnected to the Blackberry 10 device,  signalHandler() is called (see constructor):

Because the signalHandler() function has to be a static and doesn’t allow to use non-static variables, we simply use a function pointer to another function, which checks for us, whether the Arduino was connected or disconnected:

In case of a connection, a peripheral is allocated with the detected pd_peripheral_t as Parameter (For further explanation see next section). In the other case, when the Arduino was disconnected, the pd_free_peripheral() method is called and other preparations for the next connection are made (the variable m_serial is set to -1 , which is required for communication).

Our peripheral is saved as class Peripheral. This simple class contains the path, which is a property of  pd_peripheral_t itself. Later it is possible to use this class for further information. In the constructor the path is read out by a couple of constructions, which are necessary to filter the right property:

The path is one property in a long list of properties. So the first thing to do is to fetch the whole list. Then we look at each property and use the type as filter: Because our currently path the only string we will know we have the right property. Of course good programmers would check the string for example if it includes “/dev” :-)

Now it will be possible, to connect and recognize the Ardunio. How we use this interface to send instructions to the Arduino is explained in part II.