Tensy 2.0 Bluetooth Sender/ Receiver

Mit dem Tensy 2.0 und einem HC05 Bluetooth- Modul soll mit einer Android App kommuniziert werden.

Weiterlesen

Observer Pattern

Das Observer Pattern macht sich den Umstand zunutze, dass jedes Klasse die ein Interface implementiert zu einer Instanz dieses Interfaces wird. Die dort implementieren Methoden des Interfaces können nun über diese Instanz ausgeführt werden.

Weiterlesen

Android Studio, Librarys

Source code– Bibliotheken, kurz, librarys sind praktisch weil man dort oft genutzten Code oder Ressourcen ablegen und Projektübergreifend nutzen kann.

Ich beschreibe in diesem Artikel wie man für die Arbeit mit Android Studio eigene Bibliotheken erstellt und einbindet. Diese Varianten erkläre ich hier:

  • Java Archive (JAR) als lokale Bibliothek.
  • Java Archive über ein remote GitHub repository einbinden.
  • Ein Android Library Module lokal oder über ein remote GitHub repository einbinden.

JAR als lokale library in ein Android Studio Projekt einbinden

Das habe ich in diesem Artikel beschrieben: Packages

JAR über ein remote GitHub repository in ein Android Studio Projekt einbinden

Für diese Methode muss man das Gradle build tool auf seinem Rechner installiert haben. Wenn das noch nicht der Fall ist, dort wird alles weitere beschrieben: gradle.org

Wenn Gradle installiert ist, dann schaut das so aus:

bash-3.2$ gradle -v
------------------------------------------------------------
Gradle 6.0.1
------------------------------------------------------------
Build time:   2019-11-18 20:25:01 UTC
Revision:     fad121066a68c4701acd362daf4287a7c309a0f5
Kotlin:       1.3.50
Groovy:       2.5.8
Ant:          Apache Ant(TM) version 1.10.7 compiled on September 1 2019
JVM:          1.8.0_66 (Oracle Corporation 25.66-b17)
OS:           Mac OS X 10.13.6 x86_64

Mit Gradle kann man nun ganz einfach ein library project anlegen. Das ist im wesentlichen eine fertige Ordnerstruktur mit allen erforderlichen Gradle– script Dateien. Das geht so:

bash-3.2$ gradle init
Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 

Es folgen weitere Abfragen mit denen man die Programmiersprache und die Test Umgebung festlegen kann. Das Ergebnis:

-rw-r--r--  1 Berthold  staff   955 Dec 13 22:04 build.gradle
drwxr-xr-x  3 Berthold  staff   102 Dec 13 22:03 gradle
-rwxr-xr-x  1 Berthold  staff  5764 Dec 13 22:03 gradlew
-rw-r--r--  1 Berthold  staff  2942 Dec 13 22:03 gradlew.bat
-rw-r--r--  1 Berthold  staff   359 Dec 13 22:04 settings.gradle
drwxr-xr-x  4 Berthold  staff   136 Dec 13 22:04 src

Im Ordner src ist bereits eine Beispiel Klasse abgelegt die ich für das Beispiel abgeändert habe und zum testen in meinem Android Studio Projekt benutzen möchte.

/*
 * This Java source file was generated by the Gradle 'init' task.
 */
package gradleTest;
public class Library {
    public String  someLibraryMethod() {
        return "Works";
    }
}

Das nächste was man braucht ist ein GitHub Account und man muss Git auf seinem Rechner installiert haben.

In GitHub legt man nun ein repository für seine Bibliothek an. wenn man das getan hat muss man sein lokales library Verzeichnis an die Git Kontrolle übergeben. Dazu tippt man in der obersten Ebene seines Java– Projektes:

bash-3.2$ git init
bash-3.2$ git status
On branch master
Your branch is up-to-date with 'origin/master'.
Untracked files:
  (use "git add <file>..." to include in what will be committed)
	../.gitattributes
	../.gitignore
	../build.gradle
	../gradle/
	../gradlew
	../gradlew.bat
	../settings.gradle
nothing added to commit but untracked files present (use "git add" to track)

Das Projekt kann man nun ganz einfach mit seinem remote repository auf GitHub synchronisieren. Zwei Schritte sind notwendig. Erstens, man muss Git mitteilen wo es das repository findet (Zeile 1) und zweitens, man synchronisiert das lokale mit dem remote repository (Zeile 2).

bash-3.2$ git remote add origin https://github.com/codingbychanche/gradleSample.git
bash-3.2$ git push -u origin master
Counting objects: 21, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (14/14), done.
Writing objects: 100% (21/21), 57.15 KiB | 0 bytes/s, done.
Total 21 (delta 0), reused 0 (delta 0)
To https://github.com/codingbychanche/gradleSample.git
 * [new branch]      master -> master
