UNIVERSITA DEGLI STUDI DI TORINO

toaststicksrifleΛογισμικό & κατασκευή λογ/κού

15 Αυγ 2012 (πριν από 5 χρόνια και 2 μήνες)

536 εμφανίσεις

U
NIVERSITÀ DEGLI STUD
I DI
T
ORINO



F
ACOLTÀ DI SCIENTE

M
ATEMATICHE
,

F
ISICHE E
N
ATURALI

Corso di laurea in Informatica




U
U
U
N
N
N



L
L
L
I
I
I
N
N
N
G
G
G
U
U
U
A
A
A
G
G
G
G
G
G
I
I
I
O
O
O



L
L
L
O
O
O
G
G
G
O
O
O
-
-
-
L
L
L
I
I
I
K
K
K
E
E
E



P
P
P
E
E
E
R
R
R



P
P
P
R
R
R
O
O
O
G
G
G
R
R
R
A
A
A
M
M
M
M
M
M
A
A
A
R
R
R
E
E
E



P
P
P
I
I
I
C
C
C
C
C
C
O
O
O
L
L
L
I
I
I



R
R
R
O
O
O
B
B
B
O
O
O
T
T
T




Tesi di Laurea


R
ELATORE
:

Prof. G. Barbara Demo


C
ORELATORE
:

Prof. Giovan
ni Marcianò

C
ANDIDATO
:

Rinaldi Rosa Anna


ANNO ACCADEMICO

2006


2007



i

Indice

Indice

................................
................................
................................
................................
.

i

Elenco delle figure

................................
................................
................................
...........

iii

Introduzione

................................
................................
................................
......................

v

Ringraziamenti

................................
................................
................................
...............

vii

Capitolo 1

................................
................................
................................
.........................

1

Piccoli robot programmabili

................................
................................
.........................

1

1.1

L’ RCX

................................
................................
................................
........

2

1.2

Linguaggi di programmazione per i robot

................................
...................

5

1.2.1 Robolab: un linguaggio iconico

................................
........................

5

1.2.2

NQC

................................
................................
................................
..

6

1.3

Ambienti di programmazione

................................
................................
....

15

1.3.1 IDE

................................
................................
................................
.

15

1.3.2

Bricx Command Center

................................
................................
..

16

1.4

Conclusioni

................................
................................
................................

20

Capitolo 2

................................
................................
................................
.......................

21

Il lin
guaggio NQCBaby

................................
................................
..............................

21

2.1

Il linguaggio LOGO

................................
................................
..................

21

2.2

Il linguaggio NQCBaby

................................
................................
.............

26

2.3

Diagrammi sintattici di NQCBaby

................................
............................

36

2.4

Utilizzo di NQCBaby con in BricxCC

................................
......................

42

Capitolo 3

................................
................................
................................
.......................

45


ii

NQCBaby Editor

................................
................................
................................
........

45

3.1

L’interfaccia grafica

................................
................................
..................

45

3.1.1 Guida all’uso

................................
................................
..................

46

3.1.2 Dettagli Implementativi

................................
................................
..

54

3.2

Il pre
-
compilatore NQCBaby

................................
................................
....

60


3.2.1 Analisi lessicale

................................
................................
.............

62

3.2.2 Analisi sintattica

................................
................................
............

63


3.2.3 Analisi semantica

................................
................................
...........

71

3.2.4 Progettazione di un Predictive Parser

................................
.............

73

Capitolo 4

................................
................................
................................
.......................

82

Conclusioni e sviluppi

futuri

................................
................................
......................

82

Appendice A

................................
................................
................................
...................

84

Glossario

................................
................................
................................
.....................

84

Bibliografia

................................
................................
................................
.....................

89



iii

Elenco delle figure

Figura 1.1
: Mattone programmabile RCX.
................................
................................
......

2

Figura 1.2
: processore
Hitachi H8/3292.

................................
................................
.........

4

Figura 1.3
: Esempio di programma con Robolab.

................................
...........................

6

Tabella 1.1
: Elenco dei comandi in NQC.

................................
................................
.....

10

Tabella 1.2
: Elenco delle possibili condizioni.

................................
..............................

10

Tabella 1.3
: Elenco delle espressioni.
................................
................................
............

11

Tabella 1.4
: Elenco dei possibili operatori.

................................
................................
...

12

Tabella 1.5
: Elenco di tutte le funzioni utilizzate in NQC

................................
............

13

Tabella

1.6
: Elenco di tutte le costanti.
................................
................................
..........

14

Figura 1.4
: Finestra di dialogo per scaricare il firmware.

................................
.............

16

Figura 1.5
: Parte del menù a

tendina “Tools”.

................................
..............................

17

Figura 1.6
: Il pannello templates.

................................
................................
..................

17

Figura 1.7
: Vari elementi che permettono di programmare con il BricxC
C.

................

18

Figura 1.8
: Menù a tendina Compile.

................................
................................
............

18

Figura 1.9
: Rispettivamente BricxCC con errori e senza errori.

................................
...

19

Figura 2.1
: I “Fogli bianchi”.

................................
................................
........................

27

Tabella 2.1
: Le primitive del linguaggio NQCBaby.

................................
....................

28

Figura 2.2
: Nascita e vita di un programma NQCBaby.

................................
...............

30

Tabella 2.2
: Primitive di NQCBaby_1

................................
................................
..........

30

Tabella 2.3
: Primitive di N
QCBaby_2

................................
................................
.........

32

Tabella 2.4
: Primitive di NQCBaby_3

................................
................................
.........

33


iv

Tabella 2.5
: Primitive di NQCBaby_4

................................
................................
.........

34

Tabella 2.6
: Primitive di NQCBaby_5

................................
................................
.........

35

Figura 2.3
: Niklaus Wirth.

................................
................................
.............................

37

Figura 2.4
: Segnalazione error
i sintattici del BricxCC.

................................
................

43

Figura 2.5
: Segnalazione errori semantici del BricxCC.

................................
...............

43

Figura 3.1
: La finestra di dialogo che ri
chiede il percorso fino alla cartella BricxCC.
.

46

Figura 3.2
: La finestra di dialogo che permette di assegnare il nome al robot RCX.

...

46

Figura 3.3
: La finestra di con il nome di default del robot RCX.
................................
..

47

Figura 3.4
: La finestra principale del programma NQCBaby Editor.

...........................

47

Figura 3.5
: Le scelte disponibili nel menu File.

................................
............................

48

Figura 3.6
: La finestra di dialogo che permette l’apertura di documenti già salvati.

....

49

Figura 3.7
: La finestra di dialogo che permette il salvataggio di nuovi documenti.

.....

49

Figura 3.8
: La finestra di dialogo che richiede il salvataggio delle modifiche
.

............

50

Figura 3.9
: Le scelte disponibili nel menu Progetto.

................................
.....................

50

Figura 3.10
: La barra dei pulsanti.
................................
................................
.................

51

Figura 3.11
: Il pannello contenente le due aree di testo.

................................
...............

52

Figura 3.12
: La segnalazione di un errore sintattico.

................................
....................

52

Figura 3.13
: Rispettivamener pannello delle versioni e dei comandi di “Baby 4”.

......

53

Figura 3.14
: Estratto javadoc della classe Interfaccia.java.
................................
...........

55

Figura 3.15
: Lo schema dell’interfaccia.

................................
................................
.......

56

Figura 3.16
: Rappresentazione grafica dei menu.

................................
.........................

56

Tabella 3.1
: Funzioni di NQCBaby e relative classi per i gestori di eventi

..................

57

Figura 3.17
: Lo schema dell’interfaccia della classe Help.

................................
...........

60

Figura 3.18
: Pre
-
compilazione da in NQCBaby a NQC e compilazione in linguaggio
macchina.

................................
................................
................................
...

61

Figura 3.19
: Rispettivamente fase front end e back end

................................
...............

73


Introduzione

OBIETTIVO DI QUESTA TESI

L’utilizzo della robotica come strumento educativo, nella scuola dell’obbligo, sta
assumendo un ruolo sempre più importante.

Nasce, quindi, l’esigenza di fornire ai bambini uno strumento che permetta lo
ro di
programmare piccoli robot, senza la necessità di conoscerne il linguaggio “nativo”
(NQC Not Quite C) ma usando un linguaggio ad hoc con comandi in italiano:
NQCBaby.

Per questa tesi l’hardware di riferimento, scelto tra i mattoncini programmabili mes
si
in commercio dalla LEGO, è l’RCX (Robot Commander eXplorer) in quanto il suo
linguaggio di programmazione è definitivo e standardizzato.

Per quanto riguarda l’implementazione sviluppo dell’ambiente di sviluppo e del
traduttore integrati in NQCBaby Edito
r è stato utilizzato il linguaggio di
programmazione Java, versione 1.6 mentre, per quanto riguarda la documentazione di
supporto, è stato utilizzato Javadoc.


STATO DELL’ARTE

Il professore Giovanni Marcianò, docente di lettere oggi responsabile del proge
tto di
ricerca “Uso didattico della robotica” presso l'IRRE Piemonte, ha sviluppato una
versione del linguaggio NQC mediante l’uso di macro
, che permettono un’opera di
semplificazione delle sintassi native, come pura trasposizione linguistica dal
vocabolar
io tecnico inglese ad un vocabolario naturale italiano. Tali macro sono state



inserite in cinque
“fogli bianchi”
che permettono una programmazione “LOGO
-
like”
dei robot compatibili con NQC. Una volta aperti questi
“fogli bianchi”
, tramite il BCC
(Bricx Com
mand Center), gli alunni inseriranno i loro programmi.

