Facebook

Re: Arduino 3x Capacity Tester safest cryptocurrency exchange

From Wet Giraffe, 1 Year ago, written in Plain Text.
This paste is a reply to Arduino 3x Capacity Tester from BihJonCoop - view diff
URL https://pastebin.pl/view/c0bbb12b
Embed
Download Paste or View Raw
Hits: 193
  1. #include <LiquidCrystal_I2C.h>
  2. #include <SPI.h>
  3. LiquidCrystal_I2C lcd(0x3F, 16, 2);
  4. #define M1 5
  5. #define M2 4
  6. #define M3 3
  7. #define D1 10
  8. #define D2 9
  9. #define D3 8
  10. #define BUZZER 7
  11. #define B1_high A0
  12. #define B2_high A1
  13. #define B3_high A2
  14. #define Button 2
  15.  
  16. int buttonState = 0;
  17. int printStart = 0;
  18. int interval = 5000;  // Measurement Interwal (ms)
  19. float battLow = 2.8;   // End of measurement - voltage level
  20. float voltRef = 4.37;  // Reference voltage (pin 5V)
  21.  
  22. int l=0;
  23. boolean finished1 = false;
  24. boolean finished2 = false;
  25. boolean finished3 = false;
  26.  
  27. float mAh1 = 0;
  28. float mAh2 = 0;
  29. float mAh3 = 0;
  30. int poj1 = 0;
  31. int poj2 = 0;
  32. int poj3 = 0;
  33. float R1 = 4;  // Resistor R1 value [Ohm]
  34. float RB1 = 4.1; // Measured B1 circuit resistance [Ohm]
  35. float R2 = 4;  // Resistor R1 value [Ohm]
  36. float RB2 = 4.1; // Measured B2 circuit resistance [Ohm]
  37. float R3 = 4;  // Resistor R1 value [Ohm]
  38. float RB3 = 4.1; // Measured B3 circuit resistance [Ohm]
  39. float current1 = 0.0;
  40. float current2 = 0.0;
  41. float current3 = 0.0;
  42. float B1start = 0.0;
  43. float B2start = 0.0;
  44. float B3start = 0.0;
  45. float B1V1 = 0.0;  // voltage before R1
  46. float B2V1 = 0.0;  // voltage before R2
  47. float B3V1 = 0.0;  // voltage before R3
  48. float Rw1 = 0;
  49. float Rw2 = 0;
  50. float Rw3 = 0;
  51. float roznica1 = 0;
  52. float roznica2 = 0;
  53. float roznica3 = 0;
  54. float suma1 = 0;
  55. float suma2 = 0;
  56. float suma3 = 0;
  57. float X1 = 2; // voltage divider 1 ratio
  58. float X2 = 2; // voltage divider 2 ratio
  59. float X3 = 2; // voltage divider 3 ratio
  60.  
  61. int pomiar = 0;
  62. int k;
  63. boolean menu1_end = false;
  64. boolean menu_end = false;
  65. int mode = 0;
  66.  
  67. unsigned long previousMillis1 = 0;
  68. unsigned long previousMillis2 = 0;
  69. unsigned long previousMillis3 = 0;
  70. unsigned long millisPassed1 = 0;
  71. unsigned long millisPassed2 = 0;
  72. unsigned long millisPassed3 = 0;
  73.  
  74. void setup() {
  75.  
  76.   lcd.init();
  77.   lcd.backlight();
  78.   pinMode(M1, OUTPUT);
  79.   pinMode(M2, OUTPUT);
  80.   pinMode(M3, OUTPUT);
  81.   pinMode(D1, OUTPUT);
  82.   pinMode(D2, OUTPUT);
  83.   pinMode(D3, OUTPUT);
  84.   pinMode(BUZZER, OUTPUT);
  85.   digitalWrite(M1, LOW);
  86.   digitalWrite(M2, LOW);
  87.   digitalWrite(M3, LOW);
  88.   digitalWrite(D1, LOW);
  89.   digitalWrite(D2, LOW);
  90.   digitalWrite(D3, LOW);
  91.   menu();  // enter the menu
  92.   lcd.print("Battery test");
  93.   lcd.setCursor(0, 1);
  94.   lcd.print("Please wait");
  95.   delay(2000);
  96.   B1start = X1 * analogRead(B1_high) * voltRef / 1024.0; // B1 voltage - no load applied
  97.   B2start = X2 * analogRead(B2_high) * voltRef / 1024.0; // B2 voltage - no load applied
  98.   B3start = X3 * analogRead(B3_high) * voltRef / 1024.0; // B3 voltage - no load applied
  99.   lcd.clear();
  100.  
  101.   finished1 = false;
  102.   finished2 = false;
  103.   finished3 = false;
  104.   digitalWrite(BUZZER, HIGH);
  105.   delay(500);
  106.   digitalWrite(BUZZER, LOW);
  107.  
  108. }
  109.  
  110. void loop() {
  111.  
  112.   if(mode == 1){
  113.     test();
  114.   }
  115.   if(mode == 2){
  116.     discharge();
  117.   }
  118. }
  119. ////////////////////////////////////////////////////////////////////////////////////////////////
  120. void discharge() {
  121.   B1V1 = X1 * analogRead(B1_high) * voltRef / 1024.0; // B1 voltage
  122.   B2V1 = X2 * analogRead(B2_high) * voltRef / 1024.0; // B2 voltage
  123.   B3V1 = X3 * analogRead(B3_high) * voltRef / 1024.0; // B3 voltage
  124.  
  125.   if ((finished1 == true) && (finished2 == true) && (finished3 == true)) {
  126.     if(l < 3){
  127.       for (k = 0; k < 3; k++) {
  128.         digitalWrite(BUZZER, HIGH);
  129.         delay(200);
  130.         digitalWrite(BUZZER, LOW);
  131.         delay(200);
  132.     }
  133.       l++;
  134.     }
  135.   }
  136.  
  137.   if (B1V1 >= battLow && finished1 == false)
  138.   {
  139.     digitalWrite(M1, HIGH);
  140.     digitalWrite(D1, HIGH);
  141.  
  142.     lcd.setCursor(0, 0);
  143.     lcd.print("1:");
  144.     lcd.print(B1V1);
  145.     lcd.print("V");
  146.   }
  147.   if ((B1V1 < battLow) || (finished1 == true)) // Disconnects load, prints the result
  148.   {
  149.     digitalWrite(M1, LOW);
  150.  
  151.     finished1 = true;
  152.  
  153.     digitalWrite(D1, LOW);
  154.     lcd.setCursor(0, 0);
  155.     lcd.print("1:END");
  156.   }
  157.  
  158.   if (B2V1 >= battLow && finished2 == false)
  159.   {
  160.     digitalWrite(M2, HIGH);
  161.     digitalWrite(D2, HIGH);
  162.  
  163.     lcd.setCursor(9, 0);
  164.     lcd.print("2:");
  165.     lcd.print(B2V1);
  166.     lcd.print("V");
  167.   }
  168.   if ((B2V1 < battLow) || (finished2 == true)) // Disconnects load, prints the result
  169.   {
  170.     digitalWrite(M2, LOW);
  171.  
  172.     finished2 = true;
  173.  
  174.     digitalWrite(D2, LOW);
  175.     lcd.setCursor(9, 0);
  176.     lcd.print("2:END");
  177.   }
  178.  
  179.   if (B3V1 >= battLow && finished3 == false)
  180.   {
  181.     digitalWrite(M3, HIGH);
  182.     digitalWrite(D3, HIGH);
  183.  
  184.     lcd.setCursor(0, 1);
  185.     lcd.print("3:");
  186.     lcd.print(B3V1);
  187.     lcd.print("V");
  188.   }
  189.   if ((B3V1 < battLow) || (finished3 == true)) // Disconnects load, prints the result
  190.   {
  191.     digitalWrite(M3, LOW);
  192.  
  193.     finished3 = true;
  194.  
  195.     digitalWrite(D3, LOW);
  196.     lcd.setCursor(0, 1);
  197.     lcd.print("3:END     ");
  198.   }
  199.   delay(interval/4);
  200.   digitalWrite(D1, LOW);
  201.   digitalWrite(D2, LOW);
  202.   digitalWrite(D3, LOW);
  203.   delay(interval/4);
  204.   lcd.clear();
  205. }
  206. ///////////////////////////////////////////////////////////////////////////////////////////////////////
  207. void test(){
  208.   B1V1 = X1 * analogRead(B1_high) * voltRef / 1024.0; // B1 voltage
  209.   B2V1 = X2 * analogRead(B2_high) * voltRef / 1024.0; // B2 voltage
  210.   B3V1 = X3 * analogRead(B3_high) * voltRef / 1024.0; // B3 voltage
  211.  
  212.   if ((finished1 == true) && (finished2 == true) && (finished3 == true)) {
  213.     if(l < 3){
  214.       for (k = 0; k < 3; k++) {
  215.         digitalWrite(BUZZER, HIGH);
  216.         delay(200);
  217.         digitalWrite(BUZZER, LOW);
  218.         delay(200);
  219.     }
  220.       l++;
  221.     }
  222.   }
  223.  
  224.   if (B1V1 >= battLow && finished1 == false)
  225.   {
  226.     digitalWrite(M1, HIGH);
  227.     millisPassed1 = millis() - previousMillis1;
  228.     current1 = (B1V1) / R1; // Current calculation
  229.     mAh1 = mAh1 + (current1 * 1000.0) * (millisPassed1 / 3600000.0); // Capacity sum
  230.     previousMillis1 = millis();
  231.  
  232.  
  233.     if (pomiar > 0 && pomiar < 5) // 4 x voltage measurement
  234.     {
  235.       suma1 = suma1 + B1V1;
  236.     }
  237.     if (pomiar == 6)
  238.     {
  239.       suma1 = suma1 / 4;
  240.       roznica1 = B1start / suma1;
  241.       Rw1 = (roznica1 - 1) * RB1; // Internal resistance
  242.     }
  243.  
  244.     digitalWrite(D1, HIGH);
  245.     lcd.clear();
  246.     lcd.home();
  247.     lcd.print("U:");
  248.     lcd.print(B1V1);
  249.     lcd.print("V");
  250.     lcd.setCursor(9, 0);
  251.     lcd.print("I:");
  252.     lcd.print(current1);
  253.     lcd.print("A");
  254.     lcd.setCursor(0, 1);
  255.     poj1 = mAh1;
  256.     lcd.print(poj1);
  257.     lcd.print("mAh");
  258.     if (pomiar > 6)
  259.     {
  260.       lcd.setCursor(9, 1);
  261.       lcd.print("Rw:");
  262.       lcd.print(Rw1);
  263.     }
  264.     pomiar++;
  265.     delay(interval);
  266.     digitalWrite(D1, LOW);
  267.   }
  268.   if ((B1V1 < battLow) || (finished1 == true)) // Disconnects load, prints the result
  269.   {
  270.     digitalWrite(M1, LOW);
  271.  
  272.     finished1 = true;
  273.  
  274.     digitalWrite(D1, HIGH);
  275.     lcd.clear();
  276.     lcd.home();
  277.     lcd.print("1 - Koniec");
  278.     lcd.setCursor(0, 1);
  279.     poj1 = mAh1;
  280.     lcd.print(poj1);
  281.     lcd.print("mAh ");
  282.     lcd.setCursor(8, 1);
  283.     lcd.print("Rw1:");
  284.     lcd.print(Rw1);
  285.  
  286.     delay(interval * 2);
  287.     digitalWrite(D1, LOW);
  288.   }
  289.  
  290.   if (B2V1 >= battLow && finished2 == false)
  291.   {
  292.     digitalWrite(M2, HIGH);
  293.     millisPassed2 = millis() - previousMillis2;
  294.     current2 = (B2V1) / R2; // Current calculation
  295.     mAh2 = mAh2 + (current2 * 1000.0) * (millisPassed2 / 3600000.0); // Capacity sum
  296.     previousMillis2 = millis();
  297.  
  298.  
  299.     if (pomiar > 0 && pomiar < 5) // 4 x voltage measurement
  300.     {
  301.       suma2 = suma2 + B2V1;
  302.     }
  303.     if (pomiar == 6)
  304.     {
  305.       suma2 = suma2 / 4;
  306.       roznica2 = B2start / suma2;
  307.       Rw2 = (roznica2 - 1) * RB2; // Internal resistance
  308.     }
  309.  
  310.     digitalWrite(D2, HIGH);
  311.     lcd.clear();
  312.     lcd.home();
  313.     lcd.print("U:");
  314.     lcd.print(B2V1);
  315.     lcd.print("V");
  316.     lcd.setCursor(9, 0);
  317.     lcd.print("I:");
  318.     lcd.print(current2);
  319.     lcd.print("A");
  320.     lcd.setCursor(0, 1);
  321.     poj2 = mAh2;
  322.     lcd.print(poj2);
  323.     lcd.print("mAh");
  324.     if (pomiar > 6)
  325.     {
  326.       lcd.setCursor(9, 1);
  327.       lcd.print("Rw:");
  328.       lcd.print(Rw2);
  329.     }
  330.     delay(interval);
  331.     digitalWrite(D2, LOW);
  332.   }
  333.   if ((B2V1 < battLow) || (finished2 == true)) // Disconnects load, prints the result
  334.   {
  335.     digitalWrite(M2, LOW);
  336.  
  337.     finished2 = true;
  338.  
  339.     digitalWrite(D2, HIGH);
  340.     lcd.clear();
  341.     lcd.home();
  342.     lcd.print("2 - Koniec");
  343.     lcd.setCursor(0, 1);
  344.     poj2 = mAh2;
  345.     lcd.print(poj2);
  346.     lcd.print("mAh ");
  347.     lcd.setCursor(8, 1);
  348.     lcd.print("Rw2:");
  349.     lcd.print(Rw2);
  350.  
  351.     delay(interval * 2);
  352.     digitalWrite(D2, LOW);
  353.   }
  354.  
  355.   if (B3V1 >= battLow && finished3 == false)
  356.   {
  357.     digitalWrite(M3, HIGH);
  358.     millisPassed3 = millis() - previousMillis3;
  359.     current3 = (B3V1) / R3; // Current calculation
  360.     mAh3 = mAh3 + (current3 * 1000.0) * (millisPassed3 / 3600000.0); // Capacity sum
  361.     previousMillis3 = millis();
  362.  
  363.  
  364.     if (pomiar > 0 && pomiar < 5) // 4 x voltage measurement
  365.     {
  366.       suma3 = suma3 + B3V1;
  367.     }
  368.     if (pomiar == 6)
  369.     {
  370.       suma3 = suma3 / 4;
  371.       roznica3 = B3start / suma3;
  372.       Rw3 = (roznica3 - 1) * RB3; // Internal resistance
  373.     }
  374.  
  375.     digitalWrite(D3, HIGH);
  376.     lcd.clear();
  377.     lcd.home();
  378.     lcd.print("U:");
  379.     lcd.print(B3V1);
  380.     lcd.print("V");
  381.     lcd.setCursor(9, 0);
  382.     lcd.print("I:");
  383.     lcd.print(current3);
  384.     lcd.print("A");
  385.     lcd.setCursor(0, 1);
  386.     poj3 = mAh3;
  387.     lcd.print(poj3);
  388.     lcd.print("mAh");
  389.     if (pomiar > 6)
  390.     {
  391.       lcd.setCursor(9, 1);
  392.       lcd.print("Rw:");
  393.       lcd.print(Rw3);
  394.     }
  395.     delay(interval);
  396.     digitalWrite(D3, LOW);
  397.   }
  398.   if ((B3V1 < battLow) || (finished3 == true)) // Disconnects load, prints the result
  399.   {
  400.     digitalWrite(M3, LOW);
  401.  
  402.     finished3 = true;
  403.  
  404.     digitalWrite(D3, HIGH);
  405.     lcd.clear();
  406.     lcd.home();
  407.     lcd.print("3 - Koniec");
  408.     lcd.setCursor(0, 1);
  409.     poj3 = mAh3;
  410.     lcd.print(poj3);
  411.     lcd.print("mAh ");
  412.     lcd.setCursor(8, 1);
  413.     lcd.print("Rw3:");
  414.     lcd.print(Rw3);
  415.  
  416.     delay(interval * 2);
  417.     digitalWrite(D3, LOW);
  418.   }
  419. }
  420. ////////////////////////////////////////////////////////////////////////////////////////////
  421.  
  422. void menu(){
  423. lcd.clear();
  424. lcd.setCursor(0,0);
  425. lcd.print("SELECT MODE");
  426. lcd.setCursor(0,1);
  427. lcd.print("<--CLICK");
  428. while(menu1_end==false){
  429.    while(digitalRead(Button) == LOW){}
  430.       delay(800);
  431.       if(digitalRead(Button) == HIGH){
  432.         menu1_end = true;
  433.         lcd.setCursor(0,0);
  434.         if(mode == 1){lcd.print(">Mode: CAP TEST");}
  435.         if(mode == 2){lcd.print(">Mode: DISCHARGE");}
  436.       }
  437.       else{
  438.          if(mode==2){
  439.           mode = 1;
  440.         }
  441.         else{
  442.           mode++;
  443.         }      
  444.         lcd.clear();
  445.         lcd.setCursor(0,0);
  446.         if(mode == 1){lcd.print("Mode: CAP TEST");}
  447.         if(mode == 2){lcd.print("Mode: DISCHARGE");}      
  448.       }
  449.     digitalWrite(D1, HIGH);
  450.     delay(100);
  451.     digitalWrite(D1, LOW);
  452. }
  453. while(menu_end==false){
  454.    while(digitalRead(Button) == LOW){}
  455.       delay(800);
  456.       if(digitalRead(Button) == HIGH){
  457.         menu_end = true;
  458.         lcd.setCursor(0,1);
  459.         lcd.print(">Low V: "); lcd.print(battLow); lcd.print("V");
  460.       }
  461.       else{
  462.          if(battLow > 3.8){
  463.           battLow = 2.9;
  464.         }
  465.         else{
  466.           battLow = battLow+0.1;
  467.         }      
  468.         lcd.setCursor(0,1);
  469.         lcd.print("Low V: "); lcd.print(battLow); lcd.print("V");    
  470.       }
  471.     digitalWrite(D2, HIGH);
  472.     delay(100);
  473.     digitalWrite(D2, LOW);
  474.     }
  475. delay(2000);
  476. lcd.clear();
  477. }

Reply to "Re: Arduino 3x Capacity Tester"