Programming Academy

Arduino: controllare una lampada da 220V

Lo scopo è interrompere la fase di una 220v, che alimenta una lampadina, per 5 secondi e poi mantenerla per altri 5 e cosi via.

Materiale occorrente:

1 resistenza da 330 ohm

1 rele con input 28VDC10A – ouput 220/250VAC10A

1 transistor BC547

1 diodo 1N4001

Il rele è un interruttore controllato da una bobina. In base a quanta corrente entra nella bobina l’interruttore 1 sarà chiuso su 3 o su 2. Da notare che si controlla un circuito con la corrente di un’altro circuito, nel nostro caso si controlla la 220V con un circuito di 6V.

Lo schema seguito è quello sotto

Lo sketch caricato su arduino:

int tempPinBase = 13;

void setup()

{

Serial.begin(9600); //apertura porta seriale, set della velocità a 9600 bps

}

void loop()

{

digitalWrite(tempPinBase, HIGH);

delay(5000);

digitalWrite(tempPinBase, LOW);

delay(5000);

//aspetta 5 secondo prima di ripetere

}

come si vede è abbastanza semplice. Manda tensione alta, conta fino a 5, spegne, conta fino a 5.

Prima di provarlo direttamente con la 220V (con la 220V SI MUORE) ho messo al posto della lampada e del generatore, una resistenza e un LED alimentati da 5V.

Transistor BJT

Un transistor è un dispositivo elettronico a tre terminali: base, collettore e emettitore,
a volte anche chiamato BJT.

E’ formato unendo 3 strati NPN o PNP. La versione NPN è quella più usata.
Ponendo l’emettitore a massa si dice che la il transistor è viene usato con la configurazione “emettitore comune”.

La sua caratteristica principale è quella di essere pilotato in corrente, a differenza del JFET che è, invece, pilotato dalla tensione.

Il transistor ha due possibili utilizzi: interruttore controllato o amplificatore lineare .

Interruttore controllato
Se la corrente nella base è nulla allora anche le correnti nel collettore e nell’emettitore
sono nulle. Lo si può vedere come un interruttore aperto tra collettore ed emettitore. In questo caso si dice che il transistor è in “interdizione“.
Se la corrente nella base è sufficiente, si ha una corrente che entra nel collettore ed esce dall’emettitore, quindi è come se si avesse un interruttore chiuso tra collettore ed emettitore.
A differenza di un normale interruttore, la corrente può scorrere tra Collettore ed Emettitore ma non viceversa (si noti il verso della freccia sull’emettitore). La corrente di base può essere solo entrante. Si ha che la corrente del collettore è uguale alla corrente della base sommata alla corrente dell’emettitore.
In questo caso si dice che il transistor è in “saturazione“.

Amplificatore lineare
Il seguente grafico mostra la corrente di collettore Ic in funzione della tensione Vce, mantenendo costante la Ib

All’aumentare della Vce, inizialmente la Ic è zero; poi aumenta linearmente e rapidamente fino al ginocchio; superato il ginocchio, la Ic resta praticamente costante, anche se aumenta la Vce,come se fosse un interruttore chiuso.
Si nota che, in base alla corrente di base, mantenendo costante la Vce, possiamo controllare la Ic, e variarla in modo lineare.
Quindi alimentando il collettore con una certa tensione e la base con un altra, possiamo con una piccola Ib controllare, e quindi anche aumentarla (amplificarla), una grande Ic.

Per una spiegazione più approfondita, qua troverete un ottimo tutorial.

Elettronica di Base: Generatori Continua

Esistono due tipi di generatori in continua: di tensione e di corrente.

Generatore di tensione
Lo scopo principale di questo generatore è fornire una tensione costante, detta di targa, a prescindere da quale sia il carico collegato. Per poter fare questo, essendo V=R*I, variare la corrente in base al carico.
Nel caso in cui si abbia un R piccolissima, o un corto circuito, il generatore dovrà erogare una corrente altissima, nel far questo o si romperà o salterà qualche fusibile di protezione.
Quindi riassumendo avremo:

la tensione in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
la corrente in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.

Nel 99% dei casi si ha a che fare con generatori di tensione.

