Websoket with server inside Android HMI Ltouch

In 2018 eight out of ten people have a smartphone, so it is a great achievement to share data acquired by our Android HMI Ltouch
(such as the measure of a temperature) over a wireless network and look at it with a web browser.

Let’s see how using an Ltouch 7, there are only 2 steps:

Step 1
Install an http server to provide the webpage with measures; in our tests we used Http Server by Tautvydas Andrikys, it is very interesting
because it can support php after the installation of Server for PHP by the same author. Once installed these apks, tap “server address and port” to set
an http port ,default is 8000, you can change but do not use privileged ports (ports below 1024 , see for example ), then choose ip address 0.0.0.0 to answer on each ip assigned to the Ltouch.

Enable php support:

CGI setting -> enable com.esminis.server.php (Server for PHP)

Finally enable start on boot.

Copy webpage index2.html to /mnt/sdcard/htdocs/public :
adb push index2.html /mnt/sdcard/htdocs/public
Copy configuration files for php server php.ini to /mnt/sdcard/www/config :
adb push index2.html /mnt/sdcard/www/config
Copy configuration files for http server: certificate.cert / certificate.key / httpd.conf to: /mnt/sdcard/htdocs/config
adb push certificate.cert /mnt/sdcard/htdocs/config
adb push certificate.key /mnt/sdcard/htdocs/config
adb push http.conf /mnt/sdcard/htdocs/config

Reboot touch.

However you can use any http server.
Enable hotspot in the settings of Ltouch: settings -> more -> portable hotspot , here we can setup wifi parameters : network name and
password, then tap on portable hotspot to enable it

Step 2
install the apk available in the download area; it’s a simple app which uses modbus library by Biemme to read the measure of a temperature
provided by an external device and connected to the rs485 port of the touch

Now using your pc or smartphone, you can connect to the wifi network just created: open a browser and type http://192.168.43.1:8000/index2.html
in the address bar, note that you must use the port set in the http server in the address, we are using 8000, if you set another value use that
instead of 8000.

Moreover, the duo webpage/application allow us to handle input/output pins handled by Android kernel on the side of Ltouch, the ones provided
by expansion boards are handled with modbus calls and are excluded.

Source codes are available in our download area

Nuovo HMI Ltouch Plus

E’ in arrivo un nuovo pannello HMI touch screen 7″ sistema operativo Android 5.1 con ingressi ed uscite a bordo.

16 Ingressi/Uscite digitali, 4 ingressi analogici configurabili con risoluzione 16bit, 4 uscite analogiche 0..10 Volt / 4..20 mA.

Display capacitivo 7″ HD con risoluzione 1280×800 e protezione IP54. Monta un processore quad core A9 con frequenza scalabile da 400 a 1.4 G Hz.

Verrà distribuito con una libreria nativa per un facile e veloce gestione degli ingressi/uscite.

Uso dei Relè con la nuova libreria Android

In questo semplice post vi spiego come usare i 4 relè a bordo del Ltouch 4.3, HMI touch screen da 4.3″ con sistema operativo Android

La nuova libreria è scaricabile dal nostro portale download.

Tutti e quattro i relè sono disponibili in contatto di scambio con la possibilità di collegarli in Normalmente Aperto oppure in Normalmente chiuso. Un’ulteriore comodità di questi relè è la loro connessione grazie a morsetti estraibili così da permettere un plug and play veloce ed istantaneo.

Creiamo un progetto utilizzando uno degli ambienti di sviluppo per Android, in questo caso usiamo Android Sudio.

Dopo aver aggiunto la libreria BMTouch nel nostro progetto, non si fa altro che eseguire tre semplici operazioni:

1)  Inizializziamo la nostra libreria subito dopo onCreate con il comando byte LIBsetup(long pinsetting):

BMTouch.LIBsetup( BMTouch.EN15+ BMTouch.EN14 + BMTouch.EN13 + BMTouch.EN12);

pinsetting: ()long), a ciascun bit corrisponde lo stato bloccato (bit a 0) o sbloccato di un piedino (bit a 1) .
LSB del primo byte corrisoponde a GP0
Se il piedino non viene sbloccato, ogni operazione di lettura scrittura su di esso termina con un codice di errore.
exit codes: EXIT_OK per uscita terminata con successo
EXIT_HW_ERROR : hardware non riconosciuto
EXIT_WRONG_PARAM : si è cercato di attivare un piedino non esistente
EXIT_FAIL nel caso di errori

Fisicamente i relè sono assegnati così:
Relè 1 : BMTouch.EN12
Relè 2 : BMTouch.EN13
Relè 3 : BMTouch.EN14
Relè 4 : BMTouch.EN15

2) Oltre al comando di questi relè la Libreria BMTouch dispone di ulteriori input/output GPIO fisicamente presenti nell’Ltouch4.3 e dato che i relè sono come uscite, configuriamo questi piedini in modalità uscita.

