Niveau à bulle Wii Nunchuck Arduino (6 / 7 étapes)

Étape 6: Charge de sketch Arduino Wii_Nunchuck_Level

Tout d’abord, vous devez savoir quel le Nunchuck accéléromètre chaque plage de données d’axe sont. J’ai testé quelques uns d'entre eux et tous les spectacles de légères différences.  Mais surtout, les plages sont 60-70 comme minimum et 180-200 comme maximum.  Afin que la meilleure sensibilité du niveau, vous devez charger le Wiichuck_range_test tout d’abord, trouver ces valeurs (Centre (au niveau), minimum et maximum) pour chaque axe et ajuster les valeurs dans l’esquisse principale si nécessaire.

L’esquisse de test gamme est simple et rapide donc je ne vais pas expliquer le détail ici.

Le programme principal, Wii_Nunchuck_Level est montré ci-dessous et également attaché.

La fonction GetData extraire les valeurs de chaque axe et stockez-les dans Byte array accl et trouver l’orientation du niveau et retourne « orienter ».

La fonction orientation() obtenir les valeurs de l’axe actuel et trouver l’orientation du niveau.  Chaque orientation donne deux axes comme moyen (nivelé, autour de 120-130) et un axe minimum ou maximum selon la direction de la gravité.  En utilisant cette caractéristiques, il détermine l’orientation.

La loop() principale est assez simple.  Il surveille si le bouton de calibrage est pressé de voir si la broche 10 est élevé et autrement il lu les données actuelles et allumer les LEDs.  Le programme compare les données actuelles de la stockée (dans l’EEPROM de la ATmega328P) données de calibration. Il y a trois étapes d’affichage: 1) si la valeur est comprise dans certains, il s’allume la LED rouge centrale connectée à la broche numérique 7 ; 2) si la valeur est supérieure à la plage (sens au programme) et moins de 2 fois de la gamme (sens), il s’allume rouge LED et un LED verte en face (pour simuler la direction bulle) côté de la bâche ; 3) si la valeur est supérieure à 2 fois de la gamme (sens), alors seulement la LED verte est allumée.

Les valeurs d’étalonnage sont la valeur neutre de chaque axe de lecture quand il est nivelé sur cet axe. Par exemple, la lecture de données Nunchuck est entre 60-70 (ces valeurs sont différentes d’un capteur à) - g (à l’envers) sur cet axe et est de plus de 170 g (à droite). Donc la valeur neutre (nivelée) de chaque axe est d’environ 120-130. L’étalonnage commence lorsque la broche 10 passe haut reliée à V + avec un petit bouton poussoir interrupteur enfoncé. Un le processus d’étalonnage commence, afin de donner à l’utilisateur quelque temps à poser l’appareil sur une surface plane, il attend jusqu'à ce que la centrale LED rouge clignote plusieurs fois. L’étalonnage réel est fait très vite et suivie de quelques clignote plus rapidement.

/*
* Wii_Nunchuck_Level
* Février-mars 2012, Jinseok Jeon
* http://jeonlab.wordpress.com
*
* Wii Nunchuck données lues :
* nunchuck_funcs.h de WiiChuckDemo de Tod E. Kurt,
* http://todbot.com/blog/2008/02/18/wiichuck-wii-nunchuck-adapter-available/
*/

#include < Wire.h >
#include < EEPROM.h >
#include « nunchuck_funcs.h »

accl octet [3] ; lectures d’accéléromètre pour x, y, axe z
calPin int = 10 ; goupille de calibration
sens int = 1 ; sensibilité
int orient ;

void setup()
{
nunchuck_init() ;
pour (int i = 5; i < 10; i ++) {}
pinMode (i, sortie) ;
} //9 à gauche, 8 vers le haut, le centre 7, de 6 en bas et de droite 5
pinMode (calPin, entrée) ;
Delay(100) ;
}

void loop()
{
Si vous appuyez sur la broche de calibration, sauter à funcion calibrate()
Si (digitalRead(calPin) == haute) calibrate() ;

getData() ;

Si (orienter == 1 || orienter == 2) {}
Si (abs (accl [0]-EEPROM.read (0 + orient * 10)) < = 2 * sens) digitalWrite (7, HIGH) ;
Si (accl [0]-EEPROM.read (0 + orient * 10) > sens) digitalWrite (5, HIGH) ;
Si (EEPROM.read(0 + orient*10)-accl [0] > sens) digitalWrite (9, HIGH) ;
}
Si (orienter == 3 || orienter == 4) {}
Si (abs (accl [1]-EEPROM.read (1 + orient * 10)) < = 2 * sens) digitalWrite (7, HIGH) ;
Si (accl [1]-EEPROM.read (1 + orient * 10) > sens) digitalWrite (8, HIGH) ;
Si (EEPROM.read(1 + orient*10)-accl [1] > sens) digitalWrite (6, HIGH) ;
}
Si (orienter == 5 || orienter == 6) {}
Si (abs (accl [0]-EEPROM.read (0 + orient * 10)) < = 2 * sens & & abs (accl [1]-EEPROM.read (1 + orient * 10)) < = 2 * sens) digitalWrite (7, HIGH) ;
Si (accl [0]-EEPROM.read (0 + orient * 10) > sens) digitalWrite (5, HIGH) ;
Si (EEPROM.read(0 + orient*10)-accl [0] > sens) digitalWrite (9, HIGH) ;
Si (accl [1]-EEPROM.read (1 + orient * 10) > sens) digitalWrite (8, HIGH) ;
Si (EEPROM.read(1 + orient*10)-accl [1] > sens) digitalWrite (6, HIGH) ;
}

Delay(50) ;
pour (int i = 5; j’ai < 10; i ++) {//turn éteint toutes les LEDs
digitalWrite (i, faible) ;
}
}

void GetData
{
nunchuck_get_data() ;
accl [0] = nunchuck_accelx() ;
accl [1] = nunchuck_accely() ;
accl [2] = nunchuck_accelz() ;

Orient = orientation() ; obtenir l’orientation
}

Sub calibrate()
{
pour (int i = 0; i < 3; i ++) {}
digitalWrite (7, HIGH) ;
Delay(500) ;
digitalWrite (7, faible) ;
Delay(500) ;
}

getData() ;

pour (int i = 0; i < 3; i ++) {}
EEPROM.write (j’ai + orient * 10, accl[i]) ;
}

pour (int i = 0; i < 3; i ++) {}
digitalWrite (7, HIGH) ;
Delay(200) ;
digitalWrite (7, faible) ;
Delay(200) ;
}
}

int orientation()
{
Si (accl [0] > 125 & & accl [0] < 145 & & accl [2] > 110 & & accl [2] < 140) {}
s’orienter (accl [1] > 170) = 1 ; bas étage
bien s’orienter (accl [1] < 75) = 2 ; haut étage
}
ElseIf (accl [1] > 110 & & accl [1] < 140 & & accl [2] > 110 & & accl [2] < 140) {}
s’orienter (accl [0] > 180) = 3 ; gauche sur plancher
bien s’orienter (accl [0] < 90) = 4 ; directement sur le plancher
}
ElseIf (accl [1] > 110 & & accl [1] < 140 & & accl [0] > 125 & & accl [0] < 145) {}
s’orienter (accl [2] > 170) = 5 ; retour sur le plancher
bien s’orienter (accl [2] < 80) = 6 ; avant sur le plancher
}
retour d’orient ;
}