Branch master set up to track remote branch master from origin.
Beispiel library auf GitHub

Bevor man nun seine die library importiert, kann man sich überlegen ob man auf GitHub einen sogenannten release erzeugt, oder ob es genügt einen Snapshot zu importieren.

Ein release ist eine in sich abgeschlossene Version. Das kennzeichnet mit dem sogenannten Tag:

Gelb umrandet, der (Version) Tag des release.

Ein Snapshot spiegelt den aktuellen Stand der library wieder, also den letzten commit. Das bedeutet, man muss nicht immer einen release erzeugen, sondern kann während der Entwicklungsphase, ganz praktisch, alle kurzfristigen Änderungen direkt importieren und testen.

Im Weiteren beschreibe ich wieder Import eines release funktioniert. Das hat für dieses Beispiel anstandslos funktioniert. Die Snapshot Variante hat (noch) nicht geklappt.

Den Import der library in sein Android Studio Projekt habe ich über JitPack erledigt:

Nachdem man die URL seines GitHub repository’s eingetragen hat, teilt einem JitPack mit wie man das build. gradle (Für das Projekt) und das build.gradle (für das Modul) in seinem Android Studio Projekt ergänzen muss.

Wie man sehen kann listet JitPack alle Versionen und releases auf. Man kann frei wählen welche Variante der library importiert werden soll. Dazu dient letztendlich der Version Tag den man in GitHub entweder selbst vergeben hat oder der von GitHub für den Snapshot beziehungsweise die übrigen commits generiert wurde.

In Android Studio ergänzt man nun sein build.gradle script entsprechend und synchronisiert sein Projekt mit den gradle- files.

Angepasstes build.gradle script und Synchronisieren der gradle- files in Android Studio.

Nach diesem Schritt stehen einem die Klassen der importierten library in Android Studio zur Verfügung.

package berthold.gradlejavalibraryintegration;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import gradleTest.Library;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView text=(TextView)findViewById(R.id.mytext);
        Library lib=new Library();
        String name=lib.someLibraryMethod();
        text.setText(name);
    }
}

Oben kann man erkennen, dass die gradleTest.Library erfolgreich importiert werden konnte und die Klasse(n) einwandfrei erkannt werden. Der package- name ist der Pfad, innerhalb des Java– Verzeichnisses des Gradle library Projektes:

Rot umrandet: Package name: gradleTest

Der praktische Nutzen des Ganzen ist es nun, dass man sich, wenn man Änderungen an der Klasse seiner library vornimmt, über die Synchronisation mit GitHub in seinem Android Studio Projekt immer die aktuelle Version zur Verfügung hat, ohne irgendwelche copy and paste Orgien.

Android library- module importieren.

Die nötigen Schritte zum erstellen einer library in Android Studio werden dort beschrieben: Android Developers: Create a library module

Zum Anlegen einer neuen library hat man in Android Studio im wesentlichen zwei Möglichkeiten: Entweder man wandelt ein bestehendes App- module in ein library- module um, oder man erzeugt innerhalb eines bestehenden Projekts ein library module. Ich gehe auf beide Variangen ein:

Ein bestehendes App- module in eine library umwandeln

Android Developers: Create a library module

Innerhalb eines Bestehenden Projektes ein neues library module anlegen

File -> New -> Module -> Android Library. Danach findet man das neue Modul in seiner Projekt Hierarchie.

Neues library- module im Projekt.

In Abhängigkeit davon ob das library- module lokal auf dem eigenen Rechner liegen soll, oder auf einem Server – in diesem Artikel wird das am Beispiel von GitHub in Verbindung mit JitPack gezeigt – zeige ich zwei Möglichkeigen wie man es in sein eigenes Projekt einbindet.

Das library- module ist lokal auf dem Rechner abgelegt

  • Das library- module ist im Selben Projekt, wie das App- module in das man es einbinden möchte abgelegt.

    In diesem Fall muss man im Projekt lediglich die settings.gradle und im App- module die build.gradle Dateien anpassen:
settings.gradle auf der Projekt Ebene.
build.gradle auf der App- module Ebene.

  • Das library- module ist in einem anderen Projekt wie das App-module in das man es einbinden möchte

    Offen.

Das library- module ist auf GitHub abgelegt

Als erstes muss im Android library Projekt – auf der Projektebene(!) – ein git initialisiert werden. Dann erstellt man sich ein repository auf GitHub und synchronisiert es mit dem lokalen repository. Das funktioniert genau so, wie es bei dem Beispiel mit dem Java- Gradle Projekt weiter oben beschrieben steht. Für das hier gezeigte Beispiel schaut das GitHub repository so aus:

