Go Down

Topic: joistik da analogico commodore 64 (Read 417 times) previous topic - next topic

albepancio

May 19, 2019, 02:26 pm Last Edit: May 19, 2019, 03:20 pm by albepancio
salve ,
ho costruito , utilizzando un pad della xbox 360) un joystik wireless per computer 8 bit

Code: [Select]
https://www.youtube.com/watch?v=YvwLuz3YQv8
pero funziona , come i vecchi joystik solo in digitale , volevo usare anche la levetta analogica e
mi è venuto in mete di usare un periodo di 1 secondo e variare il duty da 0 a 100%.
ho pensato di assegnare ad una variabile il valore rilevato sull analogico a0 , a1
poi in base a questo valore impostare un pin low,high con un daly che varia da 100 a 1000.
avevo pensato ad un oistruzione CASE , ma non essendo molto pratica ho optato per una serie di 10 if

ed è uscito questo
Code: [Select]
#define asseX A0
#define asseY A1

int destra =3;
int sinistra = 4;
int alto = 5;
int basso = 6;
int bottone  = 7;
int sparo = 8;
void setup ()
{
  Serial.begin (9600);
  pinMode(destra, OUTPUT);
   pinMode(sinistra,OUTPUT);
    pinMode(basso, OUTPUT);
     pinMode(alto, OUTPUT);
  pinMode(sparo, OUTPUT);
  pinMode(bottone , INPUT);
}
void loop ()
{
 int xVal, yVal;

 xVal = analogRead (asseX);
 yVal = analogRead (asseY);
 digitalWrite(sparo, LOW);
 if(bottone ,HIGH){
  digitalWrite(sparo,HIGH);
 }
if(xVal && yVal == 524 ){
  digitalWrite(destra, LOW);
  digitalWrite(sinistra,LOW);
  digitalWrite(alto,LOW);
  digitalWrite(basso , LOW); 
}
if(xVal<=524 && xVal>=472){//-----posizione 1
  digitalWrite(sinistra,HIGH);
  delay(100);
  digitalWrite(sinistra,LOW);
}
if(xVal<=471&& xVal>=419){//-------posizione2
  digitalWrite(sinistra,HIGH);
  delay(200);
  digitalWrite(sinistra,LOW);
}
if(xVal<=418&& xVal>=366){//posizione-------3
  digitalWrite(sinistra,HIGH);
  delay(300);
  digitalWrite(sinistra,LOW);
}
if(xVal<=365&& xVal>=313){//------------posizione4
  digitalWrite(sinistra,HIGH);
  delay(400);
  digitalWrite(sinistra,LOW);
}
if(xVal<=312&& xVal>=260){//-----------posizione5
  digitalWrite(sinistra,HIGH);
  delay(500);
  digitalWrite(sinistra,LOW);
}
if(xVal<=259&& xVal>=207){//----------posizione6
  digitalWrite(sinistra,HIGH);
  delay(600);
  digitalWrite(sinistra,LOW);
}
if(xVal<=206&& xVal>=154){//---------posizione7
  digitalWrite(sinistra,HIGH);
  delay(700);
  digitalWrite(sinistra,LOW);
}
if(xVal<=153&& xVal>=101){//posizione------------8
  digitalWrite(sinistra,HIGH);
  delay(800);
  digitalWrite(sinistra,LOW);
}
if(xVal<=101 &&xVal>=48 ){//-----------posizione 9
  digitalWrite(sinistra,HIGH);
  delay(900);
  digitalWrite(sinistra,LOW);
}

if(xVal<=47 && xVal>=0){//-----------posizione10
  digitalWrite(sinistra,HIGH);}
 

//______________________________________fine sinistra---------------------
if(xVal>=523 && xVal>=575){//--------------posizione1
  digitalWrite(destra  ,HIGH);
  delay(100);
  digitalWrite(destra  ,LOW);
}
if(xVal>=576&& xVal>=628){//--------posizione2
  digitalWrite(destra, HIGH);
  delay(200);
  digitalWrite(destra ,LOW);
}
if(xVal>=629&&xVal>=781){//-----------posizione 3
  digitalWrite(destra ,HIGH);
  delay(300);
  digitalWrite(destra ,LOW);
}
if(xVal>=782&& xVal>=703){//----------posizione 4
  digitalWrite(destra  ,HIGH);
  delay(400);
  digitalWrite(destra ,LOW);
}
if(xVal>=704&& xVal>=756){//-----------posizione 5
  digitalWrite(destra ,HIGH);
  delay(500);
  digitalWrite(sinistra,LOW);
}
if(xVal>=757&& xVal>=809){//-----------posizione 6
  digitalWrite(destra ,HIGH);
  delay(600);
  digitalWrite(destra ,LOW);
}
if(xVal>=810&& xVal>=864){//-----------posizione 7
  digitalWrite(destra ,HIGH);
  delay(700);
  digitalWrite(destra ,LOW);
}
if(xVal>=865&& xVal>=917){//-----------posizione 8
  digitalWrite(destra ,HIGH);
  delay(800);
  digitalWrite(destra ,LOW);
}
if(xVal>=918 &&xVal>=48 ){//-----------posizione 9
  digitalWrite(destra ,HIGH);
  delay(900);
  digitalWrite(destra ,LOW);
}

if(xVal>=47 && xVal>=0){//-----------posizione 10
  digitalWrite(destra ,HIGH);
}
//----------------------------------parte destra finita---------------------------------------------

//----------------------------------inizio alto basso-------------------------------------------------
if(yVal<=524 && yVal>=472){//-----posizione 1
  digitalWrite(basso,HIGH);
  delay(100);
  digitalWrite(basso   ,LOW);
}
if(yVal<=471&& yVal>=419){//-------posizione2
  digitalWrite(basso   ,HIGH);
  delay(200);
  digitalWrite(basso   ,LOW);
}
if(yVal<=418&& yVal>=366){//posizione-------3
  digitalWrite(basso   ,HIGH);
  delay(300);
  digitalWrite(basso   ,LOW);
}
if(yVal<=365&& yVal>=313){//------------posizione4
  digitalWrite(basso   ,HIGH);
  delay(400);
  digitalWrite(basso   ,LOW);
}
if(yVal<=312&& yVal>=260){//-----------posizione5
  digitalWrite(basso   ,HIGH);
  delay(500);
  digitalWrite(basso   ,LOW);
}
if(yVal<=259&& yVal>=207){//----------posizione6
  digitalWrite(basso   ,HIGH);
  delay(600);
  digitalWrite(basso   ,LOW);
}
if(yVal<=206&& yVal>=154){//---------posizione7
  digitalWrite(basso   ,HIGH);
  delay(700);
  digitalWrite(basso   ,LOW);
}
if(yVal<=153&& yVal>=101){//posizione------------8
  digitalWrite(basso   ,HIGH);
  delay(800);
  digitalWrite(basso   ,LOW);
}
if(yVal<=101 &&yVal>=48 ){//-----------posizione 9
  digitalWrite(basso   ,HIGH);
  delay(900);
  digitalWrite(basso   ,LOW);
}

if(yVal<=47 && yVal>=0){//-----------posizione10
  digitalWrite(basso   ,HIGH);}
 

//______________________________________fine basso------------------ù


//-----------------------------------inizio alto------------------

if(yVal>=523 && yVal>=575){//--------------posizione1
  digitalWrite(alto,HIGH);
  delay(100);
  digitalWrite(sinistra,LOW);
}
if(yVal>=576&& yVal>=628){//--------posizione2
  digitalWrite(alto  , HIGH);
  delay(200);
  digitalWrite(alto   ,LOW);
}
if(yVal>=629&&yVal>=781){//-----------posizione 3
  digitalWrite(alto   ,HIGH);
  delay(300);
  digitalWrite(alto   ,LOW);
}
if(yVal>=782&& yVal>=703){//----------posizione 4
  digitalWrite(alto    ,HIGH);
  delay(400);
  digitalWrite(alto   ,LOW);
}
if(yVal>=704&& yVal>=756){//-----------posizione 5
  digitalWrite(alto ,HIGH);
  delay(500);
  digitalWrite(alto  ,LOW);
}
if(yVal>=757&& yVal>=809){//-----------posizione 6
  digitalWrite(alto   ,HIGH);
  delay(600);
  digitalWrite(destra ,LOW);
}
if(yVal>=810&& yVal>=864){//-----------posizione 7
  digitalWrite(alto   ,HIGH);
  delay(700);
  digitalWrite(destra ,LOW);
}
if(yVal>=865&& yVal>=917){//-----------posizione 8
  digitalWrite(alto   ,HIGH);
  delay(800);
  digitalWrite(alto   ,LOW);
}
if(yVal>=918 &&yVal>=48 ){//-----------posizione 9
  digitalWrite(alto   ,HIGH);
  delay(900);
  digitalWrite(alto   ,LOW);
}

if(yVal>=47 && yVal>=0){//-----------posizione 10
  digitalWrite(alto   ,HIGH);
}
//------------fine alto-----------------
 }

