Come creare un grafico in Android usando la libreria jjoe64/GraphView

In questo breve tutorial vedremo come realizzare un grafico in Android Studio per i nostri dispositivi Ltouch, utilizzando la libreria esterna jjoe64/GraphView in pochi e semplici passaggi. L’esempio da noi proposto andrà a realizzare un grafico avente come asse delle ascisse il tempo trascorso e come asse delle ordinate l’andamento della temperatura. Quest’ultima data da una sonda di temperatura PT100 collegata al dispositivo tramite ingresso analogico ( nulla vieta che la comunicazione possa avvenire in Modbus RTU ). I dati vengono letti e scritti su di una tabella ( temperature_table ) all’interno di un database locale ( DB_CHART.db ) ma in questa guida ci occuperemo solo della lettura quindi consiglio la visione del seguente articolo .
Nel caso in cui un passaggio dovesse essere poco chiaro oppure abbiate bisogno di maggiori informazioni ( per quanto riguarda la realizzazione del grafico ) tutto il materiale da cui attingere è reperibile al seguente indirizzo.
Detto ciò, il primo passaggio prevede di implementare la dipendenza nel build.gradle tramite il seguente comando:

implementation 'com.jjoe64:graphview:4.2.2'

Nel secondo passaggio invece si dovrà aprire il file xml dell’attività ( Es. layout/activity_main.xml ) e aggiungere il tag per creare il grafico vero e proprio ( disporlo all’interno a piacimento ):

Nel terzo passaggio:
-Per prima cosa inizializziamo le variabli…

LineGraphSeries dataseries = new LineGraphSeries<>(new DataPoint[0]);
SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy\nHH:mm:ss");
//Nell'onCreate()
mioGrafico = (GraphView) findViewById(R.id.TempChart);

-Dopo di che dando per scontato che il database si già popolato, utilizzo il metodo getAllData() contenuto nella classe DatabaseHelper in questo modo:

//Ottengo i vari DataPoint ( valoreX, valoreY ) da applicare in seguito al grafico
dataseries.resetData(mioDBHelper.getAllData());

Il metodo getAllData() non fa altro che un SELECT di tutti i dati all’interno della tabella ( temperature_table ) e crea un vettore DataPoint ( che è quello che poi restituisce ). Quest’ultimo contiene i vari punti del grafico ovvero l’associazione ( asseX / asseY ) dove per asseX si intende prendere il valore della riga la cui corrispondente colonna è rappresentata da Time ( in Unix timestamp ) mentre per asseY si intende prendere il valore della riga per cui la corrispondente colonna è rappresentata da Temperature:

/**
* Metodo per ottenere tutti i dati presenti all'interno della tabella temperature_table
* ( anche se alla fine tengo conto solo delle colonne Time e Temperature
* @return : DataPoint[]
*/
public DataPoint[] getAllData(){
//Ottengo il DB in modalità lettura
SQLiteDatabase mioDB = this.getReadableDatabase();
//Creo un oggetto Cursor per selezionare tutti i dati all'interno della tabella
Cursor mioCursor = mioDB.rawQuery("SELECT * FROM "+TABLE_name,null);
//Istanzio DataPoint di dimensione pari a mioCursore.getCount() ( ovvero pari al numero di
// righe )
DataPoint[] mieiDataPoint = new DataPoint[mioCursor.getCount()];
//Con questo ciclo creo i vari datapoint (x,y) e prendo min e max di entrambi gli assi
for(int i = 0; i < mioCursor.getCount(); i++){
mioCursor.moveToNext();
if (i == 0){
MinX = mioCursor.getInt(mioCursor.getColumnIndex("Time"));
MinY = mioCursor.getDouble(mioCursor.getColumnIndex("Temperature"));
}
if(i == (mioCursor.getCount()-1)){
MaxX = mioCursor.getInt(mioCursor.getColumnIndex("Time"));
MaxY = mioCursor.getDouble(mioCursor.getColumnIndex("Temperature"));
}
mieiDataPoint[i] = new DataPoint(mioCursor.getInt(mioCursor.getColumnIndex("Time")),mioCursor.getDouble(mioCursor.getColumnIndex("Temperature")));
}
//Chiudo il db ( aperto in modalità lettura )
mioDB.close();
return mieiDataPoint;
}

A questo punto non rimane altro da fare che il seguente comando per caricare DataPoint[] all’interno del grafico

