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

Test di performance canale rs485

In ogni progetto di domotica con Arduino ed Android, particolare attenzione deve essere data alla gestione degli errori nei canali di comunicazione quali per esempio rs485. Questi infatti possono accadere per diversi motivi ed il sistema deve riuscire a gestirli con successo.

In particolare, nel video che segue, volevo dimostrarvi alcuni test che ho effettuato per capire se le informazioni visualizzate nel pannello multi touch vengono correttamente aggiornate non appena la connessione viene ristabilita.

Il led rosso indica che l’Arduino sta processando richieste modbus dal master. Come potete vedere, il lampeggio si ferma quando il canale rs485 viene interrotto. Non appena quest’ultimo viene ristabilito, la segnalazione led riparte. Inoltre, date un occhio alle icone delle lampadine nel monitor: quando il bus viene ripristinato, le icone rifletteranno correttamente il loro nuovo stato.

La descrizione del progetto ed il sorgente sono scaricabili. Take a look!

Come al solito, i commenti sono ben accetti! :)

Nuovo Arm Cortex A8 touch screen

Arm Cortex powered logoVoglio condividere con voi un video di preview del nuovo touch screen 7″ Android su cui sto lavorando recentemente. Paragonandolo al MCU ARM usato in uno dei miei progetti precedenti, questo Single Board Computer (SBC) è dotato di un ARM Cortex A8 a 1Ghz, molto più potente e performante.
Viene utilizzato solitamente in sistemi industriali e domotici.

Supporta, oltre ad Android (anche la versione 4), Ubuntu e Win CE 6. E’ dotato di 512MB SDRAM DDR2, 4GB di iNand flash memory, Ethernet, porte seriali (3x Rs232, rs485, uart, i2c, spi), 4x USB Hosts, HDMI e TV OUT, 2x SD, G-sensor, interfacce GPS and GPRS e molte altre.

Dai un’occhiata alla lista completa delle specifiche tecniche. Prossimamente, troverete nel wiki gli ultimi progetti di domotica ed automazione industriale su cui sto lavorando. Se ritieni che questo prodotto sia interessante e che può rappresentare una valida soluzione ai tuoi bisogni, visita il nostro Store.

Come al solito, i commenti sono sempre ben accetti!

Android app e Modbus RTU

Abbiamo realizzato una piccola e semplice applicazione per i nostri pannelli LtouchF così da permettere agli utenti di configurare e successivamente comunicare con tutti i dispositivi modbus RTU.

BieMmeConfig, verrà installata di serie su tutti i nostri LtouchF, così renderà più semplice la configurazione dei dispositivi Modbus RTU.

In alcuni semplici passi possiamo scrivere e leggere utilizzando le funzioni 03 e 16 Modbus RTU.

Prepariamo la comunicazione; colleghiamo tramite un cavo a tre fili il dispositivo modbus ed il Ltouch.

La porta RS485 Modbus del Ltouch è posizionata nel lato su un connettore DB9 ed il bus è nel dettaglio nei pin:

  • 2 – A
  • 3 – B
  • 5 – GND

Impostiamo la velocità di comunicazioni (grazie alla nostra Libreria la app supporta la velocità fino a 115200) ed il tempo di timeout.

La funzione 03:
Node Id: corrisponde all’indirizzo dello slave in cui vado a leggere.

Start Register : corrisponde al primo registro per la lettura modbus

Number Registers: Corrisponde a quanti registri consecutivi voglio leggere

Una volta configurato questi tre campi possiamo, tramite i tre bottoni, eseguire la richiesta di lettura.

Singola lettura: Ltouch eseguirà una sola lettura e rappresenterà a video i valori letti.

Lettura a ciclo continuo: Ltouch eseguirà delle letture ad intervallo di un secondo in modalità ciclica. I valori letti verranno rappresentati a video.

La funzione 16:

Grazie a questa funzione possiamo scrivere dei valori interi; anche qui dobbiamo configurare alcuni campi come:

Node ID: Corrisponde all’indirizzo dello slave in cui vado a scrivere

