ll satellite da laboratorio Bee LabSat è stato selezionato per partecipare alla fiera internazionale delle innovazioni, nella categoria Call for School, del Maker Faire di Roma 2019. Il satellite è stato sviluppato, nel suo primo prototipo, circa dieci anni fa allo Scalfaro di Catanzaro ricevendo già allora, tra gli altri, i complimenti del centro Spaziale dell’Università di Losanna. Quest’anno, oltre a prototipo del 2010, verrà presentato il nuovo satellite in versione “Cube Sat” (dimensioni 10x10x10 cm), i cui test sono in corso di ultimazione in questi giorni presso i laboratori dell’ITTS di Catanzaro grazie al lavoro di un gruppo di docenti, ingegneri e tecnici di tutte le specializzazioni presenti nell’istituto, sotto la guida e supervisione dello scrivente. “Bee LabSat 2.0” è un sistema satellitare didattico destinato allo studio delle funzioni di Housekeeeping dello stesso. In pratica il piccolo satellite, tramite la trasmissione alla stazione terrena delle cosiddette “telemetrie”, permette di conoscere “lo stato di salute in orbita” delle sue apparecchiature fondamentali. La versione 2.0 è la rivisitazione del primo progetto, alla luce dei progressi in campo tecnologico avvenuti negli ultimi anni: nuova la scheda satellite, nuovo lo chassis progettato e sviluppato per il prototipo fiera con l’uso della stampante 3D. Bee LabSat è decisamente un piccolo “gioiellino didattico” e notevoli ne saranno le ricadute proprio su questo piano nei prossimi anni, consentendo ai giovani studenti dello Scalfaro di Catanzaro di avvicinarsi allo studio dell’affascinante e moderno settore aerospaziale.
“Ternary Spacecraft” @ DIGITHON
Dalla email di digithON:
“…. La tua startup Ternary Spacecraft è tra le 100 selezionate dal nostro comitato scientifico per partecipare alla fase finale di DigithON che si terrà a Bisceglie, in Puglia, dal 5 all’8 settembre 2019.
Ti ricordiamo che la partecipazione all’evento è del tutto gratuita e che la pitch competition si terrà i giorni 6 e 7 settembre 2019, presso le Vecchie Segherie di Bisceglie.”
Travel Game meets Ternary Logic
Il 24 ed il 26 Marzo 2019 Il ternario è “sbarcato” o meglio è stato “imbarcato” sulla Grimaldi Lines in rotta da Civitavecchia a Barcellona e viceversa. Grazie a quattro conferenze, gli studenti provenienti da mezza Italia, hanno potuto assistere alla mia lezione: “Ready for Ternary?”. Il tutto grazie ad un invito del mio ex studente Emanuele Gambino ideatore e patron del Travel Game.
Vedi Articolo: su wicontest.com
On 24 and 26 March 2019 The ternary was “landed” or rather “embarked” on Grimaldi Lines en route from Civitavecchia to Barcelona and vice versa. Thanks to four lectures, students from half of Italy were able to attend my lesson: “Ready for Ternary?” All thanks to an invitation from my former student Emanuele Gambino creator and patron of the Travel Game.
Links su “Navicella Ternaria”
Riporto qui alcuni link relativi alla mia partecipazione al Maker Faire di Roma Ottobre 2018.
- Dal sito del mio ex studente Massimiliano Capalbo: Siete Pronti per il Ternario ?
- Intervista su Esperia TV: La logica Ternaria del Prof. Talarico
- Dal mio canale YouTube: Ready For Ternary? – Ternary Spacecraft –
Ternary Spacecraft Board Brochure
…On Maker Faire Rome 2018 site
Ternary Logic: a “spacecraft” to explore it.
The figure above shows the manifest realized for Maker Faire Rome 12-14 October 2018
This project, in collaboration with Claudio La Rosa, has been selected to take part to the Maker Faire Rome 12-14 October 2018 and aims at providing an instrument to explore, what we call, the “galaxy” of Ternary Logic. It consists of two parts: an hardware one and a software one. Everything started from my previous posts:
- appunti-logica-ternaria
- monadic-and-diadic-ternary-logic-simulation-results
As known, in the BINARY system all the logic functions are in total:
- Monadics : 2 ^2 = 4
- Diadics: 2 ^ 4 = 16
Out of the four monadic functions, only one of them is currently used as logical gate: NOT. Six of diadic functions give rise to logical gates that can be used in the design of logic boards: AND, NAND, OR, NOR, XOR, XNOR.
Things are slightly different in the TERNARY system:
- Monadics : 3 ^ 3 = 27.
- Diadics: 3 ^ 9 = 19’683 (an incredibly high number)
We believe that no one has ever ventured into the complete exploration of such a large number of diadic functions (diadic gates), also due to the lack, to date, of logical components that are able to work on three levels. In this galaxy of possible components, the majority of them, have neither a symbol nor a name, so I decided to make two boards that can be interfaced with Arduino or Raspberry that allow you to explore, through the use of an oscilloscope:
- all twenty-seven logic ternary gates with an Input and one Output;
- all twenty thousand gates with two Inputs and one Output.
Each of the two boards consists of a “single universal programmable ternary logic gate”, obtained through the use of the DG403 component which realizes a mux 3: 1 for monadics and a mux 9: 1 for the diadics as well as the appropriate Trit generators (ternary variables). By programming, from time to time, the truth table of the muxes you can get all the logic gates mentioned above. Finally, by appropriately programming the Input Ternary Signals it is possible to display and study the output waveforms from which to obtain useful information on a possible use thereof in the future design of circuits boards in ternary logic.
“All Ternary Monadic Functions Generator” Board with raspberry Board
This project was born at the end of my 31 years career as a Professor of Computer Science at the Technical Institute “Ercolino Scalfaro” of Catanzaro and I dedicate it to all my former students and all the people who have appreciated me and / or have worked with me at any level . Many thanks to all!
Finally, a special dedication in memory of four people. Two very good students who left us prematurely and two special people for me:
- Rotundo Salvatore, just graduated in engineering at the University of Cosenza;
- Gregorio Cosentino, he lacked the sole discussion of the thesis at the University of Pisa (he was awarded the posthumous degree in Engineering);
- Luigi Rodomonte;
- Pino Rizzitano.
Logica Ternaria: una “navicella” per esplorarla.
La prima figura mostra il Manifesto realizzato per il Maker Faire di Roma del 12-14 Ottobre 2018.
Questo progetto, in collaborazione con Claudio La Rosa, è stato selezionato per prendere parte alla Maker Faire Roma dal 12 al 14 ottobre 2018 e ha lo scopo di fornire uno strumento ( una “navicella” ) per esplorare, quella che noi chiamiamo la “galassia” della Logica Ternaria. Consta di due parti: una hardware e una software. Tutto ha preso le mosse dai miei post precedenti:
- appunti-logica-Ternaria
- monadic-and-diadic-ternary-logic-simulation-results
Come noto, nel sistema BINARIO tutte le funzioni logiche sono in totale:
- Monadiche: 2 ^ 2 = 4
- Diadiche: 2 ^ 4 = 16
Tra le quattro funzioni monadiche, solo una di esse dà vita ad una porta logica utilizzabile: il NOT e solo sei delle funzioni diadiche danno luogo a porte logiche elementari che possono essere utilizzati nella progettazione di schede logiche: AND, NAND, OR, NOR, XOR, XNOR.
Le cose, nel sistema TERNARIO, stanno così:
- Monadiche: 3 ^ 3 = 27.
- Diadicche: 3 ^ 9 = 19’683 (un numero incredibilmente alto)
Crediamo che nessuno si sia mai avventurato nell’esplorazione completa di un così grande numero di funzioni diadiche ( porte diadiche ), anche a causa della mancanza, ad oggi, di componenti in grado di operare su tre livelli. In questa galassia di componenti possibili, la maggior parte di essi, non hanno né un simbolo né un nome, quindi abbiamo deciso di creare due schede che possono essere interfacciate con Arduino o Raspberry e che consentono di esplorare, attraverso l’uso di un oscilloscopio:
- tutte le ventisette porte logiche ternarie con un ingresso ed una uscita;
- tutte le ventimila porte con due ingressi e una uscita.
Ciascuna delle due schede realizza una “singola porta logica ternaria universale programmabile”, ottenuta attraverso l’uso del componente DG403 che realizza un Mux 3: 1 per le monadiche e un Mux 9: 1 per le diadiche, oltre agli appropriati generatori di Trit (variabili ternarie). Programmando, di volta in volta, la tabella di verità dei Mux è possibile ottenere tutte le porte logiche sopra menzionate. Infine, programmando opportunamente i segnali Ternari di ingresso è possibile visualizzare e studiare le forme d’onda di uscita, dalle quali ottenere informazioni utili per un possibile utilizzo di esse nella progettazione futura di schede circuitali in logica ternaria.
La seconda figura mostra la mia scheda “All Ternary Monadic Functions Generator” collegata ad un Raspberry.
Questo progetto è nato nell’anno della fine della mia carriera ( 31 anni ) come professore di Informatica presso l’Istituto Tecnico settore Tecnologico “Ercolino Scalfaro” di Catanzaro e lo dedico a tutti i miei ex studenti ( migliaia? ) e a tutte le persone che mi hanno voluto bene e/o hanno collaborato con me ad ogni livello. Grazie di cuore a tutti!
Infine, una dedica particolare in memoria di quattro persone. Due bravissimi studenti che ci hanno lasciato prematuramente e due persone per me speciali:
- Rotundo Salvatore, appena laureato in ingegneria all’ università di Cosenza ;
- Gregorio Cosentino, gli mancava la sola discussione della tesi all’università di Pisa ( gli è stata assegnata la laurea postuma in Ingegneria );
- Luigi Rodomonte;
- Pino Rizzitano.
Raspberry Pi mini Plotter
I made a mini plotter:
- recycling some parts from t\wo DVDs and one floppy;
- designing a simple hardware interface for raspberry Pi ( I2C driver for stepper motors )
- writing some code in python to implemnt a G-code interpreter.
A short youtube video is here. Finally, asap, I’ll post some material about it.
Monadic and Diadic Ternary Logic Simulation Results
The following two documents are relative to the simulation obtained by writing some Scratch 2.0 Scripts ( comments are in Italian ).
Appunti Logica Ternaria
I computer del futuro prossimo abbandoneranno il sistema binario per quello ternario o quaternario? E’ altamente probabile. Quelli che seguono sono alcuni mie appunti sul tema, ispirati, per il sistema ternario, dalle recenti pubblicazioni del prof. D.W. Jones dell’Università dell’Iowa.
G3TR Transistor Tester on Arduino-DUE
This little work is in memory of a great man, who honored me with his friendship: Pino Rizzitano.
This is the Arduino-DUE version of my G3TR Transistor Tester that everyone can easily build (DIY). All components required, apart an Arduino-Due board, are just two 10K resistors and a microswitch. I’ve made two different versions of the software to experiment with the SAM3X8E hardware:
- In the first one I use the direct ARM processor registers manipulation. So, each register is accessed by an “unsigned long” pointer and I gain the complete control of ARM processor hardware registers ( using C language ): g3trDue.
- In the second one I use the software drivers provided by Atmel: g3trDriverDue .
Anyway, in both versions, the Arduino IDE is just used to compile and upload the sketch to the board.
Translate a Gray Code into Decimal ( weighted method )
To translate an n-bit bynary code into decimal we use the well known formula:
[bn-1…….b1b0(2) ](10) = bn-1*(2)n-1 + ……. + b1*(2)1 +b0*(2)0
where : (2)n-1 …….(2)1 (2)0 are called weights and bi is the i-th bit.
To convert an n-bit Gray Code into his decimal representation I modified the previous formula as follow:
[gn-1…….g1g0 (gray)](10) = bn-1*(2)n-1 + ……. + b1*(2)1 + b0*(2)0
where:
-
bi is the i-th calculated bit;
-
bn-1 = gn-1
-
bi= [bi+1 – gi](MOD2) or bi= [bi+1 + gi](MOD2) with 0 =< i <= n-2;
and:
-
[bi+1 – gi](MOD2) is the two-bit subtraction ignoring the borrow;
-
[bi+1+ gi](MOD2) is the two-bit addition ignoring the carry.
Two-bit subtraction MOD2 and two-bit addition MOD2 give same result bit !
Now I will explain the conversion of a Gray code into decimal with an example.
Consider the following four-bit Gray Code :
1011(gray)
We have: n = 4. The Gray bits, starting from msb, are:
g3 =1
g2 = 0
g1 = 1
g0 = 1
and the calculated bits are:
b3 = g3 = 1
b2 = [b3 – g2](MOD2) = [1-0](MOD2) = 1
b1= [b2 – g1](MOD2) = [1-1](MOD2) = 0
b0= [b1 – g0](MOD2) = [0-1](MOD2) = 1
so, applying these calculated bits in my formula, finally we have:
[1011(gray)](10) = 1*(2)3 + 1*(2)2 + 0*(2)1 + 1*(2)0 = 13(10)
This calculation makes use of the same binary system weights and therefore proves that an n-bit Gray Code ( not a Gray Code such as that we use to code the ten digits from 0 to 9 ) may be translated into decimal by means of the weighted method shown.
Gray Code, weighted or non-weighted: that is the question!

