INPUT ANALOGICO/DIGITALE: esempio JOYSTICK SHIELD

Per il seguente esempio è stato utilizzato il JoyStick shield dell'ITEAD (https://www.itead.cc).

Per provare gli script successivi è necessario innestare il Joystick shield sulla board di arduino come mostrato in figura:

Codice Sorgente A

Il primo codice proposto non richiede l'utilizzo di alcuna libreria.  I pin di Arduino utilizzati dal JOYSTICK SHIELD sono evidenziati nello schema sottostante.

PIN Bottone connesso D3 Bottone E D4 Bottone D D5 Bottone C (Joystick) D6 Buttone B (Right) D7 Bottone A (Up) D8 Bottone F (Down) D9 Bottone G (Left) A1 Asse X A0 Asse Y

La lettura dei valori relativi ai due assi X/Y è di tipo analogico ed avviene attraverso i pin A1 (coordinata X) e A0 (Coordinata Y) con il comando analogRead(pin). Per catturare il segnale proveniente dalla pressione di un qualsiasi pulsante (anche quello connesso alla leva del joystick!) si usa il comando digitalRead( pin ). Spostando il joystick dall'origine verso destra lungo l’asse X abbiamo un incremento del valore letto su A1 da circa 514 fino a 1023. Se lo spostamento è dall'origine verso sinistra lungo l'asse X abbiamo un decremento da 514 fino a 0. Questo è il range che abbiamo già incontrato parlando  dell’ADC ( convertitore analogico digitale ) di Arduino a 10bit. Lo stesso range vale per i valori vengono letti sul pin A0 (asse Y). Spostando il joystick verso il basso varia da 504 circa fino a 0 mentre verso l’alto da 504 circa a 1023.

#define X_PIN  A1  // Pin di arduino abbinato alla lettura sull'asse X
#define Y_PIN  A0  // Pin di arduino abbinato alla lettura sull'asse Y

#define Btn_E_PIN  3     // Pin di arduino abbinato al bottone E
#define Btn_D_PIN  4     // Pin di arduino abbinato al bottone D
#define Btn_C_JS_PIN  5  // Pin di arduino abbinato al bottone JS
#define Btn_B_RG_PIN  6  // Pin di arduino abbinato al bottone B (RIGHT)
#define Btn_A_UP_PIN  7  // Pin di arduino abbinato al bottone A (UP)
#define Btn_F_DW_PIN  8  // Pin di arduino abbinato al bottone F (DOWN)
#define Btn_G_LT_PIN  9  // Pin di arduino abbinato al bottone G (LEFT)

#define X_THRESHOLD_HIGH 519  // Se il valore X sul PIN A1 è tale che: X_THRESHOLD_LOW < X <  X_THRESHOLD_HIGH
#define X_THRESHOLD_LOW  509  // allora considero il JoyStick in posizione di riposo (centrato orizzontalmente!)
#define Y_THRESHOLD_HIGH 508  // Se il valore Y sul PIN A0 è tale che Y_THRESHOLD_LOW < Y <  Y_THRESHOLD_HIGH
#define Y_THRESHOLD_LOW  499  // allora considero il JoyStick in posizione di riposo (centrato verticalmente!)
#define SENSIBILITA 10 // Imposto la variazione minina che mi porta a considerare cambiata la posizione del Joystick 

String Linea_prec;
int x_prec, y_prec;

void Cfg_JSShield()
{
    // setto i pin abbinati alla posizione del JOYSTICK in modalità di INPUT
    pinMode(X_PIN, INPUT);
    pinMode(Y_PIN, INPUT);
    // setto i pin dei bottoni in modalità INPUT
    pinMode(Btn_E_PIN, INPUT);
    pinMode(Btn_D_PIN, INPUT);
    pinMode(Btn_C_JS_PIN, INPUT);
    pinMode(Btn_B_RG_PIN, INPUT);
    pinMode(Btn_A_UP_PIN, INPUT);
    pinMode(Btn_F_DW_PIN, INPUT);
    pinMode(Btn_G_LT_PIN, INPUT);
    // Abilito le resistenze di pull-up per i bottoni
    digitalWrite(Btn_E_PIN, HIGH);
    digitalWrite(Btn_D_PIN, HIGH);
    digitalWrite(Btn_C_JS_PIN, HIGH);
    digitalWrite(Btn_B_RG_PIN, HIGH);
    digitalWrite(Btn_A_UP_PIN, HIGH);
    digitalWrite(Btn_F_DW_PIN, HIGH);
    digitalWrite(Btn_G_LT_PIN, HIGH);
}

void setup() 
{
    Linea_prec="";
    x_prec=2048; // Inizializzo con un valore assurdo per una porta analogica
    y_prec=2048; // Inizializzo con un valore assurdo per una porta analogica
    Serial.begin(9600);
    Cfg_JSShield(); // Assegno i pin associati ai bottoni e al Joystick
}

