La Pascalina La Pascalina

La Pascalina
di
Ricchi Luca, Giampaoli Marco
rivista da
Stefano Cacciaguerra Ph. D. in Informatica
Indice
Introduzione ........................................................................................................................................ 3
Specifiche iniziali................................................................................................................................. 3
Sviluppo del progetto .......................................................................................................................... 4
Funzionalità della Pascalina ............................................................................................................ 5
Script .................................................................................................................................................. 8
Conclusioni ....................................................................................................................................... 15
2
Introduzione
Lo svolgimento di questo elaborato consiste nella progettazione e nella realizzazione di
una particolare macchina, presentata durante il corso di Storia e Didattica dell’Informatica,
precisamente la “Pascalina”.
La “Pascalina” è la precorritrice della moderna calcolatrice.
Essa è stata inventata nel 1642 dal filosofo e matematico francese Blaise Pascal ed è una
macchina che permette di addizionare e sottrarre, tenendo però conto del riporto.
Per molto tempo è stata considerata la prima calcolatrice meccanica inventata, anche se
questo merito andrebbe alla calcolatrice di Wilhelm Schickard.
La sua notorietà fu amplificata dall'accurata descrizione contenuta nell'Encyclopédie, che
la rese il punto di riferimento per la realizzazione molte calcolatrici successive.
Della “Pascalina” furono costruiti una cinquantina di esemplari per operazioni sia in base
decimale che nell'unità monetaria dell'epoca.
In particolare, il primo esemplare fu costruito da Pascal per aiutare il padre, funzionario
delle imposte, a gestire la propria contabilità e, quindi, a lavorare in lire.
La nostra realizzazione della suddetta macchina nella sua versione decimale e non
finanziaria, è da destinarsi alla realtà virtuale di Second Life, che permette ad ogni utente
registrato di sviluppare un qualsiasi oggetto tridimensionale, la sua relativa interazione con
un ipotetico avatar tramite un particolare linguaggio di scripting ed il suo salvataggio nel
proprio inventario a disposizione di utilizzi e future modifiche.
Specifiche iniziali
La macchina si presenta come un parallelepipedo di ottone (Fig. 1).
Su una superficie laterale di questo parallelepipedo sono applicate sei ruote dentate
collegate ad ingranaggi interni alla scatola.
Figura 1: la Pascalina
3
Ogni ruota rappresenta in maniera incrementale da destra verso sinistra la
rappresentazione di una cifra di un numero:
avremo dunque all’estrema destra le unità, successivamente le decine e così via fino alle
centinaia di migliaia per la sesta ruota a sinistra della visione frontale.
Ogni ruota è dotata di una numerazione statica, rappresentata da un cerchio esterno più
grande e da una dinamica con un cerchio interno, entrambe numerate da 0 a 9.
Con il termine “dinamica” si intende il fatto che i numeri si muovano insieme alla ruota e
cambino dunque la loro orientazione rispetto allo spettatore.
Nella parte superiore alle ruote troviamo le sei fessure corrispondenti.
Esse indicano il valore che ha assunto la relativa ruota fino a quel momento, durante i
calcoli.
Muovendo la barra sottostante le sei fessure, verso l’alto, copriamo quest’ultime per
scoprirne altrettante.
Nel caso in cui si desideri effettuare un’addizione, useremo solo gli indici della riga
superiore, mentre per la sottrazione saranno necessario entrambe le righe, usate
naturalmente una alla volta.
Il totale delle dodici fessure scoprono i valori di sei rulli cartacei.
Ogni rullo srotolato (Fig. 2), si presenta in questo modo:
Figura 2: il rullo cartaceo srotolato
Sviluppo del progetto
Per la realizzazione del progetto è stato necessario procedere suddividendo lo sviluppo in
due fasi.
La prima fase, ovvero la realizzazione grafica, è risultata essere la parte più semplice
considerando il basso numero di primitive necessarie ad elaborare la struttura della
macchina da visualizzare; tuttavia questa netta separazione tra grafica e fase di scripting,
col senno di poi, non è risultata essere la migliore delle scelte: abbiamo riscontrato infatti
uno stretto legame di realizzazione tra primitive e script; quest’ultimo dipende fortemente
dal modo in cui vengono realizzate le prims e può anche capitare di complicare troppo la
grafica per poi non riuscire a lavorare agevolmente con il codice di interazione.
La seconda fase, ovvero quella di scripting, ha richiesto la comprensione di un linguaggio
mai visto prima, ma con una sintassi molto simile a quella del C Ansi e perciò facilmente
affrontabile.
Questa fase sviluppa le funzionalità e l’interazione con l’avatar, fondamentale a
dinamicizzare un oggetto che altrimenti sarebbe inutilizzabile. Nel successivo paragrafo
approfondiremo le suddette funzionalità per poi passare al dettaglio dello script.
4
Funzionalità della Pascalina
Tramite questa macchina è possibile eseguire le operazione aritmetiche di addizione,
sottrazione e moltiplicazione.
Premettiamo che ogni ruota fino alla penultima a sinistra, ovvero quella delle decine di
migliaia compresa, al termine di ogni giro completo segnala il riporto, tramite ingranaggi,
alla ruota successiva che effettua uno scatto in senso orario memorizzando il valore.
Supponiamo di voler sommare 12 e 28:
ci limiteremo a rappresentare i due numeri tramite le ruote dentate.
Opereremo dunque nel seguente modo:
1. ruota di 1 scatto le decine
2. ruota di 2 scatti le unità
Figura 3: stato della Pascalina dopo il passo 2.
3. ruota di 2 scatti le decine
Figura 4: stato della Pascalina dopo il passo 3.
5
4. ruota di 8 scatti le unità
Da notare il fatto che alla fine del passo 4. la ruota delle unità avrà compiuto un giro
completo e dunque segnalerà il riporto alla ruota della decine, la quale aggiungerà uno
scatto.Naturalmente alla fine del passo 4. i rulli cartacei mostreranno nelle fessure della
riga superiore i numeri (Fig. 5):
Figura 5: stato della Pascalina dopo il passo 4.
Prima di passare alla seconda operazione è necessario azzerare la macchina. Per
mantenere un maggiore realismo di utilizzo abbiamo pensato di non implementare un
pulsante di “reset” ma bensì di lasciare l’azzeramento manuale della Pascalina vera e
propria.
La procedura di azzeramento consiste nei seguenti passi:
1. assegna ad ogni ruota gli scatti mancanti ad arrivare a 9 per arrivare ad avere la
seguente situazione (Fig. 6):
Figura 6: stato della Pascalina dopo il passo 1.
6
2. ruota di uno scatto la ruota delle unità
In questo modo dopo il passo 1 avremo un nove in ogni fessura superiore e
successivamente effettuando un ulteriore scatto alle unità trasmetteremo un riporto che
per un effetto a catena si trascinerà fino alla sesta ruota a sinistra, azzerando la macchina.
Siamo ora pronti ad effettuare la sottrazione.
Eseguiamo ad esempio l’operazione 5-3.
Poiché il complemento a 9 del numero 3 è 6 possiamo sommare a 5 (il nostro minuendo) il
numero 6 per ottenere 11 come risultato. A questo punto basta sommare mentalmente la
prima cifra, 1, alle rimanenti, nel nostro caso 1, ottenendo 2.
Questo è come dire:
5-3=5+6–9
ma anche:
5 – 3 = 5 + (6 – 9)
e quindi:
5 – 3 = 5 + (-3)
Si può, perciò, affermare che la Pascalina faceva le sottrazioni come somma di numeri
negativi utilizzando il metodo del complemento a 9 del sottraendo.
Arrivando alla pratica:
Supponiamo di voler sottrarre da 82 il 27:
Opereremo dunque nel seguente modo:
1. sposta verso l’alto la barra
2. ruota di 2 scatti le decine
3. ruota di 7 scatti le unità
Figura 7: stato della Pascalina dopo il passo 3.
7
A questo punto la macchina indicherà il numero 72 che è il complemento a 9 di 27. Questo
numero va sommato a 82 dopo aver riabbassato la barra e azzerato lo strumento,
procedendo con il metodo della somma. Il risultato mostrato è 154 e sommando 1 a 54
avremo finalmente 55.
Dopo aver azzerato lo strumento possiamo procedere con una moltiplicazione:
1. spostare la barra verso il basso
2. aggiungere il moltiplicando tante volte quante dice la prima cifra del moltiplicatore a
partire dalla prima ruota (Fig. 8)
3. ripetere il passo 2 tante volte quante sono le cifre del moltiplicatore usando ogni
volta la ruota successiva.
Supponiamo di voler moltiplicare 21 x 23
Inserisco 21 tre volte partendo dalla prima ruota arrivando ad avere:
Figura 8: stato della Pascalina dopo il passo 2.
poi inserisco 21 due volte partendo dalla seconda ruota, nelle fessure viene mostrato il
risultato corretto, 483.
Per quanto pionieristica fosse, la Pascalina non riusciva a svolgere in modo agevole e
poco oneroso le operazioni di divisione.
Queste operazioni erano comunque possibili ma dovevano essere svolte per mezzo di
sottrazioni successive.
8
Script
Second Life promuove un proprio linguaggio di scripting il Linden Script Language (LSL),
utile ad animare gli oggetti.
Poiché durante lo sviluppo ci è capitato molto spesso di ripetere per diversi oggetti script
pressoché identici, mostreremo solo quelli relativi ad una particolare sezione della
macchina, mettendo in evidenza quali parti di codice variano per le altre.
La ripetizione è stata una scelta obbligata anche dalla limitazione che il mondo virtuale di
Second Life offre mettendo a disposizione durante lo sviluppo di un oggetto, un solo livello
di gerarchia.
In questo modo non è possibile replicare sotto-oggetti del principale e “linkarli” come tali,
bensì tutti devono appartenere ad un unico oggetto con una sola ed unica “root prim”.
La struttura principale è sviluppata con un parallelepipedo, leggermente inclinato per
facilitare la visualizzazione della superficie di interesse. Questa parte ha come unica
funzionalità la descrizione dell’oggetto:
default
{
state_entry()
{
llSetText("Blaise Pascal's \"Pascaline\", 1642 \n \n \n \n \n \n ", <1.0,1.0,1.0>, 1.0);
}
on_rez(integer start_param)
{
llResetScript();
}
}
Con la stessa primitiva è stata realizzata la barra che copre le fessure ed i denti delle ruote
numerate e che si muove a coprire una delle due righe nella parte superiore.
Script per la barra:
string operazione = "+";
default
{
touch_start(integer total_number)
{
vector pos = llGetLocalPos();
if(operazione == "+")
{
operazione = "-";
pos += <0,0.22,0>;
}
else if(operazione == "-")
{
operazione = "+";
pos -= <0,0.22,0>;
}
llSetPos(pos);
}
on_rez(integer start_param)
{
// Restarts the script every time the object is rezzed
llResetScript();
}
}
9
State default:
touch_start: al tocco la barra si sposta o in alto o in basso, in base alla posizione
precedente memorizzata dalla variabile globale operazione.
Le restanti componenti sono cilindri più o meno schiacciati ed incastonati all’interno di altre
primitive.
Consideriamo la sezione relativa, ad esempio, alle centinaia.
Avremo 3 oggetti fondamentali, ovvero il rullo cartaceo, il raggio della ruota dentata, ed il
bullone numerato.
Stato default del rullo cartaceo:
integer scatti;
integer scatti_completati;
default
{
state_entry()
{
llListen(448, "", NULL_KEY, "");
}
listen( integer channel, string name, key id, string message )
{
if(channel == 448)
{
scatti = (integer)message;
state rotating;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State default:
state_entry: il rullo si mette in ascolto sul canale chat 448.
listen: l’handler dell’evento intercetta un messaggio e dopo aver controllato che
proviene dal canale di interesse, pone l’oggetto allo state rotating.
Stato rotating del rullo cartaceo:
state rotating
{
state_entry()
{
scatti_completati = 0;
llSetTimerEvent(0.5);
}
timer()
{
rotation rot;
10
rotation delta;
if(++scatti_completati <= scatti)
{
rot = llGetLocalRot();
delta = llEuler2Rot(<0.0,0.0,36.0*DEG_TO_RAD>);
delta.s *= -1;
rot = delta * rot;
llSetLocalRot(rot);
}
else{
state default;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State rotating:
state_entry: viene azzerata la variabile globale scatti_completati e viene impostato
un timer di 0,5 secondi per far si che la rotazione avvenga dando il senso del
movimento all’osservatore.
timer: intercetta l’evento scatenato dal timer e compie una rotazione del rullo di 36
gradi, a meno che non abbia completato gli scatti da eseguire, e quindi è possibile
ritornare allo stato di default.
Stato default del raggio della ruota dentata:
integer scatti;
integer scatti_completati;
default
{
state_entry()
{
llListen(448, "", NULL_KEY, "");
}
listen( integer channel, string name, key id, string message )
{
if(channel == 448)
{
scatti = (integer)message;
state rotating;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State default:
state_entry: il raggio si mette in ascolto sul canale chat 448.
listen: l’handler dell’evento intercetta un messaggio e dopo aver controllato che
proviene dal canale di interesse pone l’oggetto allo state rotating.
11
Stato rotating del raggio della ruota dentata:
state rotating
{
state_entry()
{
scatti_completati = 0;
llSetTimerEvent(0.5);
}
timer()
{
rotation rot;
rotation delta;
if(++scatti_completati <= scatti)
{
rot = llGetLocalRot();
delta = llEuler2Rot(<0.0,0.0,36.0*DEG_TO_RAD>);
delta.s *= -1;
rot = delta * rot;
llSetLocalRot(rot);
}
else{
state default;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State rotating:
state_entry: viene azzerata la variabile globale scatti_completati e viene impostato
un timer di 0,5 secondi per far si che la rotazione avvenga dando il senso del
movimento all’osservatore.
timer: intercetta l’evento scatenato dal timer e compie una rotazione del raggio di 36
gradi, a meno che non abbia completato gli scatti da eseguire, e quindi è possibile
ritornare allo stato di default.
Stato default del bullone della ruota dentata:
list NUMS = ["1","2","3","4","5","6","7","8","9"];
integer scatti;
integer scatti_completati;
integer scatti_effettivi = 0;
default
{
state_entry()
{
llListen(448, "", NULL_KEY, "");
}
touch_start(integer total_number)
{
llDialog(llDetectedKey(0),"Scegliere di quante tacche girare\nla ruota delle centinaia.", NUMS, 448);
}
listen( integer channel, string name, key id, string message )
{
if(channel == 448)
{
12
scatti = (integer)message;
state rotating;
}
}
link_message(integer sender_num, integer num, string str, key id)
{
if(str == "3"){
llSay(448, "1");
// questo si fa perchè altrimenti il bullone non
// riesce a parlare con se stesso e quindi non gira.
// This is a little hack.
scatti = 1;
state rotating;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State default:
state_entry: il bullone si mette in ascolto sul canale chat 448.
touch_start: al tocco del bullone compare un Dialog per permettere all’utente di
scegliere tra gli input elencati nella list globale NUMS indicante i possibili scatti da
eseguire sulla relativa ruota (Fig. 9).
Figura 9: dialog di input per la scelta del numero di scatti
listen: viene intercettato l’input dell’utente.
link_message: l’handler intercetta i messaggi degli oggetti linkati con il bullone, in
particolare del bullone delle decine che comunica un eventuale riporto.
Stato rotating del bullone della ruota dentata:
state rotating
{
state_entry()
{
scatti_completati = 0;
llSetTimerEvent(0.5);
}
timer()
13
{
rotation rot;
rotation delta;
if(++scatti_completati <= scatti)
{
rot = llGetLocalRot();
delta = llEuler2Rot(<0.0,0.0,36.0*DEG_TO_RAD>);
delta.s *= -1; // little hack
rot = delta * rot;
llSetLocalRot(rot);
}
else{
if(scatti_effettivi + scatti > 9)
{
scatti_effettivi = (scatti_effettivi + scatti) - 10;
llMessageLinked(LINK_SET, 0, "4", NULL_KEY);
}
else
{
scatti_effettivi += scatti;
}
llSetTimerEvent(0);
state default;
}
}
on_rez(integer start_param)
{
llResetScript();
}
}
State rotating:
state_entry: viene azzerata la variabile globale scatti_completati e viene impostato
un timer di 0,5 secondi per far si che la rotazione avvenga dando il senso del
movimento all’osservatore.
timer: ogni 0,5 secondi avviene uno scatto di 36 gradi a meno che non li abbia già
effettuati tutti e quindi posso controllare e segnalare l’eventuale riporto e poi
ritornare allo stato di default.
Successivamente, ad ogni oggetto è stata applicata una texture per l’upload della quale, è
necessario pagare 10 L$, reperibili all’interno del mondo virtuale con relativa facilità.
14
Conclusioni
Siamo dunque riusciti con successo, a realizzare in un mondo virtuale, una riproduzione
funzionante della macchina calcolatrice inventata da Blaise Pascal nel 1642, capace di
effettuare le operazioni aritmetiche elementari di somma, addizione e moltiplicazione.
Su tutti gli elementi fabbricati sono stati concessi i permessi di modifica e di copia ed
incluse nel box contenitore anche le texture utlizzate durante lo sviluppo.
In tal modo possono essere cambiate a proprio piacimento le dimensioni e le
caratteristiche dell’oggetto.
Una possibile e considerevole espansione del progetto, potrebbe essere quella di
aggiungere una rappresentazione grafica del funzionamento interno della macchina,
dunque creare ad uno ad uno tutti i suoi ingranaggi, al fine di assicurarsi una maggiore
comprensione da parte degli utenti del futuro museo dell’informatica.
SITOGRAFIA
Riferimenti Web
Second Life Wiki. (2008)
http://wiki.secondlife.com/wiki/LSL_Portal
Wikipedia (2008)
http://it,wikipedia.org/wiki/Pascalina
15