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.
					

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!

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.

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.

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

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

Ecco completata la vostra importazione.

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.

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 101g. Vi 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.
					

Cari Amici,

Vogliamo augurarvi un 2016 pieno di gioia assieme a tutte le persone a voi care, famiglia, amici, parenti e persone care.

Tanti Auguri di Buon Anno da tutto il team di BieMme Italia.