Questa soluzione porta con se il vantaggio della semplicità implementativa derivante
dalla struttura flessibile del linguaggio NQC, ma al tempo stesso comporta lo
svantaggio di una possibile modifica
delle macro da parte di alunni più curiosi e la non
sincronizzazione degli eventuali messaggi d’errore con il codice scritto dai bambini.


CONTRIBUTI E ORGANIZZAZIONE DELLA RELAZIONE

Il nostro lavoro ha riguardato le seguenti attività principali:


Specific
a di una grammatica per il linguaggio NQCBaby.


Analisi dell’ambiente di sviluppo programmi BricxCC che viene usato da chi
utilizza il linguaggio originale NQC. Infatti, pensando all’utente finale ovvero i
bambini delle elementari, abbiamo cercato di essere

coerenti con lo stile del
BricxCC durante lo sviluppo del nostro software.


Progetto e sviluppo di un semplice IDE (Integrated Development Environment)
per lo sviluppo di programmi NQCBaby, dove sono disponibili dei templates
contenenti le primitive di tal
e linguaggio che facilitano la scrittura di
programmi NQCBaby e di un’area in cui viene visualizzato il corrispondente
codice NQC.


Ricerca e prova di strumenti tipo Yacc&Lex, come alternative per la
generazione del traduttore.

Molte di queste attività hann
o naturalmente richiesto l’interazione con le insegnanti che
stanno conducendo esperienze di uso dei robot nelle scuole.

Questo confronto ci è stato particolarmente utile per la verifica del primo prototipo
realizzato, che è stato usato durante fine maggi
o e inizio giugno nelle classi di alcune
scuole e per la definizione delle modifiche da realizzare per la produzione della
versione beta che sarà usata dall’inizio del prossimo anno scolastico.






























Ringraziamenti

Vorrei ringraziare pr
ima di tutto la mia famiglia, alla quale dedico la mia laurea, per essermi stata
vicino in questi anni di studio.

Inoltre ringrazio la professoressa Giuseppina Barbara Demo per la sua disponibilità e presenza in tutto
il corso del tirocinio e durante la s
tesura della tesi e per l’entusiasmo che ha dimostrato nel nostro
lavoro.

Un grazie particorale va alla mia collega di studi e grande Amica Veronica Scruci, che mi ha sempre
sopportata e ha sempre sorriso alle mie mille manie. Abbiamo iniziato questo lungo

percorso inseme e
non avremmo potuto non concluderlo così.

Non posso certo dimenticare le mie più care amiche, che mi hanno sempre spronata e grazie alle quali
sono cresciuta. Non sono mai stata una persona di tante parole ma quelle poche che ho detto non

avrei
potute dirle ad altri.

Infine, ma non meno importante, un grande ringraziamento a Sandro, che nei momenti di difficoltà è
stato sempre presente e pronto a concedere il suo tanto prezioso aiuto, e a tutti coloro che in tutti questi
mesi ci hanno aiut
ate e sostenute, facendoci sorridere nei momenti più duri.

L'esperienza universitaria ci ha lasciato tanti ricordi, alcuni tristi ma tanti belli, e tra le persone che
abbiamo conosciuto alcune ci sono rimaste nel cuore. Concludiamo questa fase della nostra

vita con la
speranza che questi nuovi amici continuino a far parte delle prossime fasi.





1

Capitolo 1

Piccoli robot programmabili

