Pubblicato il bando per una nuova edizione della Scuola di Fisica con Arduino e Smartphone

È stato pubblicato all’indirizzo https://www.uniroma1.it/it/offerta-formativa/corso-di-alta-formazione/2019/fisica-con-arduino-e-smartphone il bando per la partecipazione alla III edizione della Scuola di Fisica con Arduino e Smartphone di Sapienza.

La scuola è un’attività full time intensiva di tre giorni destinata agli insegnanti di matematica e fisica o aspiranti tali. Non ci sono prerequisiti: non è necessario saper programmare o avere competenze di elettronica per partecipare. L’esperienza delle prime due edizioni ha dimostrato che un insegnante completamente digiuno di programmazione si può trasformare in un vero e proprio maker in soli tre giorni!

20170907_144943-collageIl primo giorno insegneremo a programmare una scheda Arduino e chiederemo agli insegnanti di pensare a un esperimento che vorrebbero realizzare nella loro classe. Il secondo giorno porteremo gli insegnanti ad acquistare il materiale necessario (il budget è volutamente ridotto a 20 euro ciascuno per consentire l’esecuzione di misure precise e accurate con una spesa minima) e li assisteremo nella realizzazione pratica della loro idea. Il terzo giorno l’esperimento sarà condotto e illustrato.

È un’esperienza coinvolgente ed estremamente utile per acquisire quelle che oggi si chiamano soft-skills e per rendere l’insegnamento della fisica appetibile anche agli studenti meno motivati.

La partecipazione alla scuola è pagabile con la carta docente per gli insegnanti in servizio. Altre informazioni alle pagine dedicate del PLS-Fisica di Sapienza.

Annunci

Indagine sugli studenti di fisica

Sono ormai quattro anni che propongo ai miei studenti di fisica un questionario standardizzato a inizio corso. Il questionario serve a raccogliere i dati degli studenti necessari per lo svolgimento delle attività di laboratorio, ma con l’occasione chiedo loro alcune informazioni aggiuntive per studiare alcuni fenomeni relativi alle attitudini degli studenti al primo anno di corso all’Università.

In questi quattro anni, apparentemente sono tre gli aspetti interessanti, che denotano un chiaro trend: il numero di studenti che non ha mai sentito parlare di Arduino, il numero di studenti senza smartphone e il numero di studenti che conosce il sistema operativo Linux. Tutte le indagini sono eseguite su un campione di circa 100 studenti per anno.

Il numero di studenti che non ha mai sentito parlare di Arduino è, fortunatamente, in diminuzione, sebbene il numero assoluto di studenti che ignorano del tutto il fenomeno sia ancora molto alto: nell’ultima indagine (2017) ben il 43% degli studenti ha dichiarato di non aver mai sentito nominare questo nome.

arduino

L’andamento in funzione dell’anno è riportato nel grafico sopra. Anche la frazione di studenti che conosce Linux è in discesa, come si vede dal grafico sotto.

linux

Al contrario della precedente questa non è una buona notizia, ma c’era da aspettarselo in quanto presumibilmente dipendente dal fatto che i computer stanno diventando sempre meno diffusi in favore dei tablet. Il dato più eclatante è fornito dall’andamento del numero di studenti privi di smartphone:

smartphone

La discesa appare, in questo caso, inequivocabile particolarmente evidente e addirittura sembra essere esponenziale. Questo è ragionevole, in quanto la variazione (cioè il numero di studenti che passa dal non avere uno smartphone ad averlo in un anno) dev’essere proporzionale alla popolazione priva di smartphone.

Nell’indagine 2017 nessuno degli studenti intervistati (115) ha dichiarato di non essere in possesso di uno smartphone. Questo significa che possiamo porre un limite superiore a meno del 3% (il 2.6% per la precisione) al 95% di livello di confidenza. Possiamo cioè affermare che, con il 95% di probabilità di essere nel giusto, che almeno tra gli studenti che s’iscrivono a un corso di laurea in fisica più di 97 su 100 possiedono almeno uno smartphone.

La stima di π