ovviamente la stessa procedura va fatta per l asse y e per l altro lato dell asse x .
non ho una proto a portata quindi non posso provare se funziona collegando ai pin di uscita un led

qualche consiglio?
grazie
p.s. questo secondo me e il codice completo su i due assi e con il pulsante sparoi ( poi dovro aggiungere il pulsante salto e il pulsante freno

docdoc

Ci sono vari errori proprio di codifica, ossia di sintassi di linguaggio C
Ad esempio se scrivi:

if(xVal && yVal == 524 )

di fatto significa:

if(xVal != 0 && yVal == 524 )

Inoltre il link al video non funziona (dice che il video non esiste).

Facci vedere meglio cosa intendi fare (posta il link giusto al video) e come intendi collegare le cose (uno schemino dei collegamenti previsti, anche su carta e poi fotografato e mandato come allegato va bene), ed una migliore descrizione di come pensi che debba funzionare, poi entriamo magari meglio nel discorso programmazione.
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

albepancio

prima di tutto grazie per la risposta ,


if(xVal && yVal == 524 ) ,, qui ho sbagliato a scrivere volevo scrivere questo: if(xvall == 524 && yVal ==524)
che sojo i valori che rilevo con la levetta al centro .e con questo valore tutt ele uscite sono a livello basso.

per il video ho controllato e il link è gisto
il video è nominato joystik wireless commodore 64 / atari xe/xl.

per io circuito e semplice semplice un joystick sui pin analogici e un paio di pulsanti collegati ai pin digitali , come imput e come output 6 pin digitali che comandano dei rele cosi da simulare  un vecchio joystick.

docdoc

if(xVal && yVal == 524 ) ,, qui ho sbagliato a scrivere volevo scrivere questo: if(xvall == 524 && yVal ==524)
che sojo i valori che rilevo con la levetta al centro .e con questo valore tutt ele uscite sono a livello basso.
Ok, però intanto ti consiglio di indentare meglio il codice così diventa tutto più semplice, non solo per te ma anche per noi.. ;) (premi Ctrl-T nell'IDE di Arduino e te lo fa lui).

Poi essendo letture analogiche dovresti tollerare un certo margine per il "centro", perché basta qualche disturbo e leggeresti 523 o 525 o altro, cosa che ti darà problemi nel gioco.

Inoltre se per te 524 è "centro" non devi mettere l'uguale in:
Code: [Select]
if(xVal<=524 && xVal>=472)
dovresti lasciare:
Code: [Select]
if(xVal<524 && xVal>=472)

Per me sono anche sbagliati i delay perché quando muovi poco la leva (es. valore di poco inferiore al centro") devi mettere un delay più lungo (repeat più lento) di quando la leva la muovi di più (repeat più rapido).

Inoltre sono sbagliate le if() delle posizioni 9 e 10 della parte destra, ti sei dimenticato di impostare i relativi valori (dopo il copia-incolla hai lasciato 49 o 0).

In ogni caso ti consiglio di stabilire un range minimo di valori da considerare "centro", diciamo tra 520 e 530, se minore (non uguale) di 520 è "sinistra" (o "basso") se maggiore (non uguale) di 530 è "destra" (o "alto").

Leggendo poi il tuo codice, vedo che per dare un auto repeat al tasto prevedi 10 posizioni per ogni asse, con valori limite inferiore:

472 419 366 313 260 207 154 101 48

Di fatto un intervallo di 53 (tranne l'ultimo).

Ma fai prima a prendere il valore massimo e dividerlo in 10 parti e con questo valore calcolare il delay. Se il centro è quindi tra 520 e 530 avrai blocchi da 52 in basso e da circa 49 in alto (comunque strano che tu abbia 524, è leggermente asimmetrico perché teoricamente tra 0 e 1023 il centro dovrebbe essere 512, ma te lo dò per buono se lo hai misurato sul tuo joystick).

Ossia considerando solo un valore, per adesso, una funzione per ogni direzione che dato il valore ti restituisce un numero tra 0 (centro) e 10 (massima estensione), imposta una cosa del genere:

Code: [Select]

#define CENTRO_LOW 520
#define CENTRO_HIGH 530
#define BLOCCHI 10

float divLow = (CENTRO_LOW-0.0)/BLOCCHI;
float divHigh = (1024.0-CENTRO_HIGH)/BLOCCHI;

...

int posLow(int v)
{
  if ( v > CENTRO_LOW )
    return 0;
  return (BLOCCHI - int(v/divLow));
}

int posHigh(int v)
{
  if ( v < CENTRO_HIGH )
    return 0;
  return int((v - CENTRO_HIGH)/divHigh) + 1;
}


Come vedi nella prima parte ti ho definito i tuoi parametri che potrai cambiare più comodamente (usali spesso i #define, ti semplificano la vita) e sotto ho creato 2 funzioni che ti danno quindi valori tra 0 e 10. Questi valori di posizione ("pos") li userai per fare un delay inversamente proporzionale calcolando ad esempio 10-pos (che va quindi da 1 a 9 se escludi lo zero) che moltiplicherai per un valore (es. 50 per avere delay tra 550 e 50ms ossia una frequenza tra 2 e 20 pressioni di tasto al secondo) che magari puoi aggiungere ai #define iniziali:

Code: [Select]
#define DELAY 50
...
  int pos = posLow(xVal);
  if (pos > 0)
    delay((10-pos)*DELAY);
...


In quest'ottica prova a rivedere il tuo programma, vedrai che sarà molto più compatto (non servono più quelle sfilze di "if") e gestibile...
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Datman

#4
May 20, 2019, 05:19 pm Last Edit: May 20, 2019, 05:20 pm by Datman
Nel setup leggi i valori del joystick a riposo e memorizzali in due variabili; poi considera posizioni di riposo quei valori entro, ad esempio, +/-2.
Hi,I'm Gianluca from Roma.I play&work with electronics since I was16(1984).
After 25yrs of maintenance on cameras&video mixers,since 2013myJob is HDTVstudios design.
Since Jan2015 IPlayWith Arduino:bit.ly/2F3LPWP
Thanks 4 a Karma if U like my answer

docdoc

Nel setup leggi i valori del joystick a riposo e memorizzali in due variabili; poi considera posizioni di riposo quei valori entro, ad esempio +/-2.
Cavolo, io faccio tutta una spiegazione articolata e tu pensi di cavartela così? :D
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Datman

#6
May 20, 2019, 05:23 pm Last Edit: May 20, 2019, 05:26 pm by Datman
Nell'elettronica è normale leggere i valori analogici a riposo all'accensione e fare l'offset su di essi. :D
Le bilance pesa persone, ad esempio, possono fare lo zero toccandole per un attimo, oppure lo fanno risvegliandosi periodicamente da spente (tanto le batterie ce le mettiamo noi! :( ).
Hi,I'm Gianluca from Roma.I play&work with electronics since I was16(1984).
After 25yrs of maintenance on cameras&video mixers,since 2013myJob is HDTVstudios design.
Since Jan2015 IPlayWith Arduino:bit.ly/2F3LPWP
Thanks 4 a Karma if U like my answer

SukkoPera

#7
May 20, 2019, 05:28 pm Last Edit: May 20, 2019, 05:30 pm by SukkoPera
C'è anche il problema che i valori non è detto che coprano l'intero range 0-1023. Per questo io prevedo una vera e propria routine di calibrazione in un mio progetto simile, in cui scopro e memorizzo sia i valori a riposo che l'intero range di variazione.

Comunque il C64 ha anche due ingressi analogici, sebbene pochi giochi li supportino e ti servirebbe un DAC per sfruttarli. Pin 5 e 9 in ogni caso :).
"Code is read much more often than it is written, so plan accordingly. Design for readability."

Guida rapida a ESP8266: https://goo.gl/kzh62E

albepancio

grazie per le risposte.
mi studio il tuo codice , anche perche l istruzione return non la conosco

albepancio

#9
May 20, 2019, 06:57 pm Last Edit: May 20, 2019, 07:17 pm by albepancio
Code: [Select]
...

int posLow(int v)
{
  if ( v > CENTRO_LOW )
    return 0;
  return (BLOCCHI - int(v/divLow));
}

int posHigh(int v)
{
  if ( v < CENTRO_HIGH )
    return 0;
  return int((v - CENTRO_HIGH)/divHigh) + 1;
}

ti ringrazio pe ril consiglio ma queste due funzioni non riesco a capirle
mi studio un po il tutto .
non riesco a capire la prima  int poslow(int v) .
p.s ho letto qualcosa sul retur e sulle funzioni
e ho trovato questo
 
Code: [Select]
Esempio in cui return restituisce un intero, in questo caso 0.
int testSensore( )


{    if(analogRead(0)>400){       return 1;   }

else{      return 0;   }}


e se ho capito bene legge un valore sull analogico se è minore di 400 ( non ho capito lo 0 tra le parentesi).restituisce  come valore 1 se e minore di 400 restituisce 0

pero della tua funzione non ho capito perche scrivi int poslow(int v) perche int v?

la parte seguente credo di averla capita.

se v e maggiore restituisci come valore il risultato di questa operazione (BLOCCHI - int(v/divLow));

pero non riesco a capire  quell -int(v/divlow).

divlow lo hai impostato prima e qui ok ma quella v??

scusa ma non sono molto pratico
grazie ancora



albepancio

#10
May 20, 2019, 07:31 pm Last Edit: May 20, 2019, 08:02 pm by albepancio
Code: [Select]
int pos = posLow(xVal);
  if (pos > 0)
    delay((10-pos)*DELAY);

e di questo  non ho csapito  posLow(xVAL)  .
poslow e il risultato delle funzioni di prima ma posLow(xVal) ?????


la v sta per xVal???

p.s
int(v/divLow));   int cosi accetta solo numeri interi dal risultato xVal/divlow?

albepancio

Code: [Select]
#define CENTRO_LOW 520
#define CENTRO_HIGH 530// da 521 a 529 e la zona morta del joystick
#define BLOCCHI 10// 10 sarebbe al definizione del joystick :)

float divLow = (CENTRO_LOW-0.0)/BLOCCHI;// fattore di divisione per la parte inferiore
float divHigh = (1024.0-CENTRO_HIGH)/BLOCCHI;//fattoreparte inferiore

...

int posLow(int v)// qui dovrebbe essere int posLow(int xVal)????????
{
  if ( v > CENTRO_LOW )// se xVal è maggiore di 520 poslow e uguale a zero quindi il delay per l accensione è 0
    return 0;
  return (BLOCCHI - int(v/divLow));//se è minore esempio 300 eseguo il calcolo (10-(400/52)) che mi restituisce 2
}

int posHigh(int v)
{
  if ( v < CENTRO_HIGH )
    return 0;
  return int((v - CENTRO_HIGH)/divHigh) + 1;// qui per valori di xval superiori al centro sottrai il valore centrale e dividi pe ril fattore di divisione della parte superiore ma perche piu 1?
}

#define DELAY 50
...
  int pos = posLow(xVal);
  if (pos > 0)
    delay((10-pos)*DELAY);//qui dato il valore da 1 a 10 per la posizione viene calcolato il tempo di delay che manterra il pin a livello alto
...

ho capito bene???????
grazie ancora

docdoc

non riesco a capire la prima  int poslow(int v) .
p.s ho letto qualcosa sul retur e sulle funzioni
Beh queste sono un po' le basi della programmazione... Una funzione è qualcosa che prende in ingresso dei parametri (quello che c'è tra le parentesi nella definizione) e restituisce un valore (quello che c'è dopo "return").
Partiamo dalla prima:
Code: [Select]
int posLow(int v)
{
  if ( v > CENTRO_LOW )
    return 0;
  return (BLOCCHI - int(v/divLow));
}


La prima riga dice che definiamo una funzione che si chiama "posLow", alla quale passiamo un paramtro di tipo intero che chiamiamo "v" ("int v") e restituisce a sua volta un intero.
Quindi, come ti avevo scritto, la funzione prendendo il valore letto dalla porta analogica, ne fa la divisione in 10 blocchi (il simbolo "BLOCCHI" rappresenta il 10 ed è definito all'inizio, nella #define) e restituisce quindi un valore che va da 0 (posizione centrale) a 10 (posizione estrema).

Quindi se il valore è maggiore del centro (simbolo CENTRO_LOW) restituisco sempre 0, altrimenti restituisco il risultato di quell'espressione dove BLOCCHI è nuovamente il numero di blocchi (per noi 10) dal quale sottraggo la parte intera della divisione di "v" (il valore letto dalla porta analogica) e "divLow" che ho calcolato all'inizio e che corrisponde a quanto è "esteso" ogni blocco (es. 52 perché se il valore centrale minimo è 520 ed ho 10 blocchi, risulta 520/10 = 52).

Una cosa simile anche per posHigh che a questo punto spero tu riesca a comprendere meglio.

Quote
e di questo  non ho csapito  posLow(xVAL)  .
poslow e il risultato delle funzioni di prima ma posLow(xVal) ?????
la v sta per xVal???
Quando tu USI una funzione, le passi (in questo caso) il valore che richiede, che in quella parte di codice è xVal perché è la lettura che hai fatto. Quando chiami la funzione, il valore attuale di xVal finisce nella variabile "v" della funzione, che fa i suoi calcoli e restituisce un valore. Non passi la variabile (ossia non è che xVal "diventa" v, ma che la variabile v interna alla funzione assumerà il valore che in quel momento ha xVal). Dentro la funzione puoi chiamare il parametro (ossia la variabile che usi lì dentro) come ti pare, si può chiamare anche "valore" o "lettura" o quello che vuoi, ma questo varrà solo all'interno della funzione.

Credo che sia il caso che tu faccia un po' di pratica con i linguaggi di programmazione cercando in rete un qualsiasi mini-corso di C online o un libro se preferisci.

Dipende anche da quanto tempo vuoi/puoi dedicarci, e da quali basi parti (ma mi sembra di capire che sei abbastanza agli inizi), quindi ce ne sono a centinaia se cerchi "corso di programmazione linguaggio C" su Google.
Parlando di linguaggio C in generale puoi ad esempio iniziare da questo del Politecnico di Torino che mi pare abbastanza completo, oppure per qualcosa di più specifico per Arduino puoi provare il corso che si trova sul sito del buon Mauro Alfieri oppure QUESTO di Zanichelli. Ma come detto, se cerchi ne trovi parecchi, anche su YouTube.

Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

albepancio

grazie della risposta.

ho capito il discorso del calcolo della funzionepero  quello che non riesco a capire la prima riga
int poslow(intv)
e nello specifico come e perche viene asseganto a v il valore letto sull analogico ....

grazie ancora per l aiuto e la pazienza :O)

docdoc

#14
May 22, 2019, 01:15 pm Last Edit: May 22, 2019, 01:16 pm by docdoc
ho capito il discorso del calcolo della funzionepero  quello che non riesco a capire la prima riga
int poslow(intv)
e nello specifico come e perche viene asseganto a v il valore letto sull analogico ....
Beh, più o meno te lo avevo scritto, ossia quella riga:
dice che definiamo una funzione che si chiama "posLow", alla quale passiamo un paramtro di tipo intero che chiamiamo "v" ("int v") e restituisce a sua volta un intero.
Quindi quello è il modo per definire una funzione.

Per "usarla" la chiami passandogli (in questo caso) il valore che vuoi dargli, per ottenere il risultato. Quindi diciamo che hai xVal che vale 100, quando fai:

int pos = posLow(xVal);

stai chiamando la funzione "posLow" alla quale passi il contenuto di xVal, ossia 100, e questo valore diventa il valore della variabile "v". Al termine del calcolo il risultato restituito dalla "posLow" lo metti nella variabile "pos" (che è un intero).

Ora però credo che sia importante che tu prima di proseguire vada a vedere quei link che ti ho indicato, per iniziare a prendere pratica con la programmazione in generale e del C di Arduino in particolare, altrimenti è difficile farti un corso di programmazione con qualche messaggio sul forum ;)
Alex "docdoc" - ** se ti sono stato d'aiuto, un punto karma sarà gradito, clicca su "add" qui a sinistra, vicino al mio nome ;) **

Go Up