void loop()
{
    String LineaJS, LineaB;
    int x,y;

    // Analizzo lo stato dei bottoni
    LineaB="";
    if (digitalRead(Btn_E_PIN) == LOW)    LineaB="CLICK SU: E        ";
    if (digitalRead(Btn_D_PIN) == LOW)    LineaB="CLICK SU: D        ";
    if (digitalRead(Btn_C_JS_PIN) == LOW) LineaB="CLICK SU: JOYSTICK ";
    if (digitalRead(Btn_B_RG_PIN) == LOW) LineaB="CLICK SU: RIGHT (B)";
    if (digitalRead(Btn_A_UP_PIN) == LOW) LineaB="CLICK SU: UP    (A)";
    if (digitalRead(Btn_F_DW_PIN) == LOW) LineaB="CLICK SU: DOWN  (F)";
    if (digitalRead(Btn_G_LT_PIN) == LOW) LineaB="CLICK SU: LEFT  (G)";
    if (LineaB!="") Serial.println(LineaB);

    // Determino la posizione del Joystick
    LineaJS="";
    x = analogRead(X_PIN);
    y = analogRead(Y_PIN);
    // Se lo spostamento è minimo lo ignoro!
    if ( abs(x-x_prec) X_THRESHOLD_HIGH)
    {
        if (y > Y_THRESHOLD_HIGH)
            LineaJS="RIGHT-UP  ";
        else if (y < Y_THRESHOLD_LOW)
            LineaJS="RIGHT-DOWN";
        else
            LineaJS="RIGHT     ";
    }
    else if (x < X_THRESHOLD_LOW)
    {
        if (y > Y_THRESHOLD_HIGH)
            LineaJS="LEFT-UP   ";
        else if (y < Y_THRESHOLD_LOW)
            LineaJS="LEFT-DOWN ";
        else
            LineaJS="LEFT      ";
    }    
    else
    {
        if (y > Y_THRESHOLD_HIGH)
            LineaJS="UP        ";
        else if (y < Y_THRESHOLD_LOW)
            LineaJS="DOWN      ";
        else
            LineaJS="CENTER    ";
    }
    LineaJS=LineaJS+" - (X,Y)=("+String(x)+","+String(y)+")";
    if ( (LineaJS!="") && (LineaJS!=Linea_prec) ) Serial.println(LineaJS);
    Linea_prec=LineaJS;
    x_prec=x;
    y_prec=y;
    delay(300);
}

L'output sul monitor seriale è il seguente:

Codice Sorgente B

Il seguente codice utlizza invece una libreria da me riveduta relativa al JOYSTICK SHIELD. Per scaricare la libreria clicca qui.

#include <JoystickShield_IS.h>
/* -----------------------------------------------------------------------------------
  DEMO che legge gli spostamenti del JOYSTICK e i bottoni premuti
----------------------------------------------------------------------------------- */
// creo un'istanza di un oggetto JoystickShield
JoystickShield joystickShield; 
String Linea_prec;

void setup() 
{
    Serial.begin(9600);
    // Ricalibro il JoyStick
    delay(100);
    joystickShield.calibrateJoystick();
    
    // I pin predefiniti per il Joystick sono A1 (x) e A0 (y)
    // Per cambiarli basta utilizzare questa istruzione
    // joystickShield.setJoystickPins(1, 0);
    
    // Se si vogliono cambiare i pin predefiniti associati al bottone occorre utilizzare
    // questa istruzione: setButtonPins(pinJoystickButton, pinUp, pinRight, pinLeft, pinDown, pinE, pinD);
    // joystickShield.setButtonPins(5, 7, 6, 9, 8, 3, 4);
    Linea_prec="";
}