Il problema della cosiddetta quadratura del cerchio è molto antico. Consiste nella determinazione dell’area di un cerchio di raggio 1 (l’area del cerchio di raggio qualsiasi essendo semplicemente quella del cerchio di raggio 1 moltiplicata per il raggio al quadrato). Un modo per definire questa misura è il seguente: prendiamo un cerchio di raggio 1 e inscriviamolo in un quadrato, che evidentemente deve avere lato pari a 2 (e dunque area pari a 4). Se chiamiamo π l’area di questo cerchio, il rapporto tra quest’area e quella del quadrato è π/4.

Il 14 marzo è il cosiddetto Pi Day: il giorno del pi greco (in inglese la data del 14 marzo si scrive 3/14). Questo post è dunque un suggerimento per attività didattiche da portare avanti in quella giornata.

Se si distribuiscono N punti in maniera uniforme all’interno del quadrato, una frazione di essi cadrà all’interno del cerchio ed è evidente che il numero di punti che cade all’interno del cerchio diviso il numero di punti N sarà in media uguale al rapporto delle aree di queste figure. Chiamando Nint il numero di punti interni al cerchio possiamo perciò dire che

Nint/N ≃ π/4,

e, di conseguenza, possiamo stimare π semplicemente contando il numero Nint che cade all’interno del cerchio:

π ≃ 4Nint/N.

La statistica c’insegna che la precisione con cui potremo determinare il valore di π sarà tanto migliore quanto maggiore sarà il numero di punti Nint, che a sua volta dipende da N.

Con il linguaggio di programmazione Scratch anche i bambini possono scrivere un semplice algoritmo per stimare il valore di π.

All’indirizzo https://scratch.mit.edu/projects/149703806/ si può vedere in funzione il programma piCat che fa proprio questo. Il gattino di Scratch chiede quanti punti N si devono generare e comincia a mettere un pallino in punti a caso scelti all’interno del quadrato. Quando il pallino si trova nel cerchio (e questo lo si determina controllando il colore col quale il pallino è in contatto) cambia colore e incrementa il valore di un contatore Ninside. La stima di π è costantemente aggiornata. Con N=2000 si trovano valori molto prossimi a quello vero, pari a 3.1415926535897932384626433832795028841971693… (alla pagina http://www.piday.org/million/ trovate il valore di π con un milione di cifre dopo la virgola).

Simulazione di campi magnetici

Nei giorni scorsi, preparando le mie lezioni di Fisica per Biotecnologie, cercavo un modo efficace di spiegare qualitativamente come mai il campo magnetico prodotto da molte spire sia relativamente uniforme all’interno e poco intenso all’esterno del gruppo di spire. Volevo anche includere questa spiegazione nel mio e-book Fisica Sperimentale, che sono vicino a terminare (almeno per quanto riguarda i suoi contenuti: la forma e le eventuali correzioni richiederanno ancora molto tempo).

Non trovando nulla di soddisfacente sulla rete ho deciso di scrivere da me il software necessario (il codice è disponibile su bitbucket). In fondo non è difficile. Si parte da un filo percorso da corrente che produce un campo magnetico le cui linee di forza sono circonferenze centrate sul filo e la cui intensità è data dalla Legge di Biot-Savart.  Una spira circolare, a questo punto, si può pensare come a una coppia di fili: per simmetria, infatti, due punti opposti sulla spira sono equivalenti a tutti gli altri e ciascuno produce un campo equivalente a quello prodotto da un filo tangente alla spira in quel punto.

Avendo a disposizione il campo di una spira si può calcolare quello prodotto da molte spire semplicemente sommando (vettorialmente) quello prodotto da ciascuna di esse in un dato punto dello spazio.

Ho così scritto un programma che calcola il campo di N spire sovrapposte e di una spira che si trova a una certa distanza da queste, con l’asse allineato a quello delle altre. Facendo variare la distanza di quest’ultima spira se ne simula l’avvicinamento al gruppo di N spire. Per ogni distanza produco quindi un grafico che rappresenta con un codice di colori l’intensità del campo in un punto e uno nel quale disegno i vettori campo in punti selezionati. Salvo i grafici in altrettante immagini e da queste genero un gif animato che fa vedere come evolve il campo in questione.

