API tools faq
paste
Advertisement
NicoVape

Untitled

NicoVape
Feb 21st, 2019
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 10.08 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!