Gray code used for shaft angle encoding.
http://www.CliveMaxfield.com
To build the Gray Code we may use the mirror method, i.e. :
0 0 0
1 0 1
——- ==> ———— mirror line
1 1 1
0 1 0
A “mirror” represented by a line is placed below the two initial bits ( 0 and 1 ), giving rise to the reflection indicated. Thereafter above the mirror line we add “0” and below the mirror line we add “1”. The following is a 2D version of the two bits Code:
Using this figure we can easily build eight different 2-bits Gray Code: 00,01,11,10 – 01,11,10,00 – 11,10,00,01 – 10, 00,01,11 — 00,10,11,01 – 10,11,01,00 – 11,01,00,10 – 01,00,10,11. By iterating the riflective process allow us to extend the Gray Code representation. Here, I show two possible 3D version of 3-bits Gray Code. Note the two different colored paths: they give rise to sixteen possible different 3-bits Gray Code each! ( moving clockwise and counterclockwise ).
So, the sixteen representation for the standard four bits Gray Code are:
- 0000
- 0001
- 0011
- 0010
- 0110
- 0111
- 0101
- 0100
- 1100
- 1101
- 1111
- 1110
- 1010
- 1011
- 1001
- 1000
Some Gray Code features:
- Representation of successive word code differ one another in only a single bit.
- The last representation differ from the first one just for a single bit, so the code is cyclic ( see the 2D and 3D cubes shown above ).
If we need to use just ten representation to code decimal digit from 0 to 9, in Gray, we can estract two subset of Gray Code having both the features mentioned above.
Excess-3 Gray Code:
We extract the ten representations starting from previous “four bits word” N. 4:
Gray Dec
0010 0
0110 1
0111 2
0101 3
0100 4
1100 5
1101 6
1111 7
1110 8
1010 9
A code like this is clearly non-weighted ( the weight of second bit in the representation 0010 corrisponding to value 0 decimal should be zero and that is impossible !)
Second SubSet of Gray Code:
We can extract the first five representations and the last five representations to obtain such a code:
Gray Dec
0000 0
0001 1
0011 2
0010 3
0110 4
1110 5
1010 6
1011 7
1001 8
1000 9
A Code like this is non-weighted. See ” Fundamentals of Logic Design” – Sixty Edition – By Charles H Roth,Jr and Larry L Kynney.
In both last two cases, the argument that Gray is non-weighted is based only on the property that consecutive values differ in one bit position.
Gray Code as “weighted code”:
Given that I have not invented it, consider the four-bit gray code: b3, b2, b1, b0.
The weight of i-th bit is given by: (2 ^(i + 1)) – 1.
Thus, the weight of the bits b2, being i = 2, is: (2^3) – 1 = 7.
The weights for the four bits are then: 15, 7, 3, 1, starting from the MSB.
For the conversion into decimal of a binary Gray code is necessary to consider the sign toggling on weights of “ones” . The weight of “one” in the most significant position assumes the sign “+” and the weight of the next ‘”one” takes on the “-” sign and so on..
For example, the decimal conversion of the Gray code 1011 is:
+15 7 -3 +1 <—– weigths
1 0 1 1 (gray) ——> + 1 * (15) + 0 * (7) – 1* (3) + 1 * (1) = 13 (dec)
where in brackets are the weights.
Another example for a 5 bits Gray code:
+31 -15 7 3 +1 <—– weigths
1 1 0 0 1 (gray) ——> + 1 * (31) -1* (15) +1* (1) = 17 (dec)
Thas, just using bit weights, It is possible to write the following table:
Gray Dec
0000 0
0001 1
0010 3
0100 7
1000 15
and so on…
This Gray Code approach is totally different from the previous two. It apply to the Gray reflected ( simple mirror construction ) and It is valid for any number of bits. Finally, the book Fundamentals of Logic Design by Roth and Kenney states:
“In general, the decimal value of a coded digit cannot be computed by a simple formula when a non-weighted code is used.”
“simple formula” : this is certainly a subjective definition, based on each person’s opinion of what is simple.
Imho the Gray Code, as I showed, is a “weighted code”, if nothing else, at least in accordance with the “simple formula” approach.
To show the simple approach I am attaching:
My algorithm ( In Italian ) to translate a gray code in decimal based on weights.
My C program ( comments are in Italian ) to translate a gray code in decimal based on weights.
Note: in the document, at Brandeis University (USA), the Gray Code is defined as ” variable weighted code”, using an approach different of mine.
Acknowledgment: to Pete Sanderson for his opinions on weigthed and non-weigthed Gray Code sent to me recently via e-mail. I used, in this post, some of his considerations.
A Strange Tube Headphone Amplifier
This experiment was conducted thanks to the recycling of a Car Igntion Coil recovered from my student and the gift of a tube 12AX7 by – Jungleland – Bass Guitar Accessories by Giuseppe Ceglie – Via Indipendenza, 15 Catanzaro.
The amplifier makes use of a tube powered at low voltage ( from 40V to 60 V max for safety ) and a car ignition coil as output transformer ( impedance adapter ). The use of low voltage avoids the problems of security that you require usually when handling vacuum tubes. Typically a tube works with high voltage ( 200-250 V or more ). The result obtained is really interesting. Here is the schematic:
Versione in Italiano:
Uno strano Amplificatore per cuffia.
Questo semplice esperimento è stato realizzato riciclando:
- una bobina di accensione candela per auto recuperata da un mio studente;
- una valvola termoionica 12AX7 ( usata negli amplificatori valvolari per chitarra ) regalatami da Giuseppe Ceglie proprietario del negozio per strumenti misicali : Jungleland – Bass Guitar Accessories – Via Indipendenza, 15 Catanzaro.
L’ amplificatore fa uso di un tubo alimentato a basso voltaggio ( 40-60 Volt per motivi di sicurezza) e di una bobina per auto come trasformatore d’ uscita ( adattatore di impedenza ). L’ uso del basso voltaggio evita i problemi di sicurezza che si incontrano quando si lavora con le valvole termoioniche. Tipicamente i tubi lavorano con tensioni tra i 200-250V o anche superiori. Il risultato ottenuto è veramente interessante. E’ infatti possibile apprezzare il suono “caldo” degli amplificatori valvolari.
Audio Modulated TESLA Coil
A short yuotube video describes the first Tesla Coil assembled @ ITIS ” E. Scalfaro ” Catanzaro. Tanks to the work of Flavio Paone ( V Inf Sez A ) this interesting system has been assembled and tested. In the next school year we will work to design our Tesla Coil. Please Click Here to see it.
Versione Italiana in QR code:
Per leggere questo codice occorre:
- scaricare su un telefonino o un tablet, Android o IPhone, un QR Code Reader (in internet se ne trovano tanti gratis);
- lanciare il programma;
- puntare la telecamera del telefonino o del tablet sul codice;
- attendere qualche frazione di secondo per la decodifica del codice in testo.
Levitron Schematic
This is my version of a levitation circuit found surfing in internet. It is essentially an analog feedback system. The feedback signal is obtained by converting the magnetic field intensity near the electromagnet in a voltage by means of an hall sensor ( SS495 or SS496). My version of this circuit is based on the LM311D voltage comparator opamp. I used this circuit ( prototype ) to explain the feedback concept in the systems to my students ( V A INF a.s. 11/12). It uses an LED and a buzzer to monitor the electromagnet driving. This helps to locate the point where to put the magnet and/or metal object to levitate.
Here the post with video on the circuit test.
Transistor Tester G3TR on Arduino
Levitron First Step !
What follows is a brief video of the first Spartan experiment completed. At the moment, It was made with an electromagnet coil salvaged from an old 24 V contactor and a simple bolt. It was the first thing that happened to me underhand. The driving coil is monitored both visually and acoustically via an LED through a buzzer. The buzzer is switched off by a simple jumper. ASAP I’ll post the circuit diagram realized. Stay Tuned!
Levitazione Magnetica Primo Passo !
Quello che segue è un breve video del primo spartano esperimento portato a termine. Al momento, l’ elettrocalamita è stata realizzata con un avvolgimento recuperato da un vecchio teleruttore a 24V ed un semplice bullone. E’ stata la prima cosa che mi è capitata sottomano. L’ elettronica realizzata è da ritenersi, al momento, soddisfacente. Il pilotaggio della bobina viene monitorato sia visivamente tramite un led che acusticamente tramite un buzzer. Quest’ ultimo è disinseribile mediante un semplice ponticello. A breve pubblicherò lo schema elettrico realizzato. Stay tuned!
Levitron: Primo oggetto ITIS realizzato con stampante 3D.
Lo studente Giuseppe Ljioi ( 4 B meccanica ), ha sviluppato il disegno CAD di un Levitron ( circuito antigravità ) e gli amici fiorentini della KENT’S STRAPPER hanno realizzato per noi il prototipo in plastica con la loro stampante 3D. Stampante che loro avevano portato a Catanzaro nel nostro Istituto ( primi in Italia ! ) nel mese di Dicembre, grazie alla segnalazione del nostro studente Rizieri Mele ( 1 E ) che fa parte del team KENT’S STRAPPER. Tra noi ed il gruppo fiorentino sta per nascere una collaborazione per lo sviluppo di questo fantastico strumento open source che è la stampante 3D.
Bee LabSat ( satellite didattico ) va a ROMA
Il 12 Gennaio 2012, il satellite didattico progettato e realizzato nei laboratori dell’ ITIS “E. Scalfaro” Catanzaro parteciperà agli “Stati Generali dell’ Istruzione Tecnica e Professionale”, evento organizzato dal Ministero dell’ Istruzione che si terrà a Roma. Si tratta di una kermesse a livello nazionale che vedrà la presenza di tutte le Regioni italiane e, per ogni Regione, la presenza delle scuole che rappresentano l’eccellenza nel loro settore. Lo scopo principale degli Stati Generali è quello di mostrare le migliori esperienze didattiche realizzate dagli studenti provenienti da tutta Italia. Ogni regione avrà a disposizione un proprio spazio espositivo al Palazzetto dello Sport del Foro Italico di Roma. A noi tocca il compito di rappresentare l’ istruzione tecnica della Calabria. Oltre a “Bee LabSat” lo “Scalfaro” presenterà un plastico “Domotic House” di una casa moderna automatizzata ed il display a persistenza retinica “POV Display”.
Bee LabSat Video Clip: Bee LabSat
Di seguito la e-mail di commento alla video clip inviatami dalla dott.ssa Noca Muriel del centro spaziale dell’ Università di Losanna ( Svizzera):
“Thanks a lot!!
Your video is great!!
And this idea that you had in your lab is also awesome! Very inspiring!
Muriel.
———————————————-
Muriel Noca
Space Center EPFL
Tel: +41 21 693 69 42
———————————————”
Breve descrizione tecnica del Sistema Satellitare Didattico: Descrizione BEE LABSAT
Ultra Simple Electric Motor
Ancora più semplice rispetto a quello già pubblicato!
Tutto ciò che occorre per costruire questo semplicissimo motore elettrico è :
- una batteria ricaricabile ( 2700 mAh quella da me utilizzata );
- un piccolo magnete al neodymio ( campo magnetico elevato );
- due spille francesi;
- quattro spire di rame isolato per trasformatori;
- un elastico ( un pezzo di camera d’ aria per bicicletta quello da me utilizzato);
Very Simple Electric Motor
- tre magneti recuperati da un magnetron (vecchio forno a microonde ); ne bastano anche due;
- del filo di rame isolato;
- del nastro isolante;
- due ” spingole francesi”;
- un alimentatore per PC o delle batterie.
si realizza un bell’esperimento sul più semplice motore elettrico al mondo!
Isolare due magneti con del nastro isolante. Appoggiarvi le spille e fermarle sempre con del nastro isolante. Formare le quattro spire con del filo di rame isolato ( quello per trasformatori ) avvolgendole attorno ad una batteria del tipo AA. Carteggiare le estremità del filo che vanno ad infilarsi nelle spille per renderle conduttive. Collegare alla uscita 3.3 Volt di un vecchio alimentatore per PC (o le batterie) le due spille. Se all’ accensione il motore non gira, avviarlo manualmente ed il gioco è fatto.
Brava Milena!
A Milena Talarico, mia figlia, che attualmente sta svolgendo un Dottorato di Ricerca in Diritto del Lavoro presso l’ Università La Sapienza di Roma, è stato assegnato il premio Massimo D’Antona per la migliore tesi di laurea in diritto del Lavoro, messo a bando dal Ministero del Lavoro e delle Politiche Sociali. Il 4/ottobre/2011 il Ministro del Lavoro Maurizo Sacconi le ha consegnato il premio nella sala convegni INAIL di Roma.
Sul sito ufficiale della fondazione Massimo D’Antona sono state pubblicate la motivazione e le foto ufficiali della cerimonia. A breve verrà pubblicata la sua tesi.Successivamente la tesi verrà stampata sul secondo volume dedicato, dalla fondazione, alle tesi di laurea dei vincitori del premio.
Per vedere la cerimonia della premiazione clicca: video-premiazione .
Il satellite “Bee LabSat” sviluppato allo “Scalfaro” su CalabriaOra
Navigando su internet ho rintracciato l’articolo di CalabriaOra del 3/6/2011 che parla del satellite da laboratorio “Bee LabSat” progettato e sviluppato nell’ ITIS “E. Scalfaro” di Catanzaro. Per chi volesse leggerlo questo è il link: articolo .
Di seguito la copia della versione cartacea pubblicata da CalabriaOra.
GT_Arduino @ 8Mhz
Questo post si riferisce ad una mini ARDUINO, equipaggiata con un ATmega328P operante ad 8Mhz, realizzata velocemente con la tecnica wire-wrapp. Lo scopo è quello di illustrare ai miei studenti di informatica, nel prossimo anno scolastico, nell’ambito di Sistemi ed Automazione, la bellezza, semplicità e potenza dell’ambiente di sviluppo software, collegato alla piattaforma hardware ARDUINO, che gira su Windows, Mac e Linux. Lo schema realizzato è il seguente:
La tecnica wire-wrapp, in esperimenti come questo, risulta efficacissima. In breve tempo si riesce a costruire un prototipo da poter utilizzare senza dover passare per la fase di realizzazione di un circuito stampato. Le foto seguenti mostrano la scheda realizzata. L’ interfaccia USB viene presa in prestito dalla scheda Vx-propeller dalla quale è stato rimosso il processore.
L’ ultima foto mostra come utilizzare l’ interfaccia USB di un’ altra scheda ( in questo caso quella della VX-Propeller ) per poter scaricare gli sketch Arduino sulla mini scheda. Altri post illustreranno il test e l’ utilizzo della GT_Arduino.
Keyboard Morse Code Trainer/Sender on P8X32A
Completed version 1.0 of a program in SPIN language for the P8X32A on VX-Propeller hardware platform, of a Morse code trainer. A short video posted on YouTube shows how it works. Two “objects” (drivers) are assigned to two of the eight cogs (processors) to easily interface with a PS / 2 keyboard and a VGA monitor. The above picture shows the main menu. With F1 and F2, you can modify the transmission speed wpm. F5 and F6 allows you to change the frequency of the audible Morse tone. F9 allows you to turn on/off the tone. F10 allows to display or not the dots-dashes characters . F12 allows you to clean the screen. What was typed on the keyboard is automatically stored in a memory buffer. F11 allows to send the buffer. F3 allows to clear the buffer. F4 turn on/off the help menu. A P8X32A pin is dedicated to the connection with a CW transmitter.
Source file: GT_morseKeyer.spin (software comments are in Italian !)
Trasmettitore/Trainer Codice Morse sul P8X32A
Ultimata la versione 1.0 di un programma in linguaggio SPIN per il P8X32A, sulla piattaforma hardware VX-Propeller, di un Trasmettitore/Trainer per il codice Morse immesso da una tastiera PS/2. Un breve video postato su YOUTUBE ne illustra il funzionamento. Due “oggetti” ( o meglio driver ) vengono assegnati a due degli otto cogs ( processori ) per interfacciare agevolmente una tastiera PS/2 ed un monitor VGA. Nella foto è visibile il menù iniziale. F1 ed F2 consentono di variare la velocità di trasmissione wpm ( word per minute ). F5 ed F6 permettono di variare la frequenza del tono morse udibile. F9 consente di attivare o escludere il tono morse. F10 consente di visualizzare o meno i caratteri tratto e punto del codice. F12 permette di pulire lo schermo. Ciò che viene battuto sulla tastiera è automaticamente memorizzato in un buffer. F11 trasmette il buffer in memoria. F3 consente di cancellare il buffer. F4 attiva/disattiva il menù di help. Un pin del P8X32A viene dedicato al collegamento con un trasmettitore CW per l’ irradiazione via etere sulle frequenze dei radioamatori.
File Sorgente: GT_morseKeyer.spin ( I commenti al software sono in Italiano! )
POV 1.17 board’s balancing
In concomitanza con le 12’000 visite al blog pubblico questo articolo. Il bilanciamento statico o equilibraura della scheda del POV display è una operazione molto importante e va effettuata con la massima cura. Del resto ognuno di noi che guida un’ auto o una moto conosce, per averlo visto, il processo di equilibratura che effettua il gommista ogni volta che ripara o sostituisce un pneumatico. Un buon bilanciamento statico consente di contenere le vibrazioni ed il rumore che la scheda del display rotante trasmette alla struttura di sostegno ed a quella su cui viene poggiato o fissato. Per poter effettuare l’ operazione occorre procurarsi o autocostruirsi un equilibratore. In questo articolo viene descritto un tale dispositivo realizzato in maniera molto spartana con ciò che si ha a disposizione. L’ equilibratore utilizzato consta di:
- due pezzi di un profilato di alluminio a C ;
- un tubicino in alluminio di diametro 10mm;
- una barra filettata di diametro 8 mm divisa in quattro;
- un quadrato di plexiglass spesso;
- alcuni dadi e rondelle.
Le foto seguenti illustrano il procedimento empirico di equilibratura meglio di ogni descrizione. L’ attrezzo realizzato, seppur ancora imperfetto nel sistema di fissaggio della scheda al cilindretto metallico, si è dimostrato molto efficace. Cominciamo l’ equilibratura posizionando la scheda senza alcun contrappeso. Il risultato ottenuto è quello atteso:
Cominciamo ad aggiungere un conrtappeso al lato meno pesante ( quello in alto ):
Aumentiamo il contrappeso gradualmente fino all’equilibrio:
Quando la scheda è perfettamente orizzontale, utilizzando una bilancia pesiamo il contrappeso:
Determinato il peso, realizziamo dei contrappesi opportuni, in questo caso in ottone:
La scheda risulta perfettamente equilibrata se e solo se rimane stabile in qualunque posizione angolare la ruotiamo e fermiamo. Se la scheda rimane in equilibrio solo in posizione orizzontale ciò è da imputarsi al foro principale non perfettamente in asse.
Transistor Tester G3TR on PARALLAX propeller chip P8X32
G3TR utilizzando il propeller chip
Questa è la versione del Transistor Type Recognizer in linguaggio SPIN ( linguaggio ad alto livello pascal-Basic like ), che gira sulla VX-PROPELLER board. Una mini expansion board contenente due resistori smd ed un Botton Switch è tutto ciò che serve per realizzare il G3TR. Ovviamente, il P8X32 con i suoi 8 processori ( cogs ) a 32 bits è largamente sottoutilizzato per una applicazione come questa. Lo scopo è solo quello di introdurre, con un esempio concreto, bellezza e semplicità del linguaggio SPIN e potenza del microcontrollore stesso. Quest’ultimo con un quarzo di 5 Mhz grazie ad un circuito pll embedded lavora a 80Mhz! Utilizzando un “oggetto” ( driver ) che gira su di un cog dedicato, risulta semplicissimo interfacciare un display VGA standard in modalità testo per la visualizzazione dei messaggi di output. Al posto del monitor VGA, si sarebbe potuto utilizzare un display seriale , LCD o PC-Monitor, mediante l’ uso dell’ oggetto ( driver ) dedicato disponibile sul sito della PARALLAX. Il linguaggio SPIN, creato appositamente per questo microcontrollore 8-core, risulta, a parer mio, semplice da imparare. Per i blocchi di istruzioni, mancano i begin-end o le parentesi graffe di altri linguaggi, che vengono sostituite dall’ indentazione delle istruzioni guidata dall’ editor dedicato. Una particolarità del propeller chip : non gestisce alcun interrupt, ma usa 8 processori !
– ° –
POV 1.17 hardware tested!