void loop() 
{
  int x,y;
  String LineaJS, LineaB;
  
  // Controllo gli eventi che sono stati attivati
  joystickShield.processEvents(); 

  // Analizzo lo stato dei bottoni
  LineaB="";
  if (joystickShield.isJoystickButton()) LineaB="CLICK SU: JOYSTICK ";
  if (joystickShield.isUpButton())       LineaB="CLICK SU: UP    (A)";
  if (joystickShield.isRightButton())    LineaB="CLICK SU: RIGHT (B)";
  if (joystickShield.isDownButton())     LineaB="CLICK SU: DOWN  (F)";
  if (joystickShield.isLeftButton())     LineaB="CLICK SU: LEFT  (G)";
  if (joystickShield.isEButton())        LineaB="CLICK SU: E        ";
  if (joystickShield.isDButton())        LineaB="CLICK SU: D        ";
  if (LineaB!="") Serial.println(LineaB);
  
  // Analizzo lo stato del Joystick
  LineaJS="";
  if (joystickShield.isCenter())    LineaJS="CENTER    ";
  if (joystickShield.isUp())        LineaJS="UP        ";
  if (joystickShield.isRightUp())   LineaJS="RIGHT-UP  ";
  if (joystickShield.isRight())     LineaJS="RIGHT     ";
  if (joystickShield.isRightDown()) LineaJS="RIGHT-DOWN";
  if (joystickShield.isDown())      LineaJS="DOWN      ";
  if (joystickShield.isLeftDown())  LineaJS="LEFT-DOWN ";
  if (joystickShield.isLeft())      LineaJS="LEFT      ";
  if (joystickShield.isLeftUp())    LineaJS="LEFT-UP   ";
  x=joystickShield.xAmplitude();
  y=joystickShield.yAmplitude();
  LineaJS=LineaJS+" - (X,Y)=("+String(x)+","+String(y)+")";

  if ( (LineaJS!="") && (LineaJS!=Linea_prec) ) Serial.println(LineaJS);
  Linea_prec=LineaJS;
  delay(300);
}

L'output sul monitor seriale è il seguente:

Codice Sorgente C

L'ultimo script è completamente equivalente al precedente ma fa ricorso alle funzioni di callback (modalità implementativa supportata dalla  libreria citata in precedenza).

/* -----------------------------------------------------------------------------------
  DEMO che legge gli spostamenti del JOYSTICK e i bottoni premuti (CallBack Ver.)
----------------------------------------------------------------------------------- */
#include <JoystickShield_IS.h>

// creo un'istanza di un oggetto JoystickShield
JoystickShield joystickShield; 
String Linea_prec;

void setup() 
{
    Serial.begin(9600);
    // Ricalibro il JoyStick
    delay(100);
    joystickShield.calibrateJoystick();
    
    // I pin predefiniti per il Joystick sono A1 (x) e A0 (y)
    // Per cambiarli basta utilizzare questa istruzione
    // joystickShield.setJoystickPins(1, 0);
    
    // Se si vogliono cambiare i pin predefiniti associati al bottone occorre utilizzare
    // questa istruzione: setButtonPins(pinJoystickButton, pinUp, pinRight, pinLeft, pinDown, pinE, pinD);
    // joystickShield.setButtonPins(5, 7, 6, 9, 8, 3, 4);

    // Joystick Callbacks
    joystickShield.onJSCenter(¢er);
    joystickShield.onJSUp(&up);
    joystickShield.onJSRightUp(&rightUp);
    joystickShield.onJSRight(&right);
    joystickShield.onJSRightDown(&rightDown);
    joystickShield.onJSDown(&down);
    joystickShield.onJSLeftDown(&leftDown);
    joystickShield.onJSLeft(&left);
    joystickShield.onJSLeftUp(&leftUp);
    // joystickShield.onJSnotCenter(¬Center);

    // Button Callbacks
    joystickShield.onJoystickButton(&joystickButton);
    joystickShield.onUpButton(&upButton);
    joystickShield.onRightButton(&rightButton);
    joystickShield.onDownButton(&downButton);
    joystickShield.onLeftButton(&leftButton);
    joystickShield.onDButton(&DButton);
    joystickShield.onEButton(&EButton);
}

void loop()
{
    joystickShield.processCallbacks();
    delay(300);
}

/** Funzioni di CallBack del JoyStick **/
void JSMove(String Fr)
{ 
  int x,y;
  String LineaJS=Fr;
  x=joystickShield.xAmplitude();
  y=joystickShield.yAmplitude();
  LineaJS=LineaJS+" - (X,Y)=("+String(x)+","+String(y)+")";
  if ( (LineaJS!="") && (LineaJS!=Linea_prec) ) Serial.println(LineaJS);
  Linea_prec=LineaJS;
}
void center()    { JSMove("CENTER    "); }
void up()        { JSMove("UP        "); }
void rightUp()   { JSMove("RIGHT-UP  "); }
void right()     { JSMove("RIGHT     "); }
void rightDown() { JSMove("RIGHT-DOWN"); }
void down()      { JSMove("DOWN      "); }
void leftDown()  { JSMove("LEFT-DOWN "); }
void left()      { JSMove("LEFT      "); }
void leftUp()    { JSMove("LEFT-UP   "); }
//void notCenter() { JSMove("NOT CENTER"); }

/** Funzioni di CallBack dei bottoni **/
void joystickButton() { Serial.println("CLICK SU: JOYSTICK "); }
void upButton()       { Serial.println("CLICK SU: UP    (A)"); }
void rightButton()    { Serial.println("CLICK SU: RIGHT (B)"); }
void downButton()     { Serial.println("CLICK SU: DOWN  (F)"); }
void leftButton()     { Serial.println("CLICK SU: LEFT  (G)"); }
void EButton()        { Serial.println("CLICK SU: E        "); }
void DButton()        { Serial.println("CLICK SU: D        "); }