Il crescente interesse verso tutto ciò che è tecnologico, ha fatto sì che nell’ultimo
decennio siano stati realizzati vari pro
getti al fine di introdurre l’insegnamento
dell’informatica usando piccoli robot. In questo contesto LEGO, in collaborazione con
il Massachusetts Institute of Technology (MIT), dopo aver presentato al pubblico il suo
kit Mindstorms chiamato "RIS" (
Robotic
Invention System

-

"Sistema di Invenzione
Robotico") ha distribuito una versione educativa chiamata
LEGO Mindstorms for
Schools
, venduta con un software di programmazione basato sulla GUI ROBOLAB.

Ogni confezione del kit Robotic Invention System, al di là

del soggetto proposto,
consiste in una miriade di pezzi LEGO standard e LEGO Technics di cui l’elemento
sostanziale è RCX Brick. Tale kit rappresenta il punto di partenza per chiunque voglia
creare dei robot indipendenti.






1. Piccoli robot programmabili


2

1.1

L’ RCX

Nella confezione del R
IS si trovano: l’RCX Brick, il mattoncino programmabile
contenente il chip con il microprocessore, due motori con relativi cavetti di
collegamento e tre sensori, due di contatto Touch Sensor e un Light Sensor, sensore di
luce.

Nel RIS c’è anche tutto quel
lo che serve per programmare e gestire il mattoncino RCX
utilizzando un Personal Computer: la IR Tower, cioè un dispositivo che, collegato ad
una porta seriale a 9 pin standard o ad una porta USB RCX dispone anche di uno
spinotto per un alimentatore estern
o che permette di far lavorare il mattoncino
continuamente, eliminando i limiti imposti dalle batterie.

L’RCX Brick è un componente della Lego Mindstorms System, il cui scopo è quello di
pilotare piccoli robot mobili.

Realizzato in perfetto stile Lego, con
sente di attaccare un qualunque altro mattoncino
sia sulla facciata superiore, che su quella inferiore: si veda la figura 1.1.


Figura 1.1
: Mattone programmab
ile RCX.


1. Piccoli robot programmabili


3

Sulla facciata superiore vengono messi a disposizione alcuni componenti utili alla
costruzione e all’interazione con il mattoncino.


Innanzitutto vi sono
quattro pulsanti
, ognuno dei quali svolge una funzione specifica:


Il pulsante “On
-
Off”, contr
addistinto dal colore rosso, ha il compito di
accendere e spegnere l’RCX Brick.


Il pulsante “View”, di colore nero, mostra lo stato dei sensori e dei motori.


Il pulsante “Prgm” permette la selezione del programma da eseguire tra quelli
caricati in memoria
, esiste un massimo di programmi memorizzabile che è di
cinque. “View” e “Prgm” sono dipendenti dal firmware installato, quindi le
loro funzioni sono programmabili ma se utilizzati con il firmware standard
svolgono la funzione sopra descritta.


Il pulsante
verde “Run” manda in esecuzioni il programma selezionato.

Ancora sulla facciata superiore, sono presenti tre
porte di input
, numerate da 1 a 3 in
modo da distinguerle da quelle di output e utilizzate per il collegamento di vari tipi di
sensori presenti nel

kit (luminosità, rotazione, contatto e temperatura), e tre
porte di
output
, etichettate A, B e C, che consentono pilotaggio di attuatori (più comunemente
motori).

A completare sono disponibili sul mattonciono un display, che consente la
visualizzazione di

numeri utile anche per il debug, uno speaker e una porta a raggi
infrarossi. Quest’ultima è l’unico modo per trasferire programmi dall’IR Tower
collegata con l’esterno e l’RCX Brick. Tipicamente l’IR Tower viene collegata ad una
porta USB del PC e attrave
rso essa un’applicazione software residente su PC (nel nostro
caso Bricx Command Center come vedremo in seguito) può scaricare programmi
eseguibili sull’RCX.

Come noto l’RCX necessita di un firmware per l’esecuzione dei programmi che gli
vengono caricati.

Questo firmware interpreta i bytecode nel rispettivo codice macchina,
chiamando le routine cablate nella ROM. Il Lego RIS e NQC usano entrambi lo stesso
firmware, ovvero il “LEGO firmware”, che viene fornito con un CD
-
ROM presente
nella scatola del kit Mi
ndstorms.


1. Piccoli robot programmabili


4

La prima volta che si vuole usare il robot o quando vengono cambiate le batterie
bisogna trasferire il firmware, dopo di ciò e dopo aver inviato i programmi il robot sarà
autonomo e indipendente dal computer.

L'RCX di Lego Mindstorms si basa sul
processore Hitachi H8/3292 della famiglia
H8/3297. Il chip integra in se una CPU della serie H8/300, memoria e dispositivi di I/O,
e un controllore di interruzioni.



Figura 1.2
: processore Hitachi H8/3292.

La CPU H8/300 è un microprocessore di tipo RISC
con registri accessibili a 16 bit o a 8
bit. I modi di indirizzamento previsti sono indirizzamento indiretto di registro,
indirizzamento assoluto, indirizzamento immediato, indirizzamento relativo al Program
Counter e indirizzamento indiretto di memoria.

L
o spazio di indirizzamento è a 16 bit (dunque un totale di 64 Kbytes) per dati e
programma. Il set di istruzioni è composto di 55 istruzioni, divise in varie categorie:
trasferimento dati singoli e a blocchi, operazioni di tipo logico e aritmetiche, operaz
ioni
di shift, manipolazione di bit, salti, controllo di sistema.

Il microcontrollore contiene 16KB di ROM, e 512 bytes di RAM on
-
board. Nella ROM
sono memorizzate in modo permanente una collezione di routine di basso livello per
l’accesso ai motori, sens
ori e display LCD che in sistemi embedded viene definita
firmware.


1. Piccoli robot programmabili


5

La RAM invece viene usata, come in ogni calcolatore, per contenere le istruzioni che
devono essere eseguite dalla CPU. L’RCX è equipaggiato con 32KB di RAM
aggiuntiva. Questa serve per memo
rizzare il firmware e i programmi utente. Il firmware
che risiede in RAM è in realtà un’estensione di quello residente nella ROM. Questo
firmware che possiamo definire di alto livello può essere sostituito con altri per fornire
diverse funzionalità all’RCX
.

1.2

Linguaggi di programmazione per i robot

1.2.1 Robolab: un linguaggio iconico

Frutto della collaborazione tra Tufts University, Lego Education e National Instruments,
è un ambiente grafico per la programmazione
della robotica Lego.

Robolab è la version
e di MINDSTORMS prevista per un uso di RCX in un contesto
tipicamente scolastico, dove fondamentale è la figura del docente, ma anche la prassi di
un lavoro articolato in piccoli gruppi e finalizzato a comuni obiettivi didattici.

In figura è rappresentato
un esempio di un possibile programma e si può osservare che
le icone dello schema rappresentano azioni e controlli del programma; il semaforo verde
rappresenta il punto d’ingresso del diagramma, e quello rosso il suo elemento terminale.
Le icone con le fre
cce sono rispettivamente un “go to” e la relativa etichetta d’arrivo;
altre icone rappresentano i motori, il sensore di luce ecc. Robolab non gestisce gli
ingressi in termini di eventi: la struttura del programma è quindi basata su un ciclo
infinito di let
tura dello stato del sensore e controllo conseguente dei motori.

Robolab offre, inoltre, diversi sottoambienti: “pilot”, destinato alle fasi introduttive;
“inventor”, per successivi approfondimenti; “investigator”, per raccogliere, elaborare e
visualizzare

dati letti dai sensori. Ognuno di questi ambienti è strutturato su vari livelli
di difficoltà, in cui le funzionalità vengono rese progressivamente disponibili al crescere
della competenza dell’utente. Robolab permette, inoltre, la gestione remota (via
In
ternet) del robot.


1. Piccoli robot programmabili


6



Figura 1.3
: Esempio di programma con Robolab.

1.2.2 NQC

NQC (Not Quite C) è un semplice linguaggio di programmazione, open
-
source, con una
sintassi ispirata al C, che permette la programmazione dell’RCX.

NQC fu creato da Dave Baum,

che opera presso il Dipartimento di Computer Science
all’Utrecht University nei Paesi Bassi, ed è noto nel mondo dell’open
-
source per molti
altri progetti.

Questo linguaggio utilizza il firmware standard Lego dell'RCX, che permette di
sfruttarne appieno
le possibilità. Facile da installare, molto stabile, ben documentato e
multipiattaforma (Win, Mac, Linux), è il più usato ambiente di sviluppo per chi si
avvicina alla programmazione vera e propria dell’RCX.

I programmi in NQC consistono di task (compiti),

al massimo 10, ognuno dei quali è
costituito da un elenco di istruzioni, chiamate anche statement che terminano con un
punto e virgola. Ogni task deve avere un nome e uno solo può essere chiamato main che
viene eseguito automaticamente e che sarà quello e
seguito dal robot. Gli altri, invece,
vengono eseguiti solo tramite la chiamata con il comando start. Per delimitare l’inizio e
la fine dei task vengono usate le parentesi graffe. Un task in esecuzione può fermare
altri task utilizzando il comando stop. Un

task bloccato con tale comando può essere
fatto ripartire da capo, ma non dal punto in cui è stato bloccato.

NQC possiede un’ulteriore molteplicità di caratteristiche:


1. Piccoli robot programmabili


7


Gli output vengono rappresentati tramite constanti:


OUT_A


OUT_B


OUT_C


Permette l’utiliz
zo di variabili: viste come locazioni di memoria nelle quali
vengono memorizzati valori. Questi valori possono essere utilizzati più volte
all’interno del programma ed essere modificati. L’unico tipo utilizzato da NQC
è int che corrisponde ai numeri interi
.


Permette anche l’utilizzo di costanti definite con il comando #define. A
differenza delle variabili, una volta dichiarate, le costanti non possono essere
modificati.


Utilizza diverse strutture di controllo, tra le quali:


if else, while, do while, repea
t.


Consente la creazione di macro usando il comando #define e assegnando loro
un nome. Queste macro possono contenere frammenti di codice che hanno lo
stesso scopo delle subroutine e inline function.


Permette la creazione di subroutine con il comando sub.
Queste vengono
utilizzate per creare pezzi di codice da richiamare in vari punti del task per
evitare la ripetizione di codice. È possibile dare un nome alla subroutine. Non
possono richiamare altre subroutine e possono essere chiamate da task diversi.
Que
sto però è sconsigliato in quanto potrebbero essere usate
contemporaneamente in task diversi producendo risultati indesiderati. Il
vantaggio delle subroutine è quello di essere memorizzate una volta sola
nell’RCX.


Permette la creazione di inline function c
on il comando void. Queste hanno lo
stesso utilizzo delle subroutine ma possono avere argomenti (come in C). Lo
svantaggio, al contrario delle subroutine è quello di non essere memorizzate
separatamente ma copiate in ogni punto in cui vengono usate occupan
do così
più memoria.


Mette a disposizione i semafori, che vengono utilizzati per l’esecuzione di task
paralleli. Sono variabili che indicano quale task ha il controllo dei motori
permette l’accesso ai motori in maniera sincrona.


1. Piccoli robot programmabili


8


I motori, all’inizio di ogn
i programma, sono impostati in avanti e con una
potenza di 7. Per ogni istruzione riguardante i motori, è possibile inserire come
argomento una costante corrispondente ad un determinato motore, direzione o
modalità.


I robot Lego sono dotati di sensori che
reagiscono a determinati stimoli.
Vengono utilizzate delle costanti per indicare il numero di porta alla quale il
sensore è connesso: SENSOR_1, SENSOR_2, SENSOR_3. Inoltre, esistono
altre costanti, quali SENSOR_TOUCH per indicare il sensore al tocco,
SENSO
R_LIGHT per il sensore alla luce tra quelli di maggior utilizzo.
SENSOR_TYPE_TEMPERATURE per il sensore termico,
SENSOR_TYPE_ROTATION per il sensore di rotazione. L’RCX possiede tre
porte di input e quindi è possibile connettervi solo tre sensori, ma è pos
sibile
connettere più sensori ad una stessa porta.


L’RCX dispone di quattro timer che producono battiti da 1/10 di secondo e
sono numerati da 0 a 3 e che vengono richiamati con la funzione Timer().


Il display dell’RCX viene controllato in due modi diversi
: è possibile indicare
cosa visualizzare (l’orologio di sistema, uno dei sensori o uno dei motori)
oppure è possibile controllare il display tramite l’orologio di sistema per
mostrare, ad esempio, informazioni per la diagnostica.


L’RCX è dotato di uno spe
aker interno che emette suoni con il comando
PlaySound()
o motivi musicali con il comando
PlayTone()
.


Mette a disposizione la funzione di datalogging, infatti l’RCX può
memorizzare il valore di variabili, sensori e timer in uno spazio di memoria
chiamato d
atalog. Tali valori non possono essere utilizzati dall’RCX ma letti
dal computer permettendo di controllare, per esempio, quello che è successo al
robot.


Possedendo almeno due RCX, NQC consente di mandare messaggi da un robot
ad un altro usando la porta i
nfrarossi.


Programmando con NQC, è possibile inserire commenti all’interno del codice
tramite // se scritti solo su una riga, altrimenti /* */ per commenti di più righe.


1. Piccoli robot programmabili


9

Rispetto a C, NQC possiede alcune differenze: non consente l’utilizzo degli array,
utilizza il solo tipo int e ha speciali librerie per essere usato con il mattoncino della
Lego.

Concludendo, si possono elencare alcuni tra i vantaggi e gli svantaggi di NQC:


Vantaggi


NQC è il più utilizzato ambiente di sviluppo alternativo.


È semplice da

istallare.


La documentazione è ottima.


Svantaggi


Si basa sul firmware LEGO.


Limiti imposti dalla V.M. LASM (es. non supporta numeri in virgola
mobile).


Difficile interfacciamento con codice che coinvolga altri dispositivi.


Interfacciamento RCX
-
PC o RCX
-
Vi
sion Command.

Si elencano qui di seguito tutti i comandi, le possibili condizioni, espressioni, costanti e
funzioni che possono essere utilizzate in NQC.

COMANDI


Comando

Descrizione

while

(
cond
)
corpo

esegui il corpo zero o più volte fintanto c
he la
condizione è vera

do

corpo

while (
cond
)

esegui il corpo una o più volte fintanto che la condizione
è vera di NQC

until

(
cond
) corpo

esegui il corpo zero o più volte fintanto che la
condizione è falsa

break

esci dal corpo di un while/do/until

cont
inue

salta alla prossima iterazione di un while/do/until

repeat

(
espressione
) corpo

ripeti il corpo un determinato numero di volte

if

(
cond
)
stmt1

if

(
cond
)
stmt1

else

stmt2

esegui stmt1 se la condizione è vera. Esegui stmt2 (se
presente) se la condizion
e è falsa.

start

nome_
task

esegui il task specificato

stop

nome_
task

arresta il task specificato

function
(
argomenti
)

chiama una funzione con gli argomenti specificati

var

=
espressione

valuta un’espressione e la memorizza in una variabile
=
var

+=
espr
essione

valuta un’espressione e la aggiunge ad una variabile
=

1. Piccoli robot programmabili


10

var

-
=
espressione

valuta un’espressione e la sottrae da una variabile
=
var

*=
espressione

valuta un’espressione e la moltiplica con una variabile
=
var

/=
espressione

valuta un’espressione e ci
摩癩摥⁵湡⁶=物r扩be
=
var

|=
espressione

valuta un’espressione ed esegue un OR bit a bit con una
癡物r扩be
=
var

&=
espressione

valuta un’espressione ed esegue un AND bit a bit con
畮ì⁶=物r扩be
=
return

ritorna da una funzione a dove è stata chiamata

espre
ssione

valuta un’espressione
=
Tabella 1.1
: Elenco dei comandi in NQC.


CONDIZIONI

Le condizioni sono utilizzate dalle strutture di controllo per prendere decisioni. Nella
maggior parte dei casi la condizione implica un confronto tra espressioni.



Condizio
ne

Significato

true

sempre vero

false

sempre falso

espr1 == espr2

vero se le espressioni sono uguali

espr1 != espr2

vero se le espressioni sono diverse

espr1 < espr2

vero se la prima espressione è minore dell’altra
=
e獰爱‼==e獰爲
=
癥牯⁳r愠灲業a=e獰
ressione è minore o uguale all’altra
=
e獰爱‾⁥獰爲
=
vero se la prima espressione è maggiore dell’altra
=
e獰爱‾==e獰爲
=
vero se la prima espressione è maggiore o uguale all’altra
=
℠!潮摩o楯湥
=
湥条ò楯湥潧楣a⁤椠畮愠=潮摩o楯湥
=
c潮搱…o⁣潮搲
=
䅎䐠 汯l楣漠 瑲
a= 摵e= co湤楺楯湩= ⡶E牯r 獥= e= 獯汴a湴漠 獥= e湴牡浢攠
獯湯⁶s牥F
=
c潮搱o||=c潮搲
=
佒l 汯l楣漠瑲t=摵d=c潮o楺楯湩=⡶E牯r 獥=e=獯汴a湴漠獥=a汭e湯n畮ì=
摥汬e⁤略⃨⁶e牡F
=
Tabella 1.2
: Elenco delle possibili condizioni.


1. Piccoli robot programmabili


11

ESPRESSIONI

Ci sono diversi valori che possono es
sere usati tra le espressioni, tra cui costanti,
variabili e valori dei sensori. Nota che SENSOR_1, SENSOR_2 e SENSOR_3 sono
macro che si espandono rispettivamente a SensorValue(0), SensorValue(1) e
SensorValue(2).


Valore

Descrizione

numero

un valore cos
tante (ad esempio "123")

variabile

una variabile con un nome (ad esempio "x")

Timer(
n
)

valore del timer n, dove n è compreso tra 0 e 3

Random(
n
)

un numero casuale compreso tra 0 e n

SensorValue(
n
)

valore corrente dl sensore n, dove n è compreso tra 0 e

2

Watch()

valore dell’orologio di sistema
=
䵥獳sgeEF
=
valore dell’ultimo messaggio IR ricevuto
=
Tabella 1.3
: Elenco delle espressioni.

I valori possono essere combinati usando degli operatori. Alcuni operatori possono
essere usati solo per valutare espres
sioni costanti, il che significa che gli operandi
devono essere valori costanti. Gli operatori sono qui elencati in ordine di precedenza
(dalla più alta alla più bassa).


Operatore

Descrizione

Associazione

Restrizioni

Esempio

abs
()

sign
()

valore assoluto

segno

n/a

n/a



abs(x)

sign(x)

++

--

incremento

decremento

Sinistra

sinistra

solo variabili

solo variabili

x++ o ++x

x
--

o
--
x

-

~

meno unario

negazione bit a bit (unario)

Destra

destra

solo costanti

-
x

~123

*

/

%

moltiplicazione

divisione

modulo

Sinist
ra

sinistra

sinistra



solo costanti

x * y

x / y

123 % 4

+

-

addizione

sottrazione

Sinistra

sinistra



x + y

x
-

y

<<

>>

spostamento a sinistra

spostamento a destra

Sinistra

sinistra

solo costanti

solo costanti

123 << 4

123 >> 4

&

AND bit a bit

Sinistra



x & y

^

XOR bit a bit

Sinistra

solo costanti

123 ^ 4

|

OR bit a bit

Sinistra



x | y


1. Piccoli robot programmabili


12

&&

AND logico

Sinistra

solo costanti

123 && 4

||

OR logico

Sinistra

solo costanti

123 || 4

Tabella 1.4
: Elenco dei possibili operatori.

FUNZIONI DELL’RCX

La maggio
r parte delle funzioni richiede come argomenti dei valori costanti. Le
eccezioni sono quelle funzioni che richiedono sensori come argomento, e quelle che
possono usare qualsiasi espressione. Nel caso dei sensori, l’argomento deve essere un
nome di sensore:

SENSOR_1, SENSOR_2 o SENSOR_3. In alcuni casi esistono nomi
predefiniti (ad esempio SENSOR_TOUCH) per le costanti appropriate.


Funzione

Descrizione

Esempio

SetSensor(
sensore
,
config
)

configura un sensore

SetSensor(SENSOR_1,
SENSOR_TOUCH)

SetSensorMode(
sensore
,
modo
)

imposta la modalità del
sensore

SetSensor(SENSOR_2,
SENSOR_MODE_PERCENT)

SetSensorType(
sensore
,
tipo
)

imposta il tipo del
sensore

SetSensor(SENSOR_2,

SENSOR_TYPE_LIGHT)

ClearSensor(
sensore
)

azzera un sensore

ClearSensor(SENSOR_3)

On(
outp
ut
)

accende uno o più
output

On(OUT_A + OUT_B)

Off(
output
)

spegne uno o più output

Off(OUT_C)

Float(
output
)

spegne uno o più output
senza usare il freno

Float(OUT_B)

Fwd(
output
)

imposta la direzione
dell’output in avanti
=
c睤wl啔彁_
=
oe瘨
output
)