GitHub repository.

Als nächstes müssen die die beiden build.gradle Dateien auf der Projektebene und auf der library Ebene angepasst werden.

Das ist bei JitPack dort beschrieben: Publish an Android Library.

In meinem Beispiel schaut das so aus:

build.gradle auf der Projektebene. Die ergänzte Zeile ist blau markiert.
build.gradle auf der library Ebene. Man kann hier entweder den letzten commit (das ist der SNAPSHOT), jeden anderen commit über seine Version Tag oder einer sogenannten Release importieren.
Das repository in JitPack. Der Version- Tag dient im build.gradle auf der Modul Ebene zur Auswahl der zu implementierenden Version. Der letzte commit (SNAPSHOT) eignet für Testläufe bei der Weiterentwicklung der library. In sich abgeschlossene Versionen können als ein Release für die allgemeine Anwendung veröffentlicht werden.

Schließlich synchronisiert man sein Projekt mit den Gradle- files. Nach diesem Schritt kann die library verwendet werden.

Das geht so:

Die Klassen und Ressourcen aus der library verwenden

Die library wurde importiert. Die Abbildung unten zeigt, welche Klassen und Ressourcen darin enthalten sind (git hat die jeweils grün markiert):

Die in dieser library enthaltenen Klassen und Ressourcen werden nun automatisch erkannt:

Importierte library, Klasse seekBarHelper im App- Module nutzen.

Genau so einfach funktioniert das mit den in der library enthaltenen Resourchen:

Nutzen der in der importierten library enthaltenen styles. In diesem Fall der style TableRowsTitle

Packages

Packages sind Sammlungen von Klassen. Sie grenzen diese Klassensammlungen voneinander ab, was dabei hilft in wachsenden Projekten Namenskonflikte zu vermeiden.

Eclipse IDE

Im wesentlichen ist die Code- Struktur eines Java Projektes genauso aufgebaut wie das hierarchische Dateisystem auf ihrem Rechner. Sie gliedert sich in Module, Packages, Klassen und deren Methoden.

Screen Shot 2019-11-18 at 8.34.25 PM
Screen Shot 2019-11-19 at 8.59.01 PM

Oben links sehen Sie eine Projektstruktur, wie Sie in der Eclipse IDE  standardmäßig für ein neues Java- Projekt angelegt wird. Oben rechts sehen sie das Selbe Projekt im Finder/ Explorer so wie es in ihrem Dateisystem abgelegt wird. Beides ist identisch.

Das Package org.test wurde als Beispiel angelegt. In Eclipse funktioniert das genau so wie ein neues Projekt oder eine eine neue Klasse anzulegen. In diesem Fall wählt man eben New Package.

Das Package enthält die Klasse Test.java. Diese Klasse enthält eine Methode print():

package org.test;
public class Test {
	public static void print(){
		System.out.println("Hallo, this is test");
	}
}

Wie man sehen kann ist der Name des Packages als erste Zeile im Code enthalten. Wenn man nun aus dem Default- Package, aus der Klasse Main, auf die Klasse Test zugreifen möchte, dann hat man zwei Möglichkeiten. Entweder man stellt dem Klassennamen den Package– Namen voran:

public class Main {	
	public static void main (String args []){
		org.test.Test.print();
	}
}

Oder man benutz die import Anweisung:

import org.test.*;

public class Main {	
	public static void main (String args []){
		Test.print();
	}
}

Package Namen werden anders als Klassen komplett in Kleinbuchstaben benannt. Es ist üblich dass man dem Package Namen die Firmendomäne, rückwärts geschrieben, voranstellt. Also in etwa so: com.berthold.database.

Android Studio

Wenn man seinen Code aus Eclipse in Android Studio weiterbenutzten will, dann funktioniert das nicht, wenn man seinen Java– Dateien aus dem Default- Package als JAR exportiert. Man muss alle Dateien die man benötigt in ein neues Package kopieren, das dann in ein JAR packen und diese JAR– Datei dann in Android Studio in den lokalen lib– Ordner kopieren.

Temperatur/ Luftdrucksensor BMP0180

Der BMP0180 misst Temperatur und Luftdruck. Er kann außerdem die Barometrische Höhe berechnen. Man kann ihn mit einem Arduino verbinden und eine Wetterstation realisieren. Die Daten werden über den SPI- Bus ausgetauscht. Ich beschreibe hier wie man den BMP0180 mit dem auf dem Arduino basierenden  Tensy 2.0 benutzt. 

Weiterlesen

Tensy 2.0

Der Tensy ist ein „Arudinoieder“ Mikrocontroller, der sich in der Programmiersprache C programmieren lässt (Entwickler Homepage). In diesem Artikel fasse ich einige Dinge zum Schnelleinstieg zusammen.

 

 

 

