├── Ndh15Badge ├── .Ndh15Badge.h.swp ├── keywords.txt ├── examples │ ├── DemoCapa │ │ └── DemoCapa.ino │ ├── blinky │ │ └── blinky.ino │ ├── Mouse │ │ └── Mouse.ino │ └── DarkBadge │ │ ├── notes.h │ │ └── DarkBadge.ino ├── Ndh15Badge.h └── Ndh15Badge.cpp └── README.md /Ndh15Badge/.Ndh15Badge.h.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/virtualabs/Ndh15Badge-library/HEAD/Ndh15Badge/.Ndh15Badge.h.swp -------------------------------------------------------------------------------- /Ndh15Badge/keywords.txt: -------------------------------------------------------------------------------- 1 | Badge KEYWORD1 2 | button KEYWORD2 3 | led KEYWORD2 4 | play KEYWORD2 5 | writePage KEYWORD2 6 | readPage KEYWORD2 7 | writeByte KEYWORD2 8 | readByte KEYWORD2 9 | init KEYWORD2 10 | updateAccel KEYWORD2 11 | readX KEYWORD2 12 | readY KEYWORD2 13 | readZ KEYWORD2 14 | -------------------------------------------------------------------------------- /Ndh15Badge/examples/DemoCapa/DemoCapa.ino: -------------------------------------------------------------------------------- 1 | /* Wire is required because the badge uses I2C. */ 2 | #include 3 | 4 | /* Ndh15 badge library. */ 5 | #include 6 | 7 | void setup() 8 | { 9 | Badge.begin(); 10 | } 11 | 12 | void loop() { 13 | uint16_t capa; 14 | 15 | while (1) { 16 | capa = Badge.touch_measure(BTN_2); 17 | if (capa >= 900) { 18 | capa = capa >> 6; 19 | Badge.led(capa&0xff,(0xff - capa&0xff),capa&0xff); 20 | } else { 21 | Badge.led(0,0,0); 22 | } 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Ndh2015 Badge Arduino Library 2 | ============================= 3 | 4 | How to install 5 | -------------- 6 | 7 | Drop the Ndh15Badge folder in your *libraries* folder in your Arduino install (usually */usr/share/arduino/libraries/*), and enjoy ! 8 | 9 | 10 | Moar details about the Ndh 2015 Badge 11 | ------------------------------------- 12 | 13 | This badge is based on an Arduino Micro, same pinout plus extra components: 14 | 15 | * Acclerometer 16 | * RGB Led 17 | * Piezzo buzzer 18 | * EEPROM 19 | 20 | Everything is handled by this library. Components pinout may be found in the source code. 21 | -------------------------------------------------------------------------------- /Ndh15Badge/examples/blinky/blinky.ino: -------------------------------------------------------------------------------- 1 | /* Wire is required because the badge uses I2C. */ 2 | #include 3 | 4 | /* Ndh15 badge library. */ 5 | #include 6 | 7 | void setup() 8 | { 9 | Badge.begin(); 10 | } 11 | 12 | void loop() { 13 | int r=256,g=0,b=0; 14 | /* RED -> GREEN */ 15 | while (r>0) { 16 | g++; 17 | r--; 18 | Badge.led(r,g,b); 19 | delay(3); 20 | } 21 | /* GREEN -> BLUE */ 22 | while (g>0) { 23 | b++; 24 | g--; 25 | Badge.led(r,g,b); 26 | delay(3); 27 | } 28 | /* BLUE -> RED */ 29 | while (b>0) { 30 | b--; 31 | r++; 32 | Badge.led(r,g,b); 33 | delay(3); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /Ndh15Badge/examples/Mouse/Mouse.ino: -------------------------------------------------------------------------------- 1 | /* Wire is required because the badge uses I2C. */ 2 | #include 3 | 4 | /* Ndh15 badge library. */ 5 | #include 6 | 7 | 8 | void setup() 9 | { 10 | /* 11 | We must initialize the mouse (HID) 12 | and the badge hardware to work with 13 | the accelerometer. 14 | */ 15 | Mouse.begin(); 16 | Badge.begin(); 17 | } 18 | 19 | 20 | void loop() 21 | { 22 | int8_t x,y; 23 | 24 | /* Asks the accelerometer about the current X/Y/Z values. */ 25 | Badge.updateAccel(); 26 | 27 | /* Smooth them a bit while keeping signs. */ 28 | x = (int8_t)(Badge.readX()/32); 29 | y = (int8_t)(Badge.readY()/32); 30 | 31 | /* Send the mouse move to the computer. */ 32 | Mouse.move(-y,-x); 33 | 34 | /* If the button 1 is pressed, then click. */ 35 | if (Badge.button(BTN_1)) 36 | { 37 | /* Quick debounce. */ 38 | delay(10); 39 | if (Badge.button(BTN_1)) 40 | Mouse.click(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /Ndh15Badge/Ndh15Badge.h: -------------------------------------------------------------------------------- 1 | #ifndef __INC_NDH15BADGE_H 2 | #define __INC_NDH15BADGE_H 3 | 4 | #include 5 | 6 | /** 7 | * Ndh 2015 Badge Library header. 8 | * 9 | * Defines a single class called Ndh15Badge, implementing all the required 10 | * stuff to have fun with our improved Arduino Micro board. 11 | **/ 12 | 13 | #define byte uint8_t 14 | 15 | #define ACCELERO 0x1D 16 | #define BUZZ 5 17 | #define LED_BLUE 11 18 | #define LED_RED 9 19 | #define LED_GREEN 10 20 | #define BTN_3 PINF0 21 | #define BTN_2 PINF1 22 | #define BTN_1 PINF4 23 | 24 | class Ndh15Badge 25 | { 26 | public: 27 | 28 | /* Constructor. */ 29 | Ndh15Badge(); 30 | void begin(void); 31 | 32 | /* Capacitive buttons. */ 33 | int button(int btn); 34 | uint16_t touch_measure(uint8_t pin); 35 | 36 | /* RGB LED */ 37 | void led(byte red, byte green, byte blue); 38 | 39 | /* Buzzer (music). */ 40 | void play(long freq, long duration); 41 | 42 | /* EEPROM management. */ 43 | int writePage(uint8_t paddr, byte *pdata, int length); 44 | int readPage(uint8_t paddr, byte *pdata, int length); 45 | int writeByte(uint8_t paddr, byte b); 46 | byte readByte(uint8_t paddr); 47 | int readBytes(uint8_t paddr, byte *pdata, int length); 48 | 49 | /* Accelerometer. */ 50 | void updateAccel(void); 51 | int readX(void); 52 | int readY(void); 53 | int readZ(void); 54 | 55 | private: 56 | 57 | /* Accelerometer internals. */ 58 | void accelero_send(uint8_t reg_addr, byte data); 59 | void accelero_read(uint8_t reg_addr); 60 | int m_acc_x; 61 | int m_acc_y; 62 | int m_acc_z; 63 | 64 | /* Capacitive buttons internals. */ 65 | void adc_channel(uint8_t channel); 66 | uint16_t adc_get(void); 67 | 68 | }; 69 | 70 | extern Ndh15Badge Badge; 71 | 72 | #endif /* __INC_NDH15BADGE_H */ 73 | -------------------------------------------------------------------------------- /Ndh15Badge/examples/DarkBadge/notes.h: -------------------------------------------------------------------------------- 1 | /* Notes */ 2 | #define C0 16.35 3 | #define Db0 17.32 4 | #define D0 18.35 5 | #define Eb0 19.45 6 | #define E0 20.60 7 | #define F0 21.83 8 | #define Gb0 23.12 9 | #define G0 24.50 10 | #define Ab0 25.96 11 | #define LA0 27.50 12 | #define Bb0 29.14 13 | #define B0 30.87 14 | #define C1 32.70 15 | #define Db1 34.65 16 | #define D1 36.71 17 | #define Eb1 38.89 18 | #define E1 41.20 19 | #define F1 43.65 20 | #define Gb1 46.25 21 | #define G1 49.00 22 | #define Ab1 51.91 23 | #define LA1 55.00 24 | #define Bb1 58.27 25 | #define B1 61.74 26 | #define C2 65.41 27 | #define Db2 69.30 28 | #define D2 73.42 29 | #define Eb2 77.78 30 | #define E2 82.41 31 | #define F2 87.31 32 | #define Gb2 92.50 33 | #define G2 98.00 34 | #define Ab2 103.83 35 | #define LA2 110.00 36 | #define Bb2 116.54 37 | #define B2 123.47 38 | #define C3 130.81 39 | #define Db3 138.59 40 | #define D3 146.83 41 | #define Eb3 155.56 42 | #define E3 164.81 43 | #define F3 174.61 44 | #define Gb3 185.00 45 | #define G3 196.00 46 | #define Ab3 207.65 47 | #define LA3 220.00 48 | #define Bb3 233.08 49 | #define B3 246.94 50 | #define C4 261.63 51 | #define Db4 277.18 52 | #define D4 293.66 53 | #define Eb4 311.13 54 | #define E4 329.63 55 | #define F4 349.23 56 | #define Gb4 369.99 57 | #define G4 392.00 58 | #define Ab4 415.30 59 | #define LA4 440.00 60 | #define Bb4 466.16 61 | #define B4 493.88 62 | #define C5 523.25 63 | #define Db5 554.37 64 | #define D5 587.33 65 | #define Eb5 622.25 66 | #define E5 659.26 67 | #define F5 698.46 68 | #define Gb5 739.99 69 | #define G5 783.99 70 | #define Ab5 830.61 71 | #define LA5 880.00 72 | #define Bb5 932.33 73 | #define B5 987.77 74 | #define C6 1046.50 75 | #define Db6 1108.73 76 | #define D6 1174.66 77 | #define Eb6 1244.51 78 | #define E6 1318.51 79 | #define F6 1396.91 80 | #define Gb6 1479.98 81 | #define G6 1567.98 82 | #define Ab6 1661.22 83 | #define LA6 1760.00 84 | #define Bb6 1864.66 85 | #define B6 1975.53 86 | #define C7 2093.00 87 | #define Db7 2217.46 88 | #define D7 2349.32 89 | #define Eb7 2489.02 90 | #define E7 2637.02 91 | #define F7 2793.83 92 | #define Gb7 2959.96 93 | #define G7 3135.96 94 | #define Ab7 3322.44 95 | #define LA7 3520.01 96 | #define Bb7 3729.31 97 | #define B7 3951.07 98 | #define C8 4186.01 99 | #define Db8 4434.92 100 | #define D8 4698.64 101 | #define Eb8 4978.03 102 | 103 | // DURATION OF THE NOTES 104 | #define BPM 120 // you can change this value changing all the others 105 | #define H 2*Q //half 2/4 106 | #define Q 40000/BPM //quarter 1/4 107 | #define E Q/2 //eighth 1/8 108 | #define S Q/4 // sixteenth 1/16 109 | #define W 4*Q // whole 4/4 110 | -------------------------------------------------------------------------------- /Ndh15Badge/examples/DarkBadge/DarkBadge.ino: -------------------------------------------------------------------------------- 1 | /* Wire is required because the badge uses I2C. */ 2 | #include 3 | 4 | /* Ndh15 badge library. */ 5 | #include 6 | #include "notes.h" 7 | 8 | void setup() 9 | { 10 | Badge.begin(); 11 | } 12 | 13 | /* Dirty port of an arduino code to Ndh15Badge lib. */ 14 | void tone(int pin, float freq, float duration) { 15 | Badge.play(freq, duration); 16 | } 17 | 18 | void loop() 19 | { 20 | tone(8,LA3,Q); 21 | delay(1+Q); //delay duration should always be 1 ms more than the note in order to separate them. 22 | tone(8,LA3,Q); 23 | delay(1+Q); 24 | tone(8,LA3,Q); 25 | delay(1+Q); 26 | tone(8,F3,E+S); 27 | delay(1+E+S); 28 | tone(8,C4,S); 29 | delay(1+S); 30 | 31 | tone(8,LA3,Q); 32 | delay(1+Q); 33 | tone(8,F3,E+S); 34 | delay(1+E+S); 35 | tone(8,C4,S); 36 | delay(1+S); 37 | tone(8,LA3,H); 38 | delay(1+H); 39 | 40 | tone(8,E4,Q); 41 | delay(1+Q); 42 | tone(8,E4,Q); 43 | delay(1+Q); 44 | tone(8,E4,Q); 45 | delay(1+Q); 46 | tone(8,F4,E+S); 47 | delay(1+E+S); 48 | tone(8,C4,S); 49 | delay(1+S); 50 | 51 | tone(8,Ab3,Q); 52 | delay(1+Q); 53 | tone(8,F3,E+S); 54 | delay(1+E+S); 55 | tone(8,C4,S); 56 | delay(1+S); 57 | tone(8,LA3,H); 58 | delay(1+H); 59 | 60 | tone(8,LA4,Q); 61 | delay(1+Q); 62 | tone(8,LA3,E+S); 63 | delay(1+E+S); 64 | tone(8,LA3,S); 65 | delay(1+S); 66 | tone(8,LA4,Q); 67 | delay(1+Q); 68 | tone(8,Ab4,E+S); 69 | delay(1+E+S); 70 | tone(8,G4,S); 71 | delay(1+S); 72 | 73 | tone(8,Gb4,S); 74 | delay(1+S); 75 | tone(8,E4,S); 76 | delay(1+S); 77 | tone(8,F4,E); 78 | delay(1+E); 79 | delay(1+E);//PAUSE 80 | tone(8,Bb3,E); 81 | delay(1+E); 82 | tone(8,Eb4,Q); 83 | delay(1+Q); 84 | tone(8,D4,E+S); 85 | delay(1+E+S); 86 | tone(8,Db4,S); 87 | delay(1+S); 88 | 89 | tone(8,C4,S); 90 | delay(1+S); 91 | tone(8,B3,S); 92 | delay(1+S); 93 | tone(8,C4,E); 94 | delay(1+E); 95 | delay(1+E);//PAUSE QUASI FINE RIGA 96 | tone(8,F3,E); 97 | delay(1+E); 98 | tone(8,Ab3,Q); 99 | delay(1+Q); 100 | tone(8,F3,E+S); 101 | delay(1+E+S); 102 | tone(8,LA3,S); 103 | delay(1+S); 104 | 105 | tone(8,C4,Q); 106 | delay(1+Q); 107 | tone(8,LA3,E+S); 108 | delay(1+E+S); 109 | tone(8,C4,S); 110 | delay(1+S); 111 | tone(8,E4,H); 112 | delay(1+H); 113 | 114 | tone(8,LA4,Q); 115 | delay(1+Q); 116 | tone(8,LA3,E+S); 117 | delay(1+E+S); 118 | tone(8,LA3,S); 119 | delay(1+S); 120 | tone(8,LA4,Q); 121 | delay(1+Q); 122 | tone(8,Ab4,E+S); 123 | delay(1+E+S); 124 | tone(8,G4,S); 125 | delay(1+S); 126 | 127 | tone(8,Gb4,S); 128 | delay(1+S); 129 | tone(8,E4,S); 130 | delay(1+S); 131 | tone(8,F4,E); 132 | delay(1+E); 133 | delay(1+E);//PAUSE 134 | tone(8,Bb3,E); 135 | delay(1+E); 136 | tone(8,Eb4,Q); 137 | delay(1+Q); 138 | tone(8,D4,E+S); 139 | delay(1+E+S); 140 | tone(8,Db4,S); 141 | delay(1+S); 142 | 143 | tone(8,C4,S); 144 | delay(1+S); 145 | tone(8,B3,S); 146 | delay(1+S); 147 | tone(8,C4,E); 148 | delay(1+E); 149 | delay(1+E);//PAUSE QUASI FINE RIGA 150 | tone(8,F3,E); 151 | delay(1+E); 152 | tone(8,Ab3,Q); 153 | delay(1+Q); 154 | tone(8,F3,E+S); 155 | delay(1+E+S); 156 | tone(8,C4,S); 157 | delay(1+S); 158 | 159 | tone(8,LA3,Q); 160 | delay(1+Q); 161 | tone(8,F3,E+S); 162 | delay(1+E+S); 163 | tone(8,C4,S); 164 | delay(1+S); 165 | tone(8,LA3,H); 166 | delay(1+H); 167 | 168 | delay(2*H); 169 | } 170 | -------------------------------------------------------------------------------- /Ndh15Badge/Ndh15Badge.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Ndh 2015 Badge 3 | * 4 | * Main library file. 5 | * 6 | * Defines everything required to have fun with the badge. 7 | **/ 8 | 9 | #include "Arduino.h" 10 | #include "../Wire/Wire.h" 11 | #include "Ndh15Badge.h" 12 | 13 | 14 | /** 15 | * Constructor. 16 | * 17 | * Sets up the pin modes and ADC. 18 | * 19 | * Note that the accelerometer must be set in the setup() callback 20 | * instead of this routine, otherwise it will hang. 21 | */ 22 | 23 | Ndh15Badge::Ndh15Badge() 24 | { 25 | } 26 | 27 | 28 | void Ndh15Badge::begin(void) 29 | { 30 | /* Initialize I2C. */ 31 | Wire.begin(); 32 | 33 | /* Initialize buttons. */ 34 | ADMUX |= (1<accelero_send(0x2A, 0x00); 52 | delay(10); 53 | 54 | /* 2G full range mode. */ 55 | this->accelero_send(0x0E, B00000000); 56 | delay(1); 57 | 58 | /* Enable. */ 59 | this->accelero_send(0x2A, B00000001); 60 | delay(1); 61 | 62 | } 63 | 64 | 65 | /** 66 | * play 67 | * 68 | * Plays a note based on its frequency and duration. 69 | * A custom Tone lib replacement, but works well. 70 | */ 71 | 72 | void Ndh15Badge::play(long freq, long duration) 73 | { 74 | long delayValue = 1000000 / freq / 2; // calculate the delay value between transitions 75 | //// 1 second's worth of microseconds, divided by the frequency, then split in half since 76 | //// there are two phases to each cycle 77 | long numCycles = freq * duration / 1000; // calculate the number of cycles for proper timing 78 | //// multiply frequency, which is really cycles per second, by the number of seconds to 79 | //// get the total number of cycles to produce 80 | for (long i = 0; i < numCycles; i++) { // for the calculated length of time... 81 | digitalWrite(BUZZ, HIGH); // write the buzzer pin high to push out the diaphram 82 | delayMicroseconds(delayValue); // wait for the calculated delay value 83 | digitalWrite(BUZZ, LOW); // write the buzzer pin low to pull back the diaphram 84 | delayMicroseconds(delayValue); // wait again or the calculated delay value 85 | } 86 | } 87 | 88 | /********************************************** 89 | * Capacitive buttons routines 90 | *********************************************/ 91 | 92 | /** 93 | * adc_channel 94 | * 95 | * Select channel for ADC. 96 | **/ 97 | 98 | void Ndh15Badge::adc_channel(uint8_t channel) 99 | { 100 | ADMUX &= ~(0b11111); 101 | ADMUX |= 0b11111 & channel; 102 | } 103 | 104 | 105 | /** 106 | * adc_get 107 | * 108 | * Get value from ADC for a selected channel. 109 | **/ 110 | 111 | uint16_t Ndh15Badge::adc_get(void) 112 | { 113 | ADCSRA |= (1<adc_channel(0b11111); //set ADC mux to ground; 140 | this->adc_get(); //do a measurement (to discharge the sampling cap) 141 | 142 | this->adc_channel(pin); //set mux to right channel 143 | retval += adc_get(); //do a conversion 144 | } 145 | return retval /4; 146 | } 147 | 148 | /** 149 | * button 150 | * 151 | * Detect if a button is pressed or not. This is pure all or nothing logic. 152 | **/ 153 | 154 | int Ndh15Badge::button(int pin) 155 | { 156 | if (pin == BTN_1) 157 | return (this->touch_measure(pin)<1015); 158 | else 159 | return (this->touch_measure(pin) >= 900); 160 | } 161 | 162 | 163 | /** 164 | * led 165 | * 166 | * Drives the RGB led. 167 | * 168 | * RGB values must be in 0-255 range. 169 | **/ 170 | 171 | void Ndh15Badge::led(byte red, byte green, byte blue) 172 | { 173 | analogWrite(LED_RED, 255 - red); 174 | analogWrite(LED_GREEN, 255 - green); 175 | analogWrite(LED_BLUE, 255 - blue); 176 | } 177 | 178 | /** 179 | * writeByte 180 | * 181 | * Write a byte to the external flash memory at a given page address. 182 | **/ 183 | 184 | int Ndh15Badge::writeByte(uint8_t paddr, byte b) 185 | { 186 | return this->writePage(paddr, &b, 1); 187 | } 188 | 189 | 190 | /** 191 | * readByte 192 | * 193 | * Read byte from the external flash memory at a given page address. 194 | **/ 195 | 196 | byte Ndh15Badge::readByte(uint8_t paddr) 197 | { 198 | byte b; 199 | this->readPage(paddr, &b, 1); 200 | return b; 201 | } 202 | 203 | /** 204 | * writePage 205 | * 206 | * Write up to 8 bytes at a given page address to the ext. flash memory. 207 | **/ 208 | 209 | int Ndh15Badge::writePage(uint8_t paddr, byte *pdata, int length) 210 | { 211 | /* Must write between 1 and 8 bytes. */ 212 | if ((length <= 0) || (length > 8)) 213 | return -1; 214 | 215 | /* Write page. */ 216 | Wire.beginTransmission(0x50); 217 | Wire.write((int)(paddr & 0xFF)); 218 | byte c; 219 | for (c=0; c 8)) 241 | return -1; 242 | Wire.beginTransmission(0x50); 243 | Wire.write((int)(paddr & 0xFF)); // LSB 244 | Wire.endTransmission(); 245 | Wire.requestFrom(0x50,length); 246 | int c = 0; 247 | //for ( c = 0; c < length; c++ ) 248 | while(creadPage(paddr+i*8, &pdata[i*8], 8) != 8) 265 | return -1; 266 | /* Read left bytes. */ 267 | for (i=nb_blocks*8;i<(nb_blocks*8)+left;i++) 268 | pdata[i] = this->readByte(paddr+i); 269 | 270 | return length; 271 | } 272 | 273 | /** 274 | * accelero_send 275 | * 276 | * Internal routine to send commands to the accelerometer. 277 | **/ 278 | 279 | void Ndh15Badge::accelero_send(unsigned char reg_addr, unsigned char data) 280 | { 281 | Wire.beginTransmission(ACCELERO); 282 | Wire.write(reg_addr); 283 | Wire.write(data); 284 | Wire.endTransmission(); 285 | } 286 | 287 | 288 | /** 289 | * accelero_read 290 | * 291 | * Internal routine to get data from the accelerometer. 292 | **/ 293 | 294 | void Ndh15Badge::accelero_read(uint8_t reg_addr) 295 | { 296 | byte ACC_STATUS[7]; 297 | int accel[4]; 298 | int i=0; 299 | 300 | /* Read status from acclerometer. */ 301 | Wire.beginTransmission(ACCELERO); 302 | Wire.write(reg_addr); 303 | Wire.endTransmission(); 304 | Wire.requestFrom(ACCELERO, 7); 305 | for (i=0; i<7; i++) 306 | ACC_STATUS[i] = Wire.read(); 307 | 308 | /* Parse answer. */ 309 | for (i=1; i<7; i=i+2) 310 | { 311 | accel[0] = (ACC_STATUS[i+1]|((int)ACC_STATUS[i]<<8))>>6; // X axis 312 | if (accel[0] > 0x01FF) 313 | accel[1] = (((~accel[0])+1)- 0xFC00); 314 | else 315 | accel[1] = accel[0]; 316 | switch(i) 317 | { 318 | case 1: 319 | this->m_acc_x = accel[1]; 320 | break; 321 | 322 | case 3: 323 | this->m_acc_y = accel[1]; 324 | break; 325 | 326 | case 5: 327 | this->m_acc_z = accel[1]; 328 | break; 329 | } 330 | } 331 | } 332 | 333 | 334 | /** 335 | * accelero_init 336 | * 337 | * Initialize the accelerometer. Must be called by the setup() callback. 338 | **/ 339 | 340 | /** 341 | * updateAccel 342 | * 343 | * Retrieve data from the accelerometer. 344 | **/ 345 | 346 | void Ndh15Badge::updateAccel(void) 347 | { 348 | /* Read values from accelerometer. */ 349 | this->accelero_read(0x00); 350 | } 351 | 352 | 353 | /** 354 | * readX 355 | * 356 | * Return the last X-axis value from the accelerometer. 357 | **/ 358 | 359 | int Ndh15Badge::readX(void) 360 | { 361 | return this->m_acc_x; 362 | } 363 | 364 | 365 | /** 366 | * readY 367 | * 368 | * Return the last Y-axis value from the accelerometer. 369 | **/ 370 | 371 | int Ndh15Badge::readY(void) 372 | { 373 | return this->m_acc_y; 374 | } 375 | 376 | 377 | /** 378 | * readZ 379 | * 380 | * Return the last Z-axis value from the accelerometer. 381 | **/ 382 | 383 | int Ndh15Badge::readZ(void) 384 | { 385 | return this->m_acc_z; 386 | } 387 | 388 | Ndh15Badge Badge = Ndh15Badge(); 389 | --------------------------------------------------------------------------------