Bee LabSat – Maker Faire – Roma 2019

Bee LabSat - Sistema Satellitare Didattico

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.

Risultati immagini per logo maker faire roma 2019

Bee LabSat: Maker Faire Roma 2019

“Ternary Spacecraft” @ DIGITHON

Dalla email di digithON:

startup.jpg

“…. 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.”

StartUp: Ternary SpaceCraft

 

Travel Game meets Ternary Logic

   LOGO-TG2-300x180

Italy-Flag-2   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

 

255px-Flag_of_Great_Britain_(1707–1800).svg  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.

wicontestLogo

Ternary Logic: a “spacecraft” to explore it.

Con valori giusti lower255px-Flag_of_Great_Britain_(1707–1800).svg  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.

 

IMG-20180712-WA0002

“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.

Italy-Flag-2  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.

Appunti Logica Ternaria

primo esperimento in ternario: Arduino trit generator

Primo esperimento Logica Ternaria: Arduino “trit” Generator

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.

Rizzitano_by_Caroleo

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.

G3TR Transistor Tester

G3TR Transistor Tester

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. Thanks to Clive Maxfield ( www.CliveMaxfield.com ) for allowing me to use his image.

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:

gray2D

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 ).


gray3D-1

gray3D-2

So, the sixteen representation for the standard four bits Gray Code are:

  1. 0000
  2. 0001
  3. 0011
  4. 0010
  5. 0110
  6. 0111
  7. 0101
  8. 0100
  9. 1100
  10. 1101
  11. 1111
  12. 1110
  13. 1010
  14. 1011
  15. 1001
  16. 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

DSC_4596

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:

Tube Headphone Amplifier

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 is the circuit: 

 

Here the post with video on the circuit test.

Transistor Tester G3TR on Arduino

This is the DIY Transistor Type Recognizer  Arduino version. An  expansion board that contains two resistors and a button switch is what you need to build the G3TR ( I used the same expansion board realized for the propeller chip P8X32A ). Just only  two 10K resistors and a serial terminal program are needed to implement a simple and powerfull digital Transistor Tester .The circuit allows to test any type of transistor ( npn,pnp, n-channel, p-channel ) both low or High Power. The program tell us if the transistor under test is working or not and which is his type for example: NPN-BJT, PNP-BJT, NCHANNEL-MOSFET, PCHANNEL-MOSFET. The program test diode too and tell us where the Anode is attached ( RED CABLE or BLACK CABLE). Devices broken or shorted are decoded too.
The Arduino source file with schematic is: g3trArduino

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

Utilizzando:

  • 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 .

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

This is the Transistor Type Recognizer   in SPIN language (high level language  Pascal-Basic like), which runs on the board VX-PROPELLER. An  expansion board that contains two resistors and a button switch is what you need to build the G3TR. Obviously, the P8X32 with his eight 32-bits processors (cogs) is largely under-utilized for an application like this. My purpose is only to introduce, with a concrete example, beauty and simplicity of  SPIN language and power of the microcontroller  too. The latter with a 5 MHz quartz and a PLL embedded  it works at 80MHz! Using an “object” (drivers) that run on a dedicated cog, it is simple to  interface standard VGA display  for output messages pourpose. In place of the VGA monitor, you could use a serial display, LCD or PC monitor, using the objects (drivers) available for free on the dedicated website of Parallax. The SPIN language , created especially for this 8-core microcontroller, is, in my opinion, easy to learn. The SPIN has not begin-end  or braces for block of instructions.The guided dedicated editor allows to  compensate for this lack. A particularity of the Propeller chip : it does not handle any interrupts, but it has 8 cogs to do this job!

Source in SPIN language: g3tr_vga.spin.  Here is the circuit:

G3TR in action:

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!




The   POV 1.17 hardware has been successfully tested. Until now no change was necessary. In particular, we verified the functionality of the serial data transfer between the Atmega328 and  two 16-bit led drivers via SPI at 10 MHz. The time required to transfer 32 bits (32 LEDs) for each configuration, as:

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.


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

Some simple examples of C programs for the MSP430 ultra-low power microcontrollers from Texas Instruments running on the  “LaunchPad”.

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” .

calibrazione routine delay_ms()

POV 2.0: Il Led Controller TLC5940 in breve

16-Channel LED Driver w/EEprom DOT Correction & Grayscale PWM Control - TLC5940

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.