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

• Monadic Ternary Operators Simulation
• Diadic Ternary Operators Simulation

Appunti Logica Ternaria

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.

• sistema di numerazione eptaventesimale
• aritmetica nel sistema ternario bilanciato
• logica ternaria: funzioni monadiche
• logica ternaria: funzioni diadiche

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.

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:

[b_n-1…….b₁b₀₍₂₎ ]₍₁₀₎ = b_n-1*(2)^n-1 + ……. + b₁*(2)¹ +b₀*(2)⁰

where : (2)^n-1 …….(2)¹ (2)⁰ are called weights and b_i is the i-th bit.

To convert an n-bit Gray Code into his decimal representation I modified the previous formula as follow:

[g_n-1…….g₁g_{0 (gray)}]₍₁₀₎ = b_n-1*(2)^n-1 + ……. + b₁*(2)¹ + b₀*(2)⁰

where:

• b_i is the i-th calculated bit;

• b_n-1 = g_n-1

• b_i= [b_i+1 – g_i]_(MOD2) or b_i= [b_i+1 + g_i]_(MOD2) with 0 =< i <= n-2;

and:

• [b_i+1 – g_i]_(MOD2) is the two-bit subtraction ignoring the borrow;

• [b_i+1+ g_i]_(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:

b₃ = g₃ = 1

b₂ = [b₃ – g₂]_(MOD2) = [1-0]_(MOD2) = 1

b₁= [b₂ – g₁]_(MOD2) = [1-1]_(MOD2) = 0

b₀= [b₁ – g₀]_(MOD2) = [0-1]_(MOD2) = 1

so, applying these calculated bits in my formula, finally we have:

[1011_(gray)]₍₁₀₎ = 1*(2)³ + 1*(2)² + 0*(2)¹ + 1*(2)⁰ = 13₍₁₀₎

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:

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

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

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

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.

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

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

• leds.c
• blink_interrupt.c
• pwm_led.c
• blink_led_macro
• blink_timer_no_interrupt

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

This photo shows the prototype No 2 of version 0.1 which uses high brightness LEDs.

;

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.

POV rotating display ( propeller clock )

 

In conjunction with the 3000 visits to my blog, I public some photos of the propeller pov prototype. This is the version 0.1! It is just a preliminary study. The microcontroller used is the ATmega8. The software was developed in C using ubuntu and eclipse. From this stage, me and my students will work  in the next afternoon course  (early 2011), for developping a beautiful propeller clock (possibly a 3D version)! If you want you can visit the site dedicated to the project: pov display!

In concomitanza con le 3000 visite al mio blog, pubblico le foto del primo prototipo di pov propeller. Si tratta della versione 0.1! E’ giusto uno studio di fattibilità. Il  microcontrollore usato è l’ ATmega8. Il software è stato sviluppato in C mediante eclipse ed ubuntu. A partire da questo stadio si lavorerà con gli studenti, nel prossimo corso pomeridiano di eccellenza ( inizi 2011 ), per la realizzazione di un bel propeller clock (possibilmente una versione 3D ) ! Se vuoi puoi visitare il sito dedicato al progetto: pov display!

 

primo prototipo di pov con ATmega8

eppur si muove !

... un altro frame !

3-Phase Generator 2.0 ( more Power !)

An old laser BLDC motor has been modified to become the generator of the propeller clock. The test performed with a small incandescent lamp is very promising. If you want you can see the video of the generator test. Strange and interesting is the  Lissajoux effect visible in the movie! Here are some photos.

Un motore BLDC di una vecchia Laser è stato modificato per diventare il generatore del propeller clock. Il test effettuato con una piccola lampada ad incandescenza è molto promettente. Il video del test si trova nella sezione ( i miei video ) . Strano ed interessante è l’ effetto Lissajoux visibile nel filmato ! Seguono alcune foto.

 

Propeller Clock: motore e generatore

Un motore in continua a 24 V recuperato da una vecchia stampante viene utilizzato per far girare la scheda  del propeller clock. Un secondo motore del tipo BLDC recuperato da un vecchio floppy driver viene utilizzato per generare la tensione necessaria ad alimentare l’ elettronica del propeller clock. Nel funzionamento da generatore per propeller clock vengono scambiate le funzioni tra rotore e statore, nel senso che  il magnete circolare diventa lo statore e le bobine diventano il rotore. Il motore HDLC utilizzato nell’ esperimento, consente di realizzare un generatore di tensione alternata trifase. Il convertitore da trifase a c.c. verrà realizzato sulla scheda del propeller clock. A questo livello, il sistema realizzato può essere considerato come la versione in scala ridotta di una parte del mio  progetto  Family Eolic Station ( Stazione Eolica Familiare ) il cui video youtube è visibile cliccando Qui.

Statore del generatore:Il magnete circolare. Rotore:le bobine

generatore e motore assemblati su un pezzo di plexiglass di recupero

Il plexiglass fissato su una base in ferro. Notare la lavorazione della ghiera per il fissaggio della scheda.

Tre LED per verificare la generazione di corrente alternata del sistema Motore-Generatore

Kaleido-HDD

Si tratta di un esperimento per verificare la generazione di una tensione di alimentazione da utilizzare su di una scheda rotante.

Si inquadra nelle  prove propedeutiche necessarie per lo sviluppo di un Propeller Clock. Per questo test vengono  utilizzati:

• un vecchio hard disk con il motorino HLDC e la sua scheda di controllo funzionanti;
• quattro  magneti recuperati da altrettanti vecchi hard disk;
• due bobine (coils ) recuperate da un motore elettrico di un vecchio videoregistratore (VCR);
• Alcuni Led di varia forma e dimensioni;

 

My Plasma Speaker Schematic

More photos at flickr .

Here is my plasma speaker schematic version 1.0.

The plasma speaker:

• is made  with  recycled materials
• is beautiful to show to family and friends
• is dangerous for the voltages at the transformer secondary!
• is not to try to make it if you don’t have  technical knowledge to work with 20,000 volts!!
• develop a lot  of heat
• has  a power audio /  power consumption very low
• in my diagram, thanks to the POWER MOSFET IRF 9540, so far, has proved to be robust and highly reliable.

To make it work you have to connect the  computer audio output or an iPod output to its input.

Lo schema del mio Plasma Speaker

Qui di seguito pubblico lo schema del mio plasma speaker versione 1.0.

Il plasma speaker:

• è semplice da realizzare
• lo si realizza con materiali riciclati
• è bello da far vedere a parenti ed amici
• è PERICOLOSO per le tensioni presenti al secondario del trasformatore !!
• è da non realizzare senza le conoscenze tecniche per lavorare con 20’000 Volt !!!!
• sviluppa parecchio calore
• ha un rapporto potenza audio/potenza assorbita basso

Lo schema da me realizzato, con l’ impiego del POWER MOSFET IRF 9540, finora si è dimostrato robusto ed altamente affidabile. Per farlo funzionare collegare l’ uscita audio di un computer o di un ipod al relativo ingresso.

Pasma Speaker Schematic

Note sul capacimetro dell’ LC-METER con 555 Monostabile

Misura Capacità con 555 in modalità Monostabile.

La misura della capacità si basa sulla misura della durata dell’impulso ( pulse duration ) prodotto dal  Timer 555 in configurazione monostabile. T=1.1*R*Cx da cui Cx=T/1.1*R; dove T e’ la durata dell’ impulso di uscita generato dal 555 ed R e’ la resistenza di carica del condensatore incognito Cx. Nella misura della frequenza con LM311, la base tempi ( gate time ) e’ fissa e vengono contati il numero di fronti dell’ onda quadra prodotta dall’ LM311 durante il gate time. Qui, al contrario, è fissa la frequenza degli impulsi di clock contati, mentre la durata  dell’ impulso generato dal 555, che corrisponde al gate time, e’ variabile e dipende dalla capacita’ del condensatore sotto misura, infatti, essendo R costante, si ha: T=1.1*R*Cx.

pin Atmega32              pin 555:
37  PA3 (output) —> Trigger   2

20  PD6 (ICP1)   <—- Out          3

Note sul Frequenzimetro dell’ LC-METER con LM311

 

 

Al valore di Cx ( Lx ) si arriva attraverso una misura di frequenza. La frequenza si ottiene contando il numero di oscillazioni (periodi) dell’ onda quadra (vedi LM 311 nello schema) in un intervallo di tempo prestabilito   detto “base dei tempi”  ( gate time).

Del microcontrollore ATmega32 vengono usati:

- Timer/Counter2 come TIMER per generare la base dei tempi (in questo caso 32.77 msec)

- Timer/Counter1 come COUNTER per contare il numero di oscillazioni complete ( numero  di fronti di salita dell’ onda quadra presente su PB1 dell’ ATmega32 ) all’ interno  della finestra temporale stabilita dal TIMER ( gate time ).  La frequenza viene calcolata accumulando i conteggi delle oscillazioni di n misure  (ogni misura dura 32.77 msec) e dividendo poi per la durata della finestra temporale  effettiva ( total  gate time ).

Fx = numero oscillazioni totali/durata gatetime

Fx= num. oscill. totali /( n * 32.77 msec).

Fx(max) = 1Mhz

Tx(min) = 1/Fx(max) =1/1000000= 1 usec

Numero max conteggi Counter/Timer1 ( contatore a 16 bit) = 65’535

Durata  conteggio max Counter/Timer1 = 65535  1 usec = 65.5 msec

Essendo:

- T=1/FREQ_CPU = 1/8’000’000 = 125 usec

- TIMER/COUNTER2 un contatore ad 8 bit ( conteggio max =256 fronti dell’onda quadra)   si ha:

Base Tempi = numero fronti salita del clock * fattore prescaler * periodo clock   Base Tempi = 256*1024*T =256*1024*125usec= 32.77 msec.

per cui:

(durata Base Tempi) < ( durata conteggio max Counter/Timer1)

e   quindi Counter1 non puo’ mai andare in overflow se Fx(max) <= 1 Mhz!

Calcoli per la determinazione del valore Cx ( riferirsi allo schema ):

1)  per il parallelo L//C        si ha:     f1 =  1/ 2 pi sqrt(LC)