Codice Sorgente della libreria JOYSTICKSHIELD

Per curiosità proponiamo il sorgente della libreria utilizzata. Ecco l'header file JOYSTICKSHIELD_IS.H:

/**
   JoystickShield - Arduino Library for JoystickShield 
   (http://hardwarefun.com/projects/joystick-shield)

 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 *  wrote this file. As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer or coffee in return - Sudar
 * ----------------------------------------------------------------------------
 * 2014 edit by Markus Mücke, muecke.ma(a)gmail.com
 * Changes for JoysikShield V1.2
 * added a function to read the amplitude of the joystick
 * added a auto calibrate function for 3.3V and 5V mode
 *
 * Added functions:
 *	Functions for F and E Button
 *  Calibrate Joystick
 *  xAmplitude
 *  yAmplitude
 
 * 2018 edit by Marco Sechi, cormatron@libero.it
*/

#ifndef JoystickShield_H

#define JoystickShield_H
#define CENTERTOLERANCE 5
// per compatibilità con Arduino 1.0
#if ARDUINO >= 100
    #include <Arduino.h>
#else    
    #include <WProgram.h>
#endif
#define MAX_ANAL_VALUE 1023 // MAX valore sulla porta analogica

/********************************************************************
   Tipo enumerativo che descrive i diversi stati del Joystick
*********************************************************************/
enum JoystickStates 
{
    CENTER,  // vale 0
    UP,
    RIGHT_UP,
    RIGHT,
    RIGHT_DOWN,
    DOWN,
    LEFT_DOWN,
    LEFT,
    LEFT_UP,
    NOT_CENTER	
};

/********************************************************************
 Tipo enumerativo che descrive i diversi stati dei buttoni
********************************************************************/
enum ButtonStates 
{
     NO_BUTTON,       // vale 0
     JOYSTICK_BUTTON, // JS :pin 5
     UP_BUTTON,       // A  :pin 7 
     RIGHT_BUTTON,    // B  :pin 6
     LEFT_BUTTON,     // G  :pin 9
     DOWN_BUTTON,     // F  :pin 8
     E_BUTTON,        // E  :pin 3
     D_BUTTON         // D  :pin 4
};

class JoystickShield 
{

	public:

		JoystickShield(); // costruttore

		void setJoystickPins (byte pinX, byte pinY);
		void setButtonPins(byte , byte , byte , byte , byte , byte , byte);
		void setThreshold(int xLow, int xHigh, int yLow, int yHigh);
		void calibrateJoystick();

		void processEvents();
		
		// Joystick events
		bool isCenter();
		bool isDown();
		bool isUp();
		bool isLeft();
		bool isRight();
		bool isRightDown();
		bool isRightUp();
		bool isLeftDown();
		bool isLeftUp();
		bool isNotCenter();
		// Button events
		bool isJoystickButton();
		bool isUpButton();
		bool isRightButton();
		bool isDownButton();
		bool isLeftButton();
		bool isDButton();
		bool isEButton();
		// Joystick coordinates
		int xAmplitude();
		int yAmplitude();

		// -----------------------------------------------
		// Sezione funzioni di callback
		// -----------------------------------------------
		void processCallbacks();
		// Joystick callbacks
		void onJSEvent(void (*fCallback)(void),JoystickStates);
		void onJSCenter(void (*centerCallback)(void));
		void onJSUp(void (*upCallback)(void));
		void onJSRightUp(void (*rightUpCallback)(void));
		void onJSRight(void (*rightCallback)(void));
		void onJSRightDown(void (*rightDownCallback)(void));
		void onJSDown(void (*downCallback)(void));
		void onJSLeftDown(void (*leftDownCallback)(void));
		void onJSLeft(void (*leftCallback)(void));
		void onJSLeftUp(void (*leftUpCallback)(void));
		void onJSnotCenter(void (*notCenterCallback)(void));
		// Button callbacks
		void onBtnEvent(void (*fCallback)(void),ButtonStates);
		void onJoystickButton(void (*jsButtonCallback)(void));
		void onUpButton(void (*upButtonCallback)(void));
		void onRightButton(void (*rightButtonCallback)(void));
		void onDownButton(void (*downButtonCallback)(void));
		void onLeftButton(void (*leftButtonCallback)(void));
		void onDButton(void (*DButtonCallback)(void));
		void onEButton(void (*EButtonCallback)(void));
	
	private:

		// variabili con i valori di soglia
		int x_threshold_low;
		int x_threshold_high;
		int y_threshold_low;
		int y_threshold_high;
		// variabili che contengono i pin associati al Joystick
		byte pin_analog_x;
		byte pin_analog_y;
		// variabili che contengono i pin associati ai bottoni
		byte pin_joystick_button;
		byte pin_but_A;
		byte pin_but_B;
		byte pin_but_C;
		byte pin_but_D;
		byte pin_but_G;
		byte pin_but_F;
		byte pin_but_E;
		
		// posizione x,y del joystick
		int x_position;
		int y_position;

		// stato corrente del Joystick
		JoystickStates currentStatus;
		// contiene l'ultimo bottone che è stato premuto
		ButtonStates currentButton;

		bool isButton(ButtonStates); 
		void clearButtonStates();
		
		// -----------------------------------------------
		// Inizializzazione funzioni di callback
		// -----------------------------------------------
		void initializeCallbacks();
		// Joystick callbacks
		void (*centerCallback)(void);
		void (*upCallback)(void);
		void (*rightUpCallback)(void);
		void (*rightCallback)(void);
		void (*rightDownCallback)(void);
		void (*downCallback)(void);
		void (*leftDownCallback)(void);
		void (*leftCallback)(void);
		void (*leftUpCallback)(void);
		void (*notCenterCallback)(void);
		// Button callbacks
		void (*jsButtonCallback)(void);
		void (*upButtonCallback)(void);
		void (*rightButtonCallback)(void);
		void (*downButtonCallback)(void);
		void (*leftButtonCallback)(void);
		void (*DButtonCallback)(void);
		void (*EButtonCallback)(void);
};

#endif // di #ifndef JoystickShield_H

e la libreria vera e propria JOYSTICKSHIELD_IS.CPP:

/**
JoystickShield - Arduino Library for JoystickShield (http://hardwarefun.com/projects/joystick-shield)
Copyright 2011  Sudar Muthu  (email : sudar@sudarmuthu.com)

* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
*  wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer or coffee in return - Sudar
* ----------------------------------------------------------------------------
 
* 2014 edit by Markus Mücke, muecke.ma(a)gmail.com
* Changes for JoysikShield V1.2
* added a function to read the amplitude of the joystick
* added a auto calibrate function for 3.3V and 5V mode
* Added functions:
*    Functions for F and E Button
*    Calibrate Joystick
*    xAmplitude
*    yAmplitude

* El 20 Abril 2014 modificado por José Augusto Pujato.

* April 2018 modify by Sechi Marco

**/

#include "JoystickShield_IS.h"
/********************************************************************
 Costruttore
********************************************************************/
JoystickShield::JoystickShield() 
{
    // Definisco i pin connessi agli spostamenti del Joystick. 
    setJoystickPins(1, 0); // Nel nostro caso i pins A1 e A0.
	
    // Definisco i pin connessi ai bottoni del Joystick shield seguendo l'ordine seguente:
    // JOYSTICK, UP (A),RIGHT (B),LEFT (G),DOWN (F), E, D
    setButtonPins(5, 7, 6, 9, 8, 3, 4); 
	
    // Definisco la posizione di default del Joystick e il bottone corrente
    currentStatus = CENTER;
    currentButton = NO_BUTTON;

    // Inizializzo tutti i puntatori alle funzioni di callback a null
    initializeCallbacks();

    // Definizione dei valori di soglia temporanea (verranno poi risistemati
    // con la funzione di autocalibrazione). I valori utilizzati sono basati
    // sui valori analogici letti con il JOYSTICK a riposo
    setThreshold(509, 519, 499, 508); 
}

/** ------------------------------------------------------------------
         R O U T I N E    D I    S E T T A G G I O
     ----------------------------------------------------------------- **/
	 
/********************************************************************
 Imposto le soglie per riconoscere quando il JOYSTICK è a riposo
********************************************************************/
void JoystickShield::setThreshold(int xLow, int xHigh, int yLow, int yHigh) 
{
    x_threshold_low  = xLow;
    x_threshold_high = xHigh;
    y_threshold_low  = yLow;
    y_threshold_high = yHigh;
}

/********************************************************************
 Imposto i pin connessi al JoyStick
********************************************************************/
void JoystickShield::setJoystickPins(byte pinX, byte pinY) 
{
    pin_analog_x = pinX;
    pin_analog_y = pinY;
    // Imposto i pin del Joystick in modalità INPUT
    pinMode(pin_analog_x, INPUT);
    pinMode(pin_analog_y, INPUT);
}

