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:
0×00 – GPIO_OUT : piedino di uscita
0×10 – GPIO_IN : piedino di ingresso
0×20 – 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 0×01 – GPIO_PIN_HI
0×00 – 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

Acquisizione di ingressi analogici con il pLtouch 101g

Il video ed il progetto d’esempio che vi vogliamo presentare in questo post riguarda un esempio di Automazione Industriale con Android.

In particolare verrà spiegato come leggere valori analogici e rappresentarli a video utilizzazando il pLtouch 101gVi voglio ricordare appunto che il pLtouch 101g ha di serie 12 ingressi digitali, 8 uscite a relè, 2 uscite analogiche e 4 ingressi analogici.

Passiamo all’esempio pratico:
Colleghiamo il nostro dispositivo in corrente come in figura ( noi utlizziamo trasduttore di pressione mod. bmTR01), non esclude comunque il collegamento di tutti i dispositivi in corrente a due o tre fili (per il collegamento degli ingressi vedi pagina wiki).
Alimentiamo il pLtocuch 101g a 24Vdc tramite i morsetti estraibili nel retro del case.

Fatto questo apriamo l’IDE di eclipse.
Supponiamo abbiate già creato un progetto Android, se così non fosse prego di leggere il blog, importato e inizializzata la libreria Pltouch (leggete il nostro articolo in merito). Ciò serve a far implementare alla vostra Activity l’interfaccia PltouchListener. Grazie a questo potete mettere il vostro codice all’interno della callback onLogicExecution, come per esempio:

public class MainActivity extends Activity implements PlTouchListener, OnClickListener {
	private int val1,val2,val3,val4;
	private PltouchManager pManager;
	private TextView analog1,analog1_mA;
	private TextView analog2,analog2_mA;
	private int index;

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

		pManager = new PltouchManager(this);
		pManager.setDebug(true);
		pManager.initialize();
		pManager.addListener(this);

         };

Il codice inserito all’interno della callback onLogicExecution sarà eseguito in maniera sequenziale, un numero infinito di volte indipendentemente da tutto il resto. Una cosa importante da sapere è che tutte le chiamate inserite all’interno del metodo saranno eseguite in un thread diverso da quello della UI: Ciò implica che se volete aggiornare un qualche widget grafico dall’interno della onLogicExecution, dovete utilizzare una chiamata a runOnUiThread, come nell’esempio che segue:

@Override
	public void onLogicExecution() {
		Log.d("Pltouch", "on logic execution");

		runOnUiThread(new Runnable() {

			@Override
			public void run() {
				analog1= (TextView) findViewById(R.id.textView1);
				analog1_mA= (TextView) findViewById(R.id.textView2);

				analog2= (TextView) findViewById(R.id.textView6);
				analog2_mA= (TextView) findViewById(R.id.textView8);

				try {
					// read analog value
					val1 = pManager.analogRead(1);
					val2 = pManager.analogRead(2);
					val3 = pManager.analogRead(3);
					val4 = pManager.analogRead(4);

				} catch (IndexOutOfBounds e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (ConnectionError e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

				analog1.setText(String.valueOf(val1));
				double mA1 = (val1/202.60)+0.02;
				DecimalFormat df = new DecimalFormat("#.00");
				analog1_mA.setText(String.valueOf(df.format((double)mA1/1.00)));

				analog2.setText(String.valueOf(val2));
				double mA2 = (val2/202.60);
				analog2_mA.setText(String.valueOf(df.format((double)mA2/1.00)));
			}
		});
	}

Ho volutamente scelto di non concentrarmi su aspetti di design delle interfacce, ma bensì sugli aspetti più tecnici del progetto. Potreste essere voi, lettori, che attraverso la vostra fantasia create la miglior interfaccia che risponda alle vostre necessità.

Andiamo ad analizzare il codice nel dettaglio:
Andiamo a leggere il valore degli ingressi analogici e li appoggiamo su quattro variabili val1, val2, val3, val4 che poi ci tornano utili per convertire il valore in corrente e rappresentarlo a video.

val1 = pManager.analogRead(1);
val2 = pManager.analogRead(2);
val3 = pManager.analogRead(3);
val4 = pManager.analogRead(4);

Come si vede basta semplicemente richiamare la libreria pManager.analogRead e assegnargli il riferimento dell’ingresso analogico.

Come da figura :

1 = primo ingresso analogico morsetto VA0
2 = secondo ingresso analogico morsetto VA1
3 = terzo ingresso analogico morsetto VA2
4 = quarto ingresso analogico morsetto VA3

Rappresentiamo a video il valore letto a 12 bit degli ingressi analogici:

analog1.setText(String.valueOf(val1));

Per convertirlo proporzionalmente al valore di corrente andiamo a dividerlo per 202,60 e poi lo rappresentiamo a video .

double mA2 = (val2/202.60);
analog2_mA.setText(String.valueOf(df.format((double)mA2/1.00)));

Da questo punto potete ampliare il progetto creando delle logiche in funzione degl ingressi analogici.
Nel prossimo blog vi presenteremo l’aquisizione degli ingressi digitali.