2)  per il parallelo L//(C+Ccal) si ha:     fcal =1/ 2 pi sqrt(L(C+Ccal))

3)  per il parallelo L//(C+Cx)   si ha:     f3 =  1/ 2 pi sqrt(L(C+Cx))

e quindi:

4) f1/fcal = (1/ 2 pi sqrt(LC))/(1/ 2 pi sqrt(L(C+Ccal)))

5) (f1/fcal)^2 = (C+Ccal)/C = 1+Ccal/C

da cui:

6) Ccal/C =(f1/fcal)^2-1 = b

analogamente:

7) (f1/f3)^2 = (C+Cx)/C = 1+Cx/C

da cui:

Cx/C =(f1/f3)^2-1 = a

(Ccal/C)/(Cx/C)= b/a

infine:

Cx = Ccal * b/a

 

FLC-METER schematic

While waiting for my students transform them in eagle form, here’s the manual version of the three files relating to the scheme of my FLC meter. If you are interested in seeing it in action, click here (youtube video). The microcontroller used is an ATmega32. The software was developed in C using avr eclipse under ubuntu linux. MS1, … are microrelays by Gunter. The measurement of capacity, for educational purposes, is implemented in three ways, as you can imagine from the schematic. The same circuit is used to make a voltmeter in order to demonstrate the use of  internal ADC of the ATmega32. The display does not appear explicitly in the diagram, is a vulgar two lines of 16 alphanumeric characters / line used in 4 bit mode.

In attesa che i miei alunni li trasformino in formato eagle, qui trovi la versione manuale dei tre file relativi allo schema del mio Frequenzimetro – Induttanzimetro  – Capacimetro. Se ti interessa vederlo in azione, clicca qui ( video youtube) . Il microcontrollore adoperato è l’ ATmega32. Il software è stato sviluppato in C usando eclipse avr sotto linux ubuntu. MS1, … sono dei microrelè della Gunter . La misura della capacità, a fini didattici, viene realizzata in tre modi, come si intuisce dallo schema elettrico. Lo stesso circuito viene utilizzato per realizzare un voltmetro, al fine di dimostrare l” uso dell’ ADC interno all’ ATmega32. Il display, non visualizzato espressamente nello schema, è un volgare alfanumerico a due righe da 16 caratteri/riga utilizzato nella modalità 4 bit.