byte GPIOsetup (byte pin,byte mode,byte value):

val[0]= 0;
        BMTouch.GPIOSetupOut(BMTouch.GP15, val[0]);
        BMTouch.GPIOSetupOut(BMTouch.GP14, val[0]);
        BMTouch.GPIOSetupOut(BMTouch.GP13, val[0]);
        BMTouch.GPIOSetupOut(BMTouch.GP12, val[0]);


per configurare ciascun piedino di gpio;
pin: indice compreso tra 0 e lastgpio() , indica il piedino di gpio da utilizzare secondo la numerazione indicata per la scheda in uso
mode: indica il tipo di accesso richiesto:
0x00 – GPIO_OUT : piedino di uscita
0x10 – GPIO_IN : piedino di ingresso
0x20 – GPIO_RELEASE : rilascia il piedino
value: impostazione iniziale per i piedini configurati come uscita; ininfluente per i piedini impostati come ingresso.
Exit codes: EXIT_FAIL (1) : errore generico
EXIT_WRONG_PARAM (2) : specificato un piedino non valido
PIN_LOCKED (3) : il piedino non è stato sbloccato durante l’inizializzazione
EXIT_OK (0) : uscita terminata con successo
EXIT_SETTING_NOT_APPLICABLE : se viene impostata la scrittura o la lettura per un piedino che non la supporta

3) Supponiamo che vogliamo commutare tutti i 4 relè in ON, non ci resta che usare il comando:

byte GPIOwrite (byte pin,byte value):

val[0]= 1;
tmp=BMTouch.GPIOWrite(BMTouch.GP15, val[0]);
tmp=BMTouch.GPIOWrite(BMTouch.GP14, val[0]);
tmp=BMTouch.GPIOWrite(BMTouch.GP13, val[0]);
tmp=BMTouch.GPIOWrite(BMTouch.GP12, val[0]);

Questo non configura il piedino come uscita , ma imposta il valore in uscita nel caso di piedini configurati come uscita.
pin : intero che indica il numero di piedino, secondo la numerazione di cui sopra
value : valori possibili 0x01 – GPIO_PIN_HI
0x00 – GPIO_PIN_LOW
Exit codes: EXIT_FAIL (1) :errore generico
EXIT_WRONG_PARAM (2) :pin o value non validi
PIN_LOCKED (3) :piedino non sbloccato/disponibile
EXIT_SETTING_NOT_APPLICABLE : se viene richiesta la scrittura su un piedino che non la supporta

Nel prossimo post vi spiegheremo come usare la libreria con la funzione modbus RTU.

COME FARE UN GRAFICO CON ANDROID STUDIO E IL PLTOUCH – (Parte 3) Finalizzazione

In questa lezione vi mostriamo come finalizzare il grafico appena realizzato.

Inanzitutto tramite la vostra funzione “getData()” per prendetevi i dati e sistemate su una/piu variabili, poi aggiungete uno o piu parametri per ogni giorno della settimana inserito:


	int[][] datas = getData();	 	// calls a user created function tha gets all the data from source
	int[] d= datas [0];
	yAx2.add(new Entry(d[0],0)); 		// it requires a new Entry, Entry requires a numeric value, and for 2th argument an Integer index
	yAx2.add(new Entry(d[1],1));
	yAx2.add(new Entry(d[2],2));
	yAx2.add(new Entry(d[3],3));
	yAx2.add(new Entry(d[4],4));
	yAx2.add(new Entry(d[5],5));
	yAx2.add(new Entry(d[6],6));

Attivaze lo Zoom, lo scroll, impostate eventuali limiti di spostamento per le varie Asssi e altre opzioni.


	lc.setVisibleXRangeMaximum(65f);					//Sets the max visible field on the x Axis
        lc.setVisibleYRangeMaximum(50, YAxis.AxisDependency.LEFT);		//Sets the max visible field on the y Axis
        lc.setTouchEnabled(true);						//Activates the touch Control
        lc.setDragEnabled(true);						//Enables dragging
        lc.getAxisLeft().setAxisMinValue(0);					//Set minimum axis Zoom level
        lc.getAxisLeft().setAxisMaxValue(50);					//Set maximum axis Zoom level
        lc.setScaleMinima(0, 1);						//Set the graph total scale, from min to max

Abbiamo così realizzato con semplicità il nostro grafico!

COME FARE UN GRAFICO CON ANDROID STUDIO E IL PLTOUCH – (Parte 1) Inizializzazione

In questo esempio vi mostriamo come creare un grafico con Android Studio, sui nostri dispositivi PlTouch. Per realizzare il grafico,
utilizzare la libreria esterna MpAndroidChart, reperibile qui, oppure senza scaricarla potrete includerla sucessivamente nel vostro gradle build.