Generatore di corrente
In questo caso è la corrente che deve rimanere sempre costante. Per fare ciò, il generatore varierà la tensione. Quindi nel caso di un circuito aperto la tensione salirà fino a quando o si rompe o scattano dei circuiti di sicurezza che fanno scaricare la tensione accumulata.
Riassumendo, nel caso di un generatore di corrente si ha:

la corrente in uscita dipende ESCLUSIVAMENTE dal generatore, e non dal carico.
la tensione in uscita dipende ESCLUSIVAMENTE dal carico, e non dal generatore.

Android: Grafica 2D, le basi

I compontenti di base per poter fare grafica 2D con android sono:
la View, che tramite le chiamate al suo metodo onDraw ci permette di ridisegnare lo schermo.
il Canvas, la classe che contiene le api fondamentali per disegnare (es. drawLine(), drawCircle(), etc.) su una immagine(bitmap) .
la Bitmap, che contiene i pixel, ossia l’immagine vera e propria.
un Paint, che descrive i colori e gli stili per disegnare.

con l’esempio sotto disegniamo un rettangolo rosso

Bitmap bitMapEsempio = BitmapFactory.decodeResource(res, R.drawable.qualche img);
Canvas canvasMaschera = new Canvas(bitMapEsempio);
Paint paint = new Paint();
paint.setColor(Color.RED);
canvasMaschera.drawRect(left, top, right, bottom, paint);// se paint è null si hanno immagini opache

non alllocare troppi oggetti nel metodo View.onDraw, questo metodo viene richiamato tante volte, e quindi potrebbe rallentare di molto l’app.

Hibernate: Strategie di Fetch

Quando si a che fare con delle entity (padre) che hanno delle collection di altre entity (figli), Hibernate offre la possibilità di “tirare su” dal db la collection dei figli subito, nel momento in cui si accede al padre, o in un secondo momento, quando si cerca di accedere direttamente ai figli.

L’attributo che indica QUANDO prendere la collection dal db è lazy=”true|false”. Con true,detto anche comportamento lazy, l’oggetto figlio sarà preso dal db solo nel momento in cui viene invocato. Questo fa si che le query siano molto veloci, si prendono dal db solo i padri, però, se la lettura dei figli avviene fuori dal contesto di hibernate (come ad esempio un EJB), potremmo avere che la sessione è chiusa e quindi verrà sollevata una exception.

Con lazy = “false”, detto anche comportamento eager, non avremo problemi di sessione chiusa ma le prestazioni potrebbero decadere in quanto con una singola query si potrebbe tirare su tutto il DB.

Per indicare COME i figli devono essere letti dal db si l’attributo fetch = “select|subselect|join|batch”.

select: una seconda select è usata per leggere la collection, quindi Hibernate eseguirà una select per il padre e una select per i figli.

Se, per esempio, abbiamo 10 entity padre (A) e ciascuna padre ha al suo interno una collection di figli (B) di grandezza qualsiasi, verranno eseguite le seguenti select:

select A –> eseguita 1 volta, ci darà tutti i padri che ci interessano

select B where A.Id = ? —-> eseguita altre 10 volte

avremo quindi in totale 11 select eseguite. Questa opzione è quella di default.

join: verrà eseguita un’unica select, mettendo in JOIN il padre con tutti i suoi figli.

batch-size=N: questo è un po contorto, esso indica non quanti elementi della collection devono essere letti ma indica quante collection devono essere lette. Riconsiderando l’esempio precendente, se batch-size = 5 leggeremo al massimo 5 collection di figli per volta

select A —> 1 volta

select B where A.id in ( ?, ?, ?, ?, ? ) –> eseguito 10/5= 2 volte

le select totali questa volta sono 3, al posto delle 11 select richieste normalmente, un bel risparmio di tempo.

subselect: hibernate utilizzerà le subquery. In questo caso le select generate sono

select A—> 1 volta

select B where A.id in ( select A ) –> 1 volta

quindi in questo caso avremo 2 select in tutto.

Ogni opzione ha i suoi pro e i suoi contro, molto dipende dal tipo di DB usato e dalla complessità dello schema.

Android: Toast con Immagine e vibrazione