Digitale Ein- und Ausgabe

Digital Pins können nur zwei Zustände annehmen. Low=0, oder High=1. Beim programmieren geht man so vor:

Digitale Ausgabe:


/*
* Show how one of the Digital Pins of the Tensy
* can be used for output.
*
*/
int OUT_PIN=PIN_C7;

void setup() {
// put your setup code here, to run once:
pinMode(OUT_PIN,OUTPUT);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(OUT_PIN,HIGH);
delay(10);
digitalWrite(OUT_PIN,LOW);
delay(10);
}

Dabei passiert am Pin das Folgende:

Screen Shot 2019-10-20 at 7.18.53 PM

Ausgabe am Digital Pin.

Digital Eingabe

Wenn man prüfen möchte, ob an einem Digital- Pin eine Spannung (also High) oder keine (dann eben Low) anliegt, dann geht das ganz einfach so:


pinMode(IN_PIN,INPUT_PULLUP);
.
.
.
pinState=digitalRead(IN_PIN);
if (pinState==LOW) ...........

Wenn man nun nicht einfach nur wissen möchte, ob der Eingang auf High oder Low liegt, sondern erkennen möchte ob eine fallende Flanke anliegt (der Moment in dem der Zustand von High auf Low wechselt), dann kann man das so machen.:

 pinMode(IN_PIN,INPUT_PULLUP);
if (rdy_state==LOW &amp;&amp; rdy_last_state==HIGH){ // Detect falling edge</pre>
....
}
rdy_last_state=rdy_state;
<pre>

 

 

$PATH

Die ‚PATH‘ Variable ist eine von vielen sogenannten Environment- Variablen. Diese Variablen enthalten ’name:value‘ Paare.

Wenn in der Bash- Shell ein Text eingegeben wird, dann werden alle in $PATH aufgeführten Verzeichnissen durchsucht und geprüft, ob es sich bei dem eingegebenen Text um den Namen einer ausführbaren Datei handelt. Wird eine Datei gleichen Namens gefunden, wird sie ausgeführt.

Notwendig kann das dann werden, wenn man ein neues Programm auf seinen Rechner geladen hat und das künftig über die Bash- Shell als kommando mit seinem Namen starten möchte. Damit das klappt, macht man das:

Nehmen wir an, die ausführbare Datei ist in ‚/opt‘ abgelegt. Dann gibt man in der Shell ein:

PATH=$PATH:/opt/

Der Ordner /opt/ wird nun an die bestehende PATH- Variable angehängt und künftig in die Suche mit einbezogen.

Denn Inhalt der PATH- Variable kann man sich nun so anschauen:

echo $PATH

Wenn man sich alle Environment- Variabel und deren Inhalt anschauen möchte dann benutzt man in der Bash- Shell das folgende Kommando:

printenv

Schemantic, Board design und Auto router

Grundsätzlich zeichnet man seine Schaltung in der Schemantic- Ansicht. Durch Klicken auf die SCH/BRD -Ikone wechselt man in die Board– Ansicht:

  • Wenn es zu der Schaltung schon ein Board– Datei gibt, dann wird die geöffnet, alles was bis jetzt in die Schaltung gezeichnet wurde, wird nicht übernommen!

    Board– Datei schließen, löschen und in die Schaltungsansicht wechseln löst das Problem. Wenn man nun die SCH/BRD -Ikone wieder anklickt, dann wird man darauf aufmerksam gemacht, dass kein Board existiert und Eagle fragt, ob es ein neues erstellen soll. Das war es

  • Wenn es noch keine Board– Datei gibt, dann wird nach einer kurzen Rückfrage ein neues Board angelegt (siehe oben).

In der Board Ansicht kann man nun seine Bauteile so platzieren, wo sie auf dem Physischen Board liegen sollen. Anschließend kann mann den Autorouter starten.

Für den Autorouter muss man beachten, sollte man den wiederholt starten, das Häkchen bei use last job o.ä. weg- klickt wenn das da sein sollte.

Diese Diashow benötigt JavaScript.

IlligalStateException

Unmitelbar nachdem eine Activity beendet und die nächste gestartet wurde, wurde ein Fragment geöffnet. Das Resultat:

IlligalStateException

Die Lösung des Problems wird dort, auf StackOverflow ausführlich besprochen (Letzter Aufruf 28.5.2018).

Für mich hat das die Lösung gebracht:

Der Folgende Code sollte erst dann aufgerufen werden, wenn OnResume() aufgerufen wurde:

FragmentManager fm = getSupportFragmentManager();
FragmentTextInputDialog yn = FragmentTextInputDialog.newInstance("ss");
yn.show(fm, "fragment_text_input_dialog");