f = 10 MHz ==> T = 1 / f = 0.1 μsec, is:
T32 = 0.1 * 32 = 3.2 μsec.
If the POV runs at 50Hz, it takes 20 msec to make a complete rotation. If the round is divided into 200 sectors, the display time of each sector is:
Ts = 20/200 = 100 μsec
and 3.2 μsec of these (actually a little more) are used to update the configuration shown.
L’ hardware del POV 1.17 è stato testato!
I primi test dell’ hardware del POV 1.17 sono stati condotti con esito positivo. Fin’ ora nessuna modifica si è resa necessaria. In particolare è stata verificata la funzionalità del trasferimento dati seriali tra l’ ATmega328 ed i due led driver a 16 bit via SPI alla velocità di 10 Mhz. Il tempo necessario al trasferimento dei 32 bit ( 32 LED ) relativi ad ogni configurazione, essendo:
f= 10 Mhz ==> T=1/f= 0.1 μsec , vale:
T32=0.1 * 32 = 3.2 μsec.
Se il POV gira a 50Hz impiega 20 msec per effettuare una rotazione completa. Se il giro viene suddiviso in 200 settori, il tempo di visualizzazione di ogni settore vale:
Ts=20/200 = 100 μsec
e di questi 3.2 μsec ( in realtà qualcosa in più ) vengono utilizzati per aggiornare la configurazione visualizzata.
G3TR sul sito Americano della Texas Instruments
Il mio progetto G3TR ( Riconoscitore automatico del Tipo di un Transistor ) è stato pubblicato sul sito della Texas Instruments ( colosso mondiale dei componenti elettronici e non solo.. ) nella sezione progetti del sistema MSP430 LaunchPad: TI E2E Community.
Il satellite ITIS “Bee LabSat” al Gutemberg 2011
Calabria Ora del 26/05/2011 a pagina 22 ha pubblicato un articolo nel quale dà conto della partecipazione al Gutemberg 2011 dell’ ITIS “E. Scalfaro” Catanzaro con il satellite da laboratorio progettato , sviluppato e modificato nei corsi pomeridiani di eccellenza dagli alunni delle quinte classi della sezione Informatica e Telecomunicazioni: “ITIS EDUSAT 2010” e “ITIS EDUSAT 2011”.
Nella foto da sinistra a destra: Cristian Mustaro, Samuele Rotundo, Gabriel Gabriele, Stefano Piterà Quattromani, prof. Giuseppe Talarico, prof. Salvatore Lopes.
Al centro della foto è visibile la stazione ricevente satellitare, mentre in alto a destra si nota il “lato pannello solare” del nostro satellite “Bee LabSat“.
Di seguito la copia cartacea dell’artcicolo pubblicato da CalabriaOra.
Arrivati dalla CINA gli stampati del POV 1.17.
La qualità delle piastre arrivate è veramente di alto livello. Spettacolari le finiture in oro. I ragazzi partecipanti al corso pomeridiano di eccellenza “ITIS-EDUSAT 2” hanno visto il loro lavoro grafico sui computer materializzarsi in qualcosa di professionale. L’ adrenalina tra gli studenti è al massimo, tant’è che è subito iniziata la fase di montaggio a partire dalla verifica di continuità elettrica delle piste. I primi componenti ad essere stati montati sono stati i led smd con l’ ausilio di un microscopio digitale come documentato nelle foto seguenti.
G3TR for MSP430 launchpad
G3TR means: Giuseppe Talarico Transistor Type Recognizer.
The test result for the smd transistor in figure (coming from an old graphic board), on a serial terminal with 9600,8,N,1, shows:
G3TR> NPN BJT
The required additional hardware is very simple: just two 10K resistors. A serial terminal (PC or LCD) is needed to show the test result. It allows to identify the type of a transistor. The transistors that can be tested are: pnp or npn bjt; n-channel or p-channel mosfet;low,medium or high power. It also allows you to test any type of diode locating the external terminal connected to anode. G3TR allows to identify devices (transistor or diode) shorted or broken. The idea that allowed me to make the G3TR is shown in the following figure:
The circuit: G3TR TRANSISTOR TYPE RECOGNIZER
Source files: g3tr.c tx_uart_libc.h tx_uart_libc.c
The following is the G3TR graphic processing by students Gabriel Gabriele and Samuele Rotundo.
Waiting for POV boards……
Waiting for the circuit board of POV 1.17 I show the graphic processing of POV 1.18 and POV 2.2 (Two Side POV) with two TLC5940 and one TLC5916.
In attesa dell’ arrivo dei ciruiti stampati del POV 1.17 pubblico l’ elaborazione del POV 1.18 e del POV 2.2 ( Two Side POV ) ad opera dello studente Cristian Mustaro ( V Informatica ).
LaunchPad MSP430
Alcuni semplici esempi di programmi in C per i microcontrollori MSP430 a bassissimo consumo della Texas Instruments che girano sulla interessante piattaforma di sviluppo denominata “LaunchPad” .
POV 2.0: Il Led Controller TLC5940 in breve
Questo chip prodotto dalla Texas Instruments, che ci ha gentilmente inviato alcuni “samples”, viene adoperato nel POV 2.0. Si tratta di un integrato capace di pilotare 16 LED e che permette di regolare la luminosità di ogni LED con 4096 livelli di intensità differenti. Il TLC5940 si interfaccia ad un µcontrollore via SPI (Serial Peripheral Interface).
Le sue Modalità di Funzionamento
Il TCL5940 ha tre modi di funzionamento:
- Grayscale PWM Mode.
- Dot Correction Data Input Mode.
- EEPROM Programming Mode.
Di seguito si prende in esame il funzionamento in sola modalità GrayScale.
La Regolazione della Luminosità (Grayscale PWM Mode)
In questa modalità, come detto, è possibile impostare la luminosità di ognuno dei 16 led connessi al chip. Per programmare l’ intensità luminosa dei 16 led occorre inviare al chip un blocco dati di 192 bit.
IL Blocco Dati (192-bit Data Block)
Il blocco di dati seguente contiene tutte le informazioni necessarie per programmare la luminosità di tutti e 16 i LED ( canali ) contemporaneamente.
Il blocco dati da 192 bit è suddiviso in 16 blocchi da 12 bit cadauno. Ognuno dei blocchi da 12 bit consente di inviare un numero compreso tra 0 e 4095, per determinare, all’ interno del chip la regolazione della luminosità di ogni LED con la tecnica PWM (modulazione a larghezza di impulso). I 16 blocchi sono ordinati da OUT15 a OUT0.
Ogni blocco viene inviato al TLC5940 a partire dal bit più significativo (MSB first or big endian).
Il valore decimale 500 corrisponde:
- in esadecimale a: 1 F 4
- in binario a: 0001 1111 0100.
Per inviare a tutti i 16 LED lo stesso valore di luminosità pari a 500, occorre trasmettere il seguente data block composto da 24 byte = 24*8 bit=192 bit:
0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4
0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4, 0x1F, 0x41, 0xF4
Invece, il pattern seguente, composto da 16 parole di 12 bit ognuna, può essre usato in fase di test per accendere i 16 LED ( canali ) collegati al TLC5940 con intensità dimezzata da un led all’ altro (i canali 13,14,15 risultano spenti):
// MSB LSB
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 15 (0)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 14 (0)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 13 (0)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // Canale 12 (1)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, // Canale 11 (2)
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, // Canale 10 (4)
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, // Canale 9 (8)
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, // Canale 8 (16)
0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, // Canale 7 (32)
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // Canale 6 (64)
0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, // Canale 5 (128)
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 4 (256)
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 3 (512)
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 2 (1024)
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // Canale 1 ( 2048)
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1. // Canale 0 (4095) luminoità max
Lo stesso pattern sotto forma di 24 byte idoneo per essere inviato via SPI:
0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000000, 0b00000001, 0b00000000, 0b00100000, 0b00000100, 0b00000000, 0b10000000, 0b00010000, 0b00000010, 0b00000000, 0b01000000, 0b00001000, 0b00000001, 0b00000000, 0b00100000, 0b00000100, 0b00000000, 0b10000000, 0b00001111, 0b11111111.
Come Inviare il Data Block tramite l’ interfaccia SPI del µControllore
Il data block, una volta che è stato organizzato nel formato spiegato, è pronto per essere spedito al TLC5940 attraverso l’ interfaccia SPI. Al pin SCLK va connessa l’ uscita del clock SPI del µcontrollore. Il pin GSCLK può essere connesso al pin SCLK o ad un pin a parte del µcontrollore. Al pin SIN va invece collegata l’ uscita MOSI ( Master Out Slave In ) del µcontrollore. Per il suo funzionamento il TL5940 richiede altri due pin che non fanno parte dell’ interfaccia SPI e sono indicati come: BLANK e XLAT. Il pin BLANK controlla l’ accensione di tutti i LED. Il pin XLAT funge da impulso di scrittura del data block nel latch interno del TLC5940. I pin DCPRG e VPRG vanno connessi a massa se non si intende usare le altre due modalità di funzionamento possibili del TLC 5940.
Il data block deve essere inviato al chip seguendo i 6 passi seguenti:
- Settare BLANK
- Inviare l’ intero data block via SPI
- Resettare BLANK
- Settare XLAT
- Generare un ritardo di almeno 2us
- Resettare XLAT
Per ulteriori dettagli sulle modalità, timing, dasy chaining e quant’ altro va consultato il data-sheet del TLC5940.
Per la corretta programmazione del chip consultare anche il TLC5940 Programming Flow Chart messo a disposizione dalla TI.
POV ( propeller Clock 2.0 ) Schematic
In conjunction with the 5000 visits to my blog, I public the preliminary schematic of the new pov rotating display under development with my students at ITT of Catanaro Italy.
In concomitanza con i 5000 contatti al mio blog, pubblico lo schema preliminare della versione 2.0 del pov display che si sta sviluppando con gli studenti presso l’ ITT ( Istituto Tecnico Tecnologico ex ITIS ) di Catanzaro.
POV ( propeller clock ) 1.0 schematic
The prototype’s schematic is shown in the project site. The schematic is based on the microcontroller Atmega328 ( like Arduino) and the LED driver TLC 5916 from Texas Instruments.
Sul sito del progetto si trova lo schema del prototipo nella sua versione 1.0. Tale schema prevede l’ uso di un microcontroller ATmega328 (quello dell’ Arduino ) e del LED driver TLC 5916 della Texas Instruments.
POV display prototype 2 Vers. 0.1
POV rotating display V 0.1 Schematic
The prototype’s schematic is shown in the project site.
Sul sito del progetto si trova lo schema del prototipo nella sua versione 0.1.
You must be logged in to post a comment.