imposta
la direzione
dell’output indietro
=
oe瘨v啔__F
=
呯杧汥E
output
)

inverte la direzione
dell’output
=
呯杧汥⡏啔彃F
=
佮l睤w
output
)

accende ed imposta la
direzione in avanti

OnFwd(OUT_A)

OnRev(
output
)

accende ed imposta la
direzione indietro

OnRev(OUT_B)

OnFor(
ou
tput
,
tempo
)

accende per uno
specificato numero di
centesimi di secondo. Il
tempo può essere
un’espressione
=
佮l潲o何呟qⰠ㈰IF
=
pe瑏畴灵tE
output
,
modo
)

imposta la modalità
SetOutput(OUT_A, OUT_ON)


1. Piccoli robot programmabili


13

dell’output
=
pe瑄楲tc瑩潮o
output
,
dir
)

imposta la direzione
dell’output
=
pe瑄楲tc瑩潮⡏啔_䄬A
何呟qt䐩
=
pe瑐潷o爨
output
,
potenza
)

imposta la potenza
dell’output (0
J
㜩⸠ia=
灯瑥湺a⁰痲⁥獳敲e=
un’espressione
=
pe瑐潷o爨何呟qⰠIF
=
ta楴E
tempo
)

Attende per uno
specificato numero di
centesimi di secondo. Il
tempo può essere
u
n’espressione
=
ta楴⡸F
=
m污yp潵湤E
suono
)

esegue il suono
specificato (0
-
5)

PlaySound(SOUND_CLICK)

PlayTone(
freq
,
durata
)

esegue un tono della
frequenza indicata per
la durata specificata (in
centesimi di secondo)

PlayTone(440, 5)

ClearTimer(
timer
)

azzera
un timer (0
-
3)

ClearTimer(0)

StopAllTasks()

arresta tutti i task in
esecuzione

StopAllTasks()

SelectDisplay(
modo
)

imposta una delle 7
modalità del display: 0:
orologio, 1
-
3: valore dei
sensori, 4
-
6:
impostazione degli
output. La modalità può
essere un’es
灲e獳s潮o
=
pe汥l瑄楳t污yEㄩ
=
pe湤䵥獳sgeE
messaggio
)

invia un messaggio IR
(1
-
255). Il messaggio
può essere
un’espressione
=
pe湤䵥獳sge⡸F
=
C汥l牍r獳sge⠩
=
aòòe牡⁩=⁢畦=e爠re椠
浥獳m杧i
=
C汥l牍r獳sge⠩
=
C牥a瑥ta瑡汯g⡤業E湳楯湥F
=
c牥a⁵渠湵潶=⁤=瑡汯g=
摥汬a⁤業e
湳楯ne=
獰sc楦楣ata
=
C牥a瑥ta瑡汯g⠱〰E
=
䅤摔潄o瑡汯gE
valore
)

aggiunge un valore al
datalog. Il valore può
essere un’espressione
=
䅤摔潄o瑡汯g⡔業e爨〩F
=
pe瑗a瑣栨
ore
,
minuti
)

imposta l’orologio di
獩s瑥浡
=
pe瑗a瑣栨ㄬ㌰N
=
pe瑔tm潷o爨
hi_lo
)

imposta la potenza
della
porta ad infrarossi

SetTxPower(TX_POWER_LO)

Tabella 1.5
: Elenco di tutte le funzioni utilizzate in NQC


1. Piccoli robot programmabili


14

COSTANTI DELL’RCX

Molti valori per le funzioni dell’RCX hanno un nome sotto forma di costante che può
rendere il codice più leggibile. Dove possib
ile, è preferibile usare il nome della costante
piuttosto che il valore direttamente.


Configurazione dei sensori per
SetSensor()

SENSOR_TOUCH,

SENSOR_LIGHT,


SENSOR_ROTATION,
SENSOR_CELSIUS,
SENSOR_FAHRENHEIT,
SENSOR_PULSE,

SENSOR_EDGE

Modalità per Set
SensorMode()

SENSOR_MODE_RAW,
SENSOR_MODE_BOOL,
SENSOR_MODE_EDGE,
SENSOR_MODE_PULSE,
SENSOR_MODE_PERCENT,
SENSOR_MODE_CELSIUS,
SENSOR_MODE_FAHRENHEIT,
SENSOR_MODE_ROTATION