mioGrafico.addSeries(dataseries);

Nel caso in cui si voglia ottenere un qualcosa di più elaborato propongo di seguito un’altro esempio

//Imposto colore della linea del grafico
dataseries.setColor(Color.GREEN);
//Imposto se mettere o meno i punti ( in questo caso si )
dataseries.setDrawDataPoints(true);
//Imposto il raggio dei punti
dataseries.setDataPointsRadius(5);
//Imposto la grossezza della linea
dataseries.setThickness(3);
/*
Per settare maualmente l'asse y...
mioGrafico.getViewport().setYAxisBoundsManual(true);
mioGrafico.getViewport().setMinY(mioDBHelper.getMinY());
mioGrafico.getViewport().setMaxY(mioDBHelper.getMaxY())
*/
//Setto manualmente l'asse x
mioGrafico.getViewport().setXAxisBoundsManual(true);
//Specifico valore minimo asse x
mioGrafico.getViewport().setMinX(mioDBHelper.getMinX());
//Specifico valore massimo asse x
mioGrafico.getViewport().setMaxX(mioDBHelper.getMaxX());
//Do la possibilità di fare lo zoom e lo scroll
mioGrafico.getViewport().setScalable(true);
mioGrafico.getGridLabelRenderer().setHumanRounding(false); //In quanto uso data e ora come asse delle x
//Aggiungo al grafico i DataPoint
mioGrafico.addSeries(dataseries);

Il risultato ottenuto dovrebbe essere simile a quello in figura:

Come potrete notare manca solo un’ultimo passaggio ovvero la conversione Unix timestamp in data e ora comprensibili. La libreria ci viene in contro fornendoci gli strumenti per cambiare manualmente le label degli assi quindi basterà utilizzare quelli per raggiungere il nostro scopo.

mioGrafico.getGridLabelRenderer().setLabelFormatter(new DefaultLabelFormatter(){
@Override
public String formatLabel(double value, boolean isValueX) {
if(isValueX){
//Come mostrare i valori dell'asse x
//Ora legale europa centrale
sdf.setTimeZone(TimeZone.getTimeZone("GMT+2"));
return sdf.format(new Date((long) value * 1000L));
}else{
//Come mostrare i valori dell'asse y
return super.formatLabel(value,isValueX);
}
}
});

Da non dimenticare la creazione dell’oggetto sdf ( SimpleDataFormat ):

SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy\nHH:mm:ss");


Con questa guida è tutto, se l’articolo vi è piaciuto condividete e restate sintonizzati per non perdervi alti tutorial sul mondo Android.

Database SQLite e Datalogger in Android

Nel post di oggi andremo ad analizzare nel dettaglio i passi da seguire ai fini di realizzare un DataBase SQLite in Android Studio. In particolare il DB da noi realizzato si occuperà di salvare ad intervalli di tempo regolari informazioni in merito a temperatura e tempo, che verranno poi utilizzati per la creazione di un grafico.
Ma andiamo con ordine, per prima cosa aprite un vostro progetto o createne uno nuovo e aggiungete al suo interno una nuova classe che estenda SQLiteOpenHelper come nell’esempio qua sotto

public class DatabaseHelper extends SQLiteOpenHelper { }

A questo punto il compilatore vi obbligherà ad inserire i metodi della classe SQLiteOpenHelper quali il costruttore, onCreate() e onUpgrade(). Il primo si occuperà di creare il DB fisico locale nonchè l’oggetto DatabaseHelper ( II° parametro vuole in ingresso il nome del DataBase ), il secondo si occuperà di creare la tabella all’interno del DB, mentre il terzo si occuperà di fare alcuni accorgimenti nel caso in cui venga modificato il DB fisico locale ( ma non lo tratteremo in questa guida ). La tabella di nome temperature_table che andremo a realizzare sarà composta da tre colonne:

ID Temperatura Tempo
1 23.285 1597753508
2 23.324 1597753510

Per realizzare il tutto a livello software:

private static final String DB_name = "DB_CHART.db";
private static final String TABLE_name = "temperature_table";
private static final String COL_1 = "ID";
private static final String COL_2 = "Temperature";
private static final String COL_3 = "Time";

public DatabaseHelper(@Nullable Context context) {
  super(context, DB_name, null, 1);
}