Start Register: Rappresenta il primo registro in cui vado a scrivere

Number Registers: Rappresenta il numero di registri consecutivi nel quale scriverò il valore.

Value: Rappresenta il valore che scriverò.

Per chiudere l’applicazione basta premere sopra il logo BieMme

Comunicazione Android Arduino via RS485 e Modbus

In questo post vi parlo di uno dei progetti a cui sto lavorando in questo periodo. Consiste nell’utilizzare un pannello multi touch Android che comunica attraverso rs485 e modbus con uno (o più) Arduino board. In particolare, l’ambito principale del progetto riguarda la domotica (accensione/spegnimento/status luci, regolazione temperatura, ecc) sebbene molte delle tecniche e concetti che vedremo possono essere applicati con successo in altri campi.


La cosa carina del touch screen che ho utilizzato è l’ampia disponibilità di porte, ampia connettività in generale: Ethernet, USB, rs232, RS485 ed anche I²C. Sebbene disponga di porte molto veloci, ho espressamente scelto di utilzzare RS485 perchè i device Arduino (Uno per esempio) per supportare per esempio l’interfaccia Ethernet hanno bisogno di elettronica aggiuntiva che fa lievitare ulteriormente il prezzo (anche se dal punto di vista della fattibilità esistono diversi progetti in rete).
RS485 è uno standard molto conosciuto nell’ambito dell’automazione industriale e nella domotica. E’ half-duplex, utilizza due fili, tollera molto bene i disturbi, si riescono a raggiungere buone velocità e connettere device remoti fino anche a 1200 metri.

Inoltre, utilizzando il protocollo serial modbus, anche questo sviluppato principalmente nell’ambito dell’automazione industriale, è open, semplice e robusto da sviluppare e manutenere. Ho scelto di utilizzare la variante del modbus denominata RTU, sebbene ne esistano di altre. Continue reading

Come usare il Bundle Android per Scambiare Dati tra Thread

La domanda a cui voglio rispondere con questo post è la seguente: Come usare il bundle Android per scambiare dati tra un tread in esecuzione ed il tread principale che gestisce l’interfaccia (UI)?

Questa situazione è abbastanza comune nei progetti Android e la soluzione è molto semplice ed immediata. Il contesto può essere il seguente:

  1. Una finestra Android (activity) crea un thread in background il quale esegue dei comandi
  2. Quest’ultimo thread, per esempio, ha bisogno di comunicare al thread chiamante (main UI) il risultato della computazione

La situazione può essere gestita usando una combinazione di messaggi Android ed Android bundle.
Continue reading

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.

Come configurare l’Android Vnc Server

android vnc server from android clientIn questo post vi vorrei parlare della procedura di installazione e configurazione di un componente molto importante e utile: Android Vnc Server. Grazie a questa applicazione riuscirete a controllare da remoto un device Android. Questo tutorial è stato testato con i touch screen Ltouch, ma grazie a delle semplici modifiche è possibile estenderlo a quasi tutti i gli altri device Android.

Prerequisiti:
L’unico prerequisito è di avere un device rooted (i pannelli Ltouch lo sono già). Una conoscenza base del terminale di linux può aiutare a velocizzare la procedura di configurazione. Continue reading

Configurazione Ethernet Android attraverso comandi Shell

android network configurationIn questo post, vi vorrei parlare della configurazione Ethernet Android grazie alla potente Shell. I parametri che cambieremo saranno i seguenti: IP Address, Netmask, Gateway and DNS.

Come ben sapete, queste impostazioni possono essere cambiate direttamente dall’interfaccia Android, in particolare nel menu impostazioni del sistema. Alcune volte però è utile sapere come cambiarle utilizzando la shell di Android (alla quale si accede digitando il comando adb shell da un prompt dei comandi) soprattutto se avete necessità di cambiare gli script di inizializzazione del sistema.

I comandi che troverete nel seguito sono stati testati con i pannelli Ltouch F e pannelli Ltouch S, ma sono sicuro che possano funzionare in molti altri device quali tablet e smartphone.

Continue reading