Tipi per SetSensorType()

SENSOR_TYPE_TOUCH,
SENSOR_TYPE_TEMPERATURE,
SENSOR_TYPE_LI
GHT,
SENSOR_TYPE_ROTATION

Output per On(), Off(), ecc.

OUT_A, OUT_B, OUT_C

Modalità per SetOutput()

OUT_ON, OUT_OFF, OUT_FLOAT

Direzioni per SetDirection()

OUT_FWD, OUT_REV,
OUT_TOGGLE

Potenza di output per SetPower()

OUT_LOW, OUT_HALF, OUT_FULL

Suoni

per PlaySound()

SOUND_CLICK,
SOUND_DOUBLE_BEEP,
SOUND_DOWN, SOUND_UP,

SOUND_LOW_BEEP,

SOUND_FAST_UP

Modalità per SelectDisplay()

DISPLAY_WATCH,
DISPLAY_SENSOR_1,
DISPLAY_SENSOR_2,
DISPLAY_SENSOR_3,
DISPLAY_OUT_A,

DISPLAY_OUT_B,

DISPLAY_OUT_C

Potenza

per SetTxPower()

TX_POWER_LO, TX_POWER_HI

Tabella 1.6
: Elenco di tutte le costanti.


1. Piccoli robot programmabili


15

1.3

Ambienti di programmazione

Un ambiente integrato di sviluppo di progetti software, normalmente chiamato IDE
(Integrated Development Environment), è un software che aiuta
i programmatori nello
sviluppo del codice.

Anche per programmare i piccoli robot sono stati realizzati degli IDE: Bricx Command
Center Integrated Development Enviroment (BricxCC) è il più famoso e utilizzato
ambiente integrato per programmare i robot RCX
tramite il linguaggio NQC (sopra
descritto).

1.3.1 IDE

E verso la fine degli anni ’70 che sono comparsi i primi IDE. Basic fu il primo
linguaggio ad essere creato con un IDE, era basato sui comandi e quindi non assomiglia
molto agli IDE grafici guidati m
a menu di oggi. Da ricordare l’ambiente di
programmazione Smalltalk e la Lisp machine.

Tuttavia questi sistemi comprendevano l'intero sistema operativo, e non pemettevano
l'esecuzione sulla stessa macchina di software scritto in altri linguaggi, se non
ria
vviando il sistema.

Nel 1983 viene commercializzato il primo IDE per Personal Computer che funziona
come semplice applicazione, il Turbo Pascal della Borland, basato sul linguaggio
Pascal. Dopo di allora sono nati numerosi IDE, inizialmente con interfaccia

utente a
carattere, poi di tipo grafico.

Il termine IDE si pone in contrasto con gli strumenti command
-
line, come VI.

Un IDE sufficientemente completo generalmente comprende:


un editor per la scrittura del codice sorgente;


un compilatore e/o un interpret
e;


un tool di building automatico;


un debugger;


1. Piccoli robot programmabili


16


uno o più tool per semplificare la costruzione di una GUI.

Alcuni IDE, rivolti allo sviluppo di software orientato agli oggetti comprendono anche
un navigatore di classi, un
analizzatore di oggetti

e un
diagr
amma della gerarchia delle
classi
.

Sebbene siano in uso alcuni IDE multi
-
linguaggio, come Eclipse, NetBeans e Visual
Studio, generalmente gli IDE sono rivolti ad uno specifico linguaggio di
programmazione.

1.3.2 Bricx Command Center

Bricx Command Center

è un software open
-
source, scaricabile seguendo il seguente
link
http://bricxcc.sourceforge.net
, che fornisce molte funzioni per controllare e gestire
il robot RCX della Lego.

Per poter utilizzare il Bricx
Command Center con l’RCX bisogna innanzitutto scaricare
il firmware sul robot., ossia il codice residente che sussiste nell’accensione del robot.

All’avvio del BricxCC viene visualizzata una finestra di dialogo dalla quale si può
scegliere tra i vari firm
ware disponibili (standard, brickOS, phForth, Lejos o altri) e
inviarli immediatamente.


Figura 1.4
: Finestra di dialogo per scaricare il firmware.


1. Piccoli robot programmabili


17

Da ora è possibile controllare l’RCX, ad esempio clickando dal menù “Tools” la voce
“Direct Control” vengon
o visualizzate tutte le componenti, hardware e software, del
robot sottocontrollo.Inoltre con la voce “Watching the Brick” si possono richiedere
informazioni sullo stato di ogni pezzo, sensore, motore, variabile, programma,
impostando anche la visualizzazi
one grafica dei dati, da ricevere in un colpo solo, a
intervalli predefiniti, in flusso continuo.


Figura 1.5
: Parte del menù a tendina “Tools”.

L’utente dispone, quindi, di un editor di comandi in NQC, munito di una vasta gamma
di funzionalità utilizza
bili mediante il menù a tendina “Tools”.

L’editor è guidato dalla sintassi e fornisce un pannello chiamato “Template” che
contiene tutte le possibili espressioni del linguaggio NQC.


Figura 1.6
: Il pannello templates.


1. Piccoli robot programmabili


18

Clickando sui vari elementi il Bricx
CC visualizza su un documento aperto la
corrispondente espressione. Bisogna solo fare attenzione a modificare gli eventuali
parametri. Inoltre digitando i singoli elementi viene verificata la correttezza della
digitazione. Per cui se una parola è sintattic
amente corretta viene colorata. Il colore è
personalizzabile secondo i gusti dell’utente. Una possibile scelta potrebbe essere:
comandi in azzurro, valori in rosso e così via. Inoltre NQC è case
-
sensitive quindi
digitare una lettera minuscola invece che ma
iuscola non fa colorare la parola (ad
esempio wait (85) invece di Wait(85)), evidenziando subito l’errore.

Prima di essere inviato al robot il programma deve essere compilato. Questo si fa o
mediante il menù “Compile” e clickando la voce “Compile” o clicka
ndo il
corrispondente bottone nella toolbar.


Figura 1.7
: Vari elementi che permettono di programmare con il BricxCC.


Figura 1.8
: Menù a tendina Compile.

Al momento della compilazione il programma viene controllato sia per quanto riguarda
la parte sinta
ttica che semantica. Gli eventuali errori vengono visualizzati a fondo
pagina e clickando sulle segnalazioni vengono visualizzati gli errori sul codice. Quando
tutti gli errori sono stati corretti il pannello a fondo pagina sparirà proprio ad indicare la
c
orrettezza del programma.


1. Piccoli robot programmabili


19


Figura 1.9
: Rispettivamente BricxCC con errori e senza errori.

Con un solo clic il codice viene compilato, controllato, trasmesso al robot tramite la
porta a infrarossi. Nel caso in cui un programma venga creato e compilato senz
a che il
robot sia collegato al computer si può, in un secondo momento, scaricare l’eseguibile
sull’RCX clickando dal menù “Compile” la voce “Download” o clickando il
corrispondente bottone nella toolbar (vedere Figura 1.8).

Si ricorda ancora che il matton
cino della Lego permette di memorizzare un massimo di
cinque programmi fino ad una dimensione totale di 64 Kbyte, per cui periodicamente
bisognerà rimuoverne alcuni per eseguirne altri.

Una volta trasferito il programma nella memoria del robot (o compiland
o o solo con il
download) viene emesso un bip. A questo punto il programma può essere lanciato
pigiando il pulsante di avvio fisicamente presente sull'RCX (si veda nella Figura 1.1)
oppure il pulsante virtuale sulla barra di BCC (la freccina verde). Allo s
tesso modo,
reale o virtuale, si opera per bloccare il programma (il segnale rosso indica la funzione
STOP) e quindi il robot.



1. Piccoli robot programmabili


20

1.4

Conclusioni

In questo capitolo abbiamo descritto, situandoli nell’ambiente di utilizzo, due
componenti importanti del lavor
o: il linguaggio NQC e l’ambiente di sviluppo di
progetti per il robot RCX.

L’esigenza di introdurre anche per i piccoli robot dei linguaggi di programmazione di
alto livello e la necessità di rimanere molto vicini all’ambiente BricxCC, ha
caratterizzato i
l nostro lavoro di realizzazione dell’interfaccia grafica e la stesura di una
grammatica.


21

Capitolo 2

Il linguaggio NQCBaby

In questo capitolo raccogliamo le motivazioni che hanno portato alla nascita del
linguaggio NQCBaby insieme con la specifica di ta
le linguaggio attraverso la sua
grammatica espressa nella notazione dei grafi sintattici.

2.1

Il linguaggio LOGO

Il linguaggio LOGO, ideato e realizzato negli anni '60 dal professor Seymour Papert del
MIT (Massachusetts Institute of Tecnology), è un lingua
ggio di programmazione
fortemente orientato alla grafica e alla geometria, pensato per esser usato nelle scuole
elementari e medie inferiori perché permette anche a un principiante di ottenere subito
risultati visibili.

Papert, nel riassumere quasi trent’a
nni di attività nel campo della teoria dell’educazione
costruttivista, evidenzia come spesso la complessità dell’approccio didattico da lui
promosso sia stato ridotto al banale imparare facendo.


2. Il linguaggio NQCBaby


22

Proprio per il modello della rete neurale, alla base di un ap
prendimento che avviene
nello sviluppo di una rete concettuale, ridurre il costruttivismo alla semplice
manipolazione di oggetti non è corretto. Di più, il ridurre la teoria dell’educazione
costruttivista a pratiche didattiche deterministe è contro quella
“Filosofia del LOGO”
che, alla soglia del 2000, Papert rilancia come un approccio culturale all’educazione, e
non meramente tecnico.