@Override
public void onCreate(SQLiteDatabase db) {
   String CreationQuery = "CREATE TABLE "+TABLE_name+" ( " +
    COL_1 + " INTEGER PRIMARY KEY AUTOINCREMENT," +
    COL_2 + " REAL," +
   COL_3 + " INTEGER )";
    db.execSQL(CreationQuery);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 db.execSQL("DROP TABLE IF EXISTS "+ TABLE_name);
    onCreate(db);
}

Inseriamo i metodi per la lettura, scrittura e cancellazione ( di tutti i dati all’interno della tabella con ripristino ID al valore iniziale, metodo utile solo in questo contesto ).

/**
 * Metodo per scrivere sulla table del Database
 * @param Temperature : temperatura ( double )
 * @param Time : tempo trascorso ( long integer ) - timestamp unix
 * @return true se l'operazione è andata a buon fine, false altrimenti
*/
public boolean saveNewRow(double Temperature, long Time){
    boolean getResult;
    //Ottengo il DB in modalità scrittura
SQLiteDatabase mioDB = this.getWritableDatabase();
//Creo una nuova mappa di valori, in cui i nomi delle colonne sono le chiavi
ContentValues cv = new ContentValues();
//nomeColonna / valore
cv.put("Temperature",Temperature);
cv.put("Time",Time);
//Eseguo l'inserimento nella tabella
try{
mioDB.insert(TABLE_name,null,cv);
getResult = true;
}catch(SQLException sqle){
//Caso in cui l'inserimento non è andato a buon fine
sqle.printStackTrace();
getResult = false;
}
//Chiudo il db ( aperto in modalità scrittura )
   mioDB.close();
    return getResult;
}

/**
* Metodo per ottenere tutti i dati presenti all'interno della tabella temperature_table
* ( anche se alla fine tengo conto solo delle colonne Time e Temperature )
* @return : DataPoint[]
*/
public DataPoint[] getAllData(){
//Ottengo il DB in modalità lettura
SQLiteDatabase mioDB = this.getReadableDatabase();
//Creo un oggetto Cursor per selezionare tutti i dati all'interno della tabella
Cursor mioCursor = mioDB.rawQuery("SELECT * FROM "+TABLE_name,null);
//Istanzio DataPoint di dimensione pari a mioCursore.getCount() ( ovvero pari al numero di
// righe )
DataPoint[] mieiDataPoint = new DataPoint[mioCursor.getCount()];
//Con questo ciclo creo i vari datapoint (x,y) e prendo min e max di entrambi gli assi
for(int i = 0; i < mioCursor.getCount(); i++){
mioCursor.moveToNext();
if (i == 0){
MinX = mioCursor.getInt(mioCursor.getColumnIndex("Time"));
MinY = mioCursor.getDouble(mioCursor.getColumnIndex("Temperature"));
}
if(i == (mioCursor.getCount()-1)){
MaxX = mioCursor.getInt(mioCursor.getColumnIndex("Time"));
MaxY = mioCursor.getDouble(mioCursor.getColumnIndex("Temperature"));
}
mieiDataPoint[i] = new DataPoint(mioCursor.getInt(mioCursor.getColumnIndex("Time")),mioCursor.getDouble(mioCursor.getColumnIndex("Temperature")));
}
//Chiudo il db ( aperto in modalità lettura )
mioDB.close();
return mieiDataPoint;
}

/**
 * Metodo per cancellare tutte le righe del database, riporta anche l'autoincrement ( ID ) al
 * valore iniziale
 */
public void eraseEverything(){
//Ottengo il DB in modalità scrittura
SQLiteDatabase mioDB = this.getWritableDatabase();
//Elimino tutte le righe
mioDB.execSQL("DELETE FROM "+TABLE_name);
//Ripristino ad 1 l'autoincrement ID
mioDB.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='"+TABLE_name+"'");
//Chiudo il DB ( aperto in modalità scrittura )
mioDB.close();
}

Nel nostro caso con il metodo getAllData() estraiamo i dati e li passiamo ad un vettore di DataPoint[ ] in quanto il loro utilizzo è limitato solo alla creazione di un grafico, nulla vieta che i dati possano essere estratti e passati a variabili di altro tipo. Il consiglio è quello di non passare mai l’oggetto Cursor ( anche se l’applicativo funzionerebbe comunque ). Ricordarsi sempre di chiudere il DB ( aperto in modalità lettura/scrittura ).
Adesso non rimane altro che creare l’oggetto DatabaseHelper dove vi serve per avere accesso a tutti i metodi.