Qui sotto si vede l’animazione che rappresenta le N spire che cadono l’una sull’altra: l’intensità del campo magnetico tra le spire diventa via via più grande e uniforme (in bianco sono rappresentati i campi più intensi).

Nel video sotto invece si vedono i vettori campo magnetico in diversi punti dello spazio. Si può notare come, vicino a una singola spira, il vettore campo descriva circonferenze concentriche attorno alla spira. Sommandosi, i campi di molte spire danno luogo a un campo praticamente uniforme all’interno del solenoide formato da tante spire e orientato come il suo asse.

Le immagini sono state ottenute con gnuplot e i filmati con il programma convert di Linux.

Se siete interessati ai dettagli potete contattarmi agli usuali recapiti. Il codice è rilasciato con licenza GPL ed è quindi pubblico e utilizzabile da chiunque.

Smartphone Physics

Nei giorni scorsi abbiamo predisposto alcuni semplici esperimenti che si possono realizzare con uno smartphone. Gli esperimenti in questione riguardano lo studio dei sistemi di riferimento non inerziali e si possono realizzare grazie al fatto che su ogni dispositivo di questo tipo è presente un accelerometro che permette al telefono di sapere in quale posizione si trova (verticale, orizzontale, poggiato su un tavolo).

Per realizzare questi esperimenti usiamo un’App gratuita il cui nome è Wireless IMU, scritta da Jan Zwiener. IMU non sta per Imposta Municipale Unica, ma per Inertial Measurement Unit: il software trasmette attraverso una rete WiFi i dati dei sensori del telefono che contengono informazioni rilevanti al fine di determinarne la posizione.

Una volta installata la App io ho scritto un’applicazione Java che intercetta i dati trasmessi dal telefono e li usa, negli esempi che ho previsto, per mostrarne il grafico in funzione del tempo e registrarli su un file per un’analisi successiva. Il software è, naturalmente, libero e si può scaricare all’indirizzo https://bitbucket.org/organtin/wimu. Essendo scritto in Java il software può girare su qualunque PC, indipendentemente dal sistema operativo. Il fatto che il codice sorgente sia aperto permette a chiunque di modificarlo e di realizzare l’applicazione che crede.

Le applicazioni al momento previste sono Imu e ImuFreeFall. La prima si limita a fare un grafico delle tre componenti dell’accelerazione in funzione del tempo. Mettendo il telefono su una piattaforma girevole si vede come l’accelerazione lungo il raggio diventi non nulla. Il dispositivo infatti si troverà in un sistema non inerziale con una componente centrifuga dell’accelerazione. Per eseguire l’esperimento si può usare un vecchio giradischi. Fissate bene il telefono sulla superficie per evitare che scivoli via (un modo consiste nell’incollare una cover sulla superficie girevole e fissare il telefono su quest’ultima).

ImuFreeFall mostra il valore della componente y dell’accelerazione e il modulo di quest’ultima in funzione del tempo. L’applicazione si arresta automaticamente quando il telefono passa da accelerazione nulla ad accelerazione diversa da zero. Se si tiene il telefono in verticale, l’accelerazione misurata lungo questa direzione è quella di gravità: 9.8 ms-2. Nel momento in cui lo si lascia cadere quest’accelerazione passa improvvisamente ad assumere il valore zero. Il telefono, infatti, si trova in un sistema di riferimento non inerziale con accelerazione costante. Appena la caduta si arresta l’accelerazione torna ad assumere il valore normale e l’applicazione si ferma. In questo modo si può sperimentare l’effetto del famoso ascensore in caduta libera descritto sui libri di fisica, per il quale dubito che qualcuno voglia fare l’esperimento. Naturalmente, per evitare che l’esperimento si possa eseguire una sola volta, il telefono va fatto cadere su un’opportuna superficie che attutisca l’urto: un secchio pieno di cuscini o di fiocchi di polistirolo da imballaggio funziona perfettamente (basta avere buona mira o un’area di caduta molto ampia).

Cronaca della salute pubblica

Questa mattina mi reco presso l’Istituto Dermatologico S. Gallicano di Roma per un trattamento di crioterapia. Sulla mia impegnativa ci sono indicati tre appuntamenti a distanza di alcuni giorni (tralascio un certo numero di dettagli che potete immaginare sulla prenotazione). Alla cassa mi rilasciano quietanza di pagamento e al mio turno entro nell’ambulatorio.