“Chi programma in LOGO rifiuta la preoccupazione scolastica di avere risposte giuste e
sbagliate; rifiutare giusto e sbagli
ato non significa che "tutto va bene", la vita, il senso
della vita non è avere la risposta giusta ma portare avanti le cose! Il concetto riferibile
alla cultura del LOGO porta a "fare in modo che succeda" ed è molto più di un principio
educativo o pedago
gico. È meglio descrivibile come il riflesso di una filosofia del
vivere piuttosto che di una teoria dell'educazione. È
anche qualcosa di più specifico del
costruttivismo nel senso comune attribuito a questo termine
” [Papert99].

Fare qualcosa, e farlo funz
ionare, si distanzia da ogni precedente teoria educativa, e c'è
bisogno di una nuova definizione, che Papert definisce costruzionismo. Con questo
termine Papert si rifa a tutto quello che ha a che fare col costruire qualcosa, ma va anche
oltre il concetto
di imparare facendo.

Il termine costruttivismo si riferisce ad una teoria su come matematica e scienze e ogni
altra materia può essere insegnata e sulle aspettative in merito a come potrebbero essere
apprese. Il termine costruzionismo si riferisce anch'ess
o a principi generali di
insegnamento e apprendimento, ma comprende in sé anche una specifica area di
contenuto che viene rigettata dalla scuola tradizionale.

Scegliere un approccio costruttivista per insegnare discipline tradizionali è un compito
di chi i
nsegna, dell'insegnante: una scelta metodologica che ogni docente è bene faccia
con responsabilità. Ma i contenuti del costruzionismo sono una faccenda ben diversa.
Non si tratta di scegliere una teoria pedagogica e un metodo didattico di riferimento, ma
u
na scelta su cosa i cittadini del futuro debbano conoscere. È la scelta che Papert
sollecita vada fatta pensando al futuro della nostra civiltà e della nostra società: lo
sviluppo a cui assistiamo richiede di acquisire le competenze necessarie a partecipar
e
con cognizione di causa all'innovazione, in caso contrario ci attende una vita di
dipendenza.


2. Il linguaggio NQCBaby


23

Se quindi l’obiettivo dell’istruzione è far crescere le occasioni di apprendimento, in cui
l’alunno viene a sviluppare anche una capacità di orientamento di fro
nte a stimoli non
univoci, il docente ritrova pienamente un ruolo educativo non più nella posizione di tipo
gerarchico verso la classe ma cooperativo. Infatti non si tratta più di insegnare ad
imparare, ma di imparare cooperando, nel momento in cui accetti
amo che
“...l’attività
di concettualizzazione, originaria nel bambino, è una funzione analoga a quella che
caratterizza la ricerca dello scienziato. La formazione dei concetti è il compito comune,
di fronte alla realtà di scienziati e uomini ‘comuni’, fin
dalla nascita ...

[Damian99]
.

E l’insegnante si troverà ad accompagnare per mano gli allievi in una funzione loro
naturale: apprendere, per conoscere e padroneggiare la realtà, acquisendo concetti,
perché
“I concetti semplificano, ordinano ed organizzano
la realtà ... ma soprattutto si
intessono secondo reti che diventano sempre più fitte, man mano che si prende
coscienza delle interconnessioni presenti nelle varie sfaccettature della realtà

[Damian99]
.

Ed egli stesso si troverà ad apprendere, certamente
su un altro piano, ma assieme ai
propri allievi.

Di fronte all’incessante evoluzione delle TIC alcuni insegnanti possono vedere superato
il loro personale patrimonio di strumenti didattici sviluppati e basati su un programma
informatico. Bisogna accettare
l’idea dell’aggiornamento permanente, personale e dei
propri strumenti.

Le esigenze degli alunni cambiano: sempre più esposti alle tecnologie, anno dopo anno
dimostrano maggiore confidenza con mouse e computer, e in grado di rispondere
positivamente a prop
oste didattiche più articolate e complesse rispetto all’anno
precedente.

Per cui si richiede un ripensamento continuo sull'uso del computer a scuola, che sempre
meno è motivante in sé, ma diviene strumento efficace solo se posto al servizio di
progetti did
attici complessi, multidisciplinari, collaborativi, coerenti con lo scenario
attuale delle TIC caratterizzato da connettività e portabilità.

Nonostante siano trascorsi oltre 40 anni, il LOGO rimane comunque attuale e
comunemente usato nei progetti didattic
i non tanto
“come linguaggio di
programmazione tanto quanto invece un certo spirito nel realizzare i progetti”

[Papert99].


2. Il linguaggio NQCBaby


24


Dal punto di vista didattico, il LOGO insegnava un metodo di programmazione più
strutturato rispetto al più famoso BASIC in cui anc
he i programmi più banali
costringono ad un uso massiccio del goto. Infatti il LOGO permette di effettuare le
tipiche operazioni consentite da altri linguaggi, ma fornisce in più un insieme di
comandi chiamati
Turtle Graphics

(Grafica della tartaruga) fina
lizzati al disegno di
figure geometriche realizzate comandando opportunamente un cursore, detto tartaruga,
sullo schermo.

La geometria della tartaruga si differenzia dal modo tradizionale di disegnare al
computer perché descrive i percorsi "dall'interno"

piuttosto che "dall'esterno" o
"dall'alto". Ad esempio dicendo "gira a destra" non si esprime una direzione assoluta,
ma una direzione relativa all'orientamento corrente della tartaruga, dicendo "vai avanti
di 10 passi" ci si riferisce alla posizione e al
la direzione correnti.

Questo approccio ha molti vantaggi, ad esempio disegnare un quadrato inclinato è facile
come disegnare un quadrato con i lati orizzontali e verticali: la sequenza delle istruzioni
sarà la stessa, cambierà solo la posizione iniziale

della tartaruga. Un altro vantaggio è di
carattere pedagogico, piuttosto che computazionale, perché questo modo di disegnare è
consono all'esperienza del ragazzo, perchè è analogo al modo di muoversi nello spazio.

LOGO stimola il bambino a risolvere spec
ifici problemi e una immediata
visualizzazione globale gli consente di controllare la correttezza del suo programmino.
La tartaruga risponde interattivamente agli ordini, grazie al fatto che LOGO è
interpretato e soprattutto per venire incontro alle esigen
za della fascia d’età cui

vuole
rivolgersi.

In origine il LOGO fu utilizzato per muovere un semplice robot che stava sul
pavimento, il quale poteva essere pilotato dal computer mediante la digitazione di
istruzioni tipo FORWARD 50 per andare avanti di 50 p
assi o RIGHT 90 per girare a
destra di 90 gradi. Il primo di questi robot aveva una corazza simile a quella di una
tartaruga, da cui il nome del cursore (che nelle prime versioni su schermo era
semplicemente un piccolo triangolo). Con lo sviluppo dei monit
or il linguaggio LOGO
divenne più accessibile e negli anni '80

la tartaruga passò allo schermo grafico dove fu
utilizzata per scopi didattici (costruire forme e disegni).


2. Il linguaggio NQCBaby


25

LOGO diventa uno strumento didattico che permette non solo di apprendere determinati
concetti di una materia, ma di imparare ad imparare.

Il motivo fondamentale che lo rende “linguaggio programmativo per bambini” deriva
dal concetto di “tartaruga”: un triangolino che si muove sullo schermo lasciando una
scia luminosa sulla base di pochi or
dini fondamentali:


FORWARD


(che si abbrevia con FD)


seguito dal numero passi per
camminare avanti;


BACKWARD (che si abbrevia con BK)

seguito dal numero passi per
camminare indietro;


RIGTH (che si abbrevia con RT)


seguito dal gradi di rotazione per ruot
are a
destra;


LEFT (che si abbrevia con LT)


seguito dal gradi di rotazione per ruotare a
sinistra;


PENUP


(che si abbrevia con PU) per disattivare la visualizzazione della scia;


PENDOWN (che si abbrevia con PD) per attivare la visualizzazione della scia.

Altri ordini consentono di cambiare il tratto colorandolo o ingrossandolo, di cambiare
colore allo sfondo e così via.

Il LOGO si basa su una idea fondamentale: tutto è fatto usando dichiarazione formale:
le procedure. Ve ne sono circa 200 predefinite e su

queste si innestano quelle
dell’utente.

Negli anni '80 fu realizzata anche una variante, con istruzioni in italiano, del LOGO.

Segue un esempio, un piccolo programma che disegna un quadrato con 50 pixel di lato:


Versione LOGO in inglese:


REPEAT 4 [FORWAR
D 50 RIGHT 90]


REPEAT 4 [FD 50 RT 90] nella corrispondente sintassi abbreviata


Versione LOGO in italiano:


RIPETI 4 [AVANTI 50 DESTRA 90]


RIPETI 4 [A 50 D 90] nella corrispondente sintassi abbreviata

Riassumendo quindi possiamo dire che il LOGO è senz'a
ltro il linguaggio di
programmazione didattico per eccellenza.
Ha il vantaggio, sugli altri linguaggi, di
e
sistere nella lingua nazionale, di essere di immediata esecuzione e di essere un
linguaggio che usa le procedure.


2. Il linguaggio NQCBaby


26

Il LOGO deve essere recepito dagli
alunni come un gioco. Infatti, se impostato e
insegnato in modo corretto, aiuta il bambino:


a riflettere su ciò che fa;


sugli errori che inevitabilmente commette;


sulla possibilità di usare tali errori come alleati e non come nemici;


sulle tante possibilit
à che ci sono per risolvere un unico problema.

2.2

Il linguaggio NQCBaby