//Creazione oggetto mioDBHelper nell'onCreate() della main activity
mioDBHelper = new DatabaseHelper(this);

How to use Relay on Ltouch43

In our Ltouch43 Android HMI  there are 4 Relays and all the relays are in exchange contact. They have 24Vdc coil and max 5A contact current. All RELAY outputs are high quality relay and protected by varistors, all connectors are removable.

BMTouchGP12 – Relay R2

BMTouchGP13 – Relay R4

BMTouchGP14 – Relay R1

BMTouchGP15 – Relay R3

Before using them we must in the onCreate method :

instantiate the library BMtouch::

  • tmp = BMTouch.LIBsetup(BMTouch.EN12 + BMTouch.EN13 + BMTouch.EN14 + BMTouch.EN15);

Set PIN (GP–) as output, sets the pin (pin) indicated as output and sets its logical level as value::

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

To switch the output by activating it or not, use this command::

    • tmp=BMTouch.GPIOWrite(BMTouch.GP13, val[0]);

where val [0] corresponds to:

  • 0 relay OFF
  • 1 relay ON

ADB and micro USB for data communication

ADB stands for “Android Debug Bridge” and it basically just allows you to send commands to your device Ltouch.

Download SDK Platform Tools ADB is a small tool bundled in the Android SDK as part of the “Platform Tools.”

ADB stands for “Android Debug Bridge” and it basically just allows you to send commands to your device.

Users used to be required to download the entire SDK (which is very large) just to use ADB, but Google now allows users to download only the Platform Tools.

  • Download the SDK Platform Tools for Windows, Mac, or Linux from https://developer.android.com/studio/releases/platform-tools.html
  • Extract the ZIP file somewhere easily accessible (like C:\platform-tools) We’ve got ADB downloaded on your computer and your Android device is ready to receive instructions.
  • Now it’s time to put it all together and run your first ADB command.
  • Connect your Ltouch to the computer with a USB cable
  • The USB mode must be PTP in order for ADB to work. You can usually change this from the notification shade
  • Make sure to allow USB debugging if a pop-up appears
  • Open the platform-tools folder on your computer
  • Shift+Right Click and select Open command prompt here
  • Type adb devices and hit Enter

That’s all, good work

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.

New Ltouch7 Plus

Coming soon a new black HMI touch screen panel with Android operating system with inputs and outputs on board.
16 digital inputs / outputs, 4 configurable analog inputs with 16bit resolution, 4 analog outputs 0..10V / 4..20mA.
Display HD 7 “capacitive resolution 1028×800 IP56.

Quad core A9 dinamyc frequency scaling from 400 to 1.4G Hz.

A new native library dedicated to manage the inputs and outputs.

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;
<%%KEEPWHITESPACE%%>        BMTouch.GPIOSetupOut(BMTouch.GP15, val[0]);
<%%KEEPWHITESPACE%%>        BMTouch.GPIOSetupOut(BMTouch.GP14, val[0]);
<%%KEEPWHITESPACE%%>        BMTouch.GPIOSetupOut(BMTouch.GP13, val[0]);
<%%KEEPWHITESPACE%%>        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.

Nuovo pannello touch HMI 4,3 ” Android Ltouch43

Siamo orgogliosi di annunciare che un nuovo prodotto sarà presto rilasciato. E’ un pannello touch Android per progetti HMI di automazione industriale e domotica.

Si caratterizza di un display multi touch resisttivo da 4,3″ con un processore ancora più performante Samsung S5P6818 64-bit Octa-Core  frequenza scalabile 8*Cortex -A53  da 400MHz a 1.4 MHz dotato di uscite a relè e interfaccia di comunicazione RS485. Dispone di una memoria RAM di 2GB 32bit DDR3 ed una memoria interna eMMC da 16GB con uno slot MICROSD per memorie sopra i 128GB.

Pieno supporto a Ethernet come anche a reti wifi WAN 802.11 b/g/n. dotato di antenna interna mod. porcelain ipx interfacee bluetooth 4.0 dual mode.

Il prodotto è disponibile con cornice frontale in acciaio inox finitura a specchio con una cover posteriore sempre in acciaio inox 10/10 finitura 2B.razie a questi layer di protezione e ad un particolare processo di assemblaggio, il prodotto raggiunge un livello di protezione IP54 nella parte frontale (acqua e polvere).

