joistik da analogico commodore 64

salve ,
ho costruito , utilizzando un pad della xbox 360) un joystik wireless per computer 8 bit

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

#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

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.

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.

albepancio:
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.. :wink: (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:

if(xVal<=524 && xVal>=472)

dovresti lasciare:

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:

#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:

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

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.

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.

Cavolo, io faccio tutta una spiegazione articolata e tu pensi di cavartela così? :smiley:

Nell'elettronica è normale leggere i valori analogici a riposo all'accensione e fare l'offset su di essi. :smiley:
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! :frowning: ).

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

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

...

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

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

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?

#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

albepancio:
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:

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.

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.

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)

albepancio:
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 :wink:

li ho visti velocenment edurante la pausa lavoro,
ho incominciato con il manuale di arduino , dove ci sono alcune pagine che spiegano le funzioni di base del c e poi ci sono degli esempi di progetti ,

ti ringrazio della spiegazione e del tempo che mi hai dedicato.
se vedo un esempio mi riesce meglio capire e spero ricordare ,,, perche di memoria ce ne è poca hehehe

dalla serie di a volte ritornano.
ho avuto dei problemi e non ho avuto tempo di approfondire l ergomento.
cmq adesso ( credo ) di aver capito .

https://www.meccanismocomplesso.org/impariamo-a-programmare-in-c-con-arduino-02-le-funzioni/

ho trovato questo sito e insiema ad un libro di c++( non ne ho trovati altri)
sono arrivato a scrivere uesto .

//definisco ingrerssi joystick
#define JX A0
#define JY A1
#define firea 3
#define fireb 4
#define firec 5
#define blocchi 20
// il centro joy legge da 513 a 514
#define CentroDestra  516
#define CentroBasso   511
#define CentroSinistra  511
#define CentroAlto  516


void setup() {

  pinMode(firea , INPUT);//impusto i tasti sparo
  pinMode(fireb , INPUT);
  pinMode(firec , INPUT);

}

void loop() {
  // put your main code here, to run repeatedly:

}

int posBassa(int Jy)
{
  if ( Jy >= CentroBasso )
    return 0;

  return ((CentroBasso - JY) / blocchi  );
}
int posAlta(int Jy) {
  if ( Jy <= CentroAlto)
    return 0;
  return ((Jy - CentroAlto) / blocchi  );

}
int posSinistra(int Jy) {
  if (Jy >= CentroSinistra)
    return 0;
  return ((CentroSinistra - JY) / blocchi );
}
int posDestra(int JY) {
  if (JY <= CentroDestra)
    return 0;
  return ((JY - CentroDestra) / blocchi );
}

per compilarlo lo compila ora devo aggiungere i delay .
se ho capito bene nel loop richiamo solo le 4 funioni destra,sinistra,sopra e sotto.
pero quello che non mi è chiaro se il valore restituito viene cancellato alla fine della funzione o meno da quello che ho letto si , per non lerderlo andrebbe associato ad una variabile globale? scusate se ho detto delle bidheratte

grazie ancora per l aiuto

//definisco ingrerssi joystick
#define assex A0
#define assey A1
#define firea 3
#define fireb 4
#define firec 5
#define blocchi 25
// il centro joy legge da 513 a 514
#define CentroDestra  516
#define CentroBasso   511
#define CentroSinistra  511
#define CentroAlto  516
int JX;//varuiabili lettura ingresi
int JY;
#define ledby 4//led uscita
#define leday 5
#define leddx 6
#define ledsx 7
void setup() {
  // imposto i pin
  pinMode(fireb , INPUT);
  pinMode(firec , INPUT);
  pinMode (leddx , OUTPUT);
  pinMode (ledsx , OUTPUT);
  pinMode (leday, OUTPUT);
  pinMode (ledby, OUTPUT);

}

void loop() {

  int JY = analogRead (assex);
  int  JX = analogRead(assey);
  //--------------------------------------------------asseY
  int posBassa(int JY);
  int posAlta(int JY);
  int tempoby = posBassa(JY);
  int tempobys = 20 - tempoby;
  int tempoay = posAlta(JY);
  int tempoays = 20 - tempoay;
  //-------------------------------------------------asseX
  int posDestra(int JX);
  int posSinistra(int JX);
  int tempodx = posDestra(JX);
  int tempodxs = tempodx - 20 ;
  int temposx = posSinistra(JX);
  int temposxs =  temposx - 20;

  //----------------fase joystik basso

  if (tempoby > 0) {
    digitalWrite(ledby, HIGH);
    delay(tempoby * 30 );
    digitalWrite(ledby , HIGH);
    delay(tempobys * 30);
  }
  //---------- fase joystik alto
  if (tempoay > 0) {
    digitalWrite(leday, HIGH );
    delay(tempoay * 30);
    digitalWrite(leday, LOW );
    delay(tempoays * 30);
  }
  //-----------------------------------asse X

  //-------------------------------fase joystik destra
  if (tempodx > 0) {
    digitalWrite(leddx, HIGH);
    delay(tempodx * 30);
    digitalWrite(leddx, LOW);
    //-------------------------------fase joystik sinistra
    if (temposx > 0) {
      digitalWrite(ledsx, HIGH);
      delay(temposx * 30);
      digitalWrite(ledsx, LOW);
      delay(temposxs * 30);
    }
  }
  delay(50);


}



int posBassa(int JY)
{
  if ( JY >= CentroBasso )
    return 0;

  return int ((CentroBasso - JY) / blocchi  );
}
int posAlta(int JY) {
  if ( JY <= CentroAlto)
    return 0;
  return ((JY - CentroAlto) / blocchi  );

}
int posSinistra(int JX) {
  if (JX >= CentroSinistra)
    return 0;
  return ((CentroSinistra - JY) / blocchi );
}
int posDestra(int JX) {
  if (JX <= CentroDestra)
    return 0;
  return ((JX - CentroDestra) / blocchi );
}

finito ora con un led per lato e sembra funzionare anche se un po lento nella risposta ( mi sa che si fa piu semplice e funzionale con 4 en555 , cmq
sembra funzionare bene , ho messo quel delay(50); perche altrimenti il monitor si bloccava anzi non partiva neanche , non so il perche.

credo anzi sono certo che si potrebbe scrivere meglio e in modo piu semplice ,,,,

ancora grazie per l aiuto che mi avete dato