Questo Articolo si divide in tre Post, Inizializzazione, Settaggio dati, Finalizzazione

Per prima cosa aprite un vostro progetto o createne uno nuovo, tenendo conto che potrete posizionare il grafico su una Activity apposita oppure direttamente
sulla Main Activity.

Se volete importare la Libreria scaricandola, e non sapete come importarla in android studio, qui cè un tutorial che fa al caso vostro, altrimenti,
seguite la procedura tramite build gradle:
COLLEGAMENTO TRAMITE BUILD GRADLE:
Andate nel vostro gradle.build file e incollate le seguenti righe di codice avendo cura di posizionarle fuori application.

<code>
repositories {
    maven { url 'https://jitpack.io' }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.github.PhilJay:MPAndroidChart:v2.2.4'
    compile 'com.android.support:appcompat-v7:25.3.1'
    compile 'com.android.support:design:25.3.1'
    compile 'com.android.support.constraint:constraint-layout:1.0.2'
    testCompile 'junit:junit:4.12'
}

</code>

Bene, ora la libreria che vi permetterà di realizzare il grafico, è stata inclusa nel progetto!
Nel prossimo post vedremo come inizializzare ogni Componente in maniera corretta, restate collegati.

COME FARE UN GRAFICO CON ANDROID STUDIO E IL PLTOUCH – (Parte 2) Settaggio Dati

Per prima cosa avremmo bisogno di posizione nel file layout.xml dell’Activity il grafico, per fare ciò basta cercare nel layout designer il lineChart e inserirlo, o scrivere a mano il tag lineChart nel file xml.

A questo punto abbiamo bisogno di dichiarare alcune variabili, che ci permetterano di comunicare con gli elementi interni di questo Plugin/Libreria:



    LineChart lc; 				//lineChart Main Component
    ArrayList<String> xAx2;			//xAxis titles Array
    ArrayList<Entry> yAx2;			//yAx entry Array (Values associated with an index)
    ArrayList<ILineDataSet> dss;		//multidimensional Array containing the whole DataSet
    LineDataSet lds;			//the DataSet Component


Poi inizializziamo ogni componente, nel metodo onCreate dell’Activity:


    lc = (LineChart) findViewById(R.id.lnCH1);		//xml layout Id Reference
    dss = new ArrayList<>();				//Initiate the DataSet Component as an empty Array
    xAx2 = new ArrayList<>();				//Initiate xAxis titles as an empty Array
    yAx2 = new ArrayList<>();				//Initiate yAxis values as an empty Array

Fatto questo dobbiamo riempire il grafico con dei dati, per fare questo prima di tutto decidiamo come salvare i dati che poi andranno resi disponibili al grafico.
– TRAMITE FILE DI TESTO Vai al Tutorial
– TRAMITE DATABASE

Una volta creato il sistema di salvataggio dei dati, dopo aver istanziato i dati e fatti i dovuti controlli, creare una funzione per caricare i dati che avete salvato, in questo esempio chiameremo la funzione “getData()”

Aggiungete all’ArrayList tutti i giorni della Settimana, questi dati compariranno come titoli sul grafico.


        xAx2.add("LUNEDI");		//It only adds a string parameter to the xAxis of the Graph as a Title
        xAx2.add("MARTEDI");
        xAx2.add("MERCOLEDI");
        xAx2.add("GIOVEDI");
        xAx2.add("VENERDI");
        xAx2.add("SABATO");
        xAx2.add("DOMENICA");

Nel prossimo post vedremo come aggiungere dei valori al grafico, e completare la configurazione, restate collegati.

Aggiungere una Libreria Custom, su Android studio

In questo esempio andiamo ad illustrare come importare una Libreria personalizzata in Android Studio.

Per prima cosa aprite un vostro progetto a scelta o createne uno nuovo.

Cliccate sulla tendina nel riquadro della visione gerarchica del vostro progetto Android che trovate in alto a sinistra sotto il Menu File,
Scorrete fino ad individuare la scritta progetto e fateci click.

Copiate la vostra Libreria in formato Jar nella cartella Lib, individuabile nel percorso NomeProgetto/App/Lib

Se avete file .so associati alla Libreria, copiateli dentro alla JniLib, se non esiste dovete crearla, precisamente nel percorso, NomeProgetto/App/Src/Main

immagine1

Selezionate la libreria da voi importata, sulla cartella Lib, fate click con il tasto destro del mouse e cliccate su “Add as Library!”

immagine1

Ecco completata la vostra importazione.

Temporizzatore ritardato all’inserzione – TIMER ANDROID

Nei campi industriali come quelli domotici una delle necessità in cui ci si può imbattere è generare un evento dopo un intervallo di tempo prestabilito.
In questo semplice blog vi vogliamo presentare, in alcune semplici righe, un temporizzatore ritardato all’inserzione utilizzando dei Timer Android nel dettaglio gli Executors.

