N.B. Il blog è in fase di aggiornamento a causa di una perdita accidentale dei dati.
Ci scusiamo per la mancanza del supporto figurativo e video.
Il codice relativo ai vari script è però corretto anche se risulta alterata la sua formattazione che verrà corretta nel breve periodo formattazione che verrà comunque sistemata a breve termine
PROGRAMMARE IL TABLET E/O LO SMARTPHONE CON APPLICAZIONE DROIDSCRIPT
Utilizzare l'applicazione DroidScript per programmare tablet e/o smartphone con o.s. Android, negli ambienti:
1)tecnico_scientifico
(Testare,correggere e realizzare applicazioni nei vari settori di competenza.
Compreso il metodo per codificare gli script con JavaScript il tablet, o lo stesso smartphone, diventa un vero personal computer.)
2) didattico
(Sono stati realizzati degli script che possono avere una certa valenza per rendere la didattica più¹ produttiva. Utilizzando, in modo adeguato, le funzioni e i metodi intrinseci all'ambiente di sviluppo risulta più efficace il supporto allo studente fornito da DroidScript. )
3) scolastico e sperimentale (Per tutti gli studenti di qualsiasi ordine e grado, DroidScript, supportato dal linguaggio di programmazione JavaScript, consente di sperimentare subito qualsiasi tipo di problema in discipline quali Elettronica, Elettrotecnica, Fisica, Matematica, Statistica.....)
4) per un uso personale
(Programmare i SENSORI dello smartphone come GPS, Altimeter, Accelerometer, Light, Proximity, MagneticField.)
Risulta possibile realizzare applicazioni, significative e coinvolgenti, fruibili sia in ambito personale che professionale.
Sitodi riferimento su JavaScript
Sito di Riferimento DROIDSCRIPT
La PROGRAMMAZIONE con DROIDSCRIPT richiede di:
1) Scaricare dal PlayStore l'applicazione DroidScript.
2) Dopo installazione appare l'icona relativa sulla schermata Home del tablet o smartphone.
Figura 1
3) click su icona DS per accedere all'interfaccia con gli scripts realizzati; fig.2 a sx.
4) click sul bottone con i tre puntini in alto e appare il menu(fig. 3) al centro.
5) scegliere, fra le varie opzioni: New per creare un nuovo progetto; fig. 3 al centro.
6) assegniamo un nome al nuovo progetto, ad es. areaTtriangolo. Appare l'icona relativa allo script appena creato.
7) tenere premuto, per 1 secondo circa, su icona areaTriangolo; appare il menù a dx(fig. 4) dal quale scegliamo Edit per scrivere, modificare, salvare lo script.
fig.2 fig.3 fig.4
COME STRUTTURARE IL PROBLEMA GENERICO: PROCEDURA VALIDA INDIPENDENTEMENTE DAL LINGUAGGIO DI PROGRAMMAZIONE
Problema da risolvere
Per calcolare l'area di un triangolo è necessario effettuare le seguenti operazioni matematiche: (base * altezza)/ 2.
Poichè ci sono due variabili da conoscere (base e altezza), dobbiamo acquisirle e poi eseguire su di esse le operazioni previste dal progetto.
__________________________
1. Acquisisci base del triangolo
2. Acquisisci l'altezza del triangolo
3. Moltiplica i valori della base e dell'altezza tra di loro e dividi il risultato per 2
4. Comunica i risultati relativi al valore Area
Script di base relativo al CALCOLO AREA TRIANGOLO.
Per eseguire lo script dobbiamo cliccare una volta sul triangolo â–¶ï¸ di avanzamento posto in basso e che rappresenta il RUN dello script. In presenza di qualche imprecisione nel codice, viene interrotta l'esecuzione dello script e appare un'interfaccia su cui è indicata la tipologia di errore(runtime o lessicale); occorre rivedere il codice e rilanciare l'esecuzione fino a quando non viene eseguito in modo completo. Controllare, infine, che i valori ottenuti siano in accordo con quelli previsti in fase di progetto
Commento al codice
N.B. La numerazione delle righe di codice, comè noto, non deve essere digitata e serve solo a rendere meglio leggibile lo stesso.
Le righe di commento, di colore verde, e che non sono codice eseguibile, sono precedute dal doppio slash, anch'esso dello stesso colore. //
// Called when application is started
function OnStart // riga di codice indispensabile per far partire lo script
{
lay = app.CreateLayout("linear","VCenter,FillXY); // crea il Layout su cui porre gli oggetti. Riempie lo schermo e li pone centrati e distribuiti linearmente
txt = app.CreateText(" "); // crea una casella di testo vuota usata poi per communicare i risultati ottenuti
txt.SetText(20);// fissa le dimensioni del testo a 20
lay.AddChild(txt); // aggiunge l'oggetto testo a lay
app.TextToSpeech("dammi la base del triangolo"); // comunica a voce di voler acquisire la base
base = prompt("dammi la base del triangolo"); // appare interfaccia di dialogo
app.TextToSpeech("dammi altezza del triangolo"); // comunica a voce di voler acquisire altezza
base = prompt("dammi altezza del triangolo"); // appare interfaccia di dialogo
areaTriangolo = (base*altezza)/2 //esegue formula e pone valore in areaTriangolo
txt.SetText("areaTriangolo in mq uguale a" + areaTriangolo); // fa apparire sulla casella di testo il risultato e la stringa di testo concatenate dal +
app.TextToSpeech("areaTriangolo in mq uguale a" +areaTriangolo); // comunica a voce il risultato e usa il simbolo + per concatenare la stringa e il numero.
// Add layout to app.
app.AddLayout(lay);
Come appare il codice digitato nell'ambiente di sviluppo di DroidScript
/////////////////////////////////////////////////////////
JAVASCRIPT E IL WEB COME REALIZZARE LO STESSO SCRIPT E VISUALIZZARLO CON IL BROWSER
Premessa:
DroidScript, che si regge sul linguaggio JavaScript, consente la realizzazione di applicazioni complete e autonome(stand alone).
JavaScript, invece, non è in grado di farlo: viene usato nelle pagine WEB e lavora a supporto dei vari Browser(IE,Google,FireFox) i quali devono avere un interprete in grado di eseguirne le istruzioni.
JAVASCRIPT HA MOLTI METODI PER OPERARE SULLE PAGINE WEB E IN PARTICOLARE IL METODO document.getElementById("area")
Significato di: document.getElementById ("area").innerHTML = (Base * Height) / 2 + "triangle area"
- document rappresenta oggetto su cui si sta operando;
- getElementById("area") è il metodo applicato all'oggetto a cui abbiamo assegnato un univoco id di nome "area";
- .innerHTML rappresenta una proprietà che serve a personalizzare il contenuto di un oggetto;
- Viene restituito elemento della pagina HTML con id=" area" e di valore pari a quanto specificato dopo il segno di = e che, nel nostro caso, è il calcolo area del triangolo = (Base * Altezza)/2;
IL CODICE JAVASCRIPT, SUPPORTATO DALLE ISTRUZIONI IN HTML E RELATIVO AL CALCOLO AREA TRIANGOLO CHE ABBIAMO VISTO IN AMBIENTE DROIDSCRIPT, SI PRESENTA NELLA FORMA SOTTOSTANTE, QUALORA DEBBA ESSERE VISUALIZZATO CON IL BROWSER.
Lo script deve essere salvato nella forma AreaTriangolo.html e posto in una cartella specifica o sul desktop; può essere aperto con il classico tasto destro sulla relativa icona che appare e poi click su Apri con Google
<!DOCTYPE html>
<html>
<body>
<h2>CALCOLO AREA TRIANGOLO </h2>
<p>APPLICAZIONE JAVASCRIPT</p>
<p id = "area"></p>
<script>
Base = prompt("base del triangolo","" ) * 1; // acquisisce la base
Altezza = prompt("altezza del triangolo","" ) * 1; // acquisisce altezza
document.getElementById("area").innerHTML = (Base*Altezza)/2+" area triangolo";
</script>
</body>
</html>
////////////////////////////////////////
/////////// PROGETTO DI SEMPLICI ALGORITMI ///////////////
// LA MEDIA DI 3 NUMERI
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
n1 = prompt("dammi il primo numero")*1;
n2 = prompt("dammi il secondo numero")*1;
n3 = prompt("dammi terzo numero")*1;
media = (n1+n2+n3)/3;
//Create a text label and add it to layout.
txt = app.CreateText( "la media dei 3 numeri risulta pari a "+media);
txt.SetTextSize( 32 );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
//////////////////////////////////////
// AREA DEL CERCHIO CODIFICARE ALGORITMO CALCOLO AREA DEL CERCHIO
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
raggio = prompt("dammi il raggio del cerchio")*1;
areaCerchio = (3.14*raggio*raggio)*1;
//Create a text label and add it to layout.
txt = app.CreateText( "area del cerchio pari a "+ areaCerchio);
txt.SetTextSize( 32 );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
//////////////////////////////////////////////////
// SPESE CONDOMINIALI
// IN UN CONDOMINIO SI DECIDE DI CALCOLARE UN TASSA UNA TAMTUM CORRELATA ALLE DIMENSIONI DEGLI APPARTAMENTI, ESPRESSI IN MQ, E IN RAGIONE DI K EURO A MQ.
AL DOVUTO DEVE ESSERE SOMMATA UN QUOTA FISSA DI X(EURO)
// E UNA PERCENTUALE DEL T% DOVUTA AD AMMINISTRATORE.
// PRODURRE UN ALGORITMO CHE, DATI IN INPUT I VALORI DI X, K, T, DETERMINI AMMONTARE DELLA RATA
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
T = prompt("dammi la percentuale spettante amministratore e relativa agli euro dovuti ai mq totali")*1;
K = prompt("dammi gli euro a mq dovuti")*1;
dimensione = prompt("dammi le dimensioni appartamento in mq")*1;
X = prompt("DAMMI LA QUOTA FISSA DOVUTA IN EURO")*1;
totale=(X + dimemsione*K + T*K/100);
//Create a text label and add it to layout.
txt = app.CreateText( "quota dovuta pari a "+totale);
txt.SetTextSize( 32 );
lay.AddChild( txt );
app.AddLayout( lay);
}
////////////////////////////////////////////////////////
// ALGORITMO PER RISOLUZIONE DI UNA EQUAZIONE DI PRIMO GRADO
// Equazione di primo grado del tipo: a*x = b da cui x = -b/a
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
a = prompt("dammi il coefficiente a")*1;
b = prompt("dammi il coefficiente b")*1;
x = (-b/a);
//Create a text label and add it to layout.
txt = app.CreateText( "la soluzione pari a "+x);
txt.SetTextSize( 32 );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
///////////////////////////////////
// TELEFONATE E SCATTI: ALGORITMO CHE DETERMINI IL NUMERO DI SCATTI EFETTUATI DA UN UTENTE
// E AMMONTARE DELLA BOLLETTA SE VENGONO FORNITI I DATI RELATIVI A: Nome,Numero scatti dopo ultima bolletta
// numero scatti emersi dalla lettura attuale, il costo dello scatto, il valore del canone fisso.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
nome = prompt("dimmi come ti chiami");
scattiprima = prompt("dammi gli scatti precedenti alla lettura")*1;
scattiattuali = prompt("dammi gli scatti attuali")*1;
costoscatto = prompt(" dammi il costo dello scatto")*1;
canone = prompt("dammi il costo del canone mensile")*1;
bolletta = (scattiattuali - scattiprima)*costoscatto + canone;
//Create a text label and add it to layout.
txt = app.CreateText( "la bolletta telefonica di " +nome+ "pari a € "+bolletta);
txt.SetTextSize( 32 );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
///////////////////////////////////////
Sito di riferimento su JavaScript
SitoRiferimento DROIDSCRIPT
ISTRUZIONI FONDAMENTALI DI JAVASCRIPT VALIDE ANCHE IN AMBIENTE DROIDSCRIPT
STRUTTURA DEL LINGUAGGIO, SINTASSI DELLE ISTRUZIONI, STRUTTURE DI CONTROLLO, FUNZIONI ED EVENTI IN JAVASCRIPT
JavaScript è un linguaggio di scripting usato nelle applicazioni per il web.
Le sue caratteristiche principali sono:
- come molti linguaggi è case sensitive
- è necessario un interprete JavaScript
- è basato sugli oggetti come altri linguaggi
- gli eventi lo caratterizzano
- le pagine web sono rese dinamiche e quindi consentono interazione con utente.
__________________________________________________
Le istruzioni di OUTPUT con JavaScript
Per comunicare con ambiente esterno usa le segg. istruzioni:
1) alert("ciao a tutti");
questa istruzione viene usata per comunicare messaggi di errore attraverso una stringa e, anche, il valore di una qualsiasi variabile precedentemente calcolata . Appare una finestra di tipo modale nel senso che non consente di procedere se non dopo aver cliccato su OK
2) confirm("sono un programmatore JAVASCRIPT");
appare una finestra con due pulsanti (OK Annulla). Con il clik su OK il valore che assume confirm() è true, altrimenti è false
3) document.write("sono un programmatore JAVASCRIPT");
consente di scrivere direttamente sul documento.
Mi
______________________________________________
VARIABILI E COSTANTI IN JAVASCRIPT
LE VARIABILI IN JAVASCRIPT
Base e Altezza sono due variabili che occupano un'area di memoria a loro riservata e il loro valore può essere modificato durante l'esecuzione del procedimento usato. Non è altro che l'astrazione di una cella di memoria contenente, istante per istante, il valore della variabile a cui è stato attribuito un nome, un valore e un tipo di dato(int, float...)
Es. di VARIABILI
Base = 5; // definisce una variabile con nome Base e di valore intero pari a 5
Altezza = 15.3; // definisce una variabile reale con nome Altezza e di valore 15.3
/////////////////////////////////////////////////////////////////////////////////////////////
LE COSTANTI IN JAVASCRIPT
Tutte le grandezze che non modificano il loro valore sono dette costanti e sono rappresentate da un identificatore(nome) che, per convenzione, allo scopo di garantire leggibilità e netta distinzione, vengono nominate con lettere tutte maiuscole
Esempi di COSTANTI:
PGREGO = 3.14;
MASSIMO = 10;
MINIMO = 7;
LE COSTANTI
N.B.
Gli identificatori con una sola lettera maiuscola sono delle variabili.
Le COSTANTI hanno almeno 2lettere maiuscole
H = 5; // se la variabile ha una sola lettera questa deve essere maiuscola
HB = 5; // si tratta di una costante;
MassimoRelativo = 10; // si tratta di una COSTANTE
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
I COMMENTI CON JAVASCRIPT
Per spiegare il codice, e renderlo quindi meglio intellegibile, ci serviamo dei commenti nei due modi possibili:
1) // questo è un commento nel linguaggio JavaScript
2) /* questo è un commento nel linguaggio JavaScript */
Nel caso 1) il commento deve essere contento in una sola riga.
Nel caso 2) può essere posto su più righe.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISTRUZIONI DI INPUT CON JAVASCRIPT
Nel dover risolvere qualsiasi problema, specialmente in ambito tecnico, diventa indispensabile il dover acquisire i valori delle variabili che caratterizzano la nostra applicazione; solo adesso possono essere utilizzati all'interno di formule, può o meno complesse, relative al nostro specifico settore.
Con riferimento ad un caso specifico, ma molto semplice e indicativo, di dover acquisire la variabile base e/o altezza per il calcolo dell'area del triangolo, il codice di input da usare è il seg.:
Base = prompt(" dammi il valore della base del triangolo")*1;
Altezza = prompt("dammi il valore dell'altezza del triangolo")*1;
Osservazioni:
- notare che l'istruzione base= prompt ("dammi base triangolo...."), non necessita di una preventiva dichiarazione della variabile e il valore digitato viene messo immediatamente a disposizione in un'area di memoria a cui è stato assegnato il nome Base .
- Normalmente l'istruzione prompt() restituisce un valore stringa, ma, nel caso in cui il valore da acquisire sia un numero, occorre usare *1, dopo la parentesi tonda, allo scopo di fare ricevere al compilatore un valore esclusivamente numerico.
- tutte le istruzioni JavaScript iniziano sulla nuova riga e terminano con un punto e virgola. Non sempre è obbligatorio terminare l'istruzione con ; , ma, diventa indispensabile farlo, quando su quella riga si vogliono mettere più istruzioni.
es.
Area = 4; alert("questo è il valore area triangolo")
come si vede si tratta di una sola riga che contiene 2 istruzioni separate da un punto e virgola.
Si può, per convenzione, omettere il punto e virgola quando si sa che su quella riga c'è una sola istruzione.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OPERANDI E OPERATORI QUANDO SI EFFETTUA UN'ASSEGNAZIONE
Come in matematica, gli operandi sono i valori delle costanti del problema ed anche variabili acquisite che caratterizzano lo stesso e che intervengono attraverso formule, equazioni o altro, nel processo risolutivo.
I valori costanti vengono utilizzati nelle espressioni o assegnati alle variabili e possono essere:
- numerici interi(positivi e negativi)
- reali(numeri in virgola mobile, di tipo float)
- booleani o logici(solo 2stati possibili: true o false )
- stringa: qualsiasi sequenza di caratteri del tipo "gino45@libero.it", ma che può contenere caratteri speciali( \f \n) per avanzamento pagina e inizio riga rispettivamente.
I valori costanti interi possono essere espressi in:
- decimale(25,76,44
- esadecimale(FF1C) 11111111 = 255 e 00011100 = 28 preceduto da 0
- ottale: (034)ott = 28dec = 00011100bin preceduto da 0x
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GLI OPERATORI DI ASSEGNAZIONE
Con operatore di uguale (altezza = 5) si attribuisce un valore ad una variabile.
Con operatore nei doppio uguale ( altezza == base ) si impone una uguaglianza fra due variabili:
- altezza == base
- altezza = (base = 5)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GLI OPERATORI ARITMETICI UNARI, BINARI E TERNARI
Gli UNARI sono usati su un solo operando e determinano il cambiamento del valore:
altezza = 5
altezza = altezza++ ----------------------------------> equivale a altezza +1
altezza = altezza ----------------------------------> equivale a altezza - 1
Questi operatori possono essere messi prima(prefissi) o dopo(post-fissi) il valore della variabile:
altezza = 5
base = altezza ++ // post-fisso si assegna prima il valore ad altezza e poi si incrementa il valore per attribuirlo a base
// alla fine altezza = 5 mentre base = 6
altezza = 5
base = ++altezza // prefisso si incrementa prima il valore di altezza e questo lo si attribuisce alla base
// altezza = 5 e base = 6
__________________________________________________________
FORMA COMPATTA OPERATORI DI ASSEGNAMENTO
altezza + = base --------------------------> altezza = altezza + base
altezza - = base -------------------------> altezza = altezza - base
altezza * = base ----------------------------> altezza= altezza * base
altezza / = base. ------------------------------> altezza = altezza / base
altezza % = base ------------------------------> altezza = altezza % base
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GLI OPERATORI RELAZIONALI
Questi operatori controllano la veridicità di una relazione logica e rispondono con true o false(vero o falso)
altezza = 5
base = 4
area = 6
altezza > base
base < altezza
area >= altezza
base <= altezza
area != altezza
___________________________________________
Gli operatori logici verificano la veridicità di una espressione logica mediante true e false ed essi sono:
- ( altezza > base) || ( altezza < 7 ) operatore OR_logico che risponde con true se una sola delle due espressioni risulta vera
- ( altezza < base) && ( base > 8 ) operatore AND_logico che risponde con true se entrambe le espressioni sono vere
- base ^ altezza OResclusuvo(XOR) controlla se base e altezza sono uguali tra loro
__________________________________________________
GLI OPERATORI SULLE STRINGHE
+ a = "pino"
b = "gino"
z = a+b
alert(z) // concatenazione, risponde: pinogino
+= x = "pino" += "gino" // accodamento risponde pinogino
alert(x)
!= y = (a != b)
alert(y) // disuguaglianza risponde con true perché le stringhe non sono uguali
== k = (a == b) // uguaglianza risponde con false perché non sono uguali le stringhe
alert(k)
= m = (a =b) // risponde con gino perché assegna alla stringa b il valore della stringa a
alert(m)
/////////////////////////////////////////////////////////////////////////////////////////////
OPERATORI TERNARI IN JAVASCRIPT
Svolge questa operazione un operatore particolare indicato con ? e viene usato nel seg. modo:
prodotto = ((numero>0)?5:20) // la variabile prodotto assume il valore 5 se il numero è maggiore di 0, altrimenti prende il valore 20 se negativo o nullo.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
GLI OPERATORI POLIMORFI IN JAVASCRIPT
Sono considerati POLIMORFI tutti gli operatori che agiscono su operandi di tipo diverso ed essi sono:
+ // sia su operandi numerici sia su stringhe
+=
=
==
!=
=
Esempi:
peso = 23 + 45 // peso risulta intero perché somma di due interi
saluto = "voglio salutare" + " tutti gli amici") // risponde con: voglio salutare tutti gli amici (concatena stringhe)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LE CONVERSIONI DI TIPO CON JAVASCRIPT
In molti linguaggi di programmazione le variabili devono prima essere dichiarate e poi utilizzate e sono di tipo statico in quanto non si può modificare durante il processo. In JAVASCRIPT non esiste una sezione dichiarativa delle variabili e il loro tipo viene assegnato in modo endogeno a seconda del valore che abbiamo inizialmente assegnato. Il tipo può cambiare in fase di elaborazione.
Es.1
Saluto = "ciao a tutti"; base = 34 // la prima variabile è di tipo stringa e l'altra è numerica
In JAVASCRIPT il tipo delle variabili è dinamico in quanto cambia durante il processo....
____________________________
Es.2
base = 4; base++; base = "uno dei lati"; base = base + " del triangolo"
// dichiarazioni tutte corrette: base inizialmente numerica e poi cambia dinamicamente diventa di tipo stringa
//////////////////////////////////////////////////////////////////////////////////////////////////////////
LA CONVERSIONE IMPLICITA CON JAVASCRIPT
CONVERSIONE IMPLICITA
Conversione NUMERO-------------> STRINGA
Su operandi di tipo diverso (stringa e numero) prevale il tipo stringa e quindi si ottiene una stringa
base = 1 + " dei lati" -------------------------------------------> "1 dei lati"
//////////////////////////////////////////////////////
Conversione STRINGA-----------------------------> NUMERO
n.b.
se l'operatore è il prodotto * allora è il prevalente in quanto unico che agisce solo sui numeri.
Es.
base = "5" * 6 --------------------------------------> base = 30 // prevale il *
base = "5" + 6 --------------------------------------> base = "56" // prevale il + e quindi concatena
//////////////////////////////////////////////////////
CONVERSIONE ESPLICITA
Quando dobbiamo convertire una variabile da NUMERICO-------------------> STRINGA si usa la funzione String() nel seguente modo:
Base = 23
LatoStringa = String(Base) // alla variabile LatoStringa viene assegnato il valore 23. LatoStringa = 23
///////////////////////////////////////////////////////
Per convertire una variabile da STRINGA---------------------------------------> NUMERO
SI USANO DIVERSE FUNZIONI:
1) base = parseInt('15ad',8) // estrapola la parte intera di un numero da una stringa e restituisce 13
2) base = parseInt('15ad',10) // attribuisce 15 alla base
3) base = parseInt ('15ad',16) // attribuisce a base il valore 5549
4) base = parseInt ('2021') // attribuisce a base il valore 2021
5) base = parseInt ('55.70') // base = 55
6) base = parseInt ('05') // base = 0
7) base = parseInt ('www.www.www5.@@') // base = 5
n.b.
parseInt() per estrarre un numero è indispensabile che questo sia ad inizio stringa e se non lo trova risponde con NaN(Not a Number)
Esiste altra funzione chiamata parseFloat() che è simile a parseInt() con unica differenza che viene conservata eventuale virgola mobile presente e il relativo segno.
Es. di uso di parseFloat()
primo = 5; secondo = 30; terzo = 40; totale = eval("primo+secondo+terzo+50") // totale = 125
/////////////////////////////////////////////////////////////////////
BLOCCHI DI ISTRUZIONI IN JAVASCRIPT
Il costrutto IF ............ELSE
// Un blocco di istruzioni è soltanto un insieme di due o più istruzioni
// che devono essere eseguite, al verificarsi di determinate condizioni, all'interno dello stesso blocco logico. Viene delimitato da due parentesi graffe in apertura e in chiusura { }.
es.1
n1 = prompt("dammi primo numero")*1;
n2 = prompt("dammi secondo numero")*1;
if(n1 > n2)
{
alert(n2+" n2 è maggiore di n1"+n1);
}
else
{
alert(n1+"n2 è minore di n1"+n2);
}
_____________________________
es.2
var Num = parseInt(prompt("inserisci un numero da tastiera: ", " "));
if(Num == 5)
{
alert("il tuo numero è il "+Num);
}
else if(Num == 15)
{
alert("il tuo numero è il "+Num);
}
else
{
alert(" il tuo numero è il "+Num);
}
//////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
LA STRUTTURA DEL COSTRUTTO FOR IN JAVASCRIPT
Somma = 0; // definisce e inizializza a zero la variabile Somma
for(Count = 0; Count < 4; Count++) // ciclo FOR, da 4 a 0 compreso, per acquisire 5 numeri
{
Num = parseInt (prompt ("dammi un numero"," ")); // prompt che si ripete 5volte
Somma = Somma+Num; // somma i numeri inseriti aggiornando ogni volta la variabile
alert ("Somma = "+ Somma); // comunica ogni volta la somma parziale
}
///////////////////////////////////////////////////////////////////////
ISTRUZIONI ITERATIVE: IL COSTRUTTO WHILE
STRUTTURA DEL COSTRUTTO WHILE:
Count = 4;
while(Count >=0)
{
alert("contatore = "+ Count);
Count = Count -1;
}
////////////////////////
STRUTTURA DEL COSTRUTTO DO_WHILE
Count = 4;
do // fai tutto questo
{
alert("sto decrementando il contatore "+Count); // comunica i risultati parziali
Count = Count-1; // decrementa il contatore
}
while(Count >= 0) // mentre il contatore risulta >=0
////////////////////////
STRUTTURA DI UN IF ANNIDATO IN UN CICLO WHILE
Es.1
// Si vuole calcolare la percentuale(var Percent) di numeri(var Quanti) positivi, introdotti
// da tastiera e per questo inizializziamo la var Count al valore desiderato. I numeri positivi(var Positivi) e inizializzati a 0. Per i numeri acquisiti si usa la var Acquisisci dentro il ciclo while.
// Con l'istruzione if annidata nel WHILE si controlla se il numero digitato è positivo e si incrementa
// il contatore dei Positivi.
var Quanti, Positivi, Count, Percent, Acquisito;
Quanti = prompt ("quanti numeri vuoi leggere"," ") * 1;
Count = 0 // inizializza contatore relativo a quanti numeri si vogliono acquisire
Positivi = 0; // inizializza contatore dei numeri positivi introdotti
while(Count < Quanti)
{
Acquisito = prompt("dammi un numero intero") * 1;
if(Acquisito > 0)
Positivi = Positivi +1;
Count = Count +1;
}
Percent = (Positivi/Count )*100;
alert("sono stati introdotti un numero di positvi pari a "+ Positivi);
alert("i numeri negativi sono: "+(Count-Positivi));
alert ("la percentuale dei positivi è "+Percent);
alert ("la percentuale dei negativi è "+(100 - Percent));
////////////////////////////
Es.2
// Con questo script viene individuato il piu grande divisore di un numero
// qualsiasi introdotto da tastiera. La variabile contatore Count si inzializza
// con il valore Count= Numero-1 allo scopo di escludere la divisibilita per il numero
// stesso e poi, entro il ciclo while, la si decremeta di 1 dopo aver verificato
// con Numero%Count == 0 che lo stesso e un numero pari.
// Con il break entro il ciclo while interrompiamo subito lo stesso nel
// momento in cui viene trovato il primo divisore di Numero
Numero = prompt("Inserisci un numero"," ")*1;
var Count = Numero-1;
while(Count >= 1)
{
if (Numero % Count == 0) break
Count--;
}
alert("il divisore piu grande e "+Count);
///////////////////////////////////////////////////////////////////
LA STRUTTURA DEL COSTRUTTO SWITCH IN JAVASCRIPT
Es.
var giorno;
giorno=parseInt(prompt("dammi il giorno"));
switch(giorno)
{
case 0:
{
giorno = "domenica";
alert("domenica");
break;
}
case 1:
{
alert("lunedì");
break;
}
case 2:
{
alert( "martedì¬ dal dentista 17.50");
break;
}
case 3:
{
alert( "mercoledì e devi studiare");
break;
}
case 4:
{
alert("giovedì appuntamento con il medico ore 15.30");
break;
}
case 5:
{
alert( "venerdì partita a tennis con giorgio");
break;
}
case 6:
{
alert("sabato");
break;
}
}
////////////////////////////////////////////////////////////////////
GESTIONE DEL CICLO WHILE CON LE ISTRUZIONI BREAK E CONTINUE
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt = app.CreateText( "" );
txt.SetTextSize( 32 );
var x = 0;
while (x < 100)
{
txt.SetText(x );
lay.AddChild( txt );
app.AddLayout( lay );
x++;
if (x > 33) continue;
// se x è maggiore di 33, questa istruzione non viene più eseguita e il conteggio arriva a 100
txt.SetText(x);
if (x > 33) break;
// se x > e maggiore di 33, questa istruzione viene eseguita e il conteggio si ferma a 33
txt.SetText(x);
}
}
//////////////////////////////////////
ISTRUZIONI ITERATIVE IL CICLO DO_WHILE POST_CONDIZIONE
SOMMA DI N NUMERI
// ISTRUZIONI ITERATIVE IL COSTRUTTO WHILE
// IL CONTATORE count viene inizializzato a 0 e poi incrementato ad ogni numero inserito
// LA somma, inizializzata a 0, viene incrementata da tutti i numeri inseriti.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "" );
txt.SetTextSize(22);
lay.AddChild( txt );
var somma = 0;
var count = 0;
while (count < 5)
{
num = parseInt(prompt(" inserisci un numero")); // conversione esplicita
count++; // incrementa contatore
somma=somma + num;
}
txt.SetText("hai inserito "+ count +" numeri e la loro somma pari a "+somma); // comunica risultati
//Add layout to app.
app.AddLayout( lay );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
OUTPUT & INPUT per comunicare i risultati e acquisire variabili
Istruzioni di OUTPUT in DroidScript.
Per Visualizzare
app.Alert( "This is an alert box", "Hello Yellow World!");
Con essa viene visualizzata una finestra di dialogo con le informazioni relative a quanto si sta facendo.
Es. di OUTPUT
function OnStart()
{
lay=app. CreateLayout("linear", "VCenter, FillXY") ;
app.Alert("This is an alert box", "Hello Yellow World!", "", -100 );
app. AddLayout(lay) ;
}
____________________
L'esecuzione di queste righe di codice comporta l'apparizione di una interfaccia di dialogo sulla quale viene riportata l'informazione testuale contenuta nella stringa di testo relativa all'Alert.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Per ascoltare
app.TextToSpeech("Hello World");
L'aspetto interessante è quello relativo alla possibilità di dialogo con l'utente offerta, anche, dall'istruzione app.TextToSpeech(" HELLO WORLD ") integrata nel linguaggio stesso. Questo risulta possibile sia in fase di acquisizione delle variabili del generico problema e in regime di dichiarazione delle specifiche progettuali ma, pure, nella successiva fase di comunicazione dei risultati finali.
Come si usa l'istruzione in un caso pratico:
Es. di OUTPUT
function OnStart()
{
lay=app. CreateLayout("linear", "VCenter, FillXY");
1. h=6; // altezza del cilindro
2. r=8; // raggio del cilindro
3. PGRECO=3.14; // fissa il valore della costante
4. volumeCilindro = PGRECO*r**2*h; // calcola il volume
5. app.TextToSpeech("volume del cilindro"+ volumeCilindro);
6. app. AddLayout(lay) ;
}
Questa porzione di codice genera un segnale vocale con il quale si comunica il valore numerico del volume, oltre all'informazione contenuta nella stringa di testo. Il segno + è servito a concatenare il valore numerico alla stringa usando una sola riga di codice.
//////////////////////////////////////////////////////
ALTRE ISTRUZIONI DI OUTPUT in DroidScript
txt = app.CreateText(" ");
txt.SetText(" Hello World");
Istruzione di OUTPUT che ha grande spendibilità è la txt.SetText(" Hello World"); deve essere usata, dopo aver creato una casella di testo con txt = app.CreateText(" "), nel seg. modo:
Es. di OUTPUT relativo a un caso pratico:
function OnStart()
{
lay=app. CreateLayout("linear", "VCenter, FillXY");
txt= app.CreateText(" ");
lay.AddChild(txt); mette txt su lay
r = prompt("dammi il raggio del cilindro"); ; //acquisisce raggio
h = prompt("dammi altezza del cilindro"); //acquisisce altezza
PGRECO = 3.14; // dichiara la costante
volumeCilindro = PGRECO*r*r*h; // calcola il volume
txt.SetText(volumeCilindro+" volume del cilindro"); // visualizza sulla txt il valore del volume del cilindro con accanto la stringa " volume del cilindro"
app.AddLayout(lay) ; // mette lay su Layout
}
//////////////////////////////////////////////////////
Altra istruzione di OUTPUT molto importante è la app.ShowPopup(" ")
Viene usata come nell'esempio sotto.
function OnStart()
{
lay=app. CreateLayout("linea", "VCenter, FillXY") ;
areaCerchio = 20; // calcola area cerchio
app.ShowPopup("area del cerchio è pari a: " + areaCerchio);
app. AddLayout(lay) ;
}
L'effetto che produce è quello di far apparire sullo schermo, per qualche istante, la stringa di testo contenuta fra le doppie virgolette, con accanto il valore numerico che ha preso la grandezza di OUTPUT(areaCerchio) durante il calcolo.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
INPUT per acquisire dati
Per inserire i dati
I dati rappresentano i valori delle variabili del progetto di cui ci stiamo occupando e possono essere acquisiti, mediante tastiera, usando le istruzioni indicate sotto.
Istruzioni di INPUT in DroidScript
Es. di INPUT
raggio=prompt(" dammi il raggio del cerchio in metri");
La riga di codice, di cui sopra, fa apparire l'interfaccia di dialogo, ereditata da JavaScript(prompt), con la quale è possibile acquisire le variabili di un generico problema e utilizzarle contestualmente al progetto in esame.
Se digitiamo il relativo valore, questo viene attribuito alla variabile nel momento in cui si clicca su OK. Il valore di tale variabile può essere utilizzato solo sulle successive righe di codice dal momento che lo stesso viene eseguito, riga per riga, a partire dalla prima, secondo la modalità top/down.
----------------------------------------------------------------
Altra istruzione di INPUT che trova largo uso, e che risulta molto utile in quanto consente di acquisire vocalmente(microfono) delle informazioni, e' quella relativa alla creazione di un registratore vocale che interpreta tali messaggi.
INPUT VOCALE CON DROIDSCRIPT
Per comunicare a voce specifiche richieste
rec = app.CreateAudioRecord();
Un es. completo è riportato sotto.
È relativo ad uno script che si pone in attesa di ricevere dei comandi vocali e, in relazione alla richiesta formulata, è in grado di attivare la specifica function().
Lo script mette in evidenza le sue potenzialità essendo facilmente adattabile alle innumerevoli situazioni nelle quali ci possiamo trovare ad operare.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
nome = prompt("come ti chiami"); // attiva interfaccia di dialogo per acquisire il nome
btn = app.CreateButton("chiedimi qualcosa",0.3,0.1); // crea bottone con sopra il testo(chiedimi qualcosa)
btn.SetOnTouch(btn_OnTouch); // attiva la function() quando si preme il bottone
rec = app.CreateAudioRecorder(); // crea oggetto AudioRecord() di nome rec
rec.SetFile("/sdcard/demo.wav"); // percorso dove si salva il file audio di nome rec
rec.Start(); // avvia la registrazione
rec.Stop(); // ferma la registrazione
lay.AddChild(btn);
speech = app.CreateSpeechRec(); // crea oggetto SpeechRecord() di nome speech
speech.SetOnResult(speech_OnResult);
speech.SetOnReady(speech_OnReady); //appare (Listening)
speech.SetOnError(speech_OnError); //attiva la function Error
txt = app.CreateText("");
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
function btn_OnTouch() //attiva il riconoscimento vocale quando si tocca il bottone
{
speech.Recognize();
}
function speech_OnReady()
{
app.ShowPopup("Listening..","Short");
}
function speech_OnResult(results) //interpreta la voce
{
app.ShowPopup(results[0] );
if(results[0]== "giochi al tennis") // se results[0] contiene"giochi al tennis" viene attivato il metodo e comunica a voce
{
app.TextToSpeech("sono" +nome+" e mi piace giocare a tennis" ); // comunica a voce
}
if(results[0]=="vai a sciare")
{ // se results[0] contiene "vai a sciare" viene attivato il metodo
app.TextToSpeech("sono" + nome + " vado in montagna ma non mi piace sciare");
}
if(results[0]=="numero telefono") // se la domanda è il numero di telefono
{
app.TextToSpeech(" il numero di telefono e 33955555503"); // comunica a voce il numero
}
if(results[0]=="conto bancario") // se la domanda è il numero di conto
{
app.ShowPopup("673456" ); // se la domanda è il numero del conto
}
if(results[0]=="bancomat")
{
app.TextToSpeech("il numero della carta bancomat e 57894" );
}
if(results[0] == "triangolo")
{
b=prompt("dammi la base");
h=prompt("dammi altezza");
a=b*h/2;
app.TextToSpeech(a,"area del triangolo"); // comunica a voce il risultato
txt.SetText(a,"area del triangolo");
}
}
function speech_OnError() // attiva la function speech_OnError()
{
app.ShowPopup(nome +" parla in modo chiaro altrimenti non capisco");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
VENGONO MOSTRATE ALTRE APPLICAZIONI DI VARIO GENERE CHE POSSONO AVERE UNA CERTA VALENZA, SIA ESPLICATIVA CHE APPLICATIVA, ANCHE PER LA DIDATTICA
1) CALCOLO AREA CERCHIO E VOLUME DEL CILINDRO
volume-del cilindro Sito Rif.to
//Called when applicati on is started
function OnStart ()
{
lay=app.CreateLayout ("linear", "VCenter, FillXY")
txt=app.CreateText ("Volume Cilindro");
txt1=app.CreateText ("");
txt1.SetTextSize (20);
txt.SetTextSize(20);
pgreco=3.14; // fissa il pgreco al valore conosciuto
app.TextToSpeech ("dammi raggio cilindro"); // comunica, a voce, la richiesta della variabile raggio
r = prompt("dammi raggio cilindro"); // acquisisce, da tastiera, il valore del raggio r
app.TextToSpeech ("dammi altezza cilindro");
h = prompt("dammi altezza cilindro");
superficieCilindro = Math.round(2*pgreco*r*h+2*pgreco*r*r);
volumeCilindro = Math.round((pgreco*r*r)*h);
txt1.SetText(volumeCilindro+" volume del cilindro"); // visualizza sulla txt1 il valore del volume del cilindro
app.TextToSpeech ("volume del cilindro pari a"+volume_cilindro+" mc"); // comunica a voce il volume
app.TextToSpeech ("la superficie del cilindro risulta di"+superficieCilindro+" mq"); // comunica a voce la superficie
txt.SetText(superficieCilindro+" mq superficie del cilindro"); // visualizza la superficie il valore della superficie e la stringa("mq superficie del cilindro")
lay.AddChild (txt);
lay.AddChild (txt1);
app.AddLayout( lay );
__________________
Il codice depurato di tutti i commenti e portato all'essenziale è solo quello sottostante. Si evidenzia la funzionalità dello stesso, applicabile a qualsiasi altro tipo di problema.
//Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt = app.CreateText( "" );
txt.SetTextSize( 32 );
r=prompt("dammi il raggio area di base del cilindro");
h=prompt("dammi altezza del cilindro");
pgreco=3.14;
volumeCilindro= (pgreco*r**2*h);
txt.SetText(volumeCilindro+" volume del Cilindro");
lay.AddChild(txt );
app.AddLayout( lay );
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) CALCOLO AREE DI FIGURE GEOMETRICHE. AVVIO DELLA FUNZIONE CON IL TOCCO( TOUCH ) DELLO SCHERMO.
Basta toccare la specifica figura geometrica.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img1=app.CreateImage("/storage/emulated/0/Download/ca1.png",1.0,0.6);
lay.AddChild(img1);
img1.SetOnTouch(toccato);
app.AddLayout( lay );
}
function toccato(posizione)
{
app.ShowPopup(posizione.x[0]+ "-" + posizione.y[0]);
var x 1= posizione.x[0];
var y1 = posizione.y[0];
if (x1 > 0.40 && y1 < 0.8 && x1 < 0.5 && y1 > 0.41)
{
app.TextToSpeech("cerchio, area del cerchio viene calcolata come prodotto di pigreco per il raggio al quadrato",1.0,1.0);
}
if (x1>0.1 && y1<0.9 && x1<0.25 && y1>0.42)
{
app.TextToSpeech("triangolo, area del triangolo viene calcolata come prodotto della base per altezza diviso due",0.1,0.8 );
app.ShowPopup("area = base * altezza/2");
}
if (x1>0.7 && y1<0.8 && x1<0.9 && y1>0.41)
{
app.TextToSpeech("quadrato, area del quadrato viene calcolata come prodotto di lato per lato. ",0.6,0.8);
app.ShowPopup( "area_quadrato="+ lato * lato );
}
} ____________________________________________
Video a supporto
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) Calcolatrice che esegue le quattro operazioni aritmetiche, l'elevazione a potenza e la radice quadrata.
COMUNICA A VOCE I RISULTATI.
//Called when application is started.
function OnStart()
{
sv= app.CreateLayout( "linear", "VCenter,FillXY" );
b5=app.CreateButton("ELEVAZIONE A POTENZA x^n",0.2,0.1);
b5.SetTextColor( "#aabbcc" );
b5.SetOnTouch(eleva );
sv.AddChild(5);
b1=app.CreateButton("MOLTIPLICAZIONE",0.3,0.1);
b1.SetOnTouch(molti);
b1.SetTextColor( "#bbffcc" );
sv.AddChild(b1 );
b2=app.CreateButton("DIVISIONE",0.2,0.1);
b2.SetOnTouch(divi );
b2.SetTextColor( "#00ff11" );
sh.AddChild( b2);
b3=app.CreateButton("SOTTRAZIONE",0.2,0.1);
b3.SetOnTouch(sottra);
b3.SetTextColor( "#aabb00" );
sh.AddChild( b3 );
b4=app.CreateButton("ADDIZIONE",0.2,0.1);
b4.SetOnTouch(addi);
b4.SetTextColor( "#1cb0ac" );
sv.AddChild( b4 );
}
function eleva()
{
app.TextToSpeech("dammi la base della potenza");
x=prompt("dammi la base della tua potenza");
app.TextToSpeech("dammi esponente della potenza" );
n=prompt("dammi esponente");
potenza=Math.pow(x,n);
b9.SetText(potenza+ " potenza di " +x+" elevato a "+n);
app.TextToSpeech( potenza+ "potenza di"+ x+ "elevato a" +n );
}
function molti()
{
app.TextToSpeech( "dammi primo numero da moltiplicare" );
n1=prompt("dammi primo numero");
app.TextToSpeech( "dammi secondo numero da moltiplicare" );
n2=prompt("dammi secondo numero");
app.TextToSpeech( "dammi eventuale terzo numero da moltiplicare" );
n3=prompt("dammi terzo numero");
pro=n1*n2*n3;
app.ShowPopup( pro );
app.TextToSpeech( "il prodotto risulta uguale a" + pro);
}
function divi()
{
app.TextToSpeech( "dammi il valore del dividendo" );
n1 = prompt("dammi primo numero dividendo");
app.TextToSpeech( "dammi il valore del divisore" );
n2 = prompt("dammi secondo numero divisore");
divisione=(n1/n2); app.ShowPopup( divisione );
app.TextToSpeech( "il quoziente della divisione risulta pari a" +divisione);
}
function sottra()
{
app.TextToSpeech( "dammi il numero da cui vuoi sottrarre detto minuendo" );
n1=prompt("dammi il numero da cui devi sottrarre");
app.TextToSpeech( "dammi il numero che vuoi sottrarre detto sottraendo");
n2=prompt("dammi il primo numero che devi sottrarre");
app.TextToSpeech( "dammi eventuale secondo numero che vuoi sottrarre oppure digita zero" );
n3=prompt("dammi eventuale secondo numero da sottrarre");
sottra=n1-n2-n3;
app.ShowPopup( sottra );
app.TextToSpeech( "il risultato della sottrazione risulta pari a" +sottra );
}
function addi()
{
app.TextToSpeech( "dammi primo numero da sommare" );
n1=prompt("dammi primo numero");
app.TextToSpeech( "dammi secondo numero da sommare");
n2=prompt("dammi secondo numero");
n1=n1*1;
n2=n2*1;
app.TextToSpeech( "dammi eventuale terzo numero da sommare oppure digita zero per non alterare la somma");
n3=prompt("dammi eventuale altro numero oppure digita zero");
n3=n3*1;
addizio=n1+n2+n3;
app.ShowPopup( addizio );
app.TextToSpeech( "la somma risulta pari a" +addizio );
}
function radice()
{
app.TextToSpeech( "dammi il numero di cui vuoi trovare la radice" );
n1=prompt("dammi il numero di cui vuoi trovare la radice");
radice=Math.Sqrt(n1);
app.ShowPopup(radice);
app.TextToSpeech( "la radice di "+n1);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) SIMULAZIONE DI PROVA SCOLASTICA ADATTABILE ALLE VARIE ESIGENZE E SITUAZIONI. E' SOLO UNO SPUNTO...
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY");
var x;
x=0;
var nome;
img=app.CreateImage("/storage/emulated/0/Download/matisse.jpeg",0.9,0.5);
lay.AddChild( img );
app.TextToSpeech("dimmi come ti chiami");
nome=prompt("dimmi come ti chiami");
app.TextToSpeech("la capitale della spagna");
y=prompt("capitale spagna")
if (y=="madrid")
{
x=x+10;
app.TextToSpeech("risposta corretta",0.5,0.5);
}
else
{
app.TextToSpeech("errato studia meglio",0.5,0.5);
app.ShowPopup("errato");
}
app.TextToSpeech("chi ha dipinto il quadro Donna con cappello");
y=prompt("chi ha dipinto il quadro Donna con cappello nel mille novecento cinque");
if (y=="matisse")
{
lay.AddChild( img );
app.TextToSpeech("risposta corretta",0.8,0.8);
lay.AddChild(img);
x=x+10;
}
else
{
app.TextToSpeech("non corretta studia meglio. si tratta di matisse che lo ha realizzato nel mille novecento cinque Olio su tela conservato a san francisco presso museo arte moderna. ti ricordo che la vita di matisse si svolse per tutto il suo corso nella serenità della vita famigliare, in una casa dal gusto borghese e senza dare modo di pensare che egli conducesse una esistenza ribelle, spregiudicata o scandalosa che, invece, sembrava dover essere tipica di un innovatore rivoluzionario. Se dovessimo sintetizzare il percorso artistico del grande pittore potremmo farlo impiegando le stesse parole da lui stesso usate: come impressionista, ho dipinto direttamente dalla natura e poi ho aspirato a una maggiore concentrazione e ad una espressività più intensa nelle linee e nei colori. Per raggiungere questo obiettivo, afferma ancora, ho dovuto sacrificare altri valori come la materia, la tridimensionalità, la ricchezza dei dettagli. Ora voglio riconciliare questi valori",0.8,0.8);
}
app.TextToSpeech("capitale inghilterra");
y=prompt("capitale inghilterra");
if (y=="londra")
{
app.TextToSpeech("risposta corretta");
x=x+10;
}
else
{
app.TextToSpeech(nome+"hai sbagliato");
}
app.TextToSpeech("chi ha scritto il gattopardo");
y=prompt("chi ha scritto Il gattopardo");
if (y=="tomasi")
{
app.TextToSpeech(nome+"risposta corretta");
x=x+10;
}
else
{
app.TextToSpeech(nome+"risposta non corretta");
}
app.ShowPopup("hai ottenuto punti "+ x);
if (x>= 30)
app.TextToSpeech(nome+ "hai superato la prova");
//Add layout to app.
app.AddLayout(lay);
} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) APPLICAZIONE MULTIDISCIPLINARE CON DROIDSCRIPT(AreaTecnica)
Con il semplice tocco sul bottone specifico, si avvia la corrispondente function().
Lo script può essere personalizzato, ed esteso quanto si vuole, in base alle specifiche esigenze didattiche e, quindi, adattato ai contenuti disciplinari dei vari corsi.
//Called when application is started.
function OnStart()
{
sv= app.CreateLayout( "linear", "VCenter,FillXY" );
b1=app.CreateButton("RIFASAMENTO IMPIANTO INDUSTRIALE",0.8,0.2);
b1.SetOnTouch(rifa);
b1.SetTextColor( "#11ffcc");
bt=app.CreateButton("TRAVE INCASTRATA CHE SUPPORTA SOLAIO",0.8,0.6);
bt.SetOnTouch(trave);
//bt.SetBackColor("11ffaa");
bt.SetTextColor( "#1cb0ac");
sv.AddChild( bt );
sv.AddChild( b1);
bc=app.CreateButton("CILINDRO",0.9,0.05);
bc.SetTextColor( "#11ffcc" );
bc.SetBackColor( "#aabbcc" );
sv.AddChild( bc );
bc.SetOnTouch(cili);
txt1=app.CreateText("");
txt2=app.CreateText("");
txt3=app.CreateText("");
txt4=app.CreateText("");
txt5=app.CreateText("");
txt6=app.CreateText("","Multiline",0.8,0.3);
txt1.SetTextSize( 15 );
txt2.SetTextSize( 15 );
txt3.SetTextSize( 15 );
txt4.SetTextSize(15);
txt5.SetTextSize(15);
txt6.SetTextSize(15);
sh=app.CreateLayout("Linear","Horizontal");
sv.AddChild( sh );
b2=app.CreateButton("FIBRA OTTICA",0.2,0.05);
sh.AddChild( b2 );
b2.SetTextColor( "#ffccaa" );
b2.SetOnTouch(fibra);
b5=app.CreateButton("GOOGLE",0.2,0.05);
sh.AddChild(b5 );
b5.SetTextColor( "#aabb00" );
b5.SetOnTouch(internet );
b3=app.CreateButton("INTEGRALE",0.2,0.05);
b3.SetOnTouch(integra);
sh.AddChild( b3 );
b3.SetTextColor( "#00ccaa" );
b4=app.CreateButton("DERIVATA",0.2,0.05);
b4.SetOnTouch(deriva );
b4.SetTextColor( "#22ff22" );
sh.AddChild(b4 );
b6=app.CreateButton("CINEMATICA",0.2,0.05);
b6.SetOnTouch(cinematica);
b6.SetTextColor( "#ffbb00" );
sh.AddChild( b6);
sh=app.CreateLayout("linear","Horizontal");
sv.AddChild( sh );
b8=app.CreateButton("ANTENNA",0.2,0.05);
b8.SetTextColor( "#aa11cc" );
b8.SetOnTouch(antenna );
sh.AddChild( b8 );
b10=app.CreateButton("STORIA",0.2,0.05);
b10.SetTextColor( "#ccddaa" );
sh.AddChild( b10 );
b9=app.CreateButton("ELEVAZIONE A POTENZA x^n",0.2,0.05);
b9.SetTextColor( "#aabbcc" );
b9.SetOnTouch(eleva );
sh.AddChild( b9 );
b11=app.CreateButton("INGLESE",0.2,0.05);
b11.SetTextColor( "#aa00ff" );
sh.AddChild( b11 );
b12=app.CreateButton("Modulazione FM",0.2,0.05);
b12.SetTextColor( "#ccddff" );
b12.SetOnTouch(modula);
sh.AddChild( b12 );
sh=app.CreateLayout("Linear","Horizontal");
sv.AddChild( sh );
b13=app.CreateButton("MOLTIPLICAZIONE",0.2,0.05);
b13.SetOnTouch(molti);
b13.SetTextColor( "#bbffcc" );
sh.AddChild(b13 );
b14=app.CreateButton("DIVISIONE",0.2,0.05);
b14.SetOnTouch(divi );
b14.SetTextColor( "#00ff11" );
sh.AddChild( b14 );
b15=app.CreateButton("SOTTRAZIONE",0.2,0.05);
b15.SetOnTouch(sottra);
b15.SetTextColor( "#aabb00" );
sh.AddChild( b15 );
b16=app.CreateButton("ADDIZIONE",0.2,0.05);
b16.SetOnTouch(addi);
b16.SetTextColor( "#1cb0ac" );
sh.AddChild( b16 );
sv.AddChild( txt1 );
sv.AddChild( txt2 );
sv.AddChild( txt3 );
sv.AddChild( txt4 );
sv.AddChild(txt5 );
sv.AddChild( txt6 );
app.AddLayout(sv);
}
function internet()
{
web=app.CreateWebView(0.8,0.8);
sv.AddChild( web );
web.LoadUrl("http://google.com");
web.LoadUrl("www.comune.feroletodellachiesa.rc.it");
}
function cili()
{
sv.AddChild( txt1 );
app.TextToSpeech( "dammi il raggio cilindro" );
r=prompt("dammi il raggio del cilindro");
app.TextToSpeech( "dammi altezza cilindro" );
h=prompt("dammi altezza del cilindro");
pgreco=3.14;
areaCi= Math.round(2*pgreco*r*r+(h*2*pgreco*r))
circonCi=Math.round(2*pgreco*r);
volCi=Math.round(pgreco*r*r*h/3);
supCi=Math.round(2*pgreco*r*h);
txt1.SetText(areaCi +" mq area del cilidro");
txt2.SetText(circonCi +" m circonferenza cilindro");
txt3.SetText(volCi + " volume del cilidro");
txt4.SetText(supCi + " mq superfice del cilindro");
app.TextToSpeech( volCi+ "mc volume cilindro" );
app.TextToSpeech(areaCi + "area cilindro");
app.TextToSpeech(circonCi + "circonferenza cilindro");
}
function prodotto()
{
app.TextToSpeech("dammi primo numero");
num1=prompt("dammi primo numero");
app.TextToSpeech( "dammi secondo numero" );
num2=prompt("dammi secondo numero");
app.TextToSpeech("dammi terzo numero");
num3=prompt("dammi terzo numero");
pro=num1*num2*num3;
app.ShowPopup( pro );
app.TextToSpeech( pro );
}
function eleva()
{
app.TextToSpeech("dammi la base della potenza");
x=prompt("dammi la base della tua potenza");
app.TextToSpeech("dammi esponente della potenza" );
n=prompt("dammi esponente");
potenza=Math.pow(x,n);
b9.SetText(potenza+ " potenza di " +x+" elevato a "+ n);
app.TextToSpeech( potenza+ "potenza di"+ x + "elevato a" +n );
}
function manzo()
{
app.TextToSpeech("i promessi sposi");
}
function fibra()
{
lamda=prompt("dimmi con quale lamda opera la fibra espresso in nm");
n1=prompt("dimmi il valore indice rifrazione del core n1");
n2=prompt("dimmi il valore indice di rifrazione del cladding n2");
NA=Math.sqrt(n1*n1-n2*n2);
Teta_a=Math.asin(NA);
d=prompt("dammi il diametro del core in microm_metro");
V=(3.14*d*NA)/lamda;
N_modi=Math.round(V*V)/2.46;
app.TextToSpeech( N_modi ,"numero di modi di propagazione");
txt6.SetText(" numero di modi di propagazione" +N_modi);
// app.OpenFile( "/storage/sdcard0/Python.doc","text","Editor di testo DB");
}
function molti()
{
app.TextToSpeech( "give me first number to multiply" );
n1=prompt("give me first number");
app.TextToSpeech( "give me second number to multiply" );
n2=prompt("dammi secondo numero");
app.TextToSpeech( "signature" );
n3=prompt("give me terth number");
pro=n1*n2*n3;
app.ShowPopup( pro );
app.TextToSpeech( "il prodotto risulta uguale a" + pro);
}
function antenna()
{
Potenza=prompt("dammi la potenza in trasmissione antenna in Watt");
d=prompt("dammi la distanza in km alla quale vuoi fare le misure");
S=prompt("dammi la densità massima di irradiazione nella direzione migliore, espressa in mW/mq");
S_isotropa=Potenza/(4*3.14*1000000);
G=10*(Math.log = (0.001/S_isotropa));
txt6.SetText(G+ " db guadagno che antenna");
}
function divi()
{
app.TextToSpeech( "dammi il valore del dividendo" );
n1=prompt("dammi primo numero dividendo");
app.TextToSpeech( "dammi il valore del divisore" );
n2=prompt("dammi secondo numero divisore");
divisione=(n1/n2);
app.ShowPopup( divisione );
app.TextToSpeech( "il quoziente della divisione risulta pari a" +divisione);
}
function sottra()
{
app.TextToSpeech( "dammi il numero da cui vuoi sottrarre detto minuendo" );
n1=prompt("dammi il numero da cui devi sottrarre");
app.TextToSpeech( "dammi il numero che vuoi sottrarre detto sottraendo");
n2=prompt("dammi il primo numero che devi sottrarre");
app.TextToSpeech( "dammi eventuale secondo numero che vuoi sottrarre oppure digita zero" );
n3=prompt("dammi eventuale secondo numero da sottrarre");
sottra=n1-n2-n3;
app.ShowPopup( sottra );
app.TextToSpeech( "il risultato della sottrazione risulta pari a" +sottra );
}
function addi()
{
app.TextToSpeech( "dammi primo numero da sommare" );
n1=prompt("dammi primo numero");
app.TextToSpeech( "dammi secondo numero da sommare");
n2=prompt("dammi secondo numero");
n1=n1*1;
n2=n2*1;
app.TextToSpeech( "dammi eventuale terzo numero da sommare oppure digita zero per non alterare la somma");
n3=prompt("dammi eventuale altro numero oppure digita zero");
n3=n3*1;
addizio=n1+n2+n3;
app.ShowPopup( addizio );
app.TextToSpeech( "la somma risulta pari a" +addizio );
}
function cinematica()
{
app.TextToSpeech( "un corpo cade da una certa altezza acca partendo da fermo Si vuole calcolare il tempo che impiega a raggiungere il suolo Le considerazioni per risolvere il problema si tratta di moto rettilineo uniformemente accelerato con verticale discendente e corpo sottoposto ad accelerazione di gravita gi - Il legame esistente fra spazio percorso tempo e accelerazione di gravita e la seguente acca uguale a un mezzo per gi per il tempo al quadrato e che deve essere risolta rispetto a tempo ti e che ci da infine il tempo uguale a radice quadrata di due per acca diviso accelerazione di gravita");
g=prompt("dammi accelerazione di gravita");
h=prompt("dammi altezza dalla quale cade il corpo");
t=Math.sqrt(2*h/g);
v=g*t;
app.ShowPopup( t +" secondi che impiega il corpo a raggiungere terra" );
app.TextToSpeech( t + "secondi che impiega il corpo a raggiungere terra" );
app.ShowPopup( v +" velocità in metri al secondo con cui raggiunge il suolo" );
app.TextToSpeech( v + "velocità in metri al secondo con cui il corpo raggiunge il suolo");
}
function integra()
{
p1=prompt("dammi primo estremo integrazione" );
p2=prompt("dammi secondo estremo di integrazione");
K=prompt("dammi il valore della costante K");
n=prompt("dammi il valore n esponente integrale");
n1=prompt("dammi il valore esponente dopo integrazione");
integrale=(K*Math.pow(p2,n1))/n1;
integrale1=(K*Math.pow(p1,n1))/n1
risu=Math.round(integrale-integrale1);
app.TextToSpeech( "il valore del tuo integrale risulta pari a "+ risu );
}
function deriva()
{
K=prompt("dammi il valore della costante k che figura sotto derivata");
n=prompt("dammi esponente della x sotto derivata");y
x=prompt("dammi il valore di x");
deri=K*n*Math.pow(x,(n-1));
app.ShowPopup( "il valore della derivata risulta pari a" +deri );
}
function rifa()
{
app.TextToSpeech("Nei circuiti reali, domestici e industriali, gli utilizzatori sono connessi in parallelo ad una sola linea di alimentazione tali utilizzatori sono di solito o di natura resistiva come le lampade o i forni elettrici e altro oppure di tipo ohmico induttivo come i motori la corrente complessiva risulta in ritardo sulla tensione di un angolo fi che da luogo a un fattore di potenza cos fi di norma risulta opportuno che il valore del cos fi sia maggiore di zero virgola otto e questo allo scopo di tenere sotto controllo la potenza reattiva che di solito crea dei problemi negli impianti industriali, a causa della presenza di numerosi carichi induttivi come in molti motori elettrici presenti, accade che il cos fi risulta minore di zero otto per ottimizzare impianto si deve effettuare il rifasamento di tale impianto che viene effettuato collegando in parallelo alla linea una opportuna batteria di condensatori in modo tale da compensare la potenza reattiva induttiva prevalente");
P=prompt("dammi la potenza attiva presente in impianto");
//cos_fi_in=prompt("dammi il cos_fi iniziale");
//cos_fi_fin=prompt("dammi il cos_fi finale");
V=prompt("dammi la tensione di alimentazione");
f=prompt("dammi la frequenza della tensione di linea");
var fi;
var fi1;
fi=60;
fi1=50
C=(P*(Math.tan(fi)-Math.tan(fi1)))/(2*3.14*V*V)
app.ShowPopup( C );
}
function modula()
{
txt6.SetText("Un segnale FM trasmesso da emittente commerciale viene espresso come v_FM=15*sen[615.75*10^6*t+25sen(18.84*10^3*t)], Calcolare le frequenze di portante e modulante, la deviazione di frequenza e occupazione di banda e infine la potenza erogata ad un carico R_load","Multiline",0.8,0.3);
Ampiezza_modulato=prompt("dammi ampiezza segnale modulato fm");
m_f=prompt("dammi indice di modulazione");
omega_m=prompt("dammi il valore di omega del segnale modulato FM");
omega_p=prompt("dammi il valore della omega della portante");
R_load=prompt("dammi il valore del carico in ohm");
freq_p=omega_p/(6.28);
freq_m=omega_m/6.28;
deviazione_freq=m_f*freq_m;
B=2*(deviazione_freq+freq_m);
P=(Ampiezza_modulato*Ampiezza_modulato)/(2*R_load)
txt6.SetText(P +"Watt potenza fornita al carico dal segnale fm");
}
function trave()
{
img=app.CreateImage("/storage/SdCard/DCIM/Camera/trave.jpg");
sv.AddChild(img );
sezione=prompt("dammi la sezione della trave incastrata espressa in mm");
temp_amb=prompt("dammi temperatura ambiente in gradi centigradi nella quale si trova la trave");
temp_riscalda=prompt("dammi la temperatura della trave dopo il riscaldamento solare");
SIGMA_adm=prompt("dammi la massima tensione ammissibile per acciaio duttile che stai usando, la SIGMA_adm");
alfa=prompt("dammi il coefficiente di dilatazione acciaio espresso in 1/K");
E=prompt("dammi il modulo di elasticita acciaio espresso in N/mm^2");
Lo=prompt("dammi la lunghezza iniziale della trave espressa in mm");
Delta_T=(temp_riscalda-temp_amb);
SIGMA=Math.round(alfa*E*Delta_T);
Delta_L=alfa*Lo*Delta_T;
txt5.SetText(SIGMA +" N/mmq massima sollecitazione in compressione cui viene sottoposta la trave");
app.TextToSpeech(SIGMA + "Newton su millimetri quadri, sollecitazione alla compressione che subisce la trave in acciaio");
if(SIGMA > SIGMA_adm)
{
app.TextToSpeech("attenzione hai superato i valori di sicurezza devi rifare il progetto");
}
else
{
app.TextToSpeech(" progetto valido sei nei limiti di sicurezza");
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PROGRAMMARE IN AMBIENTE DROIDSCRIPT SENZA DOVER CREARE IL LAYOUT
Per uso sperimentale e immediato è possibile scrivere il codice relativo a quante function si vogliono attivare senza dover, necessariamente, creare il layout.
Le function() verranno eseguite in sequenza(top/down):
function ShowRandom() // function per generare in modo random dei numeri
{
var num = Math.random(); //dichiara variabile e pone uguale al valore generato che è compreso fra 0 e 1
alert( num ); // mostra il valore
}
ShowRandom(); // chiamata della function
function AreaTri() //definisce la function AreaTri()
{
var base=5;
var altezza=6;
area=(base*altezza)/2 //dichiara variabile ed esegue
alert(area+" area del triangolo con base "+base+" e altezza "+altezza);
}
AreaTri() //chiamata della function
function VolCili() //definisce generica function VolCili
{
r = prompt("dammi il raggio del cerchio");
h = prompt("dammi altezza del cilindro");
AreaCerchio = 2*3.14*r*r;
VolumeCilindro=AreaCerchio*h;
alert(AreaCerchio+" area cerchio");
alert(VolumeCilindro+" volume cilindro");
}
VolCili() //chiamata function
come appare ambiente di sviluppo con droidscript
___________________________
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
INDICE DEGLI SCRIPT ELENCATI PER ARGOMENTI E TIPOLOGIE APPLICATIVE
FISICA
CINEMATICA
1) Cinematica (moto uniformemente accelerato)
2) Cinematica di un corpo in caduta libera.
3) Cinematica di un corpo in un moto uniformemente accelerato e in caduta libera.
4) Cinematica di un corpo in moto uniformemente decelerato.
1) LEGGE DI NEWTON E EQUILIBRIO DEI CORPI
TRASMISSIONE DEL CALORE
1) Script relativo al Calcolo quantità di calore necessaria a mantenere temperatura costante in un ambiente domestico. Applicazione della Legge di Fourier.
2) Calcolo della quantità di calore necessaria a scaldare una quantità d'acqua in ambiente domestico.
--------------------------------------------------------------------------------------------------------------------------
MATEMATICA
1) Calcolo del Volume e della Superficie del cilindro.
2) Calcolo Area delimitata da parabola
3) Calcolo Area delimitata da iperbole
4) Calcolo Derivata di una funzione
5) Calcolo Integrale di una funzione
6) Le quattro operazioni aritmetiche
7) RILEVAMENTO LIVELLO ILLUMINAZIONE AMBIENTALE e di VICINANZA con i SENSORI: Proximity e Light
8) Applicazione che usa il SensorOrientation.
9) ALTIMETRO con il LocatorGPS.
_________________________________________________________________
APPLICAZIONI DISCIPLINE AREA_TECNICA(ELETTROTECNICA / ELETTRONICA)
1) APPLICAZIONE SULLA LEGGE DI OHM.
2) APPLICAZIONE SU PARTITORE DI TENSIONE A VUOTO.
3) APPLICAZIONE SU PARTITORE DI CORRENTE.
4) APPLICAZIONE SU TEOREMA DI MILLMAN.
5)APPLICAZIONE SU PARTITORE DI TENSIONE CARICATO.
6) APPLICAZIONE SU TEOREMA DI THEVENIN.
7) APPLICAZIONE SU DEFIBRILLATORE E CALCOLO SI ALCUNE GRANDEZZE (ENERGIA ELETTROSTATICA...)
1) DIMENSIONAMENTO DI UN OSCILLATORE ASTABILE CON CON 555
2) CONTROLLO LINEARE DI UN MOTORE CON BJT
3) MOTORE PASSO_PASSO E CALCOLO DI ALCUNE GRANDEZZE.
4) LE FIBRE OTTICHE MONOMODALI E CALCOLO APERTURA NUMERICA
5) CALCOLI VARI SULLE FIBRE OTTICHE: velocità propagazione impulso, indice di rifrazione....
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONI IN AMBITO FISICO
Sito Rif.to MATEMATICA_FISICA ESERCIZI
1) Cinematica di un corpo in un moto uniformemente accelerato e in caduta libera.
//Create a layout with objects vertically centered.
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
b = app.CreateButton("Calcola moto corpi in caduta libera");
lay.AddChild(b);
b.SetOnTouch(caduta);
}
function caduta()
{
// si usa la funzione TextToSpeech per comunicare verbalmente il problema da risolvere
app.TextToSpeech( "un corpo cade da una certa altezza acca partendo da fermo. Si vuole calcolare il tempo che impiega a raggiungere il suolo. Le considerazioni per risolvere il problema: si tratta di moto rettilineo uniformemente accelerato con verticale discendente e corpo sottoposto ad accelerazione di gravita gi - Il legame esistente fra spazio percorso tempo e accelerazione di gravità e il seguente acca uguale a un mezzo per gi per il tempo al quadrato e che deve essere risolta rispetto al tempo il quale risulterà uguale a radice quadrata di due per acca diviso accelerazione di gravità ");
g = prompt("dammi accelerazione di gravità ");
h = prompt("dammi altezza dalla quale cade il corpo"); //acquisisce variabile del problema
t = Math.sqrt(2*h/g); //calcola il tempo
v = g*t; //calcola la velocitÃ
app.ShowPopup( t +" secondi che impiega il corpo a raggiungere terra" ); //comunica i risultati
app.TextToSpeech( t + "secondi che impiega il corpo a raggiungere terra" );
app.ShowPopup( v +" velocità in metri al secondo con cui raggiunge il suolo" );
app.TextToSpeech( v + "velocità in metri al secondo con cui il corpo raggiunge il suolo");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) Cinematica di un corpo in moto uniformemente decelerato.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
player=app.CreateVideoView(0.8,0.2);
player.SetOnReady( video );
player.SetFile("/storage/sdcard1/DCIM/Camera/video.3gp");
lay.AddChild(player );
img1=app.CreateImage("/storage/sdcard1/DCIM/Camera/auto.jpg",0.7,0.2);
img=app.CreateImage("/storage/emulated/0/Download/Frenata-automatica-demergenza-1-640x342 (1).jpg",0.7,0.2);
img.SetOnTouch(tocca );
lay.AddChild(img);
img2=app.CreateImage("/storage/sdcard1/DCIM/Camera/formula.jpg",0.7,0.2);
//Create a text label and add it to layout.
app.TextToSpeech("una macchina viaggia a velocita' costante Vuemme quando il pilota riceve il segnale di stop. Se, prima che i riflessi nervosi gli consentano di frenare, trascorre un tempo ticonerre e se la macchina si ferma dopo altri Ti secondi, calcolare la decelerazione necessaria per fermarsi e lo spazio che in totale la macchina percorre dal momento in cui viene dato il segnale di stop. Osserva la figura e leggi le formule di ripasso del moto uniformemente accelerato questo ti aiuta per la risoluzione");
txt = app.CreateText( "Una macchina viaggia a velocita costante Vm quando il guidatore riceve il segnale di stop. \n Se, prima che i riflessi gli consentano di frenare, trascorre un tempo Tr e se la macchina si ferma dopo altri T \n secondi, calcolare quanta decelerazione occorre per fermarsi \n nel punto S partendo da A. Calcolare poi quanto spazio ha percorso \n dal momento in cui appare il segnale di Stop",0.8,0.2,"Multiline");
txt.SetTextSize(12);
txt1=app.CreateButton("Calcolare lo spazio percorso e la decelerazione necessaria per fermarsi",0.8,0.08);
txt1.SetTextSize( 12);
txt1.SetSize(1.0);
txt1.SetBackColor( "#cc22cc" );
txt1.SetOnTouch( calcola);
txt2=app.CreateText("");
txt3=app.CreateText("");
txt4=app.CreateText("");
txt5=app.CreateText("PROBLEM SOLVING");
txt5.SetTextSize(15);
txt7=app.CreateText("");
txt6=app.CreateText("");
txt8=app.CreateText("");
txt9=app.CreateText("");
txt9.SetTextSize( 12 );
txt10=app.CreateText("");
txt11=app.CreateText("");
lay.AddChild(img);
lay.AddChild( img1 );
lay.AddChild( img2 );
lay.AddChild( txt1 );
lay.AddChild( txt7);
lay.AddChild( txt10 );
lay.AddChild( txt11 );
lay.AddChild( txt8 );
lay.AddChild( txt9 );
lay.AddChild( txt3 );
lay.AddChild( txt4 );
lay.AddChild( txt6 );
lay.AddChild( txt5 );
//lay.AddChild(txt6);
lay.AddChild( txt2);
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
function calcola()
{
txt5.SetText(" " );
txt6.SetText( " ");
g=9.8;
var s;
app.TextToSpeech( "dammi la velocità costante auto in metri al secondo");
Vm=prompt("dammi la velocità costante della macchina in metri al secondo");
app.TextToSpeech( "dammi il tempo di reazione del pilota" );
Tr=prompt("dammi il tempo di reazione del pilota, in secondi");
app.TextToSpeech( "dimmi in quanti secondi si ferma auto" );
T= prompt("dimmi in quanti secondi si ferma auto");
app.TextToSpeech("dammi la massa auto in chilogrammi");
m=prompt("dammi la massa automobile in kg");
app.TextToSpeech("dammi la distanza in metri alla quale si trova la persona");
d=prompt("dimmi a che distanza alla quale si trova la persona espressa in metri");
app.TextToSpeech( "dimmi a che distanza si trova la persona");
app.TextToSpeech("dammi il coefficiente di attrito della strada");
mu=prompt("dammi il valore del coefficiente di attrito");
s=(0.5*Vm*Vm)/(mu*g)
E=0.5*(m*Vm*Vm);
q=m*Vm;
a=Vm/T;
h=Vm**2/(2*a)
S=Tr*Vm
Stot=S+h
app.ShowPopup( a +" m/s^2 decelerazione necessaria per fermarsi");
app.ShowPopup(h +" metri Spazio percorso dalla posizione A alla S di fermata");
app.ShowPopup( Stot +"metri Spazio totale percorso dal pilota");
app.ShowPopup( E, " Joule energia cinetica auto" );
app.ShowPopup( q, "kg*m/s quantità di moto auto che si muove a velocita Vm" );
app.ShowPopup( s, "metri percorsi dalla macchina con le ruote bloccate e necessari per fermarsi");
lay.AddChild(txt6);
txt7.SetText("RISULTATI IN USCITA");
//txt2.SetText( a + " m/s^2 decelerazione necessaria per fermarsi" );
txt3.SetText(h +" metri Spazio percorso dalla posizione A alla S di stop");
txt4.SetText(Stot + " metri Spazio totale percorso dopo avviso a fermarsi");
txt6.SetText(E + " Joule energia cinetica auto in moto");
txt8.SetText(a + " m/sq decelerazione necessaria per fermarsi");
txt10.SetText( q +" quantita di moto auto con velocita Vm" );
txt11.SetText( s +" metri spazio necessario per fermarsi con le ruote bloccate" );
app.TextToSpeech( a + " metri su secondo quadrato, decelerazione necessaria per fermarsi" + "e poi "+ h + "metri Spazio percorso dalla posizione di partenza A alla posizione finale S"+ "e infine" +Stot +"metri Spazio totale percorso a partire dal segnale di stop fino al punto S di fermata");
if(Stot >= d)
{
diff=Stot-d;
app.TextToSpeech( "hai travolto la persona" );
txt9.SetText("hai travolto la persona e sei andato oltre di metri " + diff);
}
}
function video()
{
app.HideProgress();
app.ShowPopup("pronto");
player.Play(); // avvia il file video
}
function tocca()
{
player.Play();
}
__________________________
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) APPLICAZIONE DELLA SECONDA LEGGE DI NEWTON
//Create a layout with objects vertically centered.
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt = app.CreateText("Calcola la massa di un'auto che ha raggiunto una velocità , in un tempo t e con una forza F(Newton) anch'essa nota.");
lay.AddChild(txt);
app.TextToSpeech( "Si conosce la velocità v alla quale dobbiamo portare un'auto e il tempo t, in sec, necessario. Conosciamo, infine, anche la forza necessaria per fare questo e si deve calcolare la massa dell'auto. "); # comunica a voce le specifiche del problema
v=prompt("dammi la velocità in km/h alla quale vuoi portare auto"); //acquisisce variabile del problema
F=prompt("dammi la forza in Newton necessaria per farle acquisire la velocità v"); //acquisisce variabile del problema
v_ms = v/3.6; # effettua la conversione da km/h in m/s
a = v_ms/t # effettua il calcolo dell'accelerazione supponendo aumento lineare della velocitÃ
m = F/a # effettua il calcolo della massa auto dalla F=m*a
app.ShowPopup( m+" Kg massa auto" ); # comunica risultati
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) PIANO INCLINATO E CONDIZIONI DI EQUILIBRIO DI UN CORPO.
// Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "Il P_I viene rappresentato da un piano rigido, che forma un angolo teta con piano orizzontale \ne quindi e formato\n dal piano inclinato di Lunghezza L, piano orizzontale di lunghezza b e altezza h e risulta essere un triangolo rettangolo. \nSe un corpo di peso Q viene posto sul piano inclinato, supposto privo di attrito, esso tende a scivolare lungo il piano e per fermarlo e necessario applicare\n una forza P in direzione parallela al piano inclinato.La componente verticale al piano espressa da Q'=Q*sen(teta) e viene equilibrata dalla reazione vincolare del piano,mentre la forza P da applicare deve risultare, per la condizione di equilibrio, pari a Q''=Q*sen(teta).\n Dalla similitudine dei triangoli otteniamo che P=Q*(h/L)","Multiline");
txt.SetTextSize(18);
txt1=app.CreateText("");
txt1.SetTextSize(18);
lay.AddChild( txt );
lay.AddChild( txt1 );
h = prompt("dammi altezza del piano inclinato");
L = prompt("dammi lunghezza del piano inclinato");
Q = prompt("dammi il peso del corpo che giace sul piano inclinato");
P = (Q*h)/L;
txt1.SetText(P +" Newton forza da applicare per ottenere equilibrio del corpo");
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) Cinematica di un corpo in caduta(MotoComposto)
// Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "" );
txt.SetTextSize(15);
lay.AddChild( txt );
h = prompt("dammi altezza, in metri, alla quale si trova aereo");
v = prompt("dammi velocità costante aereo in km/h");
v_m=v*0.277;
app.ShowPopup( v_m );
g = 9.8;
//Considerazioni da fare: acqua soggetta a due movimenti contemporanei(v=x*t moto rettilineo uniforme e poi caduta libera con accelerazione di gravita g e per la quale vale equazione h=(1/2)*g*t^2)
//si ricava la t dalla prima t=v/x e si sostituisce nella seconda h=(1/2)*g*(v/x)**2 che risolta rispetto a x ci da x= v*(2*h/g)^0.5
x=v_m*(Math.sqrt(2*h/g));
txt.SetText(x +" metri__ distanza dalla quale occorre effettuare lancio acqua");
app.AddLayout( lay );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
STRUTTURE DI TIPO MECCANICO(AreaTecnica)
1) STUDIO DI UNA LEVA E CONDIZIONI DI EQUILIBRIO
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "Si dispone di una asta metallica lunga L metri e, mediante una forza motrice P applicata a un estremo di questa asta , si vuole sollevare un peso Q di Newton \n applicato ad altro estremo. Determinare il punto di fulcro che permette di effettuare il sollevamento.",0.8,0.2,"Multiline");
//equilibrio della leva P:Q = b:a e quindi a= L - b e che sostituita nella equazione e risolta rispetto a b ci da b=(P:Q)*(L-b) e infine b=(P:Q)*L/(1+P:Q)
txt.SetTextSize(15);
txt1=app.CreateText("");
txt1.SetTextColor( "#22ff22" );
txt1.SetTextSize( 18 );
txt1.SetBackColor( "#aabb00" );
lay.AddChild( txt1 );
lay.AddChild( txt );
L=prompt("dammi la lunghezza della leva in cm");
P=prompt("dammi la forza motrice applicata a estremo asta espressa in Newton");
Q=prompt("dammi il valore del peso che vuoi sollevare espresso in Newton");
// a=L-b;
b=(P/Q)*L/(1+P/Q);
txt1.SetText(b + "cm -- distanza alla quale occorre mettere il fulcro dal carico P");
app.ShowPopup( b );
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) DIMENSIONAMENTO DI UN VERRICELLO
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "UN VERRICELLO PRESENTA UN BRACCIO DI MANOVELLA b DI VALORE NOTO E, AD ESSO, VIENE APPLICATA UNA FORZA F DI CUI SI CONOSCE IL VALORE. SI VUOLE CALCOLARE IL RAGGIO CHE DEVE AVERE IL VERRICELLO" );
lay.AddChild(txt );
img=app.CreateImage("/storage/6A42-E81D/DCIM/Camera/verricello.jpg",0.67,0.3);
txt1=app.CreateText(" ");
lay.AddChild( txt1 );
lay.AddChild(img );
// Considerazioni per la soluzione:
//si conosce il peso in kg del corpo ma, sapendo che e' sottoposto alla forza di gravita' g=9.81, esso esercita una forza resistente pari al prodotto del suo peso per accelerazione di gravita' Q= P*g
//il verricello risulta governato dalla sua equazione di equilibrio P*r_m = Q*r da cui si ricava r = r_m*(P/Q)
P = prompt("dammi la forza F in Newton applicata al verricello");
r_m = prompt("dammi la lunghezza del braccio di manovella in cm");
peso = prompt("dammi il peso applicato in kg");
Q = peso*9.81;
r = (r_m)*(P/Q);
txt.SetTextSize(18);
txt.SetText(r+" cm raggio del cilindro del verricello ");
txt1.SetText( +Q+" N forza resistente");
//Add layout to app.
app.AddLayout( lay );
}
__________________________
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) STUDIO STATICO DI UN SISTEMA IN EQUILIBRIO
//Called whem application is starded
function OnStart()
{
lay=app.CreateLayout("linear","VCenter","FilXY");
txt=app.CreateText ("Siamo in presenza di un corpo di massa M2(kg) che scorre lungo un piano inclinato con un certo attrito mu di valore noto. Il piano è inclinato di un angolo alfa. Si è provveduto a collegarlo a un filo inestensibile, e senza peso, allo scopo di consentirne equilibrio. Tale filo si arrotola intorno a una carrucola, e poi su una carrucola mobile che reca un contrappeso di massa M1. La struttura presenta poi altra carrucola fissa, supportata da una molla, di cui si conosce la costante elastica k(N/m). Si suppone che il sistema abbia raggiunto equilibrio e si vuole calcolare di quanto si è allungata la molla. Si calcola anche la tensione in ogni fune.");
lay.AddChild(txt);
txt.SetTextSize(20);
txt1=app.CreateText("");
lay.AddChild(txt1);
txt1.SetTextSize( 20);
txt2=app.CreateText("");
txt2.SetTextSize(20);
lay.AddChild(txt2);
txt3=app.CreateText("");
txt3.SetTextSize(20);
lay.AddChild(txt3);
mu=prompt("dammi il coefficiente di attrito del piano\n");
M1=prompt("dammi la massa M1 in kg\n");
M2=prompt("dammi la massa M2 in kg\n");
k=prompt("dammi la costante elastica della molla\n");
// Osservazioni:
// asse x con equazione -k*x + T1 = 0
// asse y con equazione T1 - M1*g + T2 = 0
// Fa = mu*N dove N è la componente forza peso normale al piano inclinato.
// il piano inclinato con equazione T2 + mu*M2*g*cos(alfa) - M2*g*sen(alfa) = 0
// risolvendo rispetto a x si ottiene x = (M1*g - M2*g*Math.sin(alfa) - mu*Math.cos(alfa))/k
// sostituendo il valore di x in T1 e T2 si ricavano i corrispondenti valori.
alfagradi=prompt ("dammi angolo che forma con il piano orizzontale in gradi\n");
alfa=(45*6.28)/360;
g = 9.81;
x = (M1*g-M2*g*Math.sin(alfa) - mu*Math.cos(alfa))/k; molto
T1 = k*x;
T2 = M2*9.81*(Math.sin(alfa)- mu*Math.cos(alfa));
txt.SetText("x= "+x+" metri di allungamento della molla");
txt1.SetText("T1 ="+T1+" Newton tensione sul filo a sinistra");
txt2.SetText("T2 ="+T2+" Newton tensione a destra");
app.AddLayout( lay );
}
______________________________
Esecuzione dello script
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
STRUTTURE DI TIPO MECCANICO E SOLLECITAZIONI
1) VALUTAZIONI SULLE CONDIZIONI DI SICUREZZA DI UN TIRANTE IN ACCIAIO SOTTOPOSTO A SFORZO ASSIALE DI TRAZIONE.
// Called when application is started
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/emulat oed/0/Download/ponte-del-mare.jpg",0.5,0.4);
lay.AddChild(img );
txt = app.CreateText(" Un tirante in acciaio di diametro d e lunghezza L, entrambe da specificare, viene sottoposta a trazione con una forza F prestabilita. Vogliamo valutare se le condizioni di sicurezza sono rispettate, ipotizzando di conoscere il valore della tensione limite dell'acciaio con il quale si sta lavorando.");
txt.SetTextSize(15 );
txt1=app.CreateText(" ");
lay.AddChild( txt );
lay.AddChild(txt1);
txt1.SetTextSize(15);
d=prompt("dammi il diametro in mm del Tirante");
r=d/2;
l=prompt("dammi la lunghezza del tirante in mm");
F=prompt("dammi la forza F in Newton che viene applicata al tirante");
pgreco=3.14;
Sigma_max_limite = prompt("dammi la tensione limite massima per acciaio del tirante espressa in N/mmq"); //100 N/mmq
A=pgreco*r*r;
app.ShowPopup(A+" mmq sezione del tirante");
Sigma=F/A;
Diff=Math.round(Sigma-Sigma_max_limite);
txt.SetText(Sigma+ " N/mmq Tensione interna del Tirante - Sei in condizioni di sicurezza");
txt1.SetText(A+" mmq sezione del tirante");
if(Sigma > Sigma_max_limite)
{
app.TextToSpeech("non sei in condizioni di sicurezza e sei andato oltre di" + Diff +" Newton");
}
//Add layout to app.
app.AddLayout( lay );
}
____________________
Esecuzione dello script con: diametro=10mm lunghezza=3000 mm. F=1000N Sigma_max_limite=100 N/mmq, si ottiene A=12.85 mmq. Sigma=100 N/mmq
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ImpiantiFotovoltaici
ENERGETICA E FONTI RINNOVABILI(AreaTecnica)
1) DIMENSIONAMENTO DI UN IMPIANTO SOLARE FOTOVOLTAICO
mini-modulo-solare-perovskite
Obiettivo: dimensionare un impianto fotovoltaico per soddisfare il fabbisogno energetico di una abitazione in cui vivono N persone.
Dati noti:
° rendimento superficiale di 1 mq di modulo pari a 0.12[KWp/mq]
° rendimento inverter espresso con numero da 0 a 1
° copertura in mq necessaria per per avere potenza di picco pari a 1 KW a 24 V.
° fabbisogno giornaliero di un'utenza di quattro persone.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
btn= app.CreateButton(" DIMENSIONAMENTO IMPIANTO FOTOVOLTAICO");
btn.SetOnTouch(calcola);
txt=app.CreateText( " ");
specifiche progettuali
txt.SetTextSize(20 );
lay.AddChild( txt );
lay.AddChild( btn );
//Add layout to app.
app.AddLayout( lay );
}
function calcola()
{
rend_sup=prompt("dammi il rendimento superficiale espresso come numero di kWp/mq"); // 0.12 kWp/mq
copertura =prompt("dimmi quanti metri quadri di copertura sono necessari per avere una potenza di 1 KW a 24 V");
ita=prompt("dammi il rendimento inverter"); // con numero da 0 a 1 (0.5)
fabbisogno_giornaliero_famiglia=prompt("dammi il consumo medio giornaliero in kW di una famiglia di 4 persone");
potenza_totale=fabbisogno_giornaliero_famiglia*(1+ita); // si tiene conto che inverter ha un rendimento del 50% e assorbe 12*0.5 kW= 6 KW e quindi in totale P = 12 + 6 = 18 KW
// considerazioni per la soluzione: se per avere 1 kW occorrono 8 mq, ne consegue che per ottenere la potenza_totale occorreranno S mq e quindi vale la proporzione 1kW:8 mq= potenza_totale: S mq; risolta rispetto a S ci da S=8*potenza_totale= 164 mq.
// Si deve considerare che si sta ipotizzando condizioni ottimali di irraggiamento solare(1000 W/mq) e le condizioni operative sono mediamente al di sotto di questo valore, pertanto, occorre sovradimensionare l'impianto.
S=Math.round(copertura*potenza_totale);
txt.SetText(S + "mq di copertura necessari");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
II (AreaTecnica)
1) DIMENSIONAMENTO DI UN IMPIANTO SOLARE PER LA PRODUZIONE DI ACQUA CALDA IN UNA CASA DI RIPOSO
Obiettivo: dimensionare un Impianto Solare per produrre acqua calda in una casa di riposo. Si vuole garantire una temperatura dell'acqua di accumulo nel serbatoio intorno ai 50°C.
Si usano i tipici pannelli solari che hanno una superficie utile standardizzata di circa 2.2mq e l'impianto è realizzato in modo da consentire la produzione e poi l'invio di acqua calda al serbatoio S con capienza di circa 200litri.
Dati noti:
° dimensioni del pannello d = 2.2 mq
° temperatura dell'acqua nel serbatoio Ta = 52 °C
° fabbisogno_acqua_giornaliero_persona = 75 litri
° capacità C del serbatoio in litri
° numero stanze casa di riposo pari a 15
° numero_max_ospiti_presenti pari a 30.
° inclinazione del tetto e quindi dei pannelli
° eventuali esigenze di maggiore consumo
Dati da definire usando tabelle adeguate e che determinano una correzione sui calcoli effettuati.
°posizione geografica e quindi esposizione in direzione sud-sud est.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
btn= app.CreateButton(" DIMENSIONAMENTO IMPIANTO PER ACQUA CALDA CON PANNELLI SOLARI");
btn.SetOnTouch(calcola);
txt=app.CreateText( " ");
specifiche progettuali
txt.SetTextSize(20 );
lay.AddChild( txt );
lay.AddChild( btn );
//Add layout to app.
app.AddLayout( lay );
}
function calcola()
{
C =prompt("dammi la capacità in litri del serbatoio");
N = prompt (" dimmi quante persone sono presenti al massimo nella struttura");
fabbisogno_giornaliero_acqua_persona = prompt("dammi il consumo medio giornaliero in litri di acqua per persona");
// considerazioni per la soluzione: per avere un impianto leggermente sovradimensionato il progetto viene fatto che le persone non siano N bensì N+2 e siccome ciascuno ha un fabbisogno giornaliero di L litri di acqua, ne consegue che la quantità complessiva, e quindi la capacità del serbatoio, è data C =(N+2)*fabbisogno_giornaliero_acqua_persona
// per trovare poi il numero di pannelli P necessari basta impostare la proporzione: se 1 pannello produce 150 litri ne consegue che P pannelli producono C litri di acqua calda che rappresentano il serbatoio. In formula 1:150 = P:C e da questa si ricava P= (1/150)*C.
C= fabbisogno_giornaliero_acqua_persona*(N+2);
P = (1/150)*C;
S = P*2.2; // superficie occupata dai pannelli
txt.SetText(P+" numero di pannelli "+S+" superficie occupata dai pannelli"
app. AddLayout(lay) ;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONI IN AMBITO MATEMATICO
VAI AL SITO DI MATEMATICA
CALCOLO AREA DELIMITATA DA PARABOLA
1) CALCOLO Area delimitata da parabola
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
img =app.CreateImage("/storage/extSdCard/DCIM/Camera/parabola.jpg",0.5,0.4);
txt = app.CreateText( "Area parabola avente asse coincidente con asse x e vertice in origine y^2 = 2*p*x. Si vuole calcolare area A del segmento parabolico racchiuso dalla parabola e dalla retta di equazione x=xo" );
p =prompt("dammi il parametro p della equazione");
xo=prompt("dammi il primo estremo di integrazione");
x1=prompt("dammi secondo estremo di integrazione");
app.TextToSpeech("siamo nel piano x y con equazione y quadro uguale a 2 per p per icx e pertanto y risulta uguale alla radice quadra di 2 per p per ics e quindi basta mettere sotto integrale la y uguale a 2 per p per icx e integrarla da icx con zero a ics con uno" );
A1=(4/3)*((2*p)^0.5)*(x1^1.5);
A2=(4/3)*((2*p)^0.5)*(xo^1.5);
A=A1-A2;
txt.SetText( A+ " area del settore di parabola");
app.TextToSpeech("il valore del settore di parabola risulta uguale a"+Math.round(A));
txt.SetTextSize( 12 );
lay.AddChild( img );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) CALCOLO AREA DELIMITATA DA IPERBOLE E ASSE DELLE X.
Calcolo Area delimitata da iperbole e asse delle x.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,Fill XY");
web=app.CreateWebView(0.8,0.4);
web.SetBackColor( "#00000000" );
img=app.CreateImage("/storage/extSdCard/DCIM/Camera/iperbole.jpg",0.8,0.3,-1);
lay.AddChild( web );
lay.AddChild( img );
txt=app.CreateText("Iperbole equilatera con vertice in origine degli assi e asintoti coincidenti con gli assi x e y presenta equazione x*y = k; k è un parametro che può essere >0. Vogliamo trovare area A racchiusa da iperbole, da asse x e dalle rette x=a, x=b",0.8,0.2,"Multiline");
txt.SetTextSize(15);
txt1=app.CreateText("");
txt1.SetTextSize(18);
txt2=app.CreateText("formula IPERBOLE");
txt2.SetTextSize( 20 );
txt2.SetOnTouch(formula );
a=prompt("dammi primo estremo integrazione");
b=prompt("dammi secondo estremo integrazione");
k=prompt("dammi il parametro k");
A=k*Math.log(b/a);
txt1.SetText(A+ " area racchiusa da iperbole");
app.ShowPopup(A);
lay.AddChild( txt );
lay.AddChild(txt1);
lay.AddChild( txt2);
//Add layout to app.
app.AddLayout( lay );
}
function formula()
{
txt2.SetText( "y=1/x" );
web.LoadUrl("https://it.m.wikipedia.org/wiki/Iperbole_(geometria)");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SITO DERIVATA
Video su DERIVATA
3) Calcolo della DERIVATA di una generica funzione del tipo y=k*x^n
//Called when application is started.
function OnStart ()
{
//Create a layout with objects vertically centered.
txt=app.CreateText ("DERIVATA");
txt1.SetTextSize(25);
lay.AddChild (txt);
esponente=prompt ("dammi il valore esponente n della funzione da derivare");
K=prompt ("dammi il valore della costante sotto derivata");
esponente=prompt ("dammi il valore esponente della x sotto derivata");
derivata=k*esponente;
derivata=k*esponente*x**(x-1);
txt1.SetText(derivata+"*x^"+(esponente-1)+"valore della derivata di y="+k+"*"+"x"+"^"+esponente);
app.AddChild(lay);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SITO INTEGRALE
Video su INTEGRALE
4) Calcolo dell' INTEGRALE di una generica funzione del tipo y=k*⎰x^n
// Called when applicati in Is started
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt=app.CreateText("");
txt1= app.CreateText( "la funzione da integrare ha la forma y = k*{x^n dx" );
txt.SetTextSize( 32 );
lay.AddChild(txt1 );
lay.AddChild( txt );
nome=prompt("dimmi come ti chiami");
app.TextToSpeech("dammi primo estremo");
p1=prompt("dammi primo estremo integrazione");
app.TextToSpeech( "secondo estremo" );
p2=prompt("dammi secondo estremo integrazione");
app.TextToSpeech( "dammi il valore della costante cappa che figura sotto integrale" );
k=prompt("dammi il valore della costante k");
app.TextToSpeech("dammi il valore esponente n sotto integrale");
n=prompt("dammi il valore esponente n che figura sotto la funzione integrale");
app.TextToSpeech("dammi esponente dopo integrazione");
e=prompt("dammi il valore esponente dopo integrazione e che come sappiamo risulta pari a n+1");
integrale=(k*Math.pow(p2,e))/e;
//txt.SetText( integrale );
integrale1=(k*Math.pow(p1,e))
//txt.SetText(integrale1);
risu=(integrale-integrale1);
txt.SetText(risu);
app.TextToSpeech(nome +" il valore del tuo integrale e quindi la area delimitata dalla funzione integrale risulta pari a" +risu);
//Add layout to app.
app.AddLayout( lay )
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) LA FUNZIONE SIGMOIDEA
SIGMOIDE
La funzione sigmoidea è una funzione matematica che produce una curva sigmoide; una curva avente un andamento ad "S". La funzione sigmoide viene spesso usata nello sviluppo del software per le RetiNeurali in quanto risulta utile avere informazioni codificate in termini di 0 logico e 1 logico, che caratterizzano il linguaggio dei computer. E' definita dalla formula:
{\displaystyle P(t)={\frac {1}{1+e^{-t}}}}
Lo scopo è quello di comprimere qualsiasi valore della variabile t all'interno del range di valori che vanno da 0 a 1.
Funzione_sigmoidea
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "FUNZIONE SIGMOIDE" );
txt1= app.CreateText("");
img = app.CreateImage("/storage/emulated/0/Download/Logistic-curve.png",0.8,0.4);
t = prompt("dammi il valore di t");
Sigmoide= 1/(1+Math.exp(-x));
txt.SetTextSize( 32 );
txt1.SetText( Sigmoide+" valore della funzione Sigmoide per t = "+x);
lay.AddChild( txt );
lay.AddChild( txt1 );
lay.AddChild( img );
//Add layout to app.
app.AddLayout( lay );
}
_______________________
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
6) RISOLUZIONE EQUAZIONE DI 2° GRADO
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt = app.CreateText( "Equazione 2grado" );
txt1=app.CreateText("");
lay.AddChild( txt1 );
txt1.SetTextSize(14);
a=prompt("dammi il valore di a");
b=prompt("dammi b");
c=prompt("dammi c");
n=prompt("dammi il valore di n");
x1=Math.round(-b+Math.sqrt(b**2-4*a*c))/(2*a);
x2=Math.round(-b-Math.sqrt(b**2-4*a*c))/(2*a);
txt.SetTextSize( 22 );
lay.AddChild( txt );
txt.SetText("x1 = "+x1+" prima radice "+"x2 = "+x2+" seconda radice");
txt1.SetTextSize( 22 );
app.AddLayout(lay);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PROGRESSIONI ARITMETICHE E GEOMETRICHE
La progressione aritmetica, si chiama anche progressione per differenza d detta ragione, è costituita da un certo numero di termini in cui rimane costante il valore di d fra un termine e il successivo.
Se d > 0 si ha una progressione crescente, se d<0 decrescente. Si possono presentare i seguenti casi:
1) se conosciamo (x1, n, d): xn = x1 + (n-1)*d
x1....d....x2....d....x3....d....xn
2) se conosciamo (xm, d, n): x(m+n) = xm + n*d
xm....d....d....d....x(m+n)
3) se conosciamo (xm, xp, n), con xp > xm, possiamo inserire n termini fra xm e xp usando come ragione d xm....o....o....o....o....o....xp
la formula è la seguente:
d = (xp -xm)/(n+1)
_________________________
Es.1
// Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
x1=prompt(" dammi il valore del primo termine"); // acquisisce da tastiera il valore x1
d=prompt("dammi il valore della ragione d");
n =prompt("dammi il numero n di elementi della progressione");
xn = x1+(n-1)*d); // calcola il valore ultimo elemento
app.TextToSpeech("ultimo elemento della progressione ha valore"+xn); // comunica a voce il valore di xn
txt.SetText("ultimo elemento della progressione = "+xn); // visualizza su txt il valore di xn
lay.AddChild (txt);
app.AddLayout(lay);
}
///////////////////////////////////////////////////////////////////
Es.2
// Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
xm=prompt(" dammi il valore del primo termine"); // acquisisce da tastiera il valore xm
d=prompt("dammi il valore della ragione d");
n =prompt("dammi il numero n di elementi della progressione");
x(n+m) = xm+(n*d); // calcola il valore ultimo elemento
app.TextToSpeech("ultimo elemento della progressione ha valore"+ x(n+m); // comunica a voce il valore di x(n+m)
txt.SetText("ultimo elemento della progressione = "+ x(n+m)); // visualizza su txt il valore di xn
lay.AddChild (txt);
app.AddLayout(lay);
}
////////////////////////////////////////////////////////////////////////
Es.3
// Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
xm = prompt(" dammi il valore del primo termine"); // acquisisce, da tastiera, il valore di xm
xp = prompt("dammi il valore ultimo elemento");
n = prompt("dammi il numero n di elementi della progressione");
d = (xp-xm)/(n+1); // calcola il valore della ragione
app.TextToSpeech("la valore d ha valore"+d); // comunica a voce il valore di xn
txt.SetText("la ragione è = "+d); // visualizza su txt il valore della ragione d
lay.AddChild (txt);
app.AddLayout(lay);
}
////////////////////////////////////////////////////////////////////////
SE LA PROGRESSIONE È RELATIVA A N TERMINI CONSECUTIVI ALLORA LA SOMMA DEGLI ESTREMI(x1 + xn) RISULTA UGUALE ALLA SOMMA DEI TERMINI EQUIDISTANTI DAGLI ESTREMI:
x2 + x(n-1), x3 + x(n-2), ....
Es. 3 5 7 9 11 3 + 11 = 5 + 9 =14
////////////////////////////////////////////////////////////////////////
LA SOMMA Sn DI n TERMINI CONSECUTIVI È DATA DA: Sn = ((x1 +xn)/2)*n
Es. 3 5 7 9 11 = ((3 + 11)/2)*11 = 35 e infatti 3 + 5 + 7 +9 + 11 = 35
// Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
x1=prompt("dammi il valore del primo termine"); // acquisisce, da tastiera, il valore di x1
x2=prompt("dammi il valore del secondo termine");
x3 = prompt("dammi il valore del terzo termine");
x4 = prompt("dammi il valore del quarto termine");
n =prompt("dammi ultimo elemento che vuoi sommare");
Sn = ((x1 +xn)/2)*n; // calcola il valore della somma
app.TextToSpeech("il valore della somma vale"+ Sn); // comunica a voce il valore di Sn
lay.Child (txt);
app.AddLayout(lay);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PROGRESSIONI GEOMETRICHE
Si chiama anche progressione per quoziente e in essa la successione di elementi è caratterizzata dal fatto che il rapporto q, detto ragione, fra un qualsiasi termine e quello che lo precede è costante.
CALCOLA LA MEDIA GEOMETRICA DI N NUMERI IN UNA PROGRESSIONE
JavaScript & MATH
1) LA MEDIA GEOMETRICA DI N NUMERI DATI xm e xp è data:
mg = Math.Sqrt(xm*xp)
Es.1 la progressione 2 4 ha q=2 mentre n=2 e poi xm=2 e xp=4 ne segue mg = Math.sqrt(xm*xp) =sqrt(8)
Se i termini sono n:
Es.2 la progressione 2 4 8 ha q=2 mentre n=3 e ne segue mg=ennesima_Math.sqrt(x1*x2*x3*.....xn) =ennesima_sqrt(64) = 4
//Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
xm = prompt("dammi il primo elemento");
xp = prompt("dammi ultimo elemento");
mg = Math.Sqrt(xm*xp);
app.TextToSpeech("la media geometrica vale"+ mg; // comunica a voce il valore di mg media geometrica di due numeri
lay.Child (txt);
app.AddLayout(lay);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CALCOLA IL PRODOTTO DI N TERMINI IN UNA PROGRESSIONE
2) IL PRODOTTO DI n TERMINI CONSECUTIVI È PARI A: Pn = Math.Sqrt((x1*xn)^n)
Es. la progressione 2 4 8 ha n=3 e poi xn=8 con x1=2; applicando la formula Pn =Math.Sqrt(2*4*8)^3 = Math.Sqrt(4096) = 64. Infatti Pn = 2*4*8 = 64
//Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
x1 = prompt("dammi il primo elemento");
xn = prompt("dammi ultimo elemento");
n = prompt("dammi il numero di elementi");
Pn = Math.Sqrt(x1*xn)^n;
app.TextToSpeech("la media geometrica vale"+ Pn; // comunica a voce il valore del prodotto di n numeri
lay.Child (txt);
app.AddLayout(lay);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) LA MEDIA PONDERATA
La media ponderata si applica quando essa è influenzata non solo dalle qualità numerabili dei componenti ma, anche, dalle quantità diverse dei componenti stessi.
Si vuole calcolare il peso specifico medio per unità di volume di un oggetto in oro che contiene, trattandosi di una lega, delle parti in oro (ps=19), in argento (ps=10.4) e in rame(ps=8.9).
Ipotizziamo di conoscere sia i pesi specifici dei componenti che le loro percentuali per unità di volume.
Mqp = (q1*p1 + q2*p2 + q3*p3)/(p1+p + p3)
// Called when applicati on is started
function OnStart()
{
lay=app.CreateLayout("Linear","VCenter,FillXY");
txt=app.CreateText("");
app.SetTextSize (20);
p1 = 19; // peso specifico oro
p2= 10.4; // peso specifico argento
p3 = 8.9; // peso specifico rame
q1=prompt("dammi la quantità di oro per unità di volume"); / acquisisce da tastiera il valore q1
q2=prompt("dammi la quantità d'argento");
q3=prompt("dammi la quantità di rame per unità di volume");
Mqp =(q1*p1 + q2*p2 + q3*p3)/(p1+p + p3);
txt.SetText = Mqp+ " valore media ponderata;
app.AddLayout(lay);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) // PROGRESSIONE ARITMETICA CON RAGIONE d CHE PARTA DA UN NUMERO QUALSIASI
// I vantaggi che offre la programmazione: generalizzazione
// del problema e software applicabile, quindi, a infinite
// situazioni senza dover riscrivere il codice.
// I valori del num di inizio e la ragione d vengono acquisiti
// da tastiera mediante le istruzioni di input:
// num =prompt("dammi numero iniziale")
// d = prompt("dammi la ragione della progressione")
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "Linear", "VCenter,FillXY" )
//Create a text label and add it to layout.
txt = app.CreateText( "PROGRESSIONE ARITMETICA" )
txt.SetTextSize(10 )
lay.AddChild( txt )
num=prompt("numero iniziale")*1;
var d=prompt("dammi la ragione d della progressione")*1;
var a=[];
for (var i =0; i<100; i++)
{
a.push(num +i*d); // istruzione per depositare la variabile (num +i*d) dentro array(a[])
}
txt.SetText("["+a+"]");
//Add layout to app.
app.AddLayout( lay )
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CALCOLO DELLE PROBABILITA
Un pò di teoria
SOMMA DI EVENTI: C = A + B = A ሀ B
L'evento C consiste nel verificarsi di almeno uno dei due eventi A o B.
PRODOTTO EVENTO: C = A B = A â‹‚ B
L'evento C consiste nel verificarsi simultaneo sia dell'evento A che dell'evento B
EVENTI CONTRARI: U = A + A
Quando gli eventi sono incompatibili, li rende e formano un gruppo U completo.
Ex. I numeri da 1 a 6 contengono i numeri primi A chiaramente incompatibili A (1,2,3,5) e i numeri non primi A '(2,6).
Ne consegue che la somma di eventi incompatibili produce una probabilità del 100%, ovvero 1.
EVENTI COMPATIBILI E LA LORO SOMMA: possono verificarsi simultaneamente e la loro probabilità è data da P(A+B) = P(A∪B) = P(A) + P(B) - P(A,B).
Es. Siamo in presenza di un'urna che contiene 90 palline numerate da 1 a 90 e si
Es. Siamo in presenza di un'urna che contiene 90 palline numerate da 1 a 90 e si procede all'estrazione di una sola pallina. Si vuole calcolare la probabilità cge la pallina estratta sia contemporaneamente divisibile per 2 e per 5.
P(A) = 45/90 rappresenta la probabilità che il numero sia divisibile per 2
P(B) = 18/90 rappresenta la probabilità che il numero sia divisibile per 5
P(A ∩ B) = 6/10 rappresenta la probabilità che il numero sia divisibile per 2 e per 5 e, siccome questi casi sono già contemplati dalla somma delle prime due probabilità , ne consegue che questo valore deve essere detratto anzichè sommato. P(A+B) = P(A) + P(B) - P(A,B) =45/90 + 18/90 - 9/90 = 6/10
EVENTI DIPENDENTI
In un' urna ci sono 2 palline bianche e 1 pallina nera. Viene estratta una pallina a caso da due persone in successione e senza reimmettere la prima pallina.
P(A) probabilità che venga estratta pallina nera.
P(B) probabilità che la seconda persona estragga una pallina nera.
osservazione: si tratta chiaramente di eventi dipendenti in quanto la seconda estrazione è condizionata dall'esito della prima. Se non conosciamo l'esito del secondo evento allora la probabilità del primo è P(A) =2/3. Se conosciamo l'esito del secondo evento P(B)(è uscita una pallina nera) allora la probabilità dell'evento P(A) =1/2; A dipende da B.
---------------------------------------------------------------------------------------------------------------
ALCUNI ESEMPI
1) Calcolo delle probabilitÃ
Siamo in presenza di un'urna che contiene n=3 palline nere e b=2 palline bianche. Estraendo una pallina soltanto che probabilità P(A) abbiamo di estrarne una bianca.
// Osservazioni: se indichiamo con A l'evento che consiste nell'estrazione di una pallina bianca, possiamo notare che il numero dei casi possibili risulta n=b+n mentre i casi favorevoli sono m=b perchè ci sono solo due palline bianche. Per questo si ha P(A)=b/n
// Called when application is started
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( " ");
nere=prompt("dammi il numero di palline nere");
bianche=prompt("dammi il numero di palline bianche");
//PA probabilità pallina bianca PB probabilità pallina nera
// n=bianche+nere casi_possibili; // solo bianche sono i casi favorevoli
// m=bianche rappresenta il numero dei casi_favorevoli
n = nere+bianche;
PA = bianche/n; // probabilità casi favorevoli
PB = nere/n; // probabilità casi sfavorevoli
lay.AddChild( txt );
txt1= app.CreateText("");
lay.AddChild( txt1 );
txt1.SetText(PA+" probabilità di estrarre una pallina bianca "+PB+" probabilità estrarre pallina nera");
//Add layout to app.
app.AddLayout (lay);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) CALCOLO DELLE PROBABILITÀ NEL LANCIO DI UN DADO
SOMMA DI EVENTI
// Called when aapplication is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "SommaEventi Si lancia un dado e si prendono in considerazione i seguenti eventi: A(appaia un numero dispari) + B(appaia un numero > 5). Nel complesso i numeri che soddisfano questa condizione sono(1 3 5 6)",0.8,0.4,"Multiline");
txt.SetTextSize(18);
img=app.CreateImage("/storage/emulated/0/Download/dado-desenho-png.png",0.5,0.4);
lay.AddChild(img );
num=prompt("dammi un numero da 1 a 6");
if(num==1 || num==3 || num==5 || num==6)
{
app.ShowPopup("avevi il "+(4/6 )*100+"di probabilità che uscisse questo numero");
}
else
{
app.ShowPopup("avevi il "+(2/6)*100+" di probabilità che uscisse il numero "+num);
}
lay.AddChild(txt );
//Add layout to app.
app.AddLayout( lay );
}
-------------------------------------
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) CALCOLO DELLE PROBABILITÀ NEL PRODOTTO DEGLI EVENTI
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "Prodotto di Eventi Si lancia un dado e si prendono in considerazione: eventoC(appaia un numero dispari ma che sia anche > = 5). Il solo numero che soddisfa questa condizione e' il numero 5; questo risulta dall'unione dell'eventoA, solo numeri dispari(1 3 5) e dell'eventoB, solo >= 5). In conclusione, l'evento C=A∩B ha una probabilità pari a C=1/6.",0.8,0.4,"Multiline");
txt.SetTextSize(18);
img=app.CreateImage("/storage/emulated/0/Download/dado-desenho-png.png",0.5,0.4);
lay.AddChild(img );
num=prompt("dammi un numero da 1 a 6");
if((num==1 || num==3 || num==5 || num==6) && num >= 5)
{
C = (1/6)*100;
app.ShowPopup("il numero "+num+" e il solo questo soddisfa entrambe le condizioni e ha probabilita pari a"+C);
}
else
{
app.ShowPopup("la probabilita del numero "+num+" pari a 0");
}
lay.AddChild(txt );
//Add layout to app.
app.AddLayout( lay );
}
__________________________________________________
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) SIMULAZIONE DEL GIOCO DEL DADO
Si lancia un dado virtuale e il software genera, in modo random, un numero casuale fra 1 e 6. Tale numero viene confrontato con quello scelto che è stato inserito a richiesta; se sono uguali viene visualizzato il dado corrispondente e che la scelta fatta risulta vincente.
//Called when application is started.
function OnStart() //definisce generica function
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
var num = Math.random();
txt=app.CreateText(" ");
txt.SetTextSize(40);
lay.AddChild( txt );
txt1=app.CreateText("LANCIO DI UN DADO ");
play=prompt("dimmi come ti chiami");
punta=prompt("dammi il numero vincente");
txt1.SetTextSize(40);
lay.AddChild( txt1 );
txt2=app.CreateText(" GIOCATORE ATTUALE "+play);
txt2.SetTextSize(20);
lay.AddChild( txt2 );
img1=app.CreateImage("/storage/emulated/0/Download/dado1.jpg");
img2=app.CreateImage("/storage/emulated/0/Download/dado2.jpg");
img3=app.CreateImage("/storage/emulated/0/Download/dado3.jpg");
img4=app.CreateImage("/storage/emulated/0/Download/dado4.jpg");
img5=app.CreateImage("/storage/emulated/0/Download/dado5.jpeg");
img6=app.CreateImage("/storage/emulated/0/Download/dado6.jpeg");
var num =Math.floor(Math.random() * 6 +1); //genera un numero casuale da 1 a 6
txt.SetText(num);
app.AddLayout(lay );
if(num == punta)
{
lay.AddChild(img1);
img1.Show();
img2.Hide();
img3.Hide();
img4.Hide();
img5.Hide();
img6.Hide();
app.ShowPopup("hai vinto");
app.TextToSpeech("uno vincente"+play);
}
if(num == punta)
{
lay.AddChild(img2 );
img2.Show();
img1.Hide();
img3.Hide();
img4.Hide();
img5.Hide();
img6.Hide();
app.ShowPopup("hai vinto" );
app.TextToSpeech("due vincente" +play);
}
if(num == punta)
{
lay.AddChild(img3 );
img3.Show();
img2.Hide();
img1.Hide();
img4.Hide();
img5.Hide();
img6.Hide();
app.ShowPopup("hai vinto" );
app.TextToSpeech("tre vincente" +play);
}
if(num == punta)
{
lay.AddChild(img4 );
img4.Show();
img2.Hide();
img3.Hide();
img1.Hide();
img5.Hide();
img6.Hide();
app.ShowPopup("hai vinto" );
app.TextToSpeech("quattro vincente"+play );
}
if(num == punta)
{
lay.AddChild(img5 );
img5.Show();
img2.Hide();
img3.Hide();
img4.Hide();
img1.Hide();
img6.Hide();
app.ShowPopup("hai vinto" );
app.TextToSpeech("cinque vincente" +play);
}
if(num== punta)
{
lay.AddChild(img6 );
img6.Show();
img2.Hide();
img3.Hide();
img4.Hide();
img5.Hide();
img1.Hide();
app.ShowPopup("hai vinto" );
app.TextToSpeech("sei vincente" +play);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONE DEL TEOREMA DI BAYES
5) Un'azienda produce apparecchi elettronici e ha riscontrato, in fase di test sul funzionamento(burn in), che quando i componenti usati sono di buona qualità la probabilità di un guasto è pari a PEH1 = 0.95(soltanto 50 su 1000 si guastano in un tempo prefissato di operatività ).
Lo stesso procedimento viene fatto usando dei componenti di qualità inferiore e si riscontra una probabilità di guasto pari PEH2 = 0.7(300 su 1000 probabilmente si guastano nello stesso intervallo di tempo). Per motivi legati al budget aziendale, si decide di realizzare i dispositivi usando i componenti nelle seguenti percentuali: PH1=0.4 e PH2 = 0.6; il 40% buoni e il 60% mediocri. Si vuole calcolare la probabilità , chiamata E, che durante la fase di collaudo, e nello stesso intervallo di tempo del test, non si verifichi alcun guasto.
Si ricorre alla formula di Bayes che tiene conto della diversa percentuale dei componenti e della diversa probabilità di guasto degli stessi; essa è condizionata anche dalle percentuali dei due componenti H1 e H2.
PE = PH1*PEH1/(PH1*PEH1+ PH2* PEH2)
// Called when application is started
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText(" ");
txt. SetTextSize(22);
PH1 = prompt("dammi la percentuale dei componenti di buona qualità espressa con numero da 0 a 1");
PH2 = prompt("dammi la percentuale dei componenti di mediocre qualità espressa con numero da 0 a 1");
PEH1 = prompt("dammi la probabilità di guasto quando i componenti sono di buona qualità espressa con numero da 0 a 1");
PEH2 = prompt("dammi la probabilità di guasto quando i componenti sono di mediocre qualità espressa con un numero da 0 a 1");
PE= PH1*PEH1/(PH1*PEH1+ PH2* PEH2);
lay.AddChild( txt);
txt. SetText(PE+" probabilità che si verifichi evento E");
//Add layout to app.
app.AddLayout (lay);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AUTOMI A STATI FINITI
1) SIMULAZIONE DI UN DISTRIBUTORE AUTOMATICO
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt1= app.CreateText( "PREMI QUI PER ACCENDERE DISTRIBUTORE E PER INSERIRE LE MONETE" );
txt1.SetTextSize(20);
lay.AddChild( txt1);
txt1.SetOnTouch(accendi );
txt2= app.CreateText( "" );
txt2.SetTextSize(24);
lay.AddChild( txt2);
img=app.CreateImage( "/storage/emulated/0/Download/bibite.png", 0.4,0.4 );
lay.AddChild(img );
app.AddLayout( lay );
}
function accendi()
{
attesa = prompt("inserire 1 per distributore acceso, 0 per spento");
pronto = prompt(" inserisci moneta 1 per inserito, 0 per non inserito");
if(pronto == 1 && attesa ==1)
{
img.Show();
txt2.SetText("BIBITA PRONTA");
app.TextToSpeech( " bibita pronta" );
txt1.SetText("");
}
else
{
img.Hide();
txt1.SetText( "NON PUOI RITIRARE" );
app.TextToSpeech( "non puoi ritirare la bibita" );
txt2.SetText("");
}
}
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) SIMULAZIONE DI AUTOMI A STATI FINITI
SISTEMA DI ILLUMINAZIONE DI UNA STANZA, GESTITO DA UN AUTOMA A STATI FINITI, CON LE SEGG. CARATTERISTICHE:
* NELLA STANZA SONO PRESENTI 2 INTERRUTTORI A PARETE CHE CHIAMIAMO A e B, E, POI, ALTRI DUE CHE CHIAMIAMO C e D SULLA PARETE OPPOSTA. LE IMPOSTAZIONI PER IL LORO FUNZIONAMENTO SONO LE SEGG:
A = 1 e C = 0 ACCENDE L1
B = 1 e D = 0 ACCENDE L2
C = 1 e A = 0 ACCENDE L1
D = 1 e B = 1 ENTRAMBE ACCESE
UN TASTO DI SPEGNIMENTO GENERALE
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "" );
txt.SetTextSize( 32 );
lay.AddChild( txt );
accesa1=app.CreateImage( "/storage/emulated/0/Download/accesa1.jpg", 0.7,0.3);
accesa2=app.CreateImage("/storage/emulated/0/Download/accesa2.jpg",0.7,0.3);
b1= app.CreateButton( "ACCENDI L1" );
b1.SetOnTouch( accendib1 );
b1.SetTextSize( 15 );
lay.AddChild( b1 );
b2= app.CreateButton( "ACCENDI L2" );
b2.SetOnTouch( accendib2);
b2.SetTextSize( 15 );
lay.AddChild( b2 );
b3= app.CreateButton( "ACCENDI L1" );
b3.SetOnTouch( accendib3 );
b3.SetTextSize( 15 );
lay.AddChild( b3 );
b5= app.CreateButton( "SPEGNI L1 e L2" );
b5.SetOnTouch(spegnib5);
b5.SetTextSize(20);
lay.AddChild( b5 );
b6= app.CreateButton( "ACCENDI L1 e L2" );
b6.SetOnTouch(accendi1e2);
b6.SetTextSize(20);
lay.AddChild( b6);
app.AddLayout( lay );
}
function accendib1()
{
A=prompt("Stato di A");
C=prompt("Stato di C");
if(A==1 && C==0)
{
lay.AddChild( accesa1 );
txt.SetText( "L1 ACCESA" );
}
}
function accendib2()
{
B=prompt("Stato di B");
D=prompt("Stato di D");
if(B==1 && D==0)
{
accesa1.Hide();
lay.AddChild(accesa2 );
txt.SetText( "L2 ACCESA" );
}
}
function accendib3()
{
C=prompt("Stato di C");
A=prompt("Stato di A");
if(C==1 && A==0)
{
accesa1.Hide();
lay.AddChild( accesa2 );
txt.SetText( "L1 ACCESA" );
}
}
function accendi1e2()
{
D = prompt("Stato di D");
B = prompt("Stato di B");
if(D==1 && B==1)
{
lay.AddChild(accesa2 );
lay.AddChild( accesa1 );
txt.SetText( "L2 ACCESA E L1 ACCESA" );
}
}
function spegnib5()
{
accesa1.Hide();
accesa2.Hide();
txt.SetText( "L1 SPENTA L2 SPENTA" );
}
Esecuzione script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SCRIPT DI VARIO GENERE E UTILIZZO
1) CALCOLO MASSIMO VALORE DEL BATTITO CARDIACO IN FUNZIONE DI: PRESSIONE SANGUIGNA, BATTITI A RIPOSO, ETÀ...
// Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/extSdCard/Foto/running.jpg",0.3,0.3);
var timer;
var nome;
var eta;
var altezza;
var press_sang_rip;
var battiti_rip;
var medicine;
var battiti_corsa;
nome=prompt("dimmi come ti chiami");
eta=prompt("dimmi la tua eta");
altezza=prompt("quanto sei alto");
pres_sang_rip=prompt("la tua pressione sanguigna a riposo");
battiti_rip=prompt("dimmi quante pulsazioni ha il tuo cuore a riposo");
battiti_corsa= 208-eta*0.7;
app.ShowPopup(battiti_corsa);
txt = app.CreateText( "PREPARAZIONE ATLETICA" );
txt1 =app.CreateText("");
txt1.SetTextSize( 25 );
txt1.SetTextColor( "#FF0033");
txt1.SetText( battiti_corsa +" massima frequenza cardiaca di "+ nome ); lo
txt.SetTextSize(25);
txt.SetTextColor( "#99CC33" );
lay.AddChild(txt );
lay.AddChild(txt1 );
lay.AddChild(img );
//Add layout to app.
app.AddLayout( lay );
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) CHIAMATA TELEFONICA CON DROIDSCRIPT
// Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
edtNumber = app.CreateTextEdit( "40916", .8, -1, "singleline,number,center" );
edtNumber.SetTextSize(20);
lay.AddChild(edtNumber);
btnPhone = app.CreateButton( "Call", 0.5, 0.1 );
btnPhone.SetOnTouch(chiama); // si attiva la function (chiama) quando si tocca il button
lay.AddChild( btnPhone );
app.AddLayout( lay );
}
function chiama()
{
app.Call( edtNumber.GetText() );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) RUOTARE LE IMMAGINI
Ruota immagine di qualche grado quando la si tocca.
// Called when application is started.
nome = prompt("come ti chiami");
var i;
i=0;
function OnStart()
{
s= app.CreateLayout( "linear", "VCenter,FillXY" );
txt=app.CreateText( "" );
img=app.CreateImage("\C:\Users\Administrator\Desktop\immagini\panorama.png ",0.5,0.7);
s.AddChild( img );
img.SetOnTouch(apri); // Crea la function apri al tocco su immagine
img.SetSize(0.8,0.6);
app.AddLayout(s);
s.AddChild( txt );
}
function apri(ev) // Stabilisce cosa deve fare la function (apri) attraverso la variabile ev
{
if (ev.action=="Down") // Se ev.action è di tipo down, hai cliccato sul bottone, esegui il codice fra le graffe
{
img.Move(0.2,0.3) // Muovi immagine
i=i+1; // Incrementa contatore
img.Rotate(i ); // Ruota di una unitÃ
app.ShowPopup(nome + " hai toccato "+ i,+" volte" );
txt.SetText(" hai toccato"+i+" volte");
app.TextToSpeech( "continui a toccare immagine" );
}
if (ev.action=="Up") // Se ev.action è di tipo up, appoggi il dito sul bottone, esegui il codicece fra le graffe
{
app.ShowPopup(" hai appoggiato solo il dito su di me" );
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) ESEGUIRE UN FILE mp3
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
lay.SetBackColor("yellow");
layFrame=app.CreateLayout("Frame","");
img=app.CreateImage("/storage/sdcard0/Download/vollenweider.jpg",0.6,0.3);
layFrame.AddChild(img);
lay.AddChild( layFrame);
app.AddLayout(lay);
//Create a text label and add it to layout.
btn=app.CreateButton("VOLLENWEIDER",0.4,0.05);
btn.SetOnTouch(canta);
lay.AddChild( btn);
//Add layout to app.
app.AddLayout( lay );
lay.AddChild(img );
player=app.CreateMediaPlayer();
player.SetFile("/storage/extSdCard/mp3/VollenweiderFires.mp3");
}
function canta()
{
player.SeekTo(0);
player.Play();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) CREATE_CAMERA_VIEW
Attiva e predisposizione la camera fotografica dello smartphone. Basta cliccare sul button SNAP per scattare una foto che viene anche salvata nella directory (sdcard/MyPic.jpg).
//Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "Linear", "VCenter,FillXY" );
cam = app.CreateCameraView( 0.8, 0.4 );
lay.AddChild( cam );
cam.SetPictureSize( 1024, 768 );
setTimeout( "cam.StartPreview()", 1000 );
btn = app.CreateButton( "Snap", 0.3, -1 );
btn.SetOnTouch( Snap );
lay.AddChild( btn );
app.AddLayout( lay );
}
function Snap()
{
cam.TakePicture( "/sdcard/MyPic.jpg" );
app.ShowPopup("Picture saved");
}
Esecuzione dello script
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
6) OROLOGIO DIGITALE CHE COMUNICA LA DATA E L'ORA CON I MILLESIMI DI SECONDO.
//Called when application is started.
function OnStart()
{
app.SetOrientation( "Portrait" );
app.SetDebugEnabled( false );
nome=prompt("come ti chiami");
lay = app.CreateLayout( "Linear", "FillXY,VCenter" );
txt = app.CreateText( "", -1, -1, "multiline" );
txt.SetTextSize( 30 );
lay.AddChild( txt );
txt1=app.CreateText("",-1,-1,"multiline");
lay.AddChild( txt1 );
txt1.SetTextSize(30);
txt1.SetTextColor("#ccbb0a");
app.AddLayout( lay );
app.Animate( OnAnimate, 30 );
}
function OnAnimate( time, dtime )
{
txt1.SetText("OROLOGIO DIGITALE DI "+nome);
txt.SetText( new Date().toLocaleString() + "\n" + time );
}
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
7) ACCEDERE A SITI INTERNET CON DROIDSCRIPT
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
web=app.CreateWebView(0.8,0.8);
lay.AddChild(web);
//Add layout to app.
app.AddLayout( lay );
txt1=app.CreateText("ciao ");
edt=app.CreateTextEdit(" ");
b1=app.CreateButton("FEDERER");
b2=app.CreateButton("INDEGNO POKER_MAN");
b3=app.CreateButton("IL SOLE XXIV ORE");
lay.AddChild(b1);
b1.SetOnTouch(apri1);
lay.AddChild(b2);
b2.SetOnTouch(apri2);
lay.AddChild(b3);
b3.SetOnTouch(apri3);
lay.AddChild(edt );
lay.AddChild(txt1 );
}
function apri1()
{
web.LoadUrl("http://www.rogerfederer.com");
}
function apri2()
{
web.LoadUrl("http://pokerprolabs.com/indegno/PokerStars.it");
}
function apri3()
{
web.LoadUrl("http://www.ilsole24ore.com");
}
---------------------------------
Esecuzione dello script
/////////////////////////////////////////////////////////////////////////////////////////////////////////
8) SCEGLIERE UNA FOTO DALLO SMARTPHONE
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
btnChoose = app.CreateButton("SCEGLI UNA FOTO", 0.5, 0.1 );
btnChoose.SetOnTouch( btnChoose_OnTouch );
lay.AddChild( btnChoose );
app.AddLayout( lay );
}
function btnChoose_OnTouch()
{
app.ChooseImage( "internal", OnChoose );
}
function OnChoose( path )
{
alert( "image path: " + path );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
WIFI BROADCAST
9) COMUNICAZIONE FRA SMARTPHONES COLLEGATI ALLO STESSO ROUTER E COLLOCATI IN AMBIENTI DIVERSI.
Ambiente1
Ambiente2
Ambiente3
Si devono avviare, contemporaneamente, le applicazioni su tutti gli smartphone collegati alla stessa rete domestica (non siamo su Internet!!). Gli smartphone possono essere molti, compatibilmente con le potenzialità della stessa rete, e collocati in una zona non troppo estesa e nel raggio d'azione del router(capannone industriale o similare...).
Utilizzo dell'applicazione: si possono scambiare informazioni di servizio, o di altro genere, fra vari operatori dislocati all'interno della stessa area.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/sdcard0/",0.8,0.4); //ambiente1 nel quale collocare smartphone
img1=app.CreateImage("/storage/extSdCard/Foto.jpg",0.2,-1); //ambiente2 nel quale collocare smartphone
img2=app.CreateImage("/storage/emulated/0/Download/impianto.jpg" ,0.8,0.4); //ambiente3 nel quale collocare smartphone
//img2.Hide();
//lay.AddChild( img );
btn=app.CreateButton("Send",0.3,0.1);
btn.SetMargins(0,0.05,0.0);
lay.AddChild( btn );
btn.SetOnTouch(btn_OnTouch);
app.AddLayout( lay );
net=app.CreateNetClient("UDP");
address=net.GetBroadcastAddress();
port=19700;
mac=app.GetMacAddress();
setInterval(CheckForMsg,200);
txt=app.CreateText( "" );
lay.AddChild( txt );
nome=prompt("dimmi come ti chiami");
nome1=prompt("dimmi come si chiama il tuo collega")
}
function btn_OnTouch()
{
var msg= "allarme";
var msg="impianto";
var msg="numero carta documento";
var packet = mac + "|" + msg;
net.SendDatagram(packet, "UTF-8",address,port);
}
function CheckForMsg()
{
var count=0;
var packet=net.ReceiveDatagram("UTF-8",port,1);
if(packet)
{
parts=packet.split("|");
var id= parts[0];
var msg=parts[1];
if(id != mac)
app.ShowPopup( msg );
}
if(msg== "impianto")
{
app.TextToSpeech( "sono"+nome1 +"devi mettere a terra impianto elettrico");
img2=app.CreateImage("/storage/emulated/0/Download/impianto.jpg",0.8,0.4);
lay.AddChild( img2 );
}
if(msg=="numero carta documento")
{
app.TextToSpeech("sono"+nome1+"la carta documento con numero 5544765");
}
if(msg=="allarme")
{
app.TextToSpeech("sono"+nome1+"e ti chiedo di inserire allarme con codice 4368);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONI IN AMBITO TRASMISSIONE DEL CALORE(Area tecnica)
Fourier. Farina Parma Uni
1) Calcolo quantità di calore necessaria a mantenere temperatura costante in un ambiente domestico. Applicazione della Legge di Fourier.
// Called when application is started.
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "I muri di una stanza in mattoni hanno spessore d1 e superficie complessiva A1. Si consideri poi la presenza, nella stanza, di una porta in legno dello spessore d2 e superficie A2. Progettare un software in grado di calcolare la quantita di calore necessaria per mantenere la temperatura della stanza costante e a valore prefissato",0.8,0.2, "Multiline");
txt.SetTextSize(14 );
txt1=app.CreateText("");
txt1.SetTextSize( 20 );
lay.AddChild( txt );
lay.AddChild( txt1 );
d1=prompt("dammi lo spessore dei muri in metri");
A1=prompt("dammi la superficie complessiva dei muri in mq");
d2=prompt("dammi lo spessore della porta in legno in metri");
A2=prompt("dammi la superficie della porta in mq");
To=prompt("dammi la temperatura esterna in gradi_centigradi");
Ta=prompt("dammi la temperatura della stanza che vuoi mantenere costante");
lamda_mattoni=prompt("dammi il coefficiente di conduzione termica dei mattoni espresso in W/m*k");
lamda_legno=prompt("dammi il coefficiente di conduzione termica dei muri espresso in W/m*k");
// Considerazioni: ipotizziamo che la trasmissione del calore avvenga solo per conduzione e pertanto risulta applicabile la legge di Fourier che consente il calcolo della quantità di calore Q che deve essere fornita alla stanza per sostenere il calore che viene disperso verso esterno attraverso gli elementi
deltaT=Ta-To;
Qmattoni=lamda_mattoni*(A1*deltaT/d1);
Qlegno = lamda_legno*(A2*deltaT/d2);
Q=Qmattoni+Qlegno;
app.TextToSpeech( Q +"watt");
txt1.SetText(Q+" Watt quantità di calore necessaria" );
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) Calcolo della quantità di calore necessaria a scaldare una quantità d' acqua in ambiente domestico. Calore specifico acqua.
// Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/sdcard1/DCIM/Camera/scalda.jpg",0.7,0.4);
lay.AddChild( img );
txt = app.CreateText( "Uno scaldabagno elettrico a resistenza contiene un certa quantità d'acqua che deve essere portata dalla temperatura di acquedotto To a T1. Dobbiamo calcolare la quantità di calore Q che dobbiamo fornire",0.8,0.2,"Multiline");
lay.AddChild( txt );
txt1=app.CreateText(" ");
txt.SetTextSize(13);
To=prompt("dammi il valore della temperatura ambiente");
T1=prompt("dammi il valore della temperatura a cui vuoi portare acqua");
c=prompt("dammi il calore specifico del liquido in g/cmc\n "); // 1g/cmc
m=prompt("dammi la massa di liquido da riscaldare");
Q=m*c*(T1-To);
app.ShowPopup(Q + " Joule quantità di calore che deve essere fornita");
lay.AddChild( txt );
lay.AddChild(txt1);
txt1.SetText(Q*10**(-3) + " KJoule quantità calore necessaria");
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PROGRAMMAZIONE DEI SENSORI DI TABLET O
SMARTPHONE
Elenco di alcuni sensori a bordo di tablet o smartphone che, a seconda del livello qualitativo dello stesso, possono essere presenti :
Temperature
Pressure
Humidity
Accelerometer
Rotation
StepDetector
Light
GPS
Orientation
Proximity
_______________
La fig.mostra tutti i Metodi relativi al sensore Orientation; e' scontato che ciascun sensore possieda i suoi da utilizzare contestualmente all'applicazione che si realizza.
VENGONO PROPOSTE ALCUNE APPLICAZIONI CHE POSSONO ESSERE DI RIFERIMENTO PER PROGRAMMARE I NOSTRI TABLET
ALLARME CON IL SENSORE ACCELEROMETER
SENSORI_SMATPHONE_SITO_RIFERIMENTO
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1) Accelerometer dello smartphone per generare un allarme.
// Called when application is started
var x; //variabile globale
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
p=app.CreateButton("ACCENDI",1,0.6); // Crea button
lay.AddChild(p); // Pone il button su lay
p.SetTextSize(30); // Stabilisce la larghezza di testo del button
p.SetBackColor("#00FF00"); // Stabilisce il colore del button
sensore=app.CreateSensor("Accelerometer"); // Crea oggetto sensore accelerometer
p.SetOnTouch(accendi); // Crea la function accendi al tocco del button p
sensore.SetOnChange(controlla); // impone al sensore cosa fare, durante i cambiamenti, mediante la function controlla
nome=prompt("dimmi come ti chiami"); // Acquisisce il nome
x=0; // impone un valore iniziale alla variabile x
suono=app.CreateMediaPlayer(); // Crea oggetto MediaPlayer
suono.SetFile("/storage/extSdCard/Pino_Daniele/La Grande Madre.mp3"); // stabilisce il percorso(path) del file
app.AddLayout( lay );
}
function accendi()
{
if (x==0) // Esegue test sulla variabile x
{
p.SetBackColor("#FF0000"); // Impone il testo sul button creato
p.SetText("SPEGNI"); // Impone il testo che deve apparire sul button
sensore.Start(); // Avvia il sensore
x=1;
suono.Stop(); // Blocca il suono
}
else if(x==1) // Esegue test sulla variabile x
{
p.SetBackColor("#00FF00");
p.SetText("ACCENDI"); // Impone il testo sulla casella di testo
sensore.Stop(); // Blocca il sensore
suono.Stop(); // Blocca il suono
app.TextToSpeech(nome +"premi il pulsante per avviare"); // Comunica a voce
}
}
function controlla(x,y)
{
app.ShowPopup(x+ "-" +y); // Mostra a video i valori di x e y
if (x>3 || x<-3 || y>3 || y < -3) // controlla i valori di x e y e se interni al range attiva allarme
{
app.ShowPopup("ALLARME");
app.TextToSpeech(nome +" ti stanno rubando il cellulare" ); // Comunica a voce cosa succede
suono.Play( ); // Avvia il suono
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) APPLICAZIONE CON SENSORE GPS A SUPPORTO DELLA GUIDA IN AUTO.
N.B: applicazione mancante di circa 20 righe di codice e, quindi, non funzionante; si trova sullo store.
Nozioni di Orientamento
Bearing,
Android: come inserire coordinate per trovare un luogo
Sito di Rif.to per il calcolo del Bearing
//CALLED WHEN APPLICATION IS STARTED
function OnStart()
{
//Create a layo with objects vertically centered.
s= app.CreateLayout( "linear", "VCenter,FillXY" );
player=app.CreateMediaPlayer();
player.SetFile("/Sys/Snd/Poing.ogg");
img=app.CreateImage("/storage/extSdCard/Download/images-2.jpeg",0.8,0.2,-1);
s.AddChild(img);
nome=prompt("dimmi come ti chiami");
gps=app.CreateText("Valori del GPS del
luce.Start();
luce.SetOnChange(fari); txt1.SetTextSize(14 );
txt8=app.CreateText(" ");
txt8.SetTextSize(20 );
txt8.SetBackColor("#ff00bb");
txt=app.CreateText(" ");
txt.SetTextSize(30);
txt.SetBackColor( "#006633" );
p=app.CreateButton("PORTIERA_CHIUSA");
p.SetTextSize(22);
p.SetBackColor( "#66CC00" );
txt1=app.CreateText(" ");
txt1.SetTextSize(20);
txt2=app.CreateText(" ");
txt2.SetTextSize(20);
txt3=app.CreateText(" ");
txt3.SetTextSize(20);
txt4=app.CreateText(" ");
txt4.SetTextSize(20);
txt5=app.CreateText(" ");
txt5.SetTextSize(20);
txt6=app.CreateText(" ");
txt6.SetTextSize(20);
txt7=app.CreateText(" ");
txt7.SetTextSize(20);
txt9=app.CreateText("");
txt9.SetTextSize( 20 );
s.AddChild(txt );
s.AddChild(txt1 );
s.AddChild(txt2 );
s.AddChild(txt3);
s.AddChild(txt4);
s.AddChild(txt5 );
s.AddChild(txt6);
s.AddChild(txt7 );
s.AddChild( txt8 );
s.AddChild(img );
s.AddChild( p );
sensore.SetRate(5);
app.AddLayout(s );
}
mancano righe di codice
}
function fari(accendi)
{
var lux1;
var lux2;
lux1=5; // fissa il minimo livello di riferimento per lux1
lux2= 10; // fissa il massimo livello di riferimento per lux2
if(accendi >= lux2)
{
app.ShowPopup( " devi spegnere i fari" ); // visualizza la stringa di comunicazione
txt8.SetText(" devi spegnere i fari"); // pone su txt la stringa di comunicazione
}
else if(accendi <= lux1)
{
app.ShowPopup( accendi + " devi accendere i fari"); //visualizza il valore ottenuto e la stringa
txt8.SetText(accendi + " devi accendere i fari");
app.TextToSpeech( "devi accendere i fari" );
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) APPLICAZIONE CON SENSORE GPS A SUPPORTO DELLA GUIDA IN AUTO.
Caratteristiche del software:
* consente la navigazione nei siti di MAP e di AUTOSTRADE.
* si possono scattare delle foto essendo la fotocamera sempre attiva.
* usa il sensore di luce, LIGHT, per avvisare di accendere o spegnere i fari al variare della luminosità ambiente.
* il sensore ORIENTATION controlla inclinazione dell'auto e, in caso di incidente grave con uscita di strada, viene effettuata un telefonata al pronto soccorso o ad altro soggetto specificato nel codice.
* il sensore relativo ad altitude controlla la quota altimetrica e avvisa se è stato superato il livello preimpostato.
* in caso di fermata, con velocità zero, un segnale vocale avvisa di fare attenzione ad aprire la portiera e ad azionare il freno a mano e avvisa anche della presenza del bambino sul seggiolino.
function OnStart()
{
s= app.CreateLayout( "linear", "VCenter,FillXY" );
app.AddLayout(s);
testo_casa = app.CreateText( "DATI DEL GPS" );
s.AddChild( testo_casa );
testo_casa.SetTextSize(15);
p=app.CreateButton("VAI A MAP",-1,-1,"FillX,Alum");
s.AddChild( p );
p.SetPosition(top);
p.SetTextSize(15 );
p.SetBackColor( "#ff69b4");
p.SetOnTouch( prossima);
auto=app.CreateButton("VAI AUTOSTRADE",-1,-1,"FillX,Alum");
s.AddChild(auto );
auto.SetTextSize(15);
auto.SetBackColor("#ff8c00");
auto.SetOnTouch(cercagpl);
m=app.CreateLayout("linear","VCenter,FillXY");
app.AddLayout(m);
testo_pagina=app.CreateText("SITO DI MAP");
m.AddChild( testo_pagina );
p_torna=app.CreateButton("RITORNA AL GPS",-1,-1);
m.AddChild( p_torna );
p_torna.SetOnTouch(ritorna_casa);
p_torna.SetPosition(top);
auto=app.CreateLayout("linear","VCenter,Fill XY");
app.AddLayout(auto);
testo_auto=app.CreateText("AUTOSTRADA");
auto.AddChild( testo_auto);
p_torna=app.CreateButton("RITORNA AL GPS");
N.B MANCANO RIGHE DI CODICE PERCHÉ APPLICAZIONE SI TROVA SU PLAYSTORE!
s.AddChild( web );
app.ShowProgress("Loading...");
web.LoadUrl( "https://www.automap.it/agriturismo/" );
player=app.CreateMediaPlayer();
//player.SetFile("/Sys/Snd/Poing.ogg")
app.TextToSpeech( "dimmi come si chiama il tuo bambino" );
nome = prompt("dimmi come si chiama il tuo bambino");
nome1=prompt("dimmi come ti chiami");
app.TextToSpeech("che strada stai percorrendo, ztl, citta, autostrada, statale. ");
strada=prompt("dimmi che tipo di strada stai percorrendo, citta, ztl, statale, autostrada");
gps=app.CreateText("Valori del GPS del cellulare di " +nome1);
s.AddChild(gps);
gps.SetTextColor("#4028DE");
gps.SetTextSize(15);
sensore=app.CreateLocator("GPS,Network");
sensore.Start();
s.AddChild( sensore );
luce=app.CreateSensor("Light","Medium");
luce.Start();
luce.SetOnChange(fari);
txt8=app.CreateText(" ");
txt8.SetTextSize(18);
txt8.SetBackColor("#ff00bb");
s.AddChild(luce);
txt=app.CreateText(" ");
txt.SetTextSize(20);
txt.SetBackColor( "#006633" );
s.AddChild(txt );
txt1=app.CreateText(" ");
txt1.SetTextSize(15);
s.AddChild( txt1 );
txt2=app.CreateText(" ");
txt2.SetTextSize(15);
s.AddChild( txt2 );
txt3=app.CreateText(" ");
txt3.SetTextSize(15);
s.AddChild( txt3 );
txt4=app.CreateText(" ");
txt4.SetTextSize(15);
s.AddChild( txt4);
txt5=app.CreateText(" ");
txt5.SetTextSize(15);
s.AddChild( txt5);
txt6=app.CreateText(" ");
txt6.SetTextSize(15);
s.AddChild( txt6);
txt7=app.CreateText(" ");
txt7.SetTextSize(15);
s.AddChild( txt7 );
txt8=app.CreateText(" ");
txt8.SetTextSize(15);
txt8.SetBackColor( "#cc22cc" );
s.AddChild( txt8 );
p=app.CreateButton("PORTIERA_CHIUSA");
p.SetTextSize(15);
p.SetBackColor("#cb3234" );
//s.AddChild(img );
s.AddChild( p );
sensore.SetRate(5);
app.AddLayout(s );
}
function dovesiamo(lava)
{
txt.SetText("VELOCITA in km/h: " + Math.round(lava.speed*3.6));
txt1.SetText("ALTITUDINE su livello del mare: " + Math.round(lava.altitude));
txt2.SetText("LATITUDINE: " + Math.round(lava.latitude));
txt4.SetText("DISTANZA in metri da MILANO: "+ Math.round(sensore.GetDistanceTo(45.4742803,9.1136881)));
txt3.SetText("LONGITUDINE: "+ Math.round(lava.longitude));
txt5.SetText("ACCURATEZZA: " +Math.round(lava.accuracy));
txt6.SetText("BEARING: " +lava.bearing);
txt7.SetText("PROVIDER: " +lava.provider);
txt8.SetText("LUMINOSITA AMBIENTE:"+ (lava.light));
if((lava.speed*3.6 >= 63) && (strada=="citta"))
{
app.TextToSpeech(nome +"limite superato",1.0,1.0);
}
{
app.TextToSpeech("attento alla portiera e metti freno a mano" );
p.SetBackColor( "#cb3234" );
p.SetText("ATTENZIONE A GRETA SUL SEGGIOLINO");
app.TextToSpeech(nome+"è sul seggiolino" );
p.SetBackColor( "#FF0000" );
player.Play();
}
}
N.B MANCANO RIGHE DI CODICE PERCHÉ APPLICAZIONE SI TROVA SU PLAYSTORE!
function fuoristrada(x,y,z,time)
{
//txt9.SetText( "x" +x + "\n y =" +y +"\n z=" +z); // valuta inclinazione auto
if(x< -6 || x >8) // incidente grave chiama 113
{
app.TextToSpeech(" ora telefono al centotredici" );
app.Call(027239963 );
}
}
function fari(accendi,time)
{
var lux1;
var lux2;
lux1=5;
lux2= 20
if(accendi >= lux2)
{
//app.ShowPopup(accendi + "
txt8.SetText(accendi+"devi spegnere i fari");
}
if(accendi <= lux1)
{
app.ShowPopup(accendi+ " devi accendere i fari");
txt8.SetText(accendi+ " devi accendere i fari");
N.B MANCANO RIGHE DI CODICE PERCHÉ APPLICAZIONE SI TROVA SU PLAYSTORE!
//app.TextToSpeech( "devi accendere i fari" );
}
}
function prossima()
{
web=app.CreateWebView(1,1);
m.AddChild(web);
s.Hide();
m.Hide();
auto.Show();
}
function ritorna_casa()
{
m.Hide();
auto.Hide();
s.Show();
}
function Snap()
{
cam.TakePicture( "/sdcard/MyPic.jpg" );
app.ShowPopup("Picture saved");
}
function web_OnProgess( progress )
{
app.Debug(= " + progress );
if( progress==100 ) app.HideProgress();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) SENSORE DI ROTAZIONE con Orientation_sensor
// Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
s= app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "il mio nome" );
txt.SetTextSize(25);
s.AddChild( txt );
sensore=app.CreateSensor("Orientation");
sensore.Start();
sensore.SetOnChange(leggi);
p1=app.CreateButton("AVVIA SENSORE ROTAZIONE");
p2=app.CreateButton("FERMA SENSORE ROTAZIONE");
s.AddChild( p1 );
s.AddChild( p2);
p1.SetOnTouch(avvia);
p2.SetOnTouch(ferma);
//Add layout to app.
app.AddLayout(s);
}
function leggi(x)
{
txt.SetText("ANGOLO DI ROTAZIONE: "+Math.round(x));
if (x>100)
{
app.ShowPopup("attenzione angolo di rotazione oltre il limite " + x);
}
if (x==0)
{
app.TextToSpeech("sei allineato a nord" );
app.ShowPopup("NORD");
}
if (x==90)
{
app.TextToSpeech("sei allineato a est" );
app.ShowPopup("EST");
}
if (x==180)
{
app.TextToSpeech("sei allineato a sud");
app.ShowPopup("SUD");
}
if (x==270)
{
//app.TextToSpeech("sei allineato a ovest");
app.ShowPopup("OVEST")
}
}
function avvia()
{
sensore.Start();
}
function ferma()
{
sensore.Stop();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) SENSORE DI PROSSIMITA' con il Proximity_Sensor
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
s= app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "SENSORE DI PROSSIMITA" );
txt.SetTextSize( 32 );
s.AddChild( txt );
sensore=app.CreateSensor("Proximity");
sensore.Start();
sensore.SetOnChange(leggi);
p1=app.CreateButton("AVVIA SENSORE PROSSIMITA");
p2=app.CreateButton("FERMA SENSORE PROSSIMITA");
s.AddChild(p1);
s.AddChild(p2);
p1.SetOnTouch(avvia);
p2.SetOnTouch(ferma);
//Add layout to app.
app.AddLayout(s);
}
function leggi(x)
{
txt.SetText("PROSSIMITA: "+ Math.round(x));
if ( x<3) per
{
app.ShowPopup("ti stai avvicinando troppo");
app.TextToSpeech("fai attenzione ti stai avvicinando troppo"+x);
}
}
function avvia()
{
sensore.Start();
}
function ferma()
{
sensore.Stop();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
6) RILEVAMENTO POSIZIONE CON GPS
//Called when application is started
function OnStart()
{
s=app.CreateLayout("linear","VCenter,FillXY");
loc=app.CreateLocator("GPS");
loc.SetOnChange(loc_OnChange);
loc.Start();
app.ShowPopup("Locating");
name=prompt("dimmi come ti chiami\n");
txt=app.CreateText("",0.9,0.9,"Multiline, Left");
txt.SetTextColor( "#ffffffff" );
s.AddChild(txt);
app.AddLayout(s);
}
function loc_OnChange(pos)
{
var msg=pos.latitude + "-" + pos.longitude;
app.ShowPopup(name +" sei nella posizione "+ msg);
if (pos.latitude >= 43.16753 || pos.longitude >=13.804091)
{
txt.SetText("sei nella posizione corretta " +msg);
}
else
{
app.ShowPopup("non corretta");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
7) RILEVAMENTO CAMPO_MAGNETICO
MagneticField_sensor
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
s= app.CreateLayout( "linear", "VCenter,FillXY" );
txt=app.CreateText("");
txt1=app.CreateText("");
//Create a text label and add it to layout.
txt.SetTextSize(25 );
s.AddChild(txt);
s.AddChild( txt1 );
nome=prompt("dimmi come ti chiami");
sensore=app.CreateSensor("MagneticField");
sensore.SetOnChange(leggi);
p1=app.CreateButton("AVVIA RILEVAMENTO CAMPO MAGNETICO");
p2=app.CreateButton("FERMA RILEVAMENTO");
s.AddChild(p1);
s.AddChild(p2);
p1.SetOnTouch(avvia);
p2.SetOnTouch(ferma);
//Add layout to app.
app.AddLayout(s);
}
function leggi(x)
{
txt.SetText("CAMPO_MAGNETICO: "+Math.round(x));
if (x>160)
{
var n;
n=0;
app.ShowPopup(nome+"attenzione il valore del campo magnetico supera il livello di sicurezza");
app.TextToSpeech(nome+ "livello campo magnetico superato");
app.Vibrate("0,100,30.100,50,300"); // Attiva vibrazione
n=n+1;
txt1.SetText(n +"totale persone transitate");
}
}
function avvia()
{
sensore.Start();
}
function ferma()
{
sensore.Stop()
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
8) RILEVAMENTO LIVELLO ILLUMINAZIONE AMBIENTALE e di VICINANZA con i SENSORI: Proximity e Light
//Called when application is started
function OnStart()
{
s= app.CreateLayout( "linear", "VCenter,FillXY");
nome=prompt("dimmi come ti chiami");
txt = app.CreateText( "SENSORE DI LUCE DEL CELLULARE" );
txt.SetTextSize(15);
txt1=app.CreateText("");
s.AddChild(txt);
s.AddChild(txt1 );
sensore=app.CreateSensor("Proximity");
sensore.Start();
sensore.SetOnChange(leggiP);
sensore1=app.CreateSensor("Light");
sensore1.Start();
sensore1.SetOnChange(leggiL);
//Add layout to app.
app.AddLayout(s);
p1=app.CreateButton("AVVIA RILEVAMENTO ILLUMINAZIONE");
p2=app.CreateButton("STOP RILEVAMENTO ILLUMINAZIONE");
p3=app.CreateButton("AVVIA RILEVAMENTO SENSORE PROSSIMITA'");
p4=app.CreateButton("STOP RILEVAMENTO SENSORE PROSSIMITA'");
s.AddChild(p1);
s.AddChild(p2);
s.AddChild(p3);
s.AddChild(p4);
p2.SetOnTouch(fermaL);
p1.SetOnTouch(avviaL);
p3.SetOnTouch(avviaP);
p4.SetOnTouch(fermaP);
}
function leggiP(x)
{
txt.SetText("Prossimita:" + Math.round(x));
if(Math.round(x) == 0)
{
app.TextToSpeech( "ti sei avvicinato a meno di dieci centimetri" );
}
}
function avviaP()
{
sensore.Start();
}
function fermaP()
{
sensore.Stop();
}
function leggiL(x,y,z,time)
{
txt.SetText("Illuminazione:" + Math.round(x));
if (Math.round(x) < 100)
{
app.TextToSpeech("poca luce conviene attivare quella artificiale" );
}
}
function avviaL(x)
{
sensore1.Start();
}
function fermaL()
{
sensore1.Stop();
}
--------------------------------------------
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
9) USO DEL SENSORE DI ORIENTAMENTO
//Called when application is started.function function OnStart()
function OnStart()
{
//Create a layout with objects vertically centered.
s= app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "SENSORE DI ORIENTAMENTO" );
txt.SetTextSize( 32 );
s.AddChild( txt );
//Add layout to app.
app.AddLayout(s);
sensore=app.CreateSensor("Orientation"); //Crea oggetto sensore di orientation
sensore.Start(); // Avvia il sensore
sensore.SetOnChange(leggi ); // Impone al sensore di vigilare in caso di variazioni posizione
p1=app.CreateButton("Rileva Orientamento");
p1.SetOnTouch(avvia);
p2=app.CreateButton("Stop rilevamento Orientamento");
p2.SetOnTouch(ferma);
s.AddChild(p1);
s.AddChild(p2);
}
function leggi(x) // <stabilisce cosa deve fare la funzione leggi(x)
{
txt.SetText("SENSORE DI ORIENTAMENTO:" +Math.round(x)); // fa apparire i risultati approssimati di x sulla casella di testo txt
}
function avvia()
{
sensore.Start();
}
function ferma()
{
sensore.Stop();
}
----------------------------------------------
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
10) ALTIMETRO CON LO SMARTPHONE BY GPS
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
sensore=app.CreateLocator("GPS,Network");
sensore.Start();
sensore.SetOnChange(dovesiamo);
}
txt1=app.CreateText("");
txt5=app.CreateText("");
txt6=app.CreateText("");
// lay.AddChild( txt5 );
// lay.AddChild( txt6 ); lo
function dovesiamo(lava)
{
lay.AddChild(txt5 );
txt7=app.CreateText("");
lay.AddChild( txt7 );
txt1=app.CreateText("");
txt5=app.CreateText("");
txt1.SetText("altitudine su livello del mare:" +lava.altitude);
txt5.SetText("ACCURATEZZA:" +lava.accuracy);
txt6.SetText("BEARING:" +lava.bearing);
txt7.SetText("PROVIDER:" +lava.provider);
lay.AddChild( txt1 );
lay.AddChild( txt5 );
if(lava.speed*3.6 >= 65)
{
app.TextToSpeech(nome +"hai superato il limite di velocita",1.0,1.0);
txt.SetTextColor( "#ff0000" );
}
if(lava.speed*3.6 <65)
{
//txt.SetBackColor( "#006633" );
}
if(lava.altitude > 350)
{
app.TextToSpeech(nome +"hai superato la quota di metri" + lava.altitude)
txt.SetBackColor( "#ff0000" );
}
//Add layout to app.
app.AddLayout( lay );
}
------------------------------------------------
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
11) LOCALIZZAZIONE CON IL GPS_SENSOR
function OnStart()
{
lay=app.CreateLayout("linear","VCenter,FillXY");
name=prompt("what is your name");
txt=app.CreateText("LOCALIZZAZIONE DI "+name+" CON LATITUDE E LONGITUDE");
txt.SetTextSize( 18 );
lay.AddChild(txt);
loc = app.CreateLocator("GPS,Network");
loc.SetOnChange(loc_OnChange);
loc.Start();
app.ShowPopup("Locating");
app.AddLayout(lay );
}
function loc_OnChange(pos)
{
var msg = pos.latitude + ", " + pos.longitude;
app.ShowPopup( msg );
}
---------------------------
Esecuzione dello script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONI DI VARIO GENERE E UTILITA'
1) AVVIA VIDEO CON DROIDSCRIPT
//Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "Linear", "FillXY,VCenter" );
app.ShowProgress( "Buffering..." ); // Mostra Buffering per attesa
player = app.CreateVideoView( 0.9, 0.6); //Crea larghezza del video
player.SetOnReady( player_OnReady );
player.SetOnError( player_OnError ); //Crea la funzion player_OnError
lay.AddChild( player );
player.SetFile("/storage/emulated/0/DCIM/Camera/bonfiglio1.mp4"); //Crea il percorso del file
app.AddLayout( lay );
}
function player_OnReady() //Stabilisce cosa fà la function player_OnReady()
{
app.HideProgress(); // Nasconde Progress
app.ShowPopup( "OnReady" ); // Appare messaggio OnReady
player.Play(); // Si avvia il video
}
function player_OnError()
{
app.HideProgress(); // Nasconde Progress
app.ShowPopup( "OnError" );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) SCATTA UNA FOTO CON DROIDSCRIPT
//Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "Linear", "VCenter,FillXY" );
cam = app.CreateCameraView( 0.8, 0.4 );
lay.AddChild( cam );
cam.SetPictureSize( 1024, 768 );
setTimeout( "cam.StartPreview()", 1000 );
btn = app.CreateButton( "Snap", 0.3, -1 );
btn.SetOnTouch( Snap );
lay.AddChild( btn );
app.AddLayout( lay );
}
function Snap()
{
cam.TakePicture( "/sdcard/MyPic.jpg" );
app.ShowPopup("Picture saved");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) INVIO DI UNA MAIL CON DROIDSCRIPT
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "Hai inviato messaggio" );
txt.SetTextSize( 32 );
lay.AddChild( txt );
var file="/storage/extSdCard/DCIM/Camera/motore.jpg";
app.SendMail( "pino@libero.it","MySubject","Hello",file );
//Add layout to app.
app.AddLayout( lay );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) EFFETTUARE UNA TELEFONATA
//Called when application is started.
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
edtNumber = app.CreateTextEdit( "5500", .8, -1, "singleline,number,center" );
edtNumber.SetTextSize(20);
lay.AddChild(edtNumber);
btnPhone = app.CreateButton( "Call", 0.5, 0.1 );
btnPhone.SetOnTouch( btnCall_OnTouch );
lay.AddChild( btnPhone );
app.AddLayout( lay );
}
function btnCall_OnTouch()
{
app.Call( edtNumber.GetText() );
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5) CREA UNA LISTA DI N ELEMENTI
//Called when application is started.
function OnStart()
{
lvw = app.CreateListView( "Mon tea at 17.00,Tues go to the dentist at 9.30,Wed lessons at 16.00 ,Thurs tennis at 17.00,Fri visit Florence,Sat go to the station at 9.00,Sun ", "Days" );
lvw.SetOnTouch( lvw_OnTouch );
lvw.Show();
}
function lvw_OnTouch( item )
{
app.ShowPopup( item );
}
________________
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PER GLI STUDENTI DELLE AREE TECNICHE
APPLICAZIONI DI ELETTROTECNICA
RETI ELETTRICHE LINEARI
APPLICAZIONE LEGGE DI OHM GENERALIZZATA
// Called when application is started
function OnStart() con
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt= app.CreateText( "PARTITORE DI TENSIONE A VUOTO",1.0,0.2,"Multiline");
txt1.SetTextSize(14 );
txt1=app.CreateText("Consente di ottenere una tensione minore rispetto a quella fornita dal generatore di tensione e la formula, chiamando Vi e Vo le due tensioni in entrata e in uscita, risulta Vo = E*(R2/(R1+R2))",1.0,0.2,"Multiline");
E1=prompt("dammi la tensione del generatore E1");
E2=prompt("dammi la tensione del generatore E2");
E3=prompt("dammi la tensione del generatore E3");
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
R3=prompt("dammi il valore della resistenza R3");
R4=prompt("dammi il valore della resistenza R4");
I = (E1 + E2 - E3)/(R1 + R2 + R3);
txt1.SetText(I, " corrente di maglia";
lay.AddChild( txt1 );
app.AddLayout( lay );
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CALCOLO DI UN PARTITORE DI TENSIONE A VUOTO
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt= app.CreateText( "PARTITORE DI TENSIONE A VUOTO",1.0,0.2,"Multiline");
txt1.SetTextSize(14 );
txt.SetTextSize(14 );
txt1=app.CreateText("Consente di ottenere una tensione minore rispetto a quella fornita dal generatore di tensione e la formula, chiamando Vi e Vo le due tensioni in entrata e in uscita, risulta Vo = E*(R2/(R1+R2))",1.0,0.2,"Multiline");
Vac=prompt("dammi la tensione del generatore");
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
Vbc=Vac*(R2/(R1+R2))
txt.SetText(Vo, " Volt Tensione in uscita al partitore a vuoto");
lay.AddChild( txt );
lay.AddChild( txt1 );
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
IL PARTITORE DI CORRENTE
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt= app.CreateText( "PARTITORE DI CORRENTE",1.0,0.2);
txt1.SetTextSize(14 );
txt.SetTextSize(14 );
txt1=app.CreateText("Consente di ottenere una tensione minore rispetto a quella fornita dal generatore di tensione e la formula, chiamando Vi e Vo le due tensioni in entrata e in uscita, risulta Vo = E*(R2/(R1+R2))",1.0,0.2,"Multiline");
E=prompt("dammi la tensione del generatore");
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
Req=(R1*R2)/(R1+R2);
I_tot=E/(Req);
I_R1=I_tot*(R1/(R1+R));
txt.SetText(Vo, " Volt Tensione in uscita sul partitore a vuoto");
lay.AddChild(t );
lay.AddChild( txt1 );
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONE CON CHIAMATA VOCALE
CHIAMATA A VOCE ED ESECUZIONE DI QUALSIASI FUNZIONE IN SETTORI SPECIFICI( IN AMBITO ELETTROTECNICO)
Uso dell'istruzione app.CreateSpeechRec() che consente il riconoscimento vocale e ci da la possibilità di acquisire, a richiesta dell'utente, le variabili del progetto o informazioni di vario tipo.
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
p=app.CreateButton("Parla_Rispondi",1,0.6);
lay.AddChild(p);
voce=app.CreateSpeechRec();
voce.SetOnError(errore);
voce.SetOnReady(pronto);
voce.SetOnResult(riconoscimento);
p.SetOnTouch(parla);
app.AddLayout(lay);
app.TextToSpeech( "dimmi come ti chiami" );
nome=prompt("dimmi come ti chiami");
app.TextToSpeech( "quale disciplina vuoi trattare" );
disciplina=prompt("dimmila disciplina di tuo interesse");
}i
function errore()
{
app.ShowPopup( "non ho capito");
app.TextToSpeech( "non ho capito" );
}
function parla()
{
voce.Recognize();
}
function pronto()
{
app.ShowPopup("parla sono in ascolto");
//app.TextToSpeech("parla sono in ascolto" );
}
function riconoscimento(x)
{
if (x[0] =="amico")
{
app.TextToSpeech("ciao amico" +nome +"possiamo parlare della nostra disciplina preferita " +disciplina,1,1);
}
if(x[0]=="legge sui nodi")
{
app.TextToSpeech("in un nodo la somma algebrica delle correnti e uguale a zero. Oppure, la somma delle correnti entranti in un nodo è uguale alla somma delle correnti uscenti",0.6,1);
}
if (x[0]=="rete")
{
var i;
app.TextToSpeech("in una maglia chiusa la corrente è data dal rapporto fra la tensione applicata e la resistenza totale del circuito",0.6,1);
r=prompt("dammi il valore della resistenza complessiva del circuito");
v=prompt("dammi il valore della somma algebrica delle tensioni applicate nella maglia");
i=Math.round(v/r);
app.ShowPopup("il valore della corrente di maglia e uguale a "+ i);
app.TextToSpeech("il valore in amper della corrente di maglia e pari ad ampere "+ i);
}
if (x[0]=="calore")
{
app.TextToSpeech( "dammi il valore della resistenza");
r=prompt("dammi il valore della resistenza");
app.TextToSpeech( "dammi il valore della corrente che attraversa la resistenza" );
i=prompt("dammi il valore della corrente");
var joule;
var cal;
cal=4.1886;
joule=0.23885;
var p;
p=r*i*i;
app.ShowPopup(p, " potenza dissipata per effetto joule" );
app.ShowPopup("la legge di joule esprime l'energia elettrica dissipata in calore da una resistenza sottoposta alla differenza di potenziale delta vu e attraversata dalla corrente di valore i");
app.TextToSpeech("la legge di giaul esprime quanta energia elettrica viene trasformata in calore in un certo intervallo di tempo su una resistenza sottoposta alla differenza di potenziale vu e attraversata dalla corrente i");
app.TextToSpeech("dammi il valore del tempo in secondi durante il quale circola corrente");
delta_t=prompt("dammi il valore in secondi del tempo durante il quale scorre la corrente nel circuito\n");
pj=r*i*i*delta_t;
app.ShowPopup("il valore energia termica prodotta e' pari a " + pj);
app.TextToSpeech("il valore energia termica prodotta e pari a "+ pj+"giaul");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONE DEL TEOREMA D MILLMAN
VIDEO A SUPPORTO
p
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt=app.CreateText( "PARTITORE DI TENSIONE A VUOTO",1.0,0.2,"Multiline");
txt1.SetTextSize(14);
txt.SetTextSize(14);
txt1=app.CreateText("Consente di ottenere una tensione minore rispetto a quella fornita dal generatore di tensione e la formula, chiamando Vi e Vo le due tensioni in entrata e in uscita, risulta VAB = (E1/R1 + E2/R2)/(1/R1 + 1/R2 +1/R3)",1.0,0.2,"Multiline");
E1=prompt("dammi la tensione del generatore");
E2=prompt("dammi la tensione del generatore");
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
R3=prompt("dammi il valore della resistenza R3");
VAB = (E1/R1) + E2/R2)/(1/R1 + 1/R2 +1/R3);
IR3 = VAB/R3;
txt1.SetText(IR3+ " corrente nel carico R3");
txt.SetText(VAB + "tensione di Millman");
lay.AddChild( txt );
lay.AddChild( txt1 );
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PARTITORE DI TENSIONE CARICATO
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt1= app.CreateText( " ",1.0,0.2,"Multiline");
txt.SetTextSize(14 );
txt.SetTextSize(14 );
txt1=app.CreateText("Occorre considerare che adesso le due resistenze R1 e R2 non sono più in serie a causa della presenza del carico e pertanto la formula precedente non è più valida in quanto il carico si trova in parallelo alla R2 ed occorre risolvere prima il parallelo di queste due resistenze con la nota formula Req=(R2*Rcarico/(R2+Rcarico) e solo dopo dobbiamo riapplicare la formula del partitore con la presenza della Req. pe otteniamoVo=E(Req/(R1+Req))",1.0,0.2,"Multiline");
E=prompt("dammi la tensione del generatore");
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
Rcarico=prompt("dammi il valore della resistenza Rca");
Req = R2*Rcarico/(R2+Rcarico)
Vo=E*(Req/(R1+Req))
txt.SetText(Vo, " Volt Tensione in uscita al partitore caricato");
lay.AddChild( txt );
lay.AddChild( txt1 );
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Teorema di THEVENIN
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt1= app.CreateText( " THEVENIN",1.0,0.2,"Multiline");
txt1.SetTextSize(14 );
txt=app.CreateText("Una rete elettrica lineare, per quanto possa risultare complessa, se la osserviamo da due terminali, equivale a un generatore reale di tensione. Tale tensione è quella a vuoto presente fra i due terminali, quando viene tolto il carico. L resistenza interna del generatore reale si calcola fra i morsetti aperti, dopo aver cortocircuitato tutti i generatori di tensione e aperto quelli di corrente",1.0,0.2,"Multiline");
txt.SetTextSize(12);
lay.AddChild( txt );
lay.AddChild( txt1 );
app.TextToSpeech("una rete elettrica lineare, per quanto possa risultare complessa, se la osserviamo da due terminali, equivale a un generatore reale di tensione. Tale tensione equivalente è quella a vuoto, presente fra i due terminali, quando viene tolto il carico. La resistenza interna equivalente da mettere in serie al generatore reale si calcola fra i morsetti aperti, dopo aver cortocircuitato tutti i generatori di tensione e aperto quelli di corrente");
txt.SetTextSize(12);
R1=prompt("dammi il valore della resistenza R1");
R2=prompt("dammi il valore della resistenza R2");
R4=prompt("dammi il valore della resistenza R4");
R3=prompt("dammi il valore della resistenza di carico");
E1=prompt("dammi il valore della tensione del generatore E1");
E2=prompt("dammi il valore della tensione del generatore E2");
Req=((R1+R4)*R2)/(R1+R2+R4);
Eeq=(E1*(R2/(R2+R4)))+E1;
I_Rcarico=Eeq/(Req+Rl);
app.ShowPopup (I_Rcarico +" A corrente sul carico");
app.AddLayout( lay );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CHIAMATA A VOCE DI UNA FUNZIONE
Come usare istruzione SpeechRecord();
//Called when pplication is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "Vertical,FillXY" );
lay.SetBackground("/res/drawble/pattern_carbon","repeat");
var s="<u>Commands</u><br><br>"
+"\"condensatore carica\"<br>"
+"\"scatta foto\"<br>"
+"\"Exit\"<br>";
cam=app.CreateCameraView(0.6,0.6);
cam.SetPictureSize(1024,768);
setTimeout("cam.StartPreview()",1000);
btn=app.CreateButton("Snap",0.3,-1);
btn.SetOnTouch(Snap);
lay.AddChild(btn);
//Createa text label and add it to layout.
txt = app.CreateText(s,0.9,0.8,"Multiline,Html" );
txt.SetTextSize(20);
lay.AddChild(txt);
//Addlayout to app.
app.AddLayout(lay );
app.SetVolume("System",1);
app.TextToSpeech( "rispondo ai tuoi desideri",1,1,Listen );
speech=app.CreateSpeechRec("NoBeep");
speech.SetOnResult(speech_OnResult);
speech.SetOnError(speech_OnError);
}
function Listen() // Stabilisce cosa fà la function Listen()
{
speech.Recognize(); // si mette in ascolta e acquisisce quanto viene detto
}
function speech_OnResult(results,partial)
{
var cmd=results[0].toLowerCase();
console.log(cmd);
if(cmd.indexOf("carica")>-1 && cmd.indexOf("condensatore")>-1)
{
speech.Cancel();
var E,R,C,t,Vc;
var cmd=results[0].toLowerCase();
console.log(cmd);
cmd=E;
E=prompt("dammi la tensione che agisce nel circuito in Volt");
R=prompt("dammi la resistenza equivalente del circuito espressa in ohm");
C=prompt("dammi la capacita del condensatore in Farad");
t=prompt("dimmi in quale istante devo calcolare la tensione di uscita Vc");
e=2.73
tau=R*C
Vc=E*(1-e^-(t/(tau)))
app.TextToSpeech(" la tensione in uscita dopo"+t+"vale"+Vc,1,1,Listen);
}
else if(cmd.indexOf("scatta") > -1 && cmd.indexOf("foto")>-1)
{
lay.AddChild(cam );
}
else if(cmd.indexOf("exit")>-1) di
{
app.Exit();
}
else speech.Recognize();
}
function speech_OnError(error)
{
if(!speech.IsListening()) speech.Recognize();
}
function Snap()
{
cam.TakePicture("/sdcard/MyPic.jpg");
app.ShowPopup("foto salvata" );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
IL DEFIBRILLATORE E CALCOLO DI ALCUNE GRANDEZZE
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt=app.CreateText( " ",1.0,0.2,"Multiline");
txt.AddLayout(lay);
txt.SetText("Il muscolo cardiaco si contrae in modo irregolare quando una persona è soggetta a fibrillazione ventricolare; in questi casi si interviene con il Defibrillatore. Si tratta di un condensatore in grado di accumulare della carica e, quindi, energia elettrostatica quando le sue armature vengono portate ad una certa d.d.p. che è pari a circa 2240V. Si vuol calcolare sia il valore della carica su ciascuna armatura, quando siamo al massimo della carica, sia l'energia immagazzinata in tali condizioni.");
var C;
var energia;
C = 1.75*10*-6 // valore del condensatore
V = 2240 // fissa il valore di V
//possibile soluzione: si trova la carica sulle armature con la relazione nota Q=C*V e poi si applica la E =0.5*C*V^2
Q = C*V;
E=0.5*C*V*V;
app.ShowPopup(Q+ " Coulomb carica sul condensatore ");
txt.SetText(Q +" Coulomb carica su condensatore " + E + "Joule .energia elettrostatica accumulata");
app.AddLayot(lay);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
APPLICAZIONI DI ELETTRONICA
CONVERTITORE CORRENTE/TENSIONE CON A.O.
Ricavare la funzione di trasferimento, la Vout rispetto alla corrente Ig in ingresso, ipotizzando che la stessa vari fra un minimo e un massimo.
Osservazioni per la soluzione: si tratta di una configurazione non invertente, perchè il generatore di corrente è applicato al morsetto positivo e si ha, in uscita, un segnale positivo in tensione Vout, direttamente proporzionale al livello di corrente Ig in entrata. La tensione sul morsetto + è tutta quella prodotta dal generatore di corrente che, percorrendo la resistenza Rg, determina una caduta di tensione sulla stessa pari a V+ = R*Ig. Questa tensione viene amplificata dall' amplificatore di tensione che, essendo in configurazione non invertente con Av = (1+Rf/Rs), genera, in uscita, una tensione Vout = R*Ig*(1+Rf/Rs).
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt1= app.CreateText( " ",1.0,0.2,"Multiline");
txt.SetTextSize(14 );
txt.SetTextSize(14 );
txt1=app.CreateText(",1.0,0,"Multiline");
Ig = prompt("dammi il valore della corrente in ingresso in mA");
Rf = prompt("dammi il valore della resistenza Rs");
R=prompt("dammi il valore della resistenza R in parallelo al generatore di corrente");
V+ = R*Ig;
Vout = R*Ig*(1+Rf/Rs);
txt.SetText(Vout, " Volt Tensione in uscita al variare della corrente Ig in ingresso");
lay.AddChild( txt );
lay.AddChild( txt1 );
app.AddLayot(lay);
}
Risultati in uscita: Vout = 4V con Ig = 2mA e Vout = 8V con Ig = 4mA
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
USO DI UN BJT, IN CONFIGURAZIONE BOOSTER, A SUPPORTO DI UN OPERAZIONALE CHE, DA SOLO, NON E' IN GRADO DI FORNIRE AL CARICO LA NECESSARIA CORRENTE.
Determinare:
- la corrente erogata dall'a.o.
- la potenza dissipata dal bjt.
Osservazioni per la soluzione:L'operazionale eroga una corrente che è quella di base assorbita dal bjt; questa corrente Ib viene amplificata hfe_volte e quindi Ic = hfe*Ib e ancora Ie = Ire in quanto a.o. non assorbe corrente. La tensione E, applicata al morsetto +, è uguale a quella sul morsetto - (meno di a.o.). Ai capi di Re ci stabilizza una tensione pari alla somma algebrica di Vee e E e quindi Vre = + E -(-Vee). Tale tensione determina una corrente in Re pari a Ire = (E -(-Vee))/Re, diretta verso il generatore Vee, e di valore nettamente maggiore di quella fornita dall' operazionale.
È questo l'effetto booster:corrente sul carico nettamente più grande di quella che può fornire l'operazionale.
La potenza dissipata sul bjt è data da Pd = Vce*Ic = (Vcc - E)*Ic.
// Called when application is started
function OnStart()
{
// Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
txt1= app.CreateText( " ",1.0,0.2,"Multiline");
txt.SetTextSize(14 );
txt.SetTextSize(14 );
txt1=app.CreateText(",1.0,0,"Multiline");
Vcc = prompt("dammi il valore della corrente in ingresso in mA");
Vee = prompt("dammi il valore della tensione Vee");
Re = prompt("dammi il valore della resistenza Re");
hfe = prompt("dammi il valore dell guadagno di corrente di a.o."); ;
E = prompt("dammi il valore del generatore E su morsetto non invertente");
Ire = (E -(-Vee))/Re; //corrente in emettitore, e quindi sul carico, molto più grande
Ib = Ire/hfe; //corrente in uscita ad a.o. molto piccola
Pd = (Vcc - E)*Ic. //potenza dissipata dal bjt
txt.SetText(Vout, " Volt Tensione in uscita al variare della corrente Ig in ingresso");
lay.AddChild( txt );
lay.AddChild( txt1 );
app.AddLayot(lay);
}
//////////////////////////////////////////////////////////////////////////////////
DIMENSIONAMENTO DI AMPLIFICATORE PER AUTO DA 5.5W
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "I circuiti integrati LM383 e TDA2003 sono in pratica identici, dal punto di vista prestazionale, e trovano \nlargo impiego come amplificatori per autovettura laddove e' presente una tensione di batteria pari a 14.4V. \n Normalmente possono essere impiegati in un range di tensione che va da 5V fino a 20V. \nPer quanto concerne invece la corrente che possono fornire al carico questa puo' raggiungere un valore\n di picco Ipicco=3.5A. Nell'impiego come ampli per auto, esso fornisce una potenza di P=5.5W su \nun carico, la cassa acustica, di valore pari a RL= 4 Ohm. Determinare, in queste condizioni, la corrente\n che circola nella cassa acustica",0.8,0.4,"Multiline");
txt.SetSize(12);
txt.SetTextSize(10 );
txt1=app.CreateText("");
txt1.SetTextSize(22);
lay.AddChild( txt1 );
lay.AddChild( txt );
Vbatt=14.4;
RL=prompt("dammi la resistenza della cassa in Ohm");
R1=prompt("dammi la resistenza R1 fra il morsetto - il 4 in uscita");
R2=prompt("dammi la resistenza R2 collegata fra il morsetto 2 espressa in Ohm");
Vin=prompt("dammi la tensione di ingresso in V");
// Osservazioni per la soluzione: si tratta di una configurazione non invertente con guadagno Av = (1+R2/R1)=V2/V1
// i condensatori C2 e C4 danno stabilita alle alte frequenze
// il condensatore C1 consente l'applicazione del segnale direttamente sul morsetto + in quanto in regime dinamico non si oppone alle componenti alternate e blocca le continue
Av=(1+R2/R1);
V2=Av*Vin;
Icassa =V2/RL;
txt1.SetText( Av+" guadagno ampli "+ V2+"Volt tensione in uscita sulla cassa"+IL+" Ampere corrente sulla cassa" );
app.AddLayout( lay );
}
________________________________
Esecuzione dello script
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DIMENSIONAMENTO DI UN Oscillatore ASTABILE
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/extSdCard/DCIM/Camera/555.jpg",0.8,0.4);
//Create a text label and add it to layout.
txt= app.CreateText( "Dimensiona ASTABILE",0.75,0.2,"Multiline" );
txt.SetTextSize(15 );
txt.SetBackColor( "#007fff" );
// txt.SetBackground("/storage/extSdCard/DCIM/Camera/555.jpg");
txt.SetSize(25);
txt.SetOnTouch(dimensiona);
lay.AddChild( img );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
Vcc=prompt("dammi la tensione di alimentazione");
C = prompt("dammi la capacita che intendi usare");
f = prompt("dammi la frequenza che deve avere onda quadra espressa in Hz");
}
function dimensiona()
{
Vcc=prompt("dammi la tensione di alimentazione che di solito e di 5 Volt");
C=prompt("dammi la capacita che intendi usare");
f=prompt("dammi la frequenza che deve avere onda quadra, espressa in Hz");
T=1/f;
R1=parseInt(T/(1.4*C));
R2=parseInt(Rb/30);
txt.SetText(R1+"KOhm valore che deve avere la resistenza R1\n" + R2 +"KOhm valore che deve avere R2 per ottenere D.C. del 50%");
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CONTROLLO LINEARE MOTORE
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
img=app.CreateImage("/storage/extSdCard/DCIM/Camera/motore.jpg",0.5,0.4);
//Create a text label and add it to layout.
txt = app.CreateText( "" );
txt.SetTextSize(12);
lay.AddChild( txt
lay.AddChild( img )
Ia=prompt("dammi corrente armatura motore in Ampere e che risulta circa pari a corrente emettitore");
Vcc = prompt("dammi la tensione di alimentazione");
Vi = prompt("dammi la tensione a meta corsa del potenziometro");
h_FE = prompt("dammi hfe del bjt");
Vbe=prompt("dammi la Vbe del bjt");
Va=Vi -Vbe;
Pa=Va*Ia;
Vce=Vcc-Va;
Pd=Vce*Ia;
Ib=Ia/(1+h_FE);
txt.SetText( Pa +" W potenza assorbita motore " +Pd +" W potenza dissipata bjt "+Ib +" A corrente richieste in base" );
//Add layout to app.
app.AddLayout( lay );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FIBRE OTTICHE
1) Fibra monomodale e calcolo APERTURA NUMERICA
//Called when application is started.
function OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
//Create a text label and add it to layout.
txt = app.CreateText( "Una F.O. monomodale ha le caratteristiche specificate in diametro d del core,lunghezza d`onda di taglio lamda. Si vuole determinare l`angolo di accettazione della fibra ipotizzando che il mezzo esterno sia aria che ha no=1");
d=prompt("dammi il diametro del core in micrometro\n");
lamda=prompt("dammi la lunghezza d`onda in micrometro\n");
NA=(0.76*lamda)/d
txt.SetText( NA+" apertura numerica" );
txt.SetTextSize( 32 );
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) CALCOLI VARI SULLE FIBRE OTTICHE
functioN OnStart()
{
//Create a layout with objects vertically centered.
lay = app.CreateLayout("linear", "VCenter,FillXY");
txt=app.CreateText("Si ha, in entrata ad una F.O., un impulso ottico che impiega t microsec per arrivare ad altro capo della fibra lunga L km. Si vogliono determinare gli indici di rifrazione del core e del cladding, ipotizzando di conoscere il diametro d del core e la lunghezza onda di taglio della fibra");
d = prompt("dammi il diametro d del core in micrometro\n");
t = prompt("dimmi quanti microsecondi impiega impulso a raggiungere la terminazione fibra");
lamda = prompt("dammi la lunghezza d`onda lamda in micrometro");
L=prompt("dammi lunghezza fibra in metri");
// per trovare la velocità della fibra basta ricorrere alla u=(L/t)
//per trovare l`indice di rifrazione del core si ricorre alla n1= c/u
// il calcolo di NA si fa usando NA=(0.76*lamda)/d
// l`indice n2 si ottiene dalla n2=((n1**2)-(NA**2))**0.5
c=(3)*10^8 // km/sec
//L=promt("dammi lunghezza fibra in metri")
u=L/t
n1=c/u
NA=(0.76*lamda)/d;
n2=((n1^2)-(NA^2))^0.5;
txt.SetText(u+" m/s--velocita_impulso in fibra"+ n1+" indice di rifrazione del core"+NA+" apertura numerica"+n2+" indice di rifrazione del cladding");
//Create a text label and add it to layout.
txt.SetTextSize(12);
lay.AddChild( txt );
//Add layout to app.
app.AddLayout( lay );
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sabato 10 agosto 2019
Iscriviti a:
Post (Atom)