/********************************************************************
 Imposto i pin connessi ai bottoni del JOYSTICK Shield. I parametri
 di setButtonPins sono associati alla seguente sequenza:
 JOYSTICK, UP (A),RIGHT (B),LEFT (G),DOWN (F), E, D.
 Le lettere sono quelle serigrafate sul modulo. Per deattivare un 
 bottone basta utilizzare un numero fuori dal range di arduino (esempio 255)
********************************************************************/
void JoystickShield::setButtonPins(byte pinButtonJS, byte pinButtonA, byte pinButtonB, byte pinButtonG, 
                                   byte pinButtonF,  byte pinButtonE, byte pinButtonD)  
{
    pin_joystick_button = pinButtonJS;
    pin_but_A = pinButtonA; 
    pin_but_G = pinButtonG;
    pin_but_F = pinButtonF;
    pin_but_D = pinButtonD;
    pin_but_B = pinButtonB;
    pin_but_E = pinButtonE ;

    // setto i pin dei bottoni in modalità INPUT
    pinMode(pin_joystick_button, INPUT);
    pinMode(pin_but_A, INPUT);
    pinMode(pin_but_F, INPUT);
    pinMode(pin_but_G, INPUT);
    pinMode(pin_but_E, INPUT);
    pinMode(pin_but_D, INPUT);
    pinMode(pin_but_B, INPUT);

    // Abilito le resistenze di pull-up per i bottoni
    digitalWrite(pin_joystick_button, HIGH);
    digitalWrite(pin_but_F, HIGH);
    digitalWrite(pin_but_G, HIGH);
    digitalWrite(pin_but_A, HIGH);
    digitalWrite(pin_but_E, HIGH);
    digitalWrite(pin_but_D, HIGH);
    digitalWrite(pin_but_B, HIGH);
}

/** ------------------------------------------------------------------
         R O U T I N E    D I    I N I Z I A L I Z Z A Z I O N E
     ------------------------------------------------------------------ **/

/********************************************************************
 Azzera qualsiasi info relativa al bottone premuto
********************************************************************/
void JoystickShield::clearButtonStates() 
{
    currentButton = NO_BUTTON;
}	 
/********************************************************************
 Funzione per calibrare il JoyStick - I valori analogici su A1 e A0
 vanno da 0 a 1023.  In modalità di riposo (centrato sia orizzontalmente
 che verticalmente) il mio joystick restituisce (A1,A0)=(514,503/504)
********************************************************************/
void JoystickShield::calibrateJoystick()  
{
	byte i;
	
	/* Per vedere i valori letti a riposo del JOYSTICK abilito queste righe:
	for(i = 0; i<10; i++) Serial.println(analogRead(pin_analog_x));
	for(i = 0; i<10; i++) Serial.println(analogRead(pin_analog_y));  */
	
	int xCenter = 0; // calibro x facendo 10 letture
	for(i = 0; i<10; i++)
		xCenter += analogRead(pin_analog_x);
	xCenter /= i;

	int yCenter = 0; // calibro y facendo 10 letture
	for(i = 0; i<10; i++) 
		yCenter += analogRead(pin_analog_y);
	yCenter /= i;

	// Imposto la posizione centrale accettando una certa tolleranza
	setThreshold(xCenter-CENTERTOLERANCE, xCenter+CENTERTOLERANCE, yCenter-CENTERTOLERANCE, yCenter+CENTERTOLERANCE);
}

/********************************************************************
 Testa lo stato del JS. Questa routine va messa in un loop
********************************************************************/
void JoystickShield::processEvents() 
{
    int x_direction = 0;
    int y_direction = 0;

    // leggo i pin x e y del Joystock
    x_position = analogRead(pin_analog_x);
    y_position = analogRead(pin_analog_y);

    // determimo la direzione del JoyStick
    if (x_position > x_threshold_high) 
    {
        x_direction = 1;
        x_position = map(x_position, x_threshold_high,MAX_ANAL_VALUE,0,100);
        x_position = constrain(x_position,0,100);
    } 
    else if (x_position < x_threshold_low) 
    {
        x_direction = -1;
        x_position = map(x_position, 0,x_threshold_low,-100,0);
    } 
    else
        x_position = 0;

    if (y_position > y_threshold_high) 
    {
        y_direction = 1;
        y_position = map(y_position, y_threshold_high,MAX_ANAL_VALUE,0,100);
        y_position = constrain(y_position,0,100);
    } 
    else if (y_position < y_threshold_low) 
    {
        y_direction = -1;
        y_position = map(y_position, 0,y_threshold_low,-100,0);
    } 
    else
        y_position = 0;
		
    if (x_direction == -1) 
    {
        if (y_direction == -1)
            currentStatus = LEFT_DOWN;
        else if (y_direction == 0)
            currentStatus = LEFT;
        else
            currentStatus = LEFT_UP;
    } 
    else if (x_direction == 0) 
    {
        if (y_direction == -1)
            currentStatus = DOWN;
        else if (y_direction == 0)
            currentStatus = CENTER;
        else
            currentStatus = UP;
    } 
    else 
    {
        if (y_direction == -1)
            currentStatus = RIGHT_DOWN;
        else if (y_direction == 0)
            currentStatus = RIGHT;
        else
            currentStatus = RIGHT_UP;
    }
    // Determino quale sia il bottone premuto
    if (digitalRead(pin_but_E) == LOW) currentButton =E_BUTTON ;
    if (digitalRead(pin_but_D) == LOW) currentButton = D_BUTTON;
    if (digitalRead(pin_joystick_button) == LOW) currentButton = JOYSTICK_BUTTON;
    if (digitalRead(pin_but_B) == LOW) currentButton = RIGHT_BUTTON;
    if (digitalRead(pin_but_A) == LOW) currentButton = UP_BUTTON;
    if (digitalRead(pin_but_F) == LOW) currentButton = DOWN_BUTTON;
    if (digitalRead(pin_but_G) == LOW) currentButton = LEFT_BUTTON;
}