Utilizziamo in questo caso il nostro pLtouch 101g, così da rendere l’idea concreta.

Supponiamo ora di voler attivare un uscita relè dopo un tempo T dalla presenza di un ingresso digitale.

Quello che avremo bisogno è di un metodo dal nome ScheduledExecutorService; prego di leggere questo tutorial Executors

int TimeValue = 5; / 5 second of delay for active output
if (pManager.digitalRead(0) == DigitalValues.HIGH) { // if input is HIGH
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

ScheduledFuture scheduledFuture = scheduledExecutorService.schedule(new Callable() {
	public Object call() throws Exception {
	     pManager.digitalWrite(1,DigitalValues.HIGH); //delay Time TimeValue and active output
	     return "Called!";
			}
		},
	TimeValue,TimeUnit.SECONDS); // TimeValue is time of delay - TimeUnit.SECONDS is time scale Second

	} else{
	   pManager.digitalWrite(1,DigitalValues.LOW); // if input is LOW then switch off output

	}

Nel nostro caso che utilizzando il pLtouch 101g usiamo la libreria per l’acquisizione dell’ingresso digitale, e alla presenza dell’ingresso il timer conta 5 secondi (TimeValue) dopodichè attiva la prima uscita a relè.
Nel momento in cui l’ingresso viene a mancare porto a zero l’uscita.

Salviamo dei dati nella memoria interna Android (variabili ritentive)

Capita alle volte di voler salvare dei dati così da non perdere il loro valore in un secondo momento.
Android dispone di un comando molto semplice per scrivere dei valori in formato testo nella memoria interna del dispositivo, in questo caso all’interno dei nostri pannelli Ltouch e pLtouch e successivamente recuperarli.

Premetto che questa procedura rende i dati che andiamo a salvare privati, ciò vuol dire che solamente la nostra app potrà accedervi e nessun’altra e nel momento in cui la disinstalleremo tutti i dati verranno persi.

Troverete molto utile questo Tutorial

Android dispone delle classi openFileInput e openFileOutput per scambiare dei pacchetti alla memoria interna.

  •  openFileOutput : è il metodo per creare e salvare un file
FileOutputStream fOut = openFileOutput("file name",Context.MODE_PRIVATE);

Il metodo restituisce un’istanza FileOutputStream, così è possibile richiamarla e scrivere i dati sul file:

String str = "test data";
fOut.write(str.getBytes());
fOut.close();
  • openFileInput () : Questo metodo viene utilizzato per aprire un file e leggerlo. Tale restituisce un’istanza di FileInputStream.
FileInputStream fin = openFileInput(file)

Dopodichè chiamamiamo quest’isanza per leggere un carattere alla volta e rappresentarlo:

int c;
String temp="";
while( (c = fin.read()) != -1){
temp = temp + Character.toString((char)c);
}
fin.close();

Vediamo ora un esempio pratico:

Supponiamo che si voglia salvare un dato e renderlo nel gergo tecnico dei plc ” ritentivo “, in poche parole che al riavvio della nostra app il dato non si perda, ma che si possa recuperarlo.
Salviamo il dato alla pressione di un bottone:

@Override
	public void onClick(View v) {
             if (v.getId()==R.id.btnWrite){
                 // add-write text into file
        try {
            FileOutputStream fileout=openFileOutput("BieMmeItalia.txt", MODE_PRIVATE);
            OutputStreamWriter outputWriter=new OutputStreamWriter(fileout);
            outputWriter.write("250");
            outputWriter.close();

            //display file saved message
            Toast.makeText(getBaseContext(), "File saved successfully!",
                    Toast.LENGTH_SHORT).show();

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

All’avvio dell’app andiamo a leggere il valore nel file di testo allocato nella memoria del dispostivo e poi lo rappresentiamo a video tramite una texView:

	@Override
    protected void onCreate(Bundle savedInstanceState) {
			    requestWindowFeature(Window.FEATURE_NO_TITLE);
			super.onCreate(savedInstanceState);
			setContentView(R.layout.activity_main);

			TextView valreadtoMemory = (TextView)findViewById(R.id.editText1);
		try {
	            FileInputStream fileIn=openFileInput("BieMmeItalia.txt");
	            InputStreamReader InputRead= new InputStreamReader(fileIn);

	            char[] inputBuffer= new char[READ_BLOCK_SIZE];
	            String s1="";
	            int charRead;

	            while ((charRead=InputRead.read(inputBuffer))>0) {
	                // char to string conversion
	                String readstring=String.copyValueOf(inputBuffer,0,charRead);
	                s1 +=readstring;
	           }
	            InputRead.close();
	            valreadtoMemory.setText(s1);

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

    }

Per maggior informazioni troverete del materiale anche nel nostro WiKi