Il medico mi chiede se ho le copie della quietanza. Che copie? Quelle che dovrà portare quando verrà ai prossimi appuntamenti, no? E come faccio ad averle? Le deve chiedere alla cassa, no? Io? Le devo chiedere io? Non dovrebbe essere la cassa a darmele, se sono necessarie? Ma è ovvio che sono necessarie. Lei deve capire che quando tornerà la prossima volta dovrà portarmi un pezzo di carta come questo no?

Ah, già! Che sciocco che sono. Devo capirlo. Che ci volete fare. Sono solo un fisico. A tanto non ci arrivo…

Pensate che io credevo che funzionasse tutto in un’altra maniera, visto che, all’atto della prenotazione, mi avevano dato un numero. Pensavo che con quel numero si potesse andare su un servizio Internet attraverso il quale avrei potuto pagare la prestazione con carta di credito o altro metodo. In seguito al pagamento avrei potuto ricevere un codice che il medico avrebbe potuto chiedermi per accertare l’avvenuto pagamento, come fa il controllore di un treno che chiede il codice di prenotazione al passeggero: si dice paperless, perché non si spreca carta, inchiostro, tempo e spazio (la struttura trattiene copia dei pagamenti, certamente per accatastarli inutilmente in qualche prezioso locale). Ma che cretino che sono: credevo forse di vivere nel futuro? Queste cose si vedono solo nei film di fantascienza!

Qualcuno dirà che questa cosa che ho reso pubblica è inutile. Non cambierà niente. Eppure solo pochi giorni fa avevo inutilmente tentato di fare una prenotazione via Internet invece che chiamando il CUP, ma mi ero scontrato con il fatto di non essere in possesso di un famigerato codice assistito e avevo trovato questo post: http://www.rainwiz.com/2011/08/25/il-codice-assistito-la-privacy-e-i-servizi-on-line-della-regione-lazio/.

Non ci crederete, ma oggi sono riuscito ad accedere senza quel codice! Ma guardate che non ho mica detto che funziona, eh? Badate bene. Non è che con quel servizio puoi prenotare o disdire un appuntamento. Puoi solo chiedere di essere richiamato per farlo. Chissà se lo faranno. Intanto, il fatto che non mi abbiano chiesto il codice assistito è un passo avanti…

Working with motors

In certain cases you may need to use motors for different purposes. Depending on the experiment or the device you are building, the type of motor to use can be different. In this series of posts I will show you how to use those motors with Arduino.

Servo Motors

Servo motors are motors for which you can control accurately enough the speed and the angle of rotation. They can be used to precisely move parts in your device. For examples, in physics experiment you can use a servo motor to hold a ball in a given position and release it at a given time to study its motion.

As most of the motors, servo motors can just rotate around their axis. However, with a bit of mechanics you can realise any kind of movement. To have an idea of what you can do with a rotating axis and some mechanics, just read the article on http://makezine.com/2015/04/20/understand-1700-mechanical-linkages-helpful-animations/.

Controlling a servo motor is incredibly easy with Arduino. Servo motors have three wires: usually coloured in black, red and white. The black one must be connected to the GND pin of the Arduino, while the red one to the 5V pin. They are used to feed the motor with some power. The third wire is used to control it. Any servo motor works receiving voltage pulses of a given width. Pulses are repeated at regular intervals (e.g. 20 ms), while the duration of a single pulse determines the rotation angle of the motor around its axis or its speed.

Given the working principle of a servo motor, you will not be surprised to know that you need to connect the control wire to one of the PWM (Pulse Width Modulation) pins of Arduino. PWM pins can be configured such that they provide voltage pulses at given interval with the chosen duty cycle. The duty cycle of a PWM pin is the faction of time for which the pin is at its highest voltage. An excellent tutorial on PWM pins is given here.