/********************************************************************
 Funzioni che testano le posizioni del Joystick
********************************************************************/
bool JoystickShield::isCenter() { return (currentStatus == CENTER); }
bool JoystickShield::isNotCenter() { return (currentStatus != CENTER); }
bool JoystickShield::isUp() { return (currentStatus == UP); }
bool JoystickShield::isRightUp() { return (currentStatus == RIGHT_UP); }
bool JoystickShield::isRight() { return (currentStatus == RIGHT); }
bool JoystickShield::isRightDown() { return (currentStatus == RIGHT_DOWN); }
bool JoystickShield::isDown() { return (currentStatus == DOWN); }
bool JoystickShield::isLeftDown() { return (currentStatus == LEFT_DOWN); }
bool JoystickShield::isLeft() { return (currentStatus == LEFT); }
bool JoystickShield::isLeftUp() { return (currentStatus == LEFT_UP); }

/********************************************************************
 Legge lo spostamento del Joystick 
   x=> [-100 (LEFT) - 0 (CENTER) - 100 (RIGHT)]
   y=> [-100 (DOWN) - 0 (CENTER) - 100 (UP)]
********************************************************************/
int JoystickShield::xAmplitude() { return x_position; }
int JoystickShield::yAmplitude() { return y_position; }

/********************************************************************
 Funzioni che testano il bottone premuto
********************************************************************/
bool JoystickShield::isButton(ButtonStates WhichButton) 
{
    ButtonStates tButton=currentButton;
	if (tButton == WhichButton) 
		clearButtonStates();
    return (tButton == WhichButton);
}
bool JoystickShield::isJoystickButton() { return isButton(JOYSTICK_BUTTON); } 
bool JoystickShield::isRightButton() { return isButton(RIGHT_BUTTON); } 
bool JoystickShield::isLeftButton() { return isButton(LEFT_BUTTON); } 
bool JoystickShield::isUpButton() { return isButton(UP_BUTTON); } 
bool JoystickShield::isDownButton() { return isButton(DOWN_BUTTON); } 
bool JoystickShield::isDButton() { return isButton(D_BUTTON); } 
bool JoystickShield::isEButton() { return isButton(E_BUTTON); } 

/** ------------------------------------------------------------------
      S E Z I O N E    R O U T I N E    D I    C A L L B A C K S
     ------------------------------------------------------------------ **/

/********************************************************************
 Inizializzo tutti i puntatori di callback a NULL
********************************************************************/
void JoystickShield::initializeCallbacks() 
{
    // Joystick callbacks - il this-> non è necessario
    this->centerCallback      = NULL;
    this->upCallback          = NULL;
    this->rightUpCallback     = NULL;
    this->rightCallback       = NULL;
    this->rightDownCallback   = NULL;
    this->downCallback        = NULL;
    this->leftDownCallback    = NULL;
    this->leftCallback        = NULL;
    this->leftUpCallback      = NULL;
    this->notCenterCallback   = NULL;
    // Button callbacks
    this->jsButtonCallback    = NULL;
    this->upButtonCallback    = NULL;
    this->rightButtonCallback = NULL;
    this->downButtonCallback  = NULL;
    this->leftButtonCallback  = NULL;
    this->DButtonCallback     = NULL;
    this->EButtonCallback     = NULL;
}

