SHARE
TWEET

Untitled

NicoVape Feb 21st, 2019 (edited) 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*ArduiBox firmware
  2. * Rev 1.0 Alpha
  3. * Still buggy
  4. * Setup loop : line 20 to 38
  5. * Main loop : line 46 to 129
  6. * Sub routines : line 132 to 264
  7. */
  8.  
  9. // 1 - includes for functions
  10. #include "ClickButton.h"
  11.  
  12. #include <U8g2lib.h>
  13. #include <U8x8lib.h>
  14. U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);
  15. #include "system_vars.h"
  16. #include <Wire.h>
  17. #include <ADXL335.h>
  18.  
  19. // 2 - Display driver selection
  20.  
  21.  
  22. // 3 - Multiclick init
  23. ClickButton fireSwitch(FIRE_SW_PIN, LOW, CLICKBTN_PULLUP);
  24.  
  25.  
  26. // 4 - Begin setup
  27. void setup()
  28. {
  29.   fireSwitch.debounceTime = 15; // debounce interval
  30.   fireSwitch.multiclickTime = 250; // multiclick interval
  31.   fireSwitch.longClickTime = 10000; // 10 sec fire cut-off
  32.   pinMode(FIRE_SW_PIN, INPUT_PULLUP); // setting Fire Pin as Input
  33.  
  34.   pinMode(BATTERY_READ_PIN, INPUT); // setting Battery Voltage reading as Input
  35.   pinMode(PWM_OUT_PIN, OUTPUT); // setting the PWM pin to Output
  36.   u8g2.begin();
  37.   u8g2.setFontMode(0);
  38.   u8g2.setFont(u8g2_font_lucasarts_scumm_subtitle_o_tf);
  39.   u8g2.setFontPosTop(); // Fonts origin
  40.   analogReference(DEFAULT); // For voltage ref
  41.   ADXL335 accelerometer;
  42.   // Mettre le ADXL345 à plage +/-4G en écrivant la valeur 0x01 dans le
  43.   // registre DATA_FORMAT.
  44.   AccellerometreConfigure (DATA_FORMAT, Accellerometre_1_Precision4G);
  45.   // Mettre le ADXL345 en mode de mesure en écrivant 0x08 dans le registre
  46.   // POWER_CTL.
  47.   AccellerometreConfigure (POWER_CTL, Accellerometre_1_ModeMesure);
  48.   u8g2.firstPage();
  49.  
  50.   u8g2.setFont(u8g2_font_lucasarts_scumm_subtitle_o_tf);
  51.   do {
  52.     u8g2.drawStr( 22, 0, "NicoVape");
  53.     u8g2.drawStr( 7, 18, "Minikin BHM");
  54.    
  55.   } while ( u8g2.nextPage() );
  56.   delay(4500);
  57.  
  58. };
  59.  
  60.  
  61. //////////////////////
  62. // Start of program //
  63. //////////////////////
  64.  
  65. void loop()
  66. {
  67.   u8g2.firstPage();
  68.   AccellerometreLecture ();
  69.   // reading input states and transfer to vars
  70.   fireState = digitalRead(FIRE_SW_PIN);
  71.   fireState = !fireState;
  72.  
  73.   if ( fireState == LOW ){
  74.       analogWrite(PWM_OUT_PIN, 0);
  75.   };
  76.  
  77.   if ( fireState == HIGH ){
  78.       u8g2.setPowerSave(0);
  79.   }
  80.    
  81.   // Processing fire clicks
  82.   fireSwitch.Update();
  83.   if (fireSwitch.clicks != 0){
  84.     fireClicks = fireSwitch.clicks;
  85.     //Serial.print(fireClicks);
  86.   };
  87.   avgVolts = ((battVolt * pwmRatio) / 100);
  88. //  AfficheMenu.select(fireSwitch.clicks, battVolt, pwmRatio, avgVolts, PWM_OUT_PIN, logo);
  89.  
  90.   // sleeping display for stealth
  91.  
  92.  
  93. if ((fireClicks == 3) && (lock == 0)){
  94.   if (menuMode == 0){
  95.     menuMode = 1;
  96.     fireClicks = 0;
  97.     //Serial.println("menuMode 1");
  98.   } else {
  99.     menuMode = 0;
  100.     fireClicks = 0;
  101.     currentTimeDisp = millis();
  102.     //Serial.println("menuMode 0");
  103.   }
  104.  }
  105.  
  106. if (fireClicks == 5){
  107.   if ((lock == 0) && (longHold !=1)){
  108.     lock = 1;
  109.     fireClicks = 0;
  110.     //Serial.println("lock 1");
  111.   } else {
  112.     lock = 0;
  113.     fireClicks = 0;
  114.     longHold = 0;
  115.     //Serial.println("lock 0");
  116.   }
  117.  }
  118.  
  119. if (fireClicks == -1){
  120.   if (longHold == 0){
  121.     longHold = 1;
  122.     fireClicks = 0;
  123.     //Serial.println("longHold 1");
  124.   }
  125.  }
  126.  
  127.   if (menuMode == 1) {
  128.     int Posi = Accelerometre1_AxeY;
  129.     if ((Posi < -65) && (Posi < -30)){
  130.       currentTimePwm = millis();
  131.       if (currentTimePwm - previousTimePwm >= PwmTime2) {
  132.         previousTimePwm = currentTimePwm;
  133.         //Serial.println("Down x2");
  134.         pwmChange( 2.55 );
  135.       };
  136.     } else if ((Posi < -35) && (Posi < -10)){
  137.       currentTimePwm = millis();
  138.       if (currentTimePwm - previousTimePwm >= PwmTime2) {
  139.         previousTimePwm = currentTimePwm;
  140.         //Serial.println("Down");
  141.         pwmChange( 2.55 );
  142.       };
  143.     } else if (Posi > 65){
  144.        currentTimePwm = millis();
  145.        if (currentTimePwm - previousTimePwm >= PwmTime2) {
  146.         previousTimePwm = currentTimePwm;
  147.         //Serial.println("Up x2");
  148.         pwmChange( -2.55 );
  149.        };
  150.     } else if (Posi > 35){
  151.        currentTimePwm = millis();
  152.        if (currentTimePwm - previousTimePwm >= PwmTime) {
  153.         previousTimePwm = currentTimePwm;
  154.         //Serial.println("Up");
  155.         pwmChange( -2.55 );
  156.     };
  157.     };
  158.   }
  159.   fire_event();
  160.   // processing Battery voltage reading and calcs
  161.   battValue = analogRead(BATTERY_READ_PIN);
  162.   battVolt = (battValue * batteryVoltAref) / 1024;
  163.   //Serial.println(battVolt);
  164.   pwmRatio = (pwmValue * 100)/255;
  165.   percentRatio = ((pwmRatio * battVolt) / 100);
  166.   currentTime = millis();
  167.  
  168.   // Low Battery detection
  169.   if (currentTime - previousTime >= stepForLowBatt) {
  170.     previousTime = currentTime;
  171.     if (battVolt <= cuttOff) {
  172.       lowBatt = 1;
  173.     };
  174.   };
  175.  
  176.   // processing display
  177.  
  178.   do {
  179.     menuSelect();
  180.     //sleepDisplayFct();
  181.   } while ( u8g2.nextPage() );
  182.  
  183.  
  184. };
  185.  
  186.  
  187. //-----------------------//
  188. // start of sub routines //
  189. //-----------------------//
  190. void menuSelect()
  191. {
  192.     if (menuMode == 1){
  193.         tune_screen();
  194.       } else if (lock == 1){
  195.         lock_screen();
  196.       } else if (longHold == 1){
  197.         long_screen();
  198.       } else if (lowBatt == 1){
  199.         low_batterie();
  200.       } else {
  201.         main_screen();
  202.       };
  203. }
  204.  
  205. void sleepDisplayFct()
  206. {
  207.   if (menuMode == 0){
  208.     currentTimeDisp = millis();
  209.     if (currentTimeDisp - previousTimeDisp >= sleepDisplay){
  210.       u8g2.setPowerSave(1);
  211.       previousTimeDisp = currentTimeDisp;
  212.     }
  213.   }
  214. }
  215.  
  216. void fire_event()
  217. {
  218.    
  219.   // Fire clearance and output to Mosfet
  220.   if ( fireState == HIGH && menuMode == 0){
  221.       analogWrite(PWM_OUT_PIN, pwmValue);
  222.      
  223.     } else if ( fireState == HIGH && lowBatt == 1) {
  224.       analogWrite(PWM_OUT_PIN, 0);
  225.      
  226.     } else if ( fireState == HIGH && lock == 1) {
  227.       analogWrite(PWM_OUT_PIN, 0);
  228.    
  229.     } else if ( fireState == HIGH  && menuMode == 1){
  230.       analogWrite(PWM_OUT_PIN, 0);
  231.    
  232.     } else if ( fireState == LOW ){
  233.       analogWrite(PWM_OUT_PIN, 0);
  234.    
  235.     };
  236. }
  237. void pwmChange (int internalValue)
  238. //
  239. // low and high stops for PWM consigne
  240. //
  241. {
  242.     pwmValue += internalValue;
  243.     if (pwmValue > 255){
  244.       pwmValue = 255;
  245.     } else if (pwmValue < 0){
  246.       pwmValue = 0;
  247.     };
  248. }
  249.  
  250. //*****************************************************************************
  251. // FONCTION AccellerometreConfigure
  252. //*****************************************************************************
  253. void AccellerometreConfigure (byte address, byte val)
  254. {
  255.   // Commencer la transmission à trois axes accéléromètre
  256.   Wire.beginTransmission (Accellerometre3AxesAdresse);
  257.   // Envoyer l'adresse de registre
  258.   Wire.write (address);
  259.   // Envoyer la valeur à écrire.
  260.   Wire.write (val);
  261.   // Fin de la transmission.
  262.   Wire.endTransmission ();
  263. }
  264.  
  265. //*****************************************************************************
  266. // FONCTION AccellerometreLecture ()
  267. //*****************************************************************************
  268. void AccellerometreLecture ()
  269. {
  270.   uint8_t NombreOctets_a_Lire = 6;
  271.   // Lire les données d'accélération à partir du module ADXL345.
  272.   AccellerometreLectureMemoire (DATAX0, NombreOctets_a_Lire,
  273.                                 Accellerometre3AxesMemoire);
  274.  
  275.   // Chaque lecture de l'axe vient dans une résolution de 10 bits, soit 2 octets.
  276.   // Première Octet significatif !
  277.   // Donc nous convertissons les deux octets pour un « int ».
  278.   Accelerometre1_AxeX = (((int)Accellerometre3AxesMemoire[1]) << 8) |
  279.       Accellerometre3AxesMemoire[0];
  280.   Accelerometre1_AxeY = (((int)Accellerometre3AxesMemoire[3]) << 8) |
  281.       Accellerometre3AxesMemoire[2];
  282.   Accelerometre1_AxeZ = (((int)Accellerometre3AxesMemoire[5]) << 8) |
  283.       Accellerometre3AxesMemoire[4];
  284. }
  285. //*****************************************************************************
  286. // FONCTION AccellerometreLectureMemoire
  287. //*****************************************************************************
  288. void AccellerometreLectureMemoire (byte address, int num, byte
  289.                                    Accellerometre3AxesMemoire[])
  290. {
  291.   // Démarrer la transmission à accéléromètre.
  292.   Wire.beginTransmission (Accellerometre3AxesAdresse);
  293.   // Envoie l'adresse de lire.
  294.   Wire.write (address);
  295.   // Fin de la transmission.
  296.   Wire.endTransmission ();
  297.   // Démarrer la transmission à accéléromètre.
  298.   Wire.beginTransmission (Accellerometre3AxesAdresse);
  299.   // Demande 6 octets à l'accéléromètre.
  300.   Wire.requestFrom (Accellerometre3AxesAdresse, num);
  301.  
  302.   int i = 0;
  303.   // L'accéléromètre peut envoyer moins que demandé, c'est anormal, mais...
  304.   while (Wire.available())
  305.   {
  306.     // Recevoir un octet.
  307.     Accellerometre3AxesMemoire[i] = Wire.read ();
  308.     i++;
  309.   }
  310.     // Fin de la transmission.
  311.   Wire.endTransmission ();
  312. }
  313.  
  314.  
  315. void main_screen()
  316. {
  317.     u8g2.setFont(u8g2_font_lucasarts_scumm_subtitle_o_tf);
  318.     u8g2.drawStr( 1, 1, "Batt :");
  319.     float level = battVolt;
  320.     int levelclc = round(level*100/8.4);
  321.     int levelBx = map(levelclc,0,100,0,70);
  322.     u8g2.drawRFrame(55,3,70,10,3);
  323.     u8g2.drawBox(60,3,levelBx,10);
  324.     u8g2.drawStr( 1, 18, "Power % :");
  325.     u8g2.setCursor( 92, 18 );
  326.     u8g2.print(pwmRatio);
  327.     //u8g2.drawStr( 1, 23, "Avg Volts :");
  328.     //u8g2.setCursor( 90, 23 );
  329.     avgVolts = ((battVolt * pwmRatio) / 100);
  330.     //u8g2.print(avgVolts);
  331. }
  332. void tune_screen()
  333. {
  334.     u8g2.setFont(u8g2_font_profont15_tf);
  335.     //u8g2.drawStr( 1, 1, "Reglage puissance");
  336.     u8g2.drawStr( 25, 1, "Power :");
  337.     u8g2.setCursor( 85, 1 );
  338.     u8g2.print(pwmRatio);
  339.     u8g2.setFont(u8g2_font_profont11_tf);
  340.     u8g2.drawStr( 3, 13, "+ droite / - gauche");
  341.     u8g2.setFont(u8g2_font_profont11_tf);
  342.     u8g2.drawStr( 1, 23, "3 clics pour valider");
  343.    
  344. }
  345. void lock_screen()
  346. {
  347.    analogWrite(PWM_OUT_PIN, 0);
  348.    u8g2.drawStr( 0, 0, "Lock device !");
  349.    u8g2.drawStr( 0, 18, "Unlock Clic 5 ");
  350. }
  351. void long_screen()
  352. {
  353.    analogWrite(PWM_OUT_PIN, 0);
  354.    u8g2.drawStr( 0, 0, "Long Fire !");
  355.    u8g2.drawStr( 0, 18, "Unlock Clic 5");
  356. }
  357.  
  358. void low_batterie()
  359. {
  360.    analogWrite(PWM_OUT_PIN, 0);
  361.    u8g2.drawStr( 0, 0, "Low battery  !");
  362.    u8g2.drawStr( 0, 18, "Replace it !");
  363. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top