NQCBaby nasce con l’idea di fornire un linguaggio orientato ai bambini piuttosto che ai
robot come nel caso di NQC, e si sviluppa come una versione del linguaggio open
-
source NQC orie
ntata alle attività di robotica a partire dalla scuola elementare. Questo
nuovo linguaggio è ora in sperimentazione in alcune scuole piemontesi con riferimento
al progetto “Uso didattico della robotica” dell’IRRE Piemonte (delibera n. 106 del
22/12/05).

La

metodologia pedagogica costruttivista struttura l’apprendimento di NQCBaby in fasi
precise, partendo con NQCBaby_1 e man mano aggiungendo nuovi componenti
hardware al robot che si riflettono sulla definizione del linguaggio per arrivare quindi a
NQCBaby_5
.

L’idea iniziale, proposta e utilizzata da Marcianò, era di sfruttare la flessibilità offerta
dal linguaggio NQC e di definire delle macro da usare come istruzioni primitive del
linguaggio NQCBaby. Per cui si ha la seguente definizione di istruzione dove

ad ogni
primitiva (sia P) corrisponde una traduzione in codice NQC (sia Q):

#define P Q

Non si deve però pensare a questo lavoro come un semplice intervento sul vocabolario,
l’obiettivo è stato di sintetizzare gli step tecnici in step di azione e di sem
plificare la
sintassi NQC nascondendo e anche eliminando alcuni concetti del linguaggio come le
parentesi graffe e la dichiarazione di variabili.

L’insieme di tutte le macro sono contenute in documenti chiamati “Fogli Bianchi”, che
con gradualità permetton
o una programmazione “LOGO
-
like” dei robot compatibili con

2. Il linguaggio NQCBaby


27

NQC.
Al momento sono disponibili cinque fogli bianchi “baby” e due “junior” (pensati
per la scuola media), che progressivamente portano gli alunni a cimentarsi con un
maggior numero di comandi, par
tendo quindi dalla gestione del solo movimento
(baby01) per arrivare alla programmazione con più task paralleli (junior02).

Grazie a questi “Fogli Bianchi”
i ragazzi vengono a contatto con NQC vedendo come le
loro istruzioni vengono tradotte in NQC, che al
la fine è il linguaggio che il robot
capisce.


Figura 2.1
: I “Fogli bianchi”.


2. Il linguaggio NQCBaby


28

La seguente tabella mostra l’evoluzione delle primitive nei vari linguaggi NQCBaby e
come molte istruzioni sono sintatticamente vicine al LOGO di Papert, che è
indubbiamente il

nostro punto di riferimento. LOGO è già consolidato in Italia e gli
insegnanti hanno già svolto attività in sintonia con la filosofia LOGO. Da questo punto
di partenza passare all’uso di NQCBaby sarà meno problematico per i bambini, che si
troveranno dava
nti a comandi molto simili a quelle del LOGO.


PRIMITIVE
BABY_1

PRIMITIVE

BABY_2

PRIMITIVE

BABY_3

PRIMITIVE

BABY_4

PRIMITIVE


BABY_5

Robby

Robby

Robby

Robby

Robby

ciao

ciao

ciao

Ciao

ciao

indietro ( x )

indietro ( x )

indietro ( x )

Indietro ( x )

indi
etro ( x )

avanti ( x )

avanti ( x )

avanti ( x )

avanti ( x )

avanti ( x )

sinistra ( x )

sinistra ( x )

sinistra ( x )

Sinistra ( x )

sinistra ( x )

destra ( x )

destra ( x )

destra ( x )

destra ( x )

destra ( x )

veloce ( x )

veloce ( x )

veloce ( x

)

veloce ( x )

veloce ( x )

ripeti ( x )

ripeti ( x )

ripeti ( x )

ripeti ( x )

ripeti ( x )

avantisempre

avantisempre

avantisempre

avantisempre

avantisempre

ripetisempre

ripetisempre

ripetisempre

ripetisempre

ripetisempre

fine

fine

fine

Fine

fine



--

aspetta ( x )

accendiluce

accendiluce

accendiluce



--

accendiluce

spegniluce

spegniluce

spegniluce



--

spegniluce

aspetta ( x )

aspetta ( x )

aspetta ( x )



--

sensore1_tocco

sensore1_tocco

Sensore1_tocco

sensore1_tocco



--

se_tocca

se_tocca

se_
tocca

se_tocca




--

sensore2_tocco

Sensore2_tocco

sensore2_tocco



--



--

se_toccadietro

se_toccadietro

se_toccadietro



--



--

sensore3_luce

Sensore3_luce

sensore3_luce



--



--

se_chiaro

se_chiaro

se_chiaro



--



--

se_scuro

se_scuro

se_scuro



--



--



--

sinoache_chiaro

sinoache_chiaro



--



--



--

sinoache_scuro

sinoache_scuro



--



--



--

altrimenti

altrimenti



--



--



--

acaso ( n )

acaso ( n )



--



--



--



--

uno



--



--



--



--

fai_uno



--



--



--



--

stop_uno



--



--



--



--

due



--



--



--



--

fai_due



--



--



--



--

stop_due



--



--



--



--

fine_fai

Tabella 2.1
: Le primitive del linguaggio NQCBaby.


2. Il linguaggio NQCBaby


29

In questo modo i bambini al primo anno delle elementari progrediscono nello sviluppo
delle l
oro abilità linguistiche e logiche usando il loro linguaggio nativo e anche perché
usano un linguaggio di più alto livello scritto nel linguaggio NQC. Un linguaggio di alto
livello compatto, in quanto riassume in una sola primitiva più istruzioni NQC e, ch
e
permette ai bambini di utilizzare “concetti noti” rispetto ad usare i nomi dei componenti
del robot.

L’utilizzo di “concetti noti” da un lato porta ad una programmazione “naturale” ma
dall’altro fa perdere la flessibilità del linguaggio. Per cui se consi
deriamo la primitiva
se_tocca