/********************************************************************
 Stabilisce quale funzione di callback applicare
********************************************************************/
void JoystickShield::processCallbacks() 
{
    processEvents();

    // Joystick Callbacks  - il this-> non è necessario
    if (isCenter() && this->centerCallback != NULL) this->centerCallback();
    if (isUp() && this->upCallback != NULL) this->upCallback();
    if (isRightUp() && this->rightUpCallback != NULL) this->rightUpCallback();
    if (isRight() && this->rightCallback != NULL) this->rightCallback();
    if (isRightDown() && this->rightDownCallback != NULL) this->rightDownCallback();
    if (isDown() && this->downCallback != NULL) this->downCallback();
    if (isLeftDown() && this->leftDownCallback != NULL) this->leftDownCallback();
    if (isLeft() && this->leftCallback != NULL) this->leftCallback();
    if (isLeftUp() && this->leftUpCallback != NULL) this->leftUpCallback();
    if (isNotCenter() && this->notCenterCallback != NULL) this->notCenterCallback();
    // Button Callbacks
    if (isJoystickButton() && jsButtonCallback != NULL) jsButtonCallback();
    if (isUpButton() && upButtonCallback != NULL) upButtonCallback();
    if (isRightButton() && rightButtonCallback != NULL) rightButtonCallback();
    if (isDownButton() && downButtonCallback != NULL) downButtonCallback();
    if (isLeftButton() && leftButtonCallback != NULL) leftButtonCallback();
    if (isDButton() && DButtonCallback != NULL) DButtonCallback();
    if (isEButton() && EButtonCallback != NULL) EButtonCallback();
}

/********************************************************************
 Funzioni di CallBack relative al JoyStick
********************************************************************/
void JoystickShield::onJSEvent(void (*fCallback)(void),JoystickStates JSState) 
{
    switch(JSState) //  il this-> non è necessario
    {
        case CENTER: this->centerCallback = fCallback; break;
        case UP: this->upCallback = fCallback; break;
        case RIGHT_UP: this->rightUpCallback = fCallback; break;
        case RIGHT: this->rightCallback = fCallback; break;
        case RIGHT_DOWN: this->rightDownCallback = fCallback; break;
        case DOWN: this->downCallback = fCallback; break;
        case LEFT_DOWN: this->leftDownCallback = fCallback; break;
        case LEFT: this->leftCallback = fCallback; break;
        case LEFT_UP: this->leftUpCallback = fCallback; break;
        case NOT_CENTER: this->notCenterCallback = fCallback; break;
    }
}
void JoystickShield::onJSCenter(void (*fCallback)(void)) { onJSEvent(fCallback,CENTER); }
void JoystickShield::onJSUp(void (*fCallback)(void)) { onJSEvent(fCallback,UP); }
void JoystickShield::onJSRightUp(void (*fCallback)(void)) { onJSEvent(fCallback,RIGHT_UP); }
void JoystickShield::onJSRight(void (*fCallback)(void)) { onJSEvent(fCallback,RIGHT); }
void JoystickShield::onJSRightDown(void (*fCallback)(void)) { onJSEvent(fCallback,RIGHT_DOWN); }
void JoystickShield::onJSDown(void (*fCallback)(void)) { onJSEvent(fCallback,DOWN); }
void JoystickShield::onJSLeftDown(void (*fCallback)(void)) { onJSEvent(fCallback,LEFT_DOWN); }
void JoystickShield::onJSLeft(void (*fCallback)(void)) { onJSEvent(fCallback,LEFT); }
void JoystickShield::onJSLeftUp(void (*fCallback)(void)) { onJSEvent(fCallback,LEFT_UP); }
void JoystickShield::onJSnotCenter(void (*fCallback)(void)) { onJSEvent(fCallback,NOT_CENTER); }

/********************************************************************
 Funzioni di CallBack relative ai bottoni
********************************************************************/
void JoystickShield::onBtnEvent(void (*fCallback)(void),ButtonStates BState) 
{
    switch(BState)
    {
	case JOYSTICK_BUTTON: jsButtonCallback = fCallback; break;
	case UP_BUTTON: upButtonCallback = fCallback; break;
	case RIGHT_BUTTON: rightButtonCallback = fCallback; break;
	case DOWN_BUTTON: downButtonCallback = fCallback; break;
	case LEFT_BUTTON: leftButtonCallback = fCallback; break;
	case E_BUTTON: EButtonCallback = fCallback; break;
	case D_BUTTON: DButtonCallback = fCallback; break;
    }
}
void JoystickShield::onJoystickButton(void (*fCallback)(void)) { onBtnEvent(fCallback,JOYSTICK_BUTTON); }
void JoystickShield::onUpButton(void (*fCallback)(void)) { onBtnEvent(fCallback,UP_BUTTON); }
void JoystickShield::onRightButton(void (*fCallback)(void)) { onBtnEvent(fCallback,RIGHT_BUTTON); }
void JoystickShield::onDownButton(void (*fCallback)(void)) { onBtnEvent(fCallback,DOWN_BUTTON); }
void JoystickShield::onLeftButton(void (*fCallback)(void)) { onBtnEvent(fCallback,LEFT_BUTTON); }
void JoystickShield::onEButton(void (*fCallback)(void)) { onBtnEvent(fCallback,E_BUTTON); }
void JoystickShield::onDButton(void (*fCallback)(void)) { onBtnEvent(fCallback,D_BUTTON); }