Nuove librerie ancora più veloci e performanti sviluppate dal nostro staff tecnico, scaricabili dalla nostra area download,  per disporre un massimo controllo e comando della periferica RS485 modbus e ingressi / uscite digitali (GPIO), 4 uscite a relè con contatto di scambio 5 A .

AUDIO e VIDEO : Microfono a bordo e jack audio 3.5mm e uscita aggiuntiva in HMI Type-A 1-1.4A

La periferica RS485 è completamente optoisolata con possibilità in modalità MASTER di polarizzare la linea tramite un

semplice dip-switch posto sul retro e attivare la resistenza di terminazione linea di 120 ohm.

Alimentazione a 24 Vdc con riconoscimento intelligente della tensione di linea, se al di sopra o di sotto del 20% il nostro Ltouch4_3 si spegne.

Display capacitivo 4,3 ” con risoluzione 480 X 800 dimensioni 55 x 93 mm

Sarà presto disponibile nel nostro wiki tutto il supporto tecnico per la realizzazione dei Vostri progetti domotici ed industriali.

Come configurare l’Android Vnc Server sui nuovi panneli Ltouch

In questo breve tutorial vedremo come collegarci ai ai nostri dispositivi android tramite Android Vnc Server. Tutta la serie di panneli come il Ltouch43 – Ltouch7″ – Ltouch10 “ può supportare questa funzione

Occorrerà l’eseguibile androidvncserver ed un visualizzatore da installare sul pc (ad esempio tightvnc);
androidvncserver richiede i permessi di root, occorrerà quindi un dispositivo android “rooted” per non essere vincolati all’uso di adb.
Nei nostri pannelli questo è possibile !

Per non dover lanciare un eseguibile specificandone anche il percorso, questo va copiato in una directory che faccia parte del percorso di ricerca degli eseguibili.
Visualizziamolo aprendo il prompt dei comandi di windows e lanciando:

adb shell echo $PATH

Ad esempio:

/sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin

scegliamo per semplicità /system/bin
normalmente la partizione montata su /system è in sola lettura, occorrerà rimontarla in lettura-scrittura:

adb remount

copiamo androidvncserver, che si può scaricare dal nostro sito nell’area download, in un percorso del nostro computer da dove sia possibile lanciare adb e carichiamolo nel dispositivo android:

adb push androidvncserver /system/bin/

accediamo al dispositivo android :

adb shell

impostiamo i permessi

chmod 755 /system/bin/androidvncserver

i parametri supportati si visualizzano con il comando androidvncserver -?
si consiglia di non modificare metodo di cattura lasciando framebuffer (i frame vengono letti da /dev/graphics/fb0), non tutti i metodi di cattura sono supportati da i dispositivi.
l’opzione -r permtte di impostare la rotazione dello schermo in gradi, con valori ammessi: 0 90 180 270
l’opzione -s permette di impostare il fattore di scala, non tutti i fattori di scala sono accettati, sono valori validi: 25 50 100
l’opzione -p permette di impostare una password

occorre prendere nota dell’indirizzo ip in uso ad esempio con il comando netcfg dalla shell adb (la rete wifi è indicata da wlan0 e quella cablata da eth0, ma questi nomi possono cambiare a seconda del
dispositivo android).

androidvncserver -r 90 -s 50 -p abcdef
notiamo la riga:
Listening for VNC connections on TCP port 5901
indica a quale porta connettersi con il visualizzatore, se ad esempio si usa tight vnc come visualizzatore e l’ip annotato era 192.168.2.15 , specificheremo
come remote host: 192.168.2.15:5901

in questo modo il terminale adb non è più disponibile, per terminare androidvncserver si usa la combinazione di tasti ctrl+c
per mantenerlo in eseuzione in background basta aggiungere & a fine riga di comando: androidvncserver -r 90 -s 50 -p abcdef &
per terminarne l’esecuzione usare i comandi:
ps | grep androidvncserver
annotarne il pid e terminarne l’esecuzione con
kill seguito dal pid appena annotato

con un dispositivo rooted è possibile installare busybox e creare uno script per lanciare androidvncserver direttamente dal desktop di android.
un semplice script (se androidvncserver è stato copiato in /system/bin/):

#!/system/bin/sh
/system/bin/androidvncserver -r 90 -s 50 -p abcdef

Tutto qua. Se avete trovato interessante l’articolo, condividetelo! 🙂 Come al solito, i commendi sono sempre ben accetti.