Codice per visualizzare un Toast di Android con una immagine e vibrazione:

package com.AndroidImageToast;

import android.app.Activity;
import android.os.Bundle;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

public class ImageToastExample extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Toast toast1 = new Toast(getBaseContext());
LinearLayout toastLayout = new LinearLayout(getBaseContext());
toastLayout.setOrientation(LinearLayout.HORIZONTAL);
ImageView image = new ImageView(getBaseContext());
TextView text = new TextView(getBaseContext());
image.setImageResource(R.drawable.radiazioni);
toastLayout.addView(image);
toastLayout.addView(text);
toast1.setView(toastLayout);
toast1.setGravity(Gravity.CENTER | Gravity.CENTER, 0, 0);

Vibrator v = (Vibrator) getApplicationContext()
.getSystemService(Context.VIBRATOR_SERVICE);
v.vibrate(300);

toast1.show();
}
}

Arduino: Luminosità Led Con Potenziometro

L’esperimento consiste nel regolare, tramite potenziometro, l’intensità della luce emessa da un LED.

Materiale richiesto:
1 resistenza 1KOhm
1 potenziometro
1 led
e ovviamente un arduino.
Piccolo ripasso dei componenti:

Potenziometro, fondamentalmente è un dispositivo che permette di variare la resistenza, e quindi la quantita di corrente che attraversa il circuito, tramire una semplice manopola. O meglio, non regola la quantita di corrente ma bensi la tensione. Infatti le resistenze NON bloccano la corrente! come per tutti i bipoli elettrici, si ha che I(in) = I(out), sempre!
Quello che fanno è assorbire della potenza e provocare una caduta di tensione ai capi. Ricordiamo che la prima legge di Ohm è V=R*I, essendo I costante variando R variamo la V.

Led, è un compontente che sviluppa luce al passaggio di corrente. O meglio, il led si comporta come un conduttore perfetto quando si applica una tensione in un certo modo (polarizzazione diretta), e diventa un isolante quando si inverte la tensione (polarizzazione inversa) . Tutto questo in teoria, nella realtà, osservando la curva corrente-tensione di un diodo, si nota che la conduzione in polarizzazione diretta
è possibile solo superando una tensione di soglia Vg. Il polo positivo è detto anodo, quello negativo catodo. La polarizzazione diretta è quando si applica il positivo all anodo e il negativo al catodo
Riassumento e semplificando, possiamo considerare questo dispositivo dal suo aspetto funzionale (ideale) come un interruttore, il quale risulta essere chiuso quando è polarizzato direttamente (quindi percorso da una determinata intensità di corrente) ed aperto quando è polarizzato inversamente (non consente il passaggio di intensità di corrente, nel caso ideale).

Schema elettronico

Per quanto riguarda la parte software abbiamo

int valore = 0;
int pinPonteziometro = A0;
int pinLed = 9;
void setup() {
pinMode(pinPonteziometro, INPUT); // pin potenziometro
pinMode(pinLed, OUTPUT); // pin led
Serial.begin(9600); // inizializza il collegamento seriale

}

void loop() {
valore = analogRead(pinPonteziometro); // legge il valore analogico del //potenziometro
Serial.print("Valore letto dal potenziometro:");
Serial.println(valore); // Stampa il valore letto
if (valore > 255)
digitalWrite(pinLed, HIGH); //accende il led
if (valore < 0)
digitalWrite(pinLed, LOW); //spegne il led
if (valore > 0 && valore < 255)
digitalWrite(pinLed, valore); // intensita luminosa del led uguale al valore letto dal potenziometro
delay(1000); // aspetta 1000 millisecondi, ossia un secondo
}

da notare che la luminosità del led può assumere valori che vanno da 0 a 255, mentre i valori del potenziometro vanno fino a 1024, se non sbaglio, ecco spiegato il perchè delle if.

Uno sketch è composto da due funzioni: setup() che serve a inizializzare le varie componenti e loop() che viene eseguita in continuazione su arduino. Altre funzioni native di arduino sono:

digitalWrite(a1,a2), comunica al pin digitale a1 di assumere il valore a2
analogRead(a1), legge il valore analogico dalla porta a1.