, associata alle istruzioni NQC “if (SENSOR_1 == 1) {”, possiamo notare che
è vincolata con il sensore_1 così come
se_chiaro

è legato al sensore_3.

Forniamo alcuni esempi di programmi con le primitive sopra descritte.


Program
ma che utilizza le primitive NQCBaby_1:

Robby


veloce ( 3 ) avanti ( 100 ) veloce ( 7 ) indietro ( 100 )


ripeti ( 3 ) destra ( 90 ) sinistra ( 90 ) fine


ripeti(2) indietro(10) avanti(20) fine

ciao


Programma che utilizza le primitive NQCBaby_2:

Rob
by


ripetisempre


avanti( 10 )


se_tocca


indietro ( 100 ) destra( 100 )


fine


fine

ciao


Programma che utilizza le primitive NQCBaby_3:

Robby


ripetisempre


se_scuro avanti( 10 ) accendiluce destra( 10 ) spegniluce

fine


avanti( 10 ) sinistra( 10 )


fine

ciao


Questi programmi vengono editati nei cosiddetti “Fogli Bianchi” e utilizzati insieme al
Bricx Command Center IDE, che come detto precedentemente consente la compilazione
in NQC e l’invio del programma

compilato al robot.


2. Il linguaggio NQCBaby


30

Le fasi di sviluppo di un programma NQCBaby possono essere chiarite con la seguente
figura:











Figura 2.2
: Nascita e vita di un programma NQCBaby.

Segue la descrizione di ogni primitiva NQCBaby con la relativa traduzione n
el
linguaggio NQC, partendo a spiegare i comandi di NQCBaby_1 fino ad arrivare alla
versione NQCBaby_5.



Codice in NQCBaby

Codice in NQC

Robby

Task main{

Ciao

Off(OUT_A+OUT_C); }

indietro ( x )

OnRev(OUT_A+OUT_C); Wait(x);

avanti ( x )

OnFwd(OUT_A+OUT
_C); Wait(x);

sinistra ( x )

OnFwd(OUT_C); OnRev(OUT_A); Wait(x);

destra ( x )

OnFwd(OUT_A); OnRev(OUT_C); Wait(x);

veloce ( x )

SetPower(OUT_A+OUT_C, x);

ripeti ( x )

repeat(z) {

Avantisempre

while(true) {OnFwd(OUT_A+OUT_C);};

ripetisempre

while(tru
e) {

Fine

Off(OUT_A+OUT_C); }

Tabella 2.2
: Primitive di NQCBaby_1


Robby

Ogni volta che si scrive un nuovo programma si deve assegnare un nome al robot.
Questo nome rappresenta un comando di avvio e fa si che il robot esegua quello che gli
viene ordinato

di fare.

Classe N

Programma editato,
utilizzando il
BricxCC, nel Foglio
bianco N utilizzando
il BricxCC

Compilazione in
NQC e invio al
robot dal BricxCC


2. Il linguaggio NQCBaby


31


ciao

Per concludere il programma bisogna obbligatoriamente inserire questo comando che
chiude spegne i motori del robot.


indietro ( x )

Dopo aver montato un motore sul fianco sinistro del robot e collegato alla porta A e un
motore sul lato dest
ro del robot collegato alla porta C, il robot procederà indietro per il
tempo (x) in centesimi di secondo
.


avanti ( x )

Dopo aver montato un motore sul fianco sinistro del robot e collegato alla porta A e un
motore sul lato destro del robot collegato alla

porta C, il robot in avanti per il tempo (x)
in centesimi di secondo.


sinistra ( x )

Dopo aver montato un motore sul fianco sinistro del robot e collegato alla porta A e un
motore sul lato destro del robot collegato alla porta C, il robot ruoterà verso s
inistra per
il tempo (x) in centesimi di secondo.


destra ( x )

Dopo aver montato un motore sul fianco sinistro del robot e collegato alla porta A e un
motore sul lato destro del robot collegato alla porta C, il robot ruoterà verso destra per il
tempo (x)
in centesimi di secondo.


veloce ( x )

Permette di regolare la velocità dei motori collegati alle porte A e C dell’RCX. Si
possono usare valori da 1 (lentissimo) a 7 (velocissimo).


ripeti ( x )


2. Il linguaggio NQCBaby


32

Avvia una sequenza di istruzioni che il robot deve eseguire i
n un ciclo, ovvero, una
ripetizione per (x) volte di quello che è compreso tra questo comando e fine.


avantisempre

Dopo aver montato un motore sul fianco sinistro del robot e collegato alla porta A e un
motore sul lato destro del robot collegato alla port
a C, il robot procederà in avanti senza
fermarsi. Bisogna fare comunque attenzione perchè questo comando blocca
l’esecuzione del programma e le successive istruzioni non verranno eseguire.


ripetisempre

Avvia una sequenza di istruzioni che il robot deve es
eguire in un ciclo infinito, ovvero,
una ripetizione senza fine delle istruzioni comprese tra questo comando e fine.


fine

Chiude la sequenza di istruzioni che il robot deve eseguire in un ciclo. Va posto
obbligatoriamente dopo i comandi che avviano cicli.



Codice in NQCBaby

Codice in NQC

Accendiluce

On(OUT_B);

spegniluce

Off(OUT_B);

aspetta ( x )

wait(x);

sensore1_tocco

SetSensor(SENSOR_1,SENSOR_TOUCH);

se_tocca

if (SENSOR_1 == 1) {

Tabella 2.3
: Primitive di NQCBaby_2

accendiluce

Dopo aver collegat
o la lampadina LEGO alla porta B, questo comando permette di
accendere la lampadina a piacere.


spegniluce

Dopo aver collegato la lampadina LEGO alla porta B, questo comando permette
spegnere la lampadina a piacere.


2. Il linguaggio NQCBaby


33


aspetta ( x )

Introduce una pausa lunga

(x) centesimi di secondo nel programma. Il robot continuerà
a eseguire le istruzioni ricevute per questo tempo (x) prima di eseguire i comandi
successivi.


sensore1_tocco

Setta il robot ad avere un sensore di contatto collegato alla porta 1. Senza questa
informazione il robot non potrà poi eseguire i comandi che prevedono l’uso del sensore,
come se_tocca.


se_tocca

Legge il valore del sensore di contatto collegato alla porta 1 e se diviene = 1 (ovvero
viene premuto) fa eseguire al robot le istruzioni comp
rese tra questo comando e fine.



Codice in NQCBaby

Codice in NQC

sensore2_tocco

SetSensor(SENSOR_2,SENSOR_TOUCH);

se_toccadietro

if (SENSOR_1 == 1) {

sensore3_luce

SetSensor(SENSOR_3,SENSOR_LIGHT);

se_chiaro

if (SENSOR_3 > 48) {

se_scuro

if (SENSOR_3

<= 48) {

Tabella 2.4
: Primitive di NQCBaby_3

sensore2_tocco

Se si dispone di un altro sensore di contatto permette di informare il robot che il sensore
è collegato alla porta 2. In genere questa primitiva serve quando sul robot viene
collegato un sensor
e del contatto sia davanti che dietro. Senza questa informazione il
robot non potrà poi eseguire i comandi che prevedono l’uso del sensore, come
se_toccadietro.


se_toccadietro


2. Il linguaggio NQCBaby


34

Legge il valore del sensore di contatto collegato alla porta 2 e se diviene =
1 (ovvero
viene premuto) fa eseguire al robot le istruzioni comprese tra questo comando e fine.


sensore3_luce

Setta il robot ad avere un sensore di luce collegato alla porta 3. Senza questa
informazione il robot non potrà poi eseguire i comandi che prev
edono l’uso del sensore,
come se_chiaro o se_scuro.


se_chiaro

Legge il valore del sensore di luce collegato alla porta 3 e se superiore al valore indicato
(in questo caso 48) fa eseguire al robot le istruzioni comprese tra questo comando e fine.


se_scur
o

Legge il valore del sensore di luce collegato alla porta 3 e se uguale o inferiore al valore
indicato (in questo caso 48) fa eseguire al robot le istruzioni comprese tra questo
comando e fine.



Codice in NQCBaby

Codice in NQC

sinoache_chiaro

until (SE
NSOR_3 > 48) {

sinoache_scuro

until (SENSOR_3 <= 48) {

altrimenti

Else

acaso ( n )

Random (n)

Tabella 2.5
: Primitive di NQCBaby_4

sinoache_chiaro

Legge il valore del sensore di luce collegato alla porta 3 e sino a quando il suo valore
non diviene magg
iore della soglia indicata (in questo caso
48
) fa eseguire al robot le
istruzioni comprese tra questo comando e fine.


sinoache_scuro


2. Il linguaggio NQCBaby


35

Legge il valore del sensore di luce collegato alla porta 3 e sino a quando il suo valore
non diviene minore o uguale della

soglia indicata (in questo caso
48
) fa eseguire al
robot le istruzioni comprese tra questo comando e fine.


altrimenti

Permette di programmare un’azione da far svolgere al robot nel caso la precedente
istruzione “se” risultasse falsa. Va quindi posta dopo

comandi come se_chiaro,
se_scuro, se_tocca e se_toccadietro. Diversamente scatta un errore logico.


acaso ( n )

Permette di avere valori casuali tra 0 e n
-
1 al posto di valori fissi nei comandi dati al
robot. Particolarmente utile in molti compiti di espl
orazione in cui solo procedendo
casualmente il robot può coprire l’intera area di esplorazione.



Codice in NQCBaby

Codice in NQC

uno

task prima() {

fai_uno

start prima;

stop_uno

stop prima;

due

task seconda() {

fai_due

start seconda;

stop_due

stop
seconda;

fine_fai

}

Tabella 2.6
: Primitive di NQCBaby_5

uno

Questo comando permette di definire una procedura chiamata uno. Va scritto all’esterno
del programma principale, racchiuso tra Robby e ciao nel quale può essere richiamata
con il comando fai_un
o.


fai_uno

Permette di chiamare la procedura uno e può essere invocata all’interno di altre
procedure.



2. Il linguaggio NQCBaby


36

stop_uno

Permette di fermare la procedura uno in esecuzione, e può essere invocata all’interno di
altre procedure (Robby o due).

due

Questo comando per
mette di definire una procedura chiamata due. Va scritto all’esterno
del programma principale, racchiuso tra Robby e ciao nel quale può essere richiamata
con il comando fai_due.


fai_due

Permette di chiamare la procedura due e può essere invocata all’inter
no di altre
procedure.


stop_due

Permette di fermare la procedura due in esecuzione, e può essere invocata all’interno di
altre procedure (Robby o uno).


fine_fai

Per concludere una procedura, sia uno che due, bisogna obbligatoriamente inserire
questo coma
ndo.

2.3

Diagrammi sintattici di NQCBaby

Negli anni ’70, fin dalle prime presentazioni del linguaggio Pascal, Niklaus Wirth usò i
diagrammi sintattici che da allora furono un modo molto usato per la specifica di
grammatiche.

I Diagrammi Sintattici descriv
ono la grammatica mediante l’utilizzo di grafi e come tali
sono costituiti da:


nodi etichettati con simboli (terminali e non terminali), collegati da archi
orientati;


2. Il linguaggio NQCBaby


37


un arco da
i

a
j

significa che il simbolo
i

è seguito al simbolo
j
;


p
iù archi rappresent
ano le possibili alternative.


Anche per descrivere la sintassi del linguaggio NQCBaby, peraltro molto semplice,
abbiamo scelto di usare questo tipo di specifica e di rappresentare con dei rettangoli gli
elementi non terminali del linguaggio, mentre i simb
oli terminali sono inseriti in ovali o
tondi.


Figura 2.3
: Niklaus Wirth.

Segue la descrizione della grammatica di NQCBaby con i Diagrammi sintattici.

Programma



2. Il linguaggio NQCBaby


38

Task


Nome Task




Chiusura Task




Operazioni Senza Chiusura (OSC)






2. Il linguaggio NQCBaby


39

Operazioni Con
Chiusura (OCC)




Operazioni Dei Task (ODT)




OSC_Senza_Numeri





2. Il linguaggio NQCBaby


40

OSC_Con_Numeri




OCC_Con_Numeri




OCC_Senza_Numeri





2. Il linguaggio NQCBaby


41

Numero




Casuale




Percorrendo il grafo da sinistra a destra si ottengono le frasi sintatticamente corrette del
linguaggio.

Analogamente si può vedere se una determinata frase può essere generata
dal corrispondente grafo sintattico. Se si incontrano simboli non terminali si deve
percorrere il grafo corrispondente il cui nome compare tra parentesi angolate .

Vediamo alcuni esem
pi di un programmi generati dai grafi sintattici appena vista.

Esempio 1:

Robby


ripetisempre


se_chiaro indietro ( 10 ) destra ( acaso ( 30 ) ) spegniluce
fine


avanti ( 10 ) sinistra ( 10 )


fine

ciao


Esempio 2:

Robby

ciao


2. Il linguaggio NQCBaby


42

2.4

Utilizzo

di NQCBaby con in BricxCC

Come già accennato, utilizzando il linguaggio di programmazione NQC è stato
possibile creare un nuovo linguaggio, chiamato NQCBaby, costituito da comandi in
italiano di facile utilizzo per i giovani studenti. Tali comandi sono st
ati creati usando
delle macro tramite l’istruzione #define di NQC e inseriti nei fogli di lavoro, che il