Putting the pin to zero makes the PWM pin to stay off, while putting it at its maximum value of 255 makes the pin to stay always on, i.e. with a duty cycle of 100%. In order to observe a square wave on the pin you must put it at 128, such that f=128/255=0.5 and the duty cycle is 50%. Any other number makes the pin to produce a square wave whose pulse width ranges from 0 to T, where T depends on the Arduino flavour. On the Arduino UNO T is about 2 ms.

With Arduino you don’t need to compute the values yourself to control a servo motor. The Servo library is in fact available for use and provides all the relevant configurations automatically. Consider the following sketch:

Servo myservo;

void setup() {
  myservo.attach(9);
}

void loop() {
  myservo.write(90);
  delay(1500);
  myservo.write(0);
  delay(1500);
}

The attach() method in setup() just tells Arduino to which pin the motor is attached, represented by the object myservo, defined as a member of the main class (Servo myservo). In the example the servo is attached to pin 9. You can then provide an angle, in degrees, to the write() method. Its effect depends on which type of servo motor you have.

There are, in fact, two types of servo motors: continuous rotation and standard. The write() command makes a standard servo rotate of the specified angle. A call to

  myservo.write(90);

with a standard servo makes it rotate of 90 degrees. With the above sketch a servo of this type rotates of 90 degrees, then holds that position for 1.5 s, before returning at its initial position, where it stays for 1.5 s. Being in the loop the above rotations are repeated continuously.

When a servo motor of this type is powered and is receiving a train of pulses, it resists to forces applied to it holding its position. Of course you cannot apply forces too large, if you do not want to damage your servo. The maximum torque you can exert on the servo axis is one of the characteristics you can find on the servo data sheet.

The maximum torque is usually measured in kg·cm and is the product of the mass of a weight suspended at a given distance on a beam mounted on the motor axis. Using a servo whose maximum torque is 10 kg·cm you can suspend 10 kg at a distance of 1 cm from the axis as well as 1 kg at 10 cm. The larger the distance, the lower the weight the servo can tolerate. Needless to say, it is not a good idea to use a servo close to its limit. If you need a given torque, choose a servo that can tolerate at least twice that torque.

In order to compute the torque in N·cm it is enough to multiply the torque in kg·cm by 9.8, i.e. by the gravitational acceleration. In this case a servo whose maximum torque is 10 kg·cm can tolerate a force acting 1 cm far from the axis of 10·9.8=98 N, or a force of 9.8 N acting at a distance of 10 cm from the axis.

Continuos rotation servo motors, instead, rotate clockwise or anticlockwise until they are powered. The number passed to the write() method represents the rotation speed: numbers from 0 to 89 make the motor axis rotate anticlockwise (seen from above), while numbers from 91 to 180 make it rotating clockwise. The maximum speed is attained for 0 or 180. The higher the number, the slower the speed if the number is less than 90. On the contrary, if the number is larger than 90, the speed increases with the number. Setting the speed at 90 makes the servo stop rotating. In the above sketch, then the servo rotates anticlockwise for 1.5 s, then stops for other 1.5 s and so on.

Here you can find the motor we used for our tests, but it is plenty of them in the Farnell Electronics store. Here is a video showing our continuous rotation servo working with the sketch outlined above.

This post appears on the Element14 Arduino Blog, who partly sponsored it, and its content will be included in my Scientific Arduino publication.

 

The RC circuit

This time I am going to share with you an amazingly simple experience that is made possible using just an Arduino UNO board, a resistor and a capacitor. The RC circuit is a classic circuit in physics teaching and is composed by just a resistor R and a capacitor C in series. For details you can look at the Charging a Capacitor page of the HyperPhysics pages. Pupils study the charging and discharging of the capacitor when the circuit is connected to a battery. A rather simple mathematics gives the laws governing the process. It is easy to show that the voltage across the capacitor VC is a function of the time t: when the capacitor is not charged and is connected to a voltage V0 through the resistor, one gets

VC(t)=V0(1et/θ)

Here  θ is a parameter having the dimensions of a time called the time constant of the circuit and is given by the product RC. When the capacitor is at its full charge and the two leads of the circuit are short circuited, the voltage across the capacitor drops with time with an exponential law whose time constant is still given by RC.

In the past, making the experience in a physics laboratory, was not so easy for students. The time constants that one can get using easily available components are short. For R of the order of few tens of kΩ and C of the order of few μF, the time constant is of the order of 10×103×10-6≈10-2s, i.e. a hundredth of a second. In order to measure the voltage across the capacitor as a function of time you need to connect the leads of a multimeter to the capacitor and read its value as a function of time, so you need time constants of the order, at least, of few seconds. That requires extremely large values of C (and R) that, of course, are not impossible to obtain, but are not so easy to find. Even in this case you can only collect few values.

With an Arduino board the job is greatly simplified and, needless to say, the precision you can attain with it is impressive.

The circuit, shown in the picture below (made with Fritzing), is easily realised connecting one of the leads of the resistor to the 5V pin of Arduino; the resistor is mounted in series with the capacitor that, in turn, has its second lead to the ground (GND). In order to measure the voltage across the capacitor, we connect the first lead of the capacitor to one of the Arduino analog inputs (A5).

 

RC.png

Initially, the red wire is not connected to the 5V pin and the capacitor is not charged. Using the new Arduino IDE one can plot the values written to the Serial monitor as a function of time (in fact as a function of the reading). Consider the following code:

void loop() {
  while (fabs(analogRead(A5)*5/1024. - lastReading) < 0.1) {
    // do nothing
  }
  for (int i = 0; i < 480; i++) {
    float currentReading = analogRead(A5)*5/1024.;
    Serial.println(currentReading);
  }
  while (1) {
    // do nothing
  }
}

The first loop just waits until the current reading of the A5 pin (analogRead(A5)) differs from the value of lastReading for more than one tenth of a volt. The fabs function returns the absolute value of its argument. The reading of the analog input can be an integer number between 0 and 1024 representing a voltage ranging from 0 to 5 V. Multiplying the reading by 5 and dividing it by 1024 we then get the value of the voltage across the capacitor in Volts. Note the dot after 1024 that is needed to make the value a floating point number. If the dot is missing, both 5 and 1024 are represented as integers in the Arduino memory, as well as the value returned by analogRead(A5). This can lead to important consequences. Suppose, for example, that the analogRead(A5) function returns 123. Once multiplied by 5, we get 615 that, divided by 1024 gives just zero! In fact, 615/1024 is a ratio between two integers and the result is interpreted as an integer, too. Writing 615/1024. (with the dot after 1024) forces the CPU to represent the number 1024 as a floating point number and any operation made using an integer (615) and a floating point number (1024.) is a floating point number (about 0.6).

The value of lastReading must be set in the setup() of the Arduino sketch, in which we also initialise the Serial monitor with

Serial.begin(9600);

The first loop, then, is needed to start the program as well as the Serial plotter, having the time to connect the red wire to the 5V pin. Only when such a wire is connected to that pin the capacitor starts charging and the voltage across its leads starts raising. At this point we just read a fixed number of values of such a voltage (480 in our case) and write them on the Serial monitor. Each value written to the Serial monitor is shown on the Serial plotter versus time (in fact each value written to the Serial monitor is plotted against a sequential number, but in our case the readings are made at almost constant intervals of time, hence the horizontal axis values are proportional to time).

Once we read all the values we just stop doing anything with the last loop. The result is shown below.

arduino-charge-RC.png

Such a very nice curve is exactly what we expected. You can even measure the discharge curve just repeating the experience in the following way: once charged, the capacitor remains charged until it is short circuited on the resistor. So, just disconnect the red wire from the 5V pin, restart the program and the Serial plotter, and connect the free lead of the red wire to the ground. The capacitor starts discharging on the resistor and the voltage across it changes. Soon after, the program makes 480 readings of the voltage and plot them, as can be seen below.

arduino-discharge-RC.png

You can even be more quantitative with a slight change into the Arduino sketch. Consider the following:

float lastReading;
unsigned long time;

void setup() {
  Serial.begin(9600);
  lastReading = analogRead(A5)*5/1024.;
}

void loop() {
  while (fabs(analogRead(A5)*5/1024. - lastReading) < 0.1) {
    time = micros();
  }
  for (int i = 0; i < 480; i++) {
    unsigned long now = micros(); 
    Serial.print(now - time);
    Serial.print(" ");
    float currentReading = analogRead(A5)*5/1024.;
    Serial.println(currentReading);
  }
  while (1) {
    // do nothing
  }
}

At the beginning of the loop we still wait for a change in the voltage, but in this case we collect the current time in the time variable. The current time is given by the micros() function returning the number of microseconds elapsed since the start of the sketch. As soon as the voltage changes we start measuring the voltages across the capacitor, but in this case we also get the time of each measurement and send to the Serial monitor both the time elapsed since the start of the measurements and the measurement values.

We write those two numbers to the Serial monitor, then copy and paste them into a text file for subsequent analysis. The picture below shows the data collected by us, during the charge:

RC.png

Times are in microseconds and you can see how rapid is the process. The capacitor is almost at its full charge already after 2 seconds. We used a resistor whose resistance was R=9.94 kΩ. We can then get the value of the capacitor from these measurements. With some mathematics one obtains a time constant θ of 0.53 s, from which we can derive C as θ/R≈54 μF. The nominal value of the capacitor we used is 47 μF. The error in the determination of it is then less than 15%.

This post appears on the Element14 Blog too, and is partly sponsored by Farnell Electronics. It will also appear in my free e-book on Scientific Arduino for teachers and students.

The Minchioduino

There are words, in Italian, that are not very polite, who becomes funny and acceptable when they change gender. That’s the case for “minchio” (pronounced minkio), used to give a name to something that does not have a name or for which you don’t know it.

A friend of mine bought, few weeks ago, a device to control remotely the air conditioners in his house on the beach. The device was supposed to learn from any remote controller and replicate its behaviour. It can be controlled from a phone using SMS. Sadly, that device did not work for my friend. In fact it works fine with all other appliances (TV, VCR, etc.), but for the air conditioners.

I then proposed to build it from scratch using an Arduino, an IR sensor, an IR LED and a GSM shield. We tested a prototype of it as follows: after a bit of hacking of the Shirriff’s libraries for IR remotes, we were able to read the whole set of codes produced by the air conditioner remote controller (air conditioners’ codes are much longer than TV ones); we then tried to mimic them using our LED, but unfortunately it didn’t work, too. Hard to say why.

However, a maker never gives up: failure is not an option! Hence I switched to plan B. I opened the remote DSC_0399controller and found the contacts corresponding to each key. A picture of the remote controller board is on the left: pressing a key makes a short circuit between two tracks on the board (the black ones). Such tracks are made of a conductive paint on top of the copper tracks behind them. They are separated from them by means of a thin isolation layer. I then carefully removed, usingDSC_0401 (1) sand paper, both the conductive tracks and the isolation layer in order to access the copper tracks. You can see the result in the photo on the right. The conductive paint connects with copper tracks where you can see those small copper dots in the picture: making a short circuit between two appropriate contacts produces the same effect of pressing a key.

DSC_0406 DSC_0408 (1)

This way, I could solder wires on the board. Since the tracks are quite fragile, I fixed the wires along the tracks using some wax dropped from a candle (quite smart, uh? See pictures). Each pair of wires were connected to the pins of a CD4066, an integrated circuit with four  switches that can be controlled by means of a digital signal. I used two CD4066 (I needed to switch the air conditioners on to heat and to cool, to switch it off, to increase and decrease the temperature).

The inputs for the CD4066 is driven by an Arduino YUN. It also reads an LM35 sensor to get the current temperature. The YUN is the ideal board because it connects to WiFi, that is available in my friend’s home. It also run a custom Linux version on which I can run a python script. We called such a system: the minchioduino.

Using the techniques explained in a previous post of mine, I was able to do the following: the Arduino continuously  polls the twitter timeline of my friend. A command for the minchioduino consists of a tweet starting with “#minchio“, followed by the command that can be heat, cool, off, + or - (whose meaning is obvious). You can even start heating or cooling for a given amount of time, then the system automatically stops after the specified time (e.g. #minchio heat 0.2 switches on heating for 12 minutes: 0.2 hours). Once a command is got, it is removed from the twitter timeline, while the current status is posted. This way the user knows if the system accepted the command and what is the actual status.

Crea un sito o un blog gratuitamente presso WordPress.com.

Su ↑