Guest User

Arduino Mini PC

a guest
Apr 30th, 2013
160
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <LcdBarGraph.h>
  2. #include <math.h>
  3. #include <LiquidCrystal.h>
  4. int cont=0;
  5. int x=0;
  6. int vet[9] = { -2, -2, -2, -2, -2, -2, -2, -2, -2 };
  7. LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
  8. byte lcdNumCols = 16;
  9. LcdBarGraph lbg(&lcd, 16);
  10. int arg=0;
  11. int argtemp=0;
  12. int maxarg=9;
  13. int page=0;
  14. int maxpage=0;
  15. int adc_key_in  = 0;
  16. int bpm = 30;
  17.     int buttonState;
  18.     int buttonState2;
  19.     int buttonState3;
  20. float vballx = 1;
  21. float vbally = 0.2;
  22. float xball = 1;
  23. float yball = 1;
  24. int xmax = 80;
  25. int delaytime = 60;
  26. int score;
  27. byte dot[8] = {
  28.   0x0,
  29.   0x0,
  30.   0x0,
  31.   0x0,
  32.   0x0,
  33.   0x0,
  34.   0x0,
  35.   0x0
  36. };
  37. byte paddle[8] = {
  38.   B00000,
  39.   B00000,
  40.   B00000,
  41.   B00000,
  42.   B00000,
  43.   B11000,
  44.   B11000,
  45.   B11000
  46. };
  47. byte wallFR [8] = {
  48.   0x0,
  49.   0x0,
  50.   0x0,
  51.   0x0,
  52.   0x0,
  53.   0x0,
  54.   0x0,
  55.   0x0
  56. };
  57. byte wallFL [8] = {
  58.   0x0,
  59.   0x0,
  60.   0x0,
  61.   0x0,
  62.   0x0,
  63.   0x0,
  64.   0x0,
  65.   0x0
  66. };
  67. byte wallBR [8] = {
  68.   0x0,
  69.   0x0,
  70.   0x0,
  71.   0x0,
  72.   0x0,
  73.   0x0,
  74.   0x0,
  75.   0x0
  76. };
  77. byte wallBL [8] = {
  78.   0x0,
  79.   0x0,
  80.   0x0,
  81.   0x0,
  82.   0x0,
  83.   0x0,
  84.   0x0,
  85.   0x0
  86. };
  87. boolean wallarray [16] = {
  88.   1,1,1,1,
  89.   1,1,1,1,
  90.   1,1,1,1,
  91.   1,1,1,1};
  92.  
  93. int paddle_pos = 1;
  94. const int whole = (60000/bpm);
  95. const int half = 30000/bpm;
  96. const int quarter = 15000/bpm;
  97. const int eight = 7500 / bpm;
  98. const int sixteenth = 3750 / bpm;
  99. const int thirty2 = 1875 / bpm;
  100. int getserial(){   // ok non fate troppe domande, serve per ottenere da seriale un numero intero che supera il 9 cioè 10 viene scomposto in 1 e 0 in pratica qui lo "rimonto"
  101.    while (Serial.available() > 0)
  102.   {
  103.     vet[cont] = Serial.read()-48;   //trasformo da codice ascii a numero utilizzabil
  104.     cont++;
  105.     delay(10);
  106.   }
  107.    
  108.  if(cont > 0)
  109.   {
  110.     cont = 0;
  111.    
  112.    
  113.       if (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 &&  vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2  && vet[2] ==  -2  && vet[1] ==  -2 )
  114.                                                                                
  115.     {                                                                      
  116.       x = vet[0];                                                          
  117.     }
  118.     else
  119.    
  120.     if (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2  && vet[2] ==  -2 ) //  
  121.     {
  122.       x = (vet[0]* 10 +   vet[1]    );
  123.     }
  124.     else
  125.     if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 &&  vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2 ) //
  126.     {
  127.       x = (vet[0] * 100 + vet[1]* 10+ vet[2]);
  128.     }
  129.     else
  130.     if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2  && vet[4] ==  -2  )
  131.     {
  132.       x = (vet[0] * 1000 + vet[1] * 100 + vet[2]* 10 + vet[3]);  
  133.       } else
  134.       if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2   )
  135.       {
  136.       x = (vet[0] * 10000 + vet[1] * 1000 + vet[2]* 100 + vet[3]* 10 + vet[4]);  
  137.      
  138.       } else
  139.        if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 )
  140.       {
  141.       x = (vet[0] * 100000 + vet[1] * 10000 + vet[2]* 1000 + vet[3]* 100 + vet[4]* 10 + vet[5]);  
  142.      
  143.       } else
  144.        
  145.         if  (vet[8] == -2 && vet[7] == -2 )
  146.       {
  147.       x = (vet[0] * 1000000 + vet[1] * 100000 + vet[2]* 10000 + vet[3]* 1000 + vet[4]* 100 + vet[5]* 10+ vet[6]);  
  148.      
  149.       } else  
  150.        
  151.           if  (vet[8] == -2 )
  152.       {
  153.       x = (vet[0] * 10000000 + vet[1] * 1000000 + vet[2]* 100000 + vet[3]* 10000 + vet[4]* 1000 + vet[5]* 100 + vet[6]* 10+ vet[6]);  
  154.      
  155.       } else
  156.        
  157.        
  158.        
  159.  x = (vet[0] * 100000000 + vet[1] * 10000000 + vet[2]* 1000000 + vet[3]* 100000 + vet[4]* 10000 + vet[5]* 1000 + vet[6]* 100 + vet[7] * 10 + vet[8]);
  160.        
  161.      
  162.  if (vet[0] < -2 || vet[1] < -2 || vet[2] < -2 || vet[3] < -2 || vet[4] < -2 || vet[5] < -2 || vet[6] < -2 || vet[7] < -2 || vet[8] < -2 ) x = 0;
  163.  if (vet[0] > 9 || vet[1] > 9 || vet[2] > 9 || vet[3] > 9 || vet[4] > 9 || vet[5] > 9 || vet[6] > 9 || vet[7] > 9 || vet[8] > 9)  x = 0;
  164.  
  165.  if (x == -2 || x== -1) x=0;
  166.          
  167.    
  168.      
  169.  if (vet[0] >= -2 && vet[1]  >= -2 &&  vet[2]  >= -2 &&  vet[3] >= -2 && vet[4] >= -2 && vet[5] >= -2 && vet[6] >= -2 && vet[7] >= -2 && vet[8] >= -2 &&
  170.   vet[0] <= 9 && vet[1] <= 9 &&  vet[2] <= 9 &&  vet[3] <= 9 &&  vet[4] <= 9 &&  vet[5] <= 9 &&  vet[6] <= 9 &&  vet[7] <= 9 &&  vet[8] <= 9 )
  171.   vet[0]=-2;
  172.   vet[1]=-2;
  173.   vet[2]=-2;
  174.   vet[3]=-2;
  175.   vet[4]=-2;
  176.   vet[5]=-2;
  177.   vet[6]=-2;
  178.   vet[7]=-2;
  179.   vet[8]=-2;
  180.   return(x);
  181.  
  182.   }
  183. }
  184. void getPaddle() {
  185.  
  186.   if (buttonState == HIGH){
  187.      
  188.       if (paddle_pos > 1) paddle_pos -= 1;
  189.     }
  190.  
  191.   if (buttonState2 == HIGH){
  192.       if (paddle_pos < 14) paddle_pos += 1;
  193.    }
  194. }
  195. int exitcheck(){
  196.   buttonState3 = digitalRead(8);
  197. if (buttonState3 == HIGH){
  198.         lcd.clear();
  199.         delay(200);
  200.         arg=0;
  201.         page=0;
  202.         return 1;
  203.     }  
  204. }
  205.  void drawwalls()
  206. {
  207.   for (int i=0; i < 8; i+=4)
  208.   {
  209.     for (int j = 0; j<4; j++)
  210.     {
  211.       wallFL[j+i]=wallarray[i/2]*16+wallarray[i/2]*8+wallarray[i/2+1]*2+wallarray[i/2+1]*1;
  212.       wallFR[j+i]=wallarray[i/2+4]*16+wallarray[i/2+4]*8+wallarray[i/2+5]*2+wallarray[i/2+5]*1;
  213.       wallBL[j+i]=wallarray[i/2+8]*16+wallarray[i/2+8]*8+wallarray[i/2+9]*2+wallarray[i/2+9]*1;
  214.       wallBR[j+i]=wallarray[i/2+12]*16+wallarray[i/2+12]*8+wallarray[i/2+13]*2+wallarray[i/2+13]*1;
  215.     }
  216.   }
  217.   lcd.createChar(2,wallFL);
  218.   lcd.createChar(3,wallFR);
  219.   lcd.createChar(4,wallBL);
  220.   lcd.createChar(5,wallBR);
  221.   lcd.setCursor(14,0);
  222.   lcd.write((byte)2);
  223.   lcd.write((byte)4);
  224.   lcd.setCursor(14,1);
  225.   lcd.write((byte)3);
  226.   lcd.write((byte)5);
  227. }
  228. void placedot(int x, int y) {
  229.   createdot(x%5,y%8);
  230.   lcd.setCursor(x/5,y/8);
  231.   lcd.write((byte)0);
  232. }
  233.  
  234. void placepaddle(int y) {
  235.   for (int i=0;i<8;i++){
  236.     paddle[i]=0x0;
  237.   }
  238.   if (y%8>0) paddle[y%8-1] = 0x10;
  239.   paddle[y%8] = 0x10;
  240.   if (y%8<7)paddle[y%8+1] = 0x10;
  241.   lcd.createChar(1,paddle);
  242.   lcd.setCursor(0,y/8);
  243.   lcd.write((byte)1);
  244. }
  245. void createdot(int x, int y)  {
  246.   for (int i=0;i<8;i++){
  247.     dot[i]=0x0;
  248.   }
  249.   if (y > 0) dot[y-1] = (B11000 >> x);
  250.   dot[y] = (B11000 >> x);
  251.   lcd.createChar(0,dot);
  252. }
  253. int blockcounter = 0;
  254. void handlecollisions()
  255. {
  256.   xball = xball + vballx;
  257.   yball = yball + vbally;
  258.   //Handle collisions in y
  259.   if ((yball > 15) || (yball < 1)) {
  260.     vbally = -vbally;
  261.   }
  262.   //Handle Collisions in x
  263.  
  264.   if (xball > 69) //is the ball in the correct area
  265.   {
  266.     for (int i=0;i < 16; i++)
  267.     {
  268.       if (xball>(70+2*(i%2)+5*(i/8))) {//x condition met
  269.         if ((yball>(2*(i%8)))&&(yball<(2*(i%8)+4))){ // y condition met
  270.           if (wallarray[i] == 1){ //wall exists
  271.            delay(eight);
  272.             wallarray[i]=0;
  273.             vballx = -vballx;
  274.             xball = 70;
  275.           }
  276.         }
  277.       }
  278.     }
  279.   }
  280.   if (xball > xmax)   {
  281.     vballx = -vballx;
  282.   }
  283.  
  284.   if (xball < 1)   {
  285.     if (paddle_pos > int(yball)-2 && paddle_pos < int(yball)+2){
  286.       delay(sixteenth);
  287.       vballx = -vballx;
  288.       vbally *= random(1,4) ;
  289.       vbally /= 2;
  290.       Serial.println(vbally);
  291.       score += 1;
  292.       //xmax -= 2;
  293.       delaytime -= 2;
  294.       vballx += 0.1;
  295.       int left = 0;
  296.       for (int i=0;i<16;i++)
  297.       { left += wallarray[i];
  298.       }
  299.       if (left < 1)       {
  300.         lcd.clear();
  301.         lcd.print("EVVIVA!");
  302.         lcd.print(score);
  303.         delay(3000);
  304.         xmax = 80;
  305.         score = 0;
  306.         delaytime = 60;
  307.         for (int i=0;i< 16;i++)
  308.         {wallarray[i]=1;}
  309.  
  310.       }
  311.     }
  312.     else {
  313.       vballx = -vballx;
  314.       vbally *= random(1,4) ;
  315.       vbally /= 2;
  316.       score -=1;
  317.     }
  318.   }
  319. }
  320.  
  321. void setup() {
  322.   pinMode(8, INPUT);
  323.   pinMode(7, INPUT);
  324.   pinMode(6, INPUT);
  325.   pinMode(A5, OUTPUT);
  326.   pinMode(A4, OUTPUT);
  327.   pinMode(A3, OUTPUT);
  328.   pinMode(13, OUTPUT);
  329.   digitalWrite(A5,LOW);
  330.   digitalWrite(A4,LOW);
  331.   digitalWrite(A3,LOW);
  332.   digitalWrite(13,HIGH);
  333.   lcd.begin(16, 2);
  334.   lcd.print("Benvenuto!");
  335.   delay(1000);
  336.   lcd.clear();
  337.   lcd.print("Fisica Portatile");
  338.   lcd.setCursor(0, 1);
  339.   lcd.print("Karavania L.");
  340.   lcd.setCursor(0, 0);
  341.   delay(2000);
  342.   buttonState = digitalRead(6);
  343.   buttonState2 = digitalRead(7);
  344.   buttonState3 = digitalRead(8);
  345.   Serial.begin(9600);
  346.  
  347. }
  348.  
  349. void loop() {
  350.   lcd.clear();
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363. /////////////////////////////////////////////
  364.   while(arg == 0){
  365.      buttonState = digitalRead(6);
  366.      buttonState2 = digitalRead(7);
  367.      buttonState3 = digitalRead(8);
  368.     if(argtemp==0){
  369.       lcd.setCursor(0, 0);
  370.       lcd.print("Leggi Newton");
  371.       lcd.setCursor(0, 1);
  372.       lcd.print(argtemp);
  373.     }
  374.     if(argtemp==1){
  375.       lcd.setCursor(0, 0);
  376.       lcd.print("Il Pendolo");
  377.       lcd.setCursor(0, 1);
  378.       lcd.print(argtemp);
  379.     }
  380.     if(argtemp==2){
  381.       lcd.setCursor(0, 0);
  382.       lcd.print("Luce");
  383.       lcd.setCursor(0, 1);
  384.       lcd.print(argtemp);
  385.     }
  386.     if(argtemp==3){
  387.       lcd.setCursor(0, 0);
  388.       lcd.print("Temperatura");
  389.       lcd.setCursor(0, 1);
  390.       lcd.print(argtemp);
  391.     }
  392.     if(argtemp==4){
  393.       lcd.setCursor(0, 0);
  394.       lcd.print("Esposimetro");
  395.       lcd.setCursor(0, 1);
  396.       lcd.print(argtemp);
  397.     }
  398.     if(argtemp==5){
  399.       lcd.setCursor(0, 0);
  400.       lcd.print("VU Meter");
  401.       lcd.setCursor(0, 1);
  402.       lcd.print(argtemp);
  403.     }
  404.     if(argtemp==6){
  405.       lcd.setCursor(0, 0);
  406.       lcd.print("The Game");
  407.       lcd.setCursor(0, 1);
  408.       lcd.print(argtemp);
  409.     }
  410.     if(argtemp==7){
  411.       lcd.setCursor(0, 0);
  412.       lcd.print("Credits");
  413.       lcd.setCursor(0, 1);
  414.       lcd.print(argtemp);
  415.     }
  416.     if(argtemp==8){
  417.       lcd.setCursor(0, 0);
  418.       lcd.print("La Mia Vita...");
  419.       lcd.setCursor(0, 1);
  420.       lcd.print(argtemp);
  421.     }
  422.     if(argtemp==9){
  423.       lcd.setCursor(0, 0);
  424.       lcd.print("Seriale...");
  425.       lcd.setCursor(0, 1);
  426.       lcd.print(argtemp);
  427.     }
  428.       if (buttonState == HIGH){
  429.         lcd.clear();
  430.         delay(200);
  431.         if(argtemp<=0){
  432.             argtemp=maxarg;
  433.           }
  434.         else{
  435.           argtemp--;
  436.           }
  437.        }
  438.      if (buttonState2 == HIGH){
  439.         lcd.clear();
  440.         delay(200);
  441.         if(argtemp>=0){
  442.           lcd.setCursor(0, 1);
  443.           lcd.print(argtemp);
  444.           if(argtemp<=maxarg){
  445.             argtemp++;
  446.           }
  447.           if(argtemp>maxarg){
  448.             argtemp=0;
  449.           }
  450.           }
  451.       }
  452.       if (buttonState3 == HIGH){
  453.         lcd.clear();
  454.         delay(200);
  455.         arg=argtemp+1;
  456.         //argtemp=0;
  457.       }
  458. }
  459.   if(arg>0){
  460.     if(arg==1){
  461.      
  462.    
  463.    
  464.    
  465.       while(arg==1){
  466.         maxpage=6;
  467.          buttonState = digitalRead(6);
  468.          buttonState2 = digitalRead(7);
  469.          buttonState3 = digitalRead(8);
  470.         if(page==0){
  471.           lcd.setCursor(0, 0);
  472.           lcd.print("Un corpo sottopo");
  473.           lcd.setCursor(0, 1);
  474.           lcd.print("sto a forze null");
  475.           }
  476.         if(page==1){
  477.           lcd.setCursor(0, 0);
  478.           lcd.print("si muove di moto");
  479.           lcd.setCursor(0, 1);
  480.           lcd.print("rettilineo unif.");
  481.           }
  482.         if(page==2){
  483.           lcd.setCursor(0, 0);
  484.           lcd.print("Seconda legge:");
  485.           lcd.setCursor(0, 1);
  486.           lcd.print("F(v)=m*a(v)");
  487.           }
  488.         if(page==3){
  489.           lcd.setCursor(0, 0);
  490.           lcd.print("Terza legge:");
  491.           lcd.setCursor(0, 1);
  492.           lcd.print("Se il corpo 1 exe");
  493.           }
  494.         if(page==4){
  495.           lcd.setCursor(0, 0);
  496.           lcd.print("una forza F sul c");
  497.           lcd.setCursor(0, 1);
  498.           lcd.print("orpo 2 allora il ");
  499.           }
  500.           if(page==5){
  501.           lcd.setCursor(0, 0);
  502.           lcd.print("corpo 2 esercita ");
  503.           lcd.setCursor(0, 1);
  504.           lcd.print("una forza -F su 1");
  505.           }
  506.           if(page==6){
  507.           lcd.setCursor(0, 0);
  508.           lcd.print("The End! ");
  509.           lcd.setCursor(0, 1);
  510.           lcd.print("----------------");
  511.           }
  512.      if (buttonState == HIGH){
  513.         lcd.clear();
  514.         delay(200);
  515.         if(page<=0){
  516.             page=maxpage;
  517.           }
  518.         else{
  519.           page--;
  520.           }
  521.        }
  522.      if (buttonState2 == HIGH){
  523.         lcd.clear();
  524.         delay(200);
  525.         if(page>=0){
  526.           if(page<=maxpage){
  527.             page++;
  528.           }
  529.           if(page>maxpage){
  530.             page=0;
  531.           }
  532.           }
  533.       }
  534.       if (buttonState3 == HIGH){
  535.         lcd.clear();
  536.         delay(200);
  537.         arg=0;
  538.         page=0;
  539.       }
  540.      }
  541.     }
  542.    
  543.    
  544.    
  545.    
  546.     if(arg==2){
  547.       while(arg==2){
  548.            maxpage=3;
  549.          buttonState = digitalRead(6);
  550.          buttonState2 = digitalRead(7);
  551.          buttonState3 = digitalRead(8);
  552.         if(page==0){
  553.           lcd.setCursor(0, 0);
  554.           lcd.print("F=m*g*sen(ß)");
  555.           lcd.setCursor(0, 1);
  556.           lcd.print("l=L*(ß)");
  557.           }
  558.         if(page==1){
  559.           lcd.setCursor(0, 0);
  560.           lcd.print("F=k*x -> x=l e");
  561.           lcd.setCursor(0, 1);
  562.           lcd.print("k=(mg)/L");
  563.           }
  564.         if(page==2){
  565.           lcd.setCursor(0, 0);
  566.           lcd.print("T=2π|/(m/k)=");
  567.           lcd.setCursor(0, 1);
  568.           lcd.print("T=2π|/(L/g)");
  569.           }
  570.           if(page==3){
  571.           lcd.setCursor(0, 0);
  572.           lcd.print("The End! ");
  573.           lcd.setCursor(0, 1);
  574.           lcd.print("----------------");
  575.           }
  576.      if (buttonState == HIGH){
  577.         lcd.clear();
  578.         delay(200);
  579.         if(page<=0){
  580.             page=maxpage;
  581.           }
  582.         else{
  583.           page--;
  584.           }
  585.        }
  586.      if (buttonState2 == HIGH){
  587.         lcd.clear();
  588.         delay(200);
  589.         if(page>=0){
  590.           if(page<=maxpage){
  591.             page++;
  592.           }
  593.           if(page>maxpage){
  594.             page=0;
  595.           }
  596.           }
  597.       }
  598.       if (buttonState3 == HIGH){
  599.         lcd.clear();
  600.         delay(200);
  601.         arg=0;
  602.         page=0;
  603.       }
  604.      }
  605.     }
  606.    
  607.    
  608.    
  609.    
  610.      if(arg==3){
  611.       while(arg==3){
  612.            maxpage=2;
  613.          buttonState = digitalRead(6);
  614.          buttonState2 = digitalRead(7);
  615.          buttonState3 = digitalRead(8);
  616.         if(page==0){
  617.           lcd.setCursor(0, 1);
  618.           lcd.print("Potenza: 1");
  619.           digitalWrite(A5,LOW);
  620.           digitalWrite(A3,HIGH);
  621.           digitalWrite(A4,HIGH);
  622.           int lum=analogRead(A1);
  623.           lbg.drawValue((lum), 200);
  624.           delay(10);
  625.           }
  626.         if(page==1){
  627.           lcd.setCursor(0, 1);
  628.           lcd.print("Potenza: 2");
  629.           digitalWrite(A5,HIGH);
  630.           digitalWrite(A3,LOW);
  631.           digitalWrite(A4,LOW);
  632.           int lum=analogRead(A1);
  633.           lbg.drawValue((lum), 200);
  634.           delay(10);
  635.           }
  636.         if(page==2){
  637.           lcd.setCursor(0, 1);
  638.           lcd.print("Potenza: 3");
  639.           digitalWrite(A5,HIGH);
  640.           digitalWrite(A3,HIGH);
  641.           digitalWrite(A4,HIGH);
  642.           int lum=analogRead(A1);
  643.           lbg.drawValue((lum), 200);
  644.           delay(10);
  645.         }
  646.      if (buttonState == HIGH){
  647.         lcd.clear();
  648.         delay(200);
  649.         if(page<=0){
  650.             page=maxpage;
  651.           }
  652.         else{
  653.           page--;
  654.           }
  655.        }
  656.      if (buttonState2 == HIGH){
  657.         lcd.clear();
  658.         delay(200);
  659.         if(page>=0){
  660.           if(page<=maxpage){
  661.             page++;
  662.           }
  663.           if(page>maxpage){
  664.             page=0;
  665.           }
  666.           }
  667.       }
  668.       if (buttonState3 == HIGH){
  669.         lcd.clear();
  670.         digitalWrite(A5,LOW);
  671.         digitalWrite(A4,LOW);
  672.         digitalWrite(A3,LOW);
  673.         delay(200);
  674.         arg=0;
  675.         page=0;
  676.     }
  677.    }
  678.   }
  679.  
  680.  
  681.  
  682.  
  683.  
  684.  
  685.  
  686.    if(arg==4){
  687.      int a=0;
  688.      int b=0;
  689.      int c=0;
  690.      int temptemp=0;
  691.       while(arg==4){
  692.          maxpage=3;
  693.          buttonState = digitalRead(6);
  694.          buttonState2 = digitalRead(7);
  695.          buttonState3 = digitalRead(8);
  696.         if(page==0){
  697.           lcd.setCursor(0, 0);
  698.           lcd.print("Val temperatura:");
  699.           int temp=analogRead(A2);
  700.           lcd.setCursor(0, 1);
  701.           lcd.print(temp);
  702.           float tempv=(temp*5.000)/1024.000;
  703.           lcd.setCursor(7, 1);
  704.           lcd.print("@V");
  705.           lcd.setCursor(9, 1);
  706.           lcd.print(tempv);
  707.  
  708.           }
  709.           if(page==1){
  710.           lcd.setCursor(0, 1);
  711.           lcd.print("X3");
  712.           int temp=analogRead(A2);
  713.           lcd.setCursor(4, 1);
  714.           lcd.print(temp-124);
  715.           float tempv=(temp*5.000)/1024.000;
  716.           lcd.setCursor(9, 1);
  717.           lcd.print("@V");
  718.           lcd.setCursor(11, 1);
  719.           lcd.print(tempv);
  720.           if(a==0){
  721.            temptemp=analogRead(A2);
  722.            a++;
  723.           }
  724.           lcd.setCursor(0, 0);
  725.           lbg.drawValue((temp-820), 100);
  726.           delay(50);
  727.  
  728.           }
  729.          
  730.           if(page==2){
  731.           lcd.setCursor(0, 1);
  732.           lcd.print("X2");
  733.           int temp=analogRead(A2);
  734.           lcd.setCursor(4, 1);
  735.           lcd.print(temp-124);
  736.           float tempv=(temp*5.000)/1024.000;
  737.           lcd.setCursor(9, 1);
  738.           lcd.print("@V");
  739.           lcd.setCursor(11, 1);
  740.           lcd.print(tempv);
  741.           if(b==0){
  742.            temptemp=analogRead(A2);
  743.            b++;
  744.           }
  745.           lcd.setCursor(0, 0);
  746.           lbg.drawValue((temp-820), 200);
  747.           delay(50);
  748.  
  749.           }
  750.          
  751.           if(page==3){
  752.           lcd.setCursor(0, 1);
  753.           lcd.print("X1");
  754.           int temp=analogRead(A2);
  755.           lcd.setCursor(4, 1);
  756.           lcd.print(temp-124);
  757.           float tempv=(temp*5.000)/1024.000;
  758.           lcd.setCursor(9, 1);
  759.           lcd.print("@V");
  760.           lcd.setCursor(11, 1);
  761.           lcd.print(tempv);
  762.           if(c==0){
  763.            temptemp=analogRead(A2);
  764.            c++;
  765.           }
  766.           lcd.setCursor(0, 0);
  767.           lbg.drawValue((temp-820), 400);
  768.           delay(50);
  769.  
  770.           }
  771.      if (buttonState == HIGH){
  772.         lcd.clear();
  773.         delay(200);
  774.         if(page<=0){
  775.             page=maxpage;
  776.           }
  777.         else{
  778.           page--;
  779.           }
  780.        }
  781.      if (buttonState2 == HIGH){
  782.         lcd.clear();
  783.         delay(200);
  784.         if(page>=0){
  785.           if(page<=maxpage){
  786.             page++;
  787.           }
  788.           if(page>maxpage){
  789.             page=0;
  790.           }
  791.           }
  792.       }
  793.       if (buttonState3 == HIGH){
  794.         lcd.clear();
  795.         delay(200);
  796.         arg=0;
  797.         page=0;
  798.     }  
  799.    }
  800.   }
  801.  
  802.  
  803.  
  804.  
  805.  
  806.  
  807.  
  808.   if(arg==5){
  809.      int a=0;
  810.      int lumtemp=0;
  811.      int b=0;
  812.      int c=0;
  813.       while(arg==5){
  814.          maxpage=3;
  815.          buttonState = digitalRead(6);
  816.          buttonState2 = digitalRead(7);
  817.          buttonState3 = digitalRead(8);
  818.         if(page==0){
  819.           lcd.setCursor(0, 0);
  820.           lcd.print("Val Luminosita:");
  821.           int lum=analogRead(A1)+1;
  822.           lcd.setCursor(0, 1);
  823.           lcd.print(lum);
  824.           float lumv=(lum*5.000)/1024.000;
  825.           lcd.setCursor(7, 1);
  826.           lcd.print("@V");
  827.           lcd.setCursor(9, 1);
  828.           lcd.print(lumv);
  829.  
  830.           }
  831.           if(page==1){
  832.           lcd.setCursor(0, 1);
  833.           lcd.print("X3");
  834.           int lum=analogRead(A1)+1;
  835.           lcd.setCursor(4, 1);
  836.           lcd.print(lum);
  837.           float lumv=(lum*5.000)/1024.000;
  838.           lcd.setCursor(9, 1);
  839.           lcd.print("@V");
  840.           lcd.setCursor(11, 1);
  841.           lcd.print(lumv);
  842.           if(a==0){
  843.            lumtemp=analogRead(A1)+1;
  844.            a++;
  845.           }
  846.           lcd.setCursor(0, 0);
  847.           lbg.drawValue((lum), 200);
  848.           delay(10);
  849.           }
  850.           if(page==2){
  851.           lcd.setCursor(0, 1);
  852.           lcd.print("X2");
  853.           int lum=analogRead(A1)+1;
  854.           lcd.setCursor(4, 1);
  855.           lcd.print(lum);
  856.           float lumv=(lum*5.000)/1024.000;
  857.           lcd.setCursor(9, 1);
  858.           lcd.print("@V");
  859.           lcd.setCursor(11, 1);
  860.           lcd.print(lumv);
  861.           if(b==0){
  862.            lumtemp=analogRead(A1)+1;
  863.            b++;
  864.           }
  865.           lcd.setCursor(0, 0);
  866.           lbg.drawValue((lum), 600);
  867.           delay(10);
  868.  
  869.           }
  870.           if(page==3){
  871.           lcd.setCursor(0, 1);
  872.           lcd.print("X1");
  873.           int lum=analogRead(A1)+1;
  874.           lcd.setCursor(4, 1);
  875.           lcd.print(lum);
  876.           float lumv=(lum*5.000)/1024.000;
  877.           lcd.setCursor(9, 1);
  878.           lcd.print("@V");
  879.           lcd.setCursor(11, 1);
  880.           lcd.print(lumv);
  881.           if(c==0){
  882.            lumtemp=analogRead(A1)+1;
  883.            c++;
  884.           }
  885.           lcd.setCursor(0, 0);
  886.           lbg.drawValue((lum), 1025);
  887.           delay(10);
  888.  
  889.           }
  890.      if (buttonState == HIGH){
  891.         lcd.clear();
  892.         delay(200);
  893.         if(page<=0){
  894.             page=maxpage;
  895.           }
  896.         else{
  897.           page--;
  898.           }
  899.        }
  900.      if (buttonState2 == HIGH){
  901.         lcd.clear();
  902.         delay(200);
  903.         if(page>=0){
  904.           if(page<=maxpage){
  905.             page++;
  906.           }
  907.           if(page>maxpage){
  908.             page=0;
  909.           }
  910.           }
  911.       }
  912.       if (buttonState3 == HIGH){
  913.         lcd.clear();
  914.         delay(200);
  915.         arg=0;
  916.         page=0;
  917.     }  
  918.    }
  919.   }
  920.  
  921.  
  922.  
  923.   if(arg==6){
  924.      int soutemp=0;
  925.      int a=0;
  926.      int b=0;
  927.      int c=0;
  928.      int d=0;
  929.      int tem=0;
  930.      int tem2=0;
  931.      int mesure[21];
  932.       while(arg==6){
  933.          maxpage=4                                                                                                   ;
  934.          buttonState = digitalRead(6);
  935.          buttonState2 = digitalRead(7);
  936.          buttonState3 = digitalRead(8);
  937.         if(page==0){
  938.           lcd.setCursor(0, 0);
  939.           lcd.print("Val Suono:");
  940.           int sou=analogRead(A0)+1;
  941.           lcd.setCursor(0, 1);
  942.           lcd.print(sou);
  943.           float souv=(sou*5.000)/1024.000;
  944.           lcd.setCursor(7, 1);
  945.           lcd.print("@V");
  946.           lcd.setCursor(9, 1);
  947.           lcd.print(souv);
  948.  
  949.           }
  950.           if(page==1){
  951.           //a=0;
  952.           b=0;
  953.           c=0;
  954.           d=0;
  955.           lcd.setCursor(0, 1);
  956.           lcd.print("X3");
  957.           int sou=analogRead(A0)+1;
  958.           lcd.setCursor(4, 1);
  959.           lcd.print(abs(sou-200));
  960.           float souv=(sou*5.000)/1024.000;
  961.           lcd.setCursor(9, 1);
  962.           lcd.print("@V");
  963.           lcd.setCursor(11, 1);
  964.           lcd.print(souv);
  965.           if(a==0){
  966.            soutemp=analogRead(A0)+1;
  967.            a++;
  968.           }
  969.           lcd.setCursor(0, 0);
  970.           lbg.drawValue(abs(((sou+soutemp)/2)-200), 80);
  971.           delay(5);
  972.           }
  973.           if(page==2){
  974.           a=0;
  975.           //b=0;
  976.           c=0;
  977.           d=0;
  978.           lcd.setCursor(0, 1);
  979.           lcd.print("X2");
  980.           int sou=analogRead(A0)+1;
  981.           lcd.setCursor(4, 1);
  982.           lcd.print(abs(sou-200));
  983.           float souv=(sou*5.000)/1024.000;
  984.           lcd.setCursor(9, 1);
  985.           lcd.print("@V");
  986.           lcd.setCursor(11, 1);
  987.           lcd.print(souv);
  988.           if(b==0){
  989.            soutemp=analogRead(A0);
  990.            b++;
  991.           }
  992.           else b--;
  993.           lcd.setCursor(0, 0);
  994.           lbg.drawValue(abs(((sou+soutemp)/2)-200), 400);
  995.           delay(5);
  996.  
  997.           }
  998.           if(page==3){
  999.           a=0;
  1000.           b=0;
  1001.           //c=0;
  1002.           d=0;
  1003.           lcd.setCursor(0, 1);
  1004.           lcd.print("X1");
  1005.           int sou=analogRead(A0)+1;
  1006.           lcd.setCursor(4, 1);
  1007.           lcd.print(abs(sou-200));
  1008.           float souv=(sou*5.000)/1024.000;
  1009.           lcd.setCursor(9, 1);
  1010.           lcd.print("@V");
  1011.           lcd.setCursor(11, 1);
  1012.           lcd.print(souv);
  1013.           if(c==0){
  1014.            soutemp=analogRead(A0)+1;
  1015.            c++;
  1016.           }
  1017.           lcd.setCursor(0, 0);
  1018.           lbg.drawValue(abs(((sou+soutemp)/2)-200), 1000);
  1019.           delay(5);
  1020.  
  1021.           }
  1022.           if(page==4){
  1023.             a=0;
  1024.             b=0;
  1025.             c=0;
  1026.             //d=0;
  1027.             lcd.setCursor(0, 1);
  1028.             lcd.print("Cal");
  1029.             int sou=analogRead(A0)+1;
  1030.             lcd.setCursor(4, 1);
  1031.             lcd.print(abs(sou-soutemp));
  1032.             float souv=(sou*5.000)/1024.000;
  1033.             lcd.setCursor(9, 1);
  1034.             lcd.print("@V");
  1035.             lcd.setCursor(11, 1);
  1036.             lcd.print(souv);
  1037.           if(tem<6){
  1038.             if(tem<6){
  1039.               mesure[tem]=sou;
  1040.               tem2=tem2+mesure[tem];
  1041.             }
  1042.             tem++;
  1043.           }
  1044.           else{
  1045.             tem=0;
  1046.             tem2=tem2/5;
  1047.           if(d==0){
  1048.            lcd.setCursor(0,0);
  1049.            lcd.print("OK Per Calibrare");
  1050.            delay(100);
  1051.            while(buttonState3 == LOW)
  1052.             {
  1053.               delay(10);
  1054.               buttonState3 = digitalRead(8);
  1055.  
  1056.             }
  1057.             lcd.clear();
  1058.             soutemp=tem2;
  1059.             d++;
  1060.             buttonState3 = LOW;
  1061.             delay(100);
  1062.  
  1063.               }
  1064.             lcd.setCursor(0, 0);
  1065.             lbg.drawValue(abs(((tem2))-soutemp), 100);
  1066.             tem2=0;
  1067.           }
  1068.  
  1069.           }
  1070.      if (buttonState == HIGH){
  1071.         lcd.clear();
  1072.         delay(200);
  1073.         if(page<=0){
  1074.             page=maxpage;
  1075.           }
  1076.         else{
  1077.           page--;
  1078.           }
  1079.        }
  1080.      if (buttonState2 == HIGH){
  1081.         lcd.clear();
  1082.         delay(200);
  1083.         if(page>=0){
  1084.           if(page<=maxpage){
  1085.             page++;
  1086.           }
  1087.           if(page>maxpage){
  1088.             page=0;
  1089.           }
  1090.           }
  1091.       }
  1092.       if (buttonState3 == HIGH){
  1093.         lcd.clear();
  1094.         delay(200);
  1095.         arg=0;
  1096.         page=0;
  1097.     }  
  1098.    }
  1099.   }
  1100.  
  1101.  
  1102.  
  1103.  
  1104.    if(arg==7){
  1105.      int a=0;
  1106.       while(arg==7){
  1107.         if(a==0){
  1108.             lcd.setCursor(0,1);
  1109.             lcd.print("Get the Bricks");
  1110.             delay(1000);
  1111.             lcd.setCursor(0,1);
  1112.             lcd.print("Press to Start");
  1113.             while(buttonState == LOW)
  1114.             {
  1115.               delay(10);
  1116.               buttonState = digitalRead(6);
  1117.  
  1118.             }
  1119.             a++;
  1120.         }
  1121.         buttonState = digitalRead(6);
  1122.         buttonState2 = digitalRead(7);
  1123.         buttonState3 = digitalRead(8);
  1124.  
  1125.         lcd.clear();
  1126.         getPaddle();
  1127.  
  1128.         drawwalls();
  1129.         placepaddle(paddle_pos);
  1130.         handlecollisions();
  1131.         placedot(xball,yball);
  1132.  
  1133.         delay(delaytime);
  1134.        if (buttonState3 == HIGH){
  1135.         lcd.clear();
  1136.         delay(200);
  1137.         arg=0;
  1138.         page=0;
  1139.     }  
  1140.        
  1141.        
  1142.    }
  1143.   }  
  1144.  
  1145.  if(arg==8){
  1146.       while(arg==8){
  1147.          buttonState3 = digitalRead(8);
  1148.         if(page==0){
  1149.           char string[9]="Made By:";
  1150.           char string2[18]="Lorenzo Karavania";
  1151.           lcd.setCursor(0, 0);
  1152.           for (int thisChar = 0; thisChar < 8; thisChar++) {
  1153.              lcd.print(string[thisChar]);
  1154.              delay(200);
  1155.              if(exitcheck()==1) break;
  1156.             }
  1157.           lcd.autoscroll();
  1158.           lcd.setCursor(16,1);
  1159.           for (int thisChar = 0; thisChar < 17; thisChar++) {
  1160.               lcd.print(string2[thisChar]);
  1161.               delay(400);
  1162.               if(exitcheck()==1) break;
  1163.             }
  1164.         lcd.noAutoscroll();
  1165.         lcd.clear();
  1166.           }
  1167.       if (buttonState3 == HIGH){
  1168.         lcd.clear();
  1169.         delay(200);
  1170.         arg=0;
  1171.         page=0;
  1172.     }  
  1173.    }
  1174.   }
  1175.    if(arg==9){
  1176.       while(arg==9){
  1177.          buttonState3 = digitalRead(8);
  1178.         if(page==0){
  1179.           char string[9]="Amo Solo";
  1180.           char string2[18]="Caterina";
  1181.           lcd.setCursor(0, 0);
  1182.           for (int thisChar = 0; thisChar < 8; thisChar++) {
  1183.              lcd.print(string[thisChar]);
  1184.              delay(200);
  1185.              if(exitcheck()==1) break;
  1186.             }
  1187.           lcd.autoscroll();
  1188.           lcd.setCursor(16,1);
  1189.           for (int thisChar = 0; thisChar < 8; thisChar++) {
  1190.               lcd.print(string2[thisChar]);
  1191.               delay(400);
  1192.               if(exitcheck()==1) break;
  1193.             }
  1194.         lcd.noAutoscroll();
  1195.         lcd.clear();
  1196.           }
  1197.       if (buttonState3 == HIGH){
  1198.         lcd.clear();
  1199.         delay(200);
  1200.         arg=0;
  1201.         page=0;
  1202.     }  
  1203.    }
  1204.   }
  1205.  
  1206.  
  1207.  
  1208.   if(arg==10){
  1209.     int arg2=0;
  1210.     int maxarg2=2;
  1211.     int argtemp2=0;
  1212.     int calibrate=0;
  1213.     maxpage=2;
  1214.     Serial.print(9);
  1215.     Serial.print(0);
  1216.       while(arg==10){
  1217.        
  1218.        
  1219.          while(arg2 == 0){
  1220.      buttonState = digitalRead(6);
  1221.      buttonState2 = digitalRead(7);
  1222.      buttonState3 = digitalRead(8);
  1223.     if(argtemp2==0){
  1224.       lcd.setCursor(0, 0);
  1225.       lcd.print("Suono");
  1226.       lcd.setCursor(0, 1);
  1227.       lcd.print(argtemp2);
  1228.     }
  1229.     if(argtemp2==1){
  1230.       lcd.setCursor(0, 0);
  1231.       lcd.print("Luminosita");
  1232.       lcd.setCursor(0, 1);
  1233.       lcd.print(argtemp2);
  1234.     }
  1235.     if(argtemp2==2){
  1236.       lcd.setCursor(2, 0);
  1237.       lcd.print("Visualizza");
  1238.       lcd.setCursor(0, 1);
  1239.       lcd.print(argtemp2);
  1240.       lcd.setCursor(4, 1);
  1241.       lcd.print("Seriale");
  1242.     }
  1243.       if (buttonState == HIGH){
  1244.         lcd.clear();
  1245.         delay(200);
  1246.         if(argtemp2<=0){
  1247.             argtemp2=maxarg2;
  1248.           }
  1249.         else{
  1250.           argtemp2--;
  1251.           }
  1252.        }
  1253.      if (buttonState2 == HIGH){
  1254.         lcd.clear();
  1255.         delay(200);
  1256.         if(argtemp2>=0){
  1257.           lcd.setCursor(0, 1);
  1258.           lcd.print(argtemp2);
  1259.           if(argtemp2<=maxarg2){
  1260.             argtemp2++;
  1261.           }
  1262.           if(argtemp2>maxarg2){
  1263.             argtemp2=0;
  1264.           }
  1265.           }
  1266.       }
  1267.       if (buttonState3 == HIGH){
  1268.         lcd.clear();
  1269.         delay(200);
  1270.         arg2=argtemp2+1;
  1271.         //argtemp=0;
  1272.       }
  1273.      }
  1274.        
  1275.        if(arg2==1){
  1276.          int d=0;
  1277.          int lastserial=1; // non zero altrimenti dividi per 0
  1278.         while(arg2 == 1){
  1279.             maxpage=3;
  1280.             buttonState = digitalRead(6);
  1281.             buttonState2 = digitalRead(7);
  1282.             buttonState3 = digitalRead(8);
  1283.             if(d==0){
  1284.            lcd.setCursor(0,0);
  1285.            lcd.print("OK Per Calibrare");
  1286.            delay(100);
  1287.            while(buttonState3 == LOW)
  1288.             {
  1289.               delay(10);
  1290.               buttonState3 = digitalRead(8);
  1291.  
  1292.             }
  1293.             lcd.clear();
  1294.             calibrate=analogRead(A0);
  1295.             d++;
  1296.             buttonState3 = LOW;
  1297.             delay(100);
  1298.  
  1299.               }
  1300.             if(page==0){
  1301.               lcd.setCursor(0,0);
  1302.               lcd.print("Suono");
  1303.               lcd.setCursor(11,0);
  1304.               lcd.print("X3");
  1305.               int sou=analogRead(A0);
  1306.               lcd.setCursor(0, 1);
  1307.               lcd.print(abs(sou-calibrate));
  1308.               float souv=(sou*5.000)/1024.000;
  1309.               lcd.setCursor(9, 1);
  1310.               lcd.print("@V");
  1311.               lcd.setCursor(11, 1);
  1312.               lcd.print(souv);
  1313.               if((abs(sou-calibrate)<50)){
  1314.                 int ser=(9*(abs(sou-calibrate)))/50;
  1315.                 Serial.print(ser);
  1316.               }
  1317.               else{
  1318.                 int ser=9;
  1319.                 Serial.print(ser);
  1320.                  }
  1321.             }
  1322.              
  1323.               if(page==1){
  1324.               lcd.setCursor(0,0);
  1325.               lcd.print("Suono");
  1326.               lcd.setCursor(11,0);
  1327.               lcd.print("X2");
  1328.               int sou=analogRead(A0);
  1329.               lcd.setCursor(0, 1);
  1330.               lcd.print(abs(sou-calibrate));
  1331.               float souv=(sou*5.000)/1024.000;
  1332.               lcd.setCursor(9, 1);
  1333.               lcd.print("@V");
  1334.               lcd.setCursor(11, 1);
  1335.               lcd.print(souv);
  1336.               if((abs(sou-calibrate)<100)){
  1337.                 int ser=(9*(abs(sou-calibrate)))/100;
  1338.                 Serial.print(ser);
  1339.               }
  1340.               else{
  1341.                 int ser=9;
  1342.                 Serial.print(ser);
  1343.                  }
  1344.             }
  1345.             if(page==2){
  1346.               lcd.setCursor(0,0);
  1347.               lcd.print("Suono");
  1348.               lcd.setCursor(11,0);
  1349.               lcd.print("X1");
  1350.               int sou=analogRead(A0);
  1351.               lcd.setCursor(0, 1);
  1352.               lcd.print(abs(sou-calibrate));
  1353.               float souv=(sou*5.000)/1024.000;
  1354.               lcd.setCursor(9, 1);
  1355.               lcd.print("@V");
  1356.               lcd.setCursor(11, 1);
  1357.               lcd.print(souv);
  1358.               if((abs(sou-calibrate)<200)){
  1359.                 int ser=(9*(abs(sou-calibrate)))/200;
  1360.                 Serial.print(ser);
  1361.               }
  1362.             }
  1363.              
  1364.               if(page==3){
  1365.               //if (Serial.available()) {
  1366.               lcd.setCursor(0,0);
  1367.               lcd.print("Suono");
  1368.               int sou=analogRead(A0);
  1369.               lcd.setCursor(0, 1);
  1370.               lcd.print(abs(sou-calibrate));
  1371.               float souv=(sou*5.000)/1024.000;
  1372.               lcd.setCursor(4, 1);
  1373.               lcd.print("@V");
  1374.               lcd.setCursor(6, 1);
  1375.               lcd.print(souv);
  1376.               if(Serial.available() >0){
  1377.                  delay(10);
  1378.                  int lastserial2=(getserial()-1000);
  1379.                  lastserial=lastserial2/2;
  1380.                }
  1381.                lcd.setCursor(11, 1);
  1382.               lcd.print(lastserial);
  1383.               if((abs(sou-calibrate)<lastserial)){
  1384.                  
  1385.                 int ser=(9*(abs(sou-calibrate)))/lastserial;
  1386.                 Serial.print(ser);
  1387.               }
  1388.               else{
  1389.                 int ser=9;
  1390.                 Serial.print(ser);
  1391.                  }
  1392.            
  1393.             /*else {
  1394.                     lcd.setCursor(0,0);
  1395.                     lcd.print("Connetti");
  1396.                     lcd.setCursor(0,1);
  1397.                     lcd.print("Seriale");
  1398.             }*/
  1399.               }
  1400.                      
  1401.                    if (buttonState == HIGH){
  1402.             lcd.clear();
  1403.             delay(200);
  1404.             if(page<=0){
  1405.                 page=maxpage;
  1406.               }
  1407.             else{
  1408.               page--;
  1409.               }
  1410.            }
  1411.          if (buttonState2 == HIGH){
  1412.             lcd.clear();
  1413.             delay(200);
  1414.             if(page>=0){
  1415.               if(page<=maxpage){
  1416.                 page++;
  1417.               }
  1418.               if(page>maxpage){
  1419.                 page=0;
  1420.               }
  1421.               }
  1422.           }
  1423.           if (buttonState3 == HIGH){
  1424.             lcd.clear();
  1425.             delay(200);
  1426.             arg=0;
  1427.             arg2=0;
  1428.             page=0;
  1429.         }  
  1430.         }//if arg 2
  1431.         }//while arg2
  1432.        
  1433.            if(arg2== 2){
  1434.          int d=0;
  1435.          int lastserial=1;// non zero altrimenti dividi per 0
  1436.         while(arg2 == 2){
  1437.             maxpage=6;
  1438.            
  1439.             buttonState = digitalRead(6);
  1440.             buttonState2 = digitalRead(7);
  1441.             buttonState3 = digitalRead(8);
  1442.             if(d==0){
  1443.            lcd.setCursor(0,0);
  1444.            lcd.print("OK Per Calibrare");
  1445.            delay(100);
  1446.            while(buttonState3 == LOW)
  1447.             {
  1448.               delay(10);
  1449.               buttonState3 = digitalRead(8);
  1450.  
  1451.             }
  1452.             lcd.clear();
  1453.             calibrate=analogRead(A1);
  1454.             d++;
  1455.             buttonState3 = LOW;
  1456.             delay(100);
  1457.  
  1458.               }
  1459.             if(page==0){
  1460.               lcd.setCursor(0,0);
  1461.               lcd.print("Luminosita");
  1462.               lcd.setCursor(11,0);
  1463.               lcd.print("CalX3");
  1464.               int lum=analogRead(A1);
  1465.               lcd.setCursor(0, 1);
  1466.               lcd.print(abs(lum-calibrate));
  1467.               float lumv=(lum*5.000)/1024.000;
  1468.               lcd.setCursor(9, 1);
  1469.               lcd.print("@V");
  1470.               lcd.setCursor(11, 1);
  1471.               lcd.print(lumv);
  1472.               if((abs(lum-calibrate)<30)){
  1473.                 int ser=(9*(abs(lum-calibrate)))/30;
  1474.                 Serial.print(ser);
  1475.               }
  1476.               else{
  1477.                 int ser=9;
  1478.                 Serial.print(ser);
  1479.                  }
  1480.             }
  1481.              
  1482.               if(page==1){
  1483.               lcd.setCursor(0,0);
  1484.               lcd.print("Luminosita");
  1485.               lcd.setCursor(11,0);
  1486.               lcd.print("CalX2");
  1487.               int lum=analogRead(A1);
  1488.               lcd.setCursor(0, 1);
  1489.               lcd.print(abs(lum-calibrate));
  1490.               float lumv=(lum*5.000)/1024.000;
  1491.               lcd.setCursor(9, 1);
  1492.               lcd.print("@V");
  1493.               lcd.setCursor(11, 1);
  1494.               lcd.print(lumv);
  1495.               if((abs(lum-calibrate)<70)){
  1496.                 int ser=(9*(abs(lum-calibrate)))/70;
  1497.                 Serial.print(ser);
  1498.               }
  1499.               else{
  1500.                 int ser=9;
  1501.                 Serial.print(ser);
  1502.                  }
  1503.             }
  1504.             if(page==2){
  1505.               lcd.setCursor(0,0);
  1506.               lcd.print("Luminosita");
  1507.               lcd.setCursor(11,0);
  1508.               lcd.print("CalX1");
  1509.               int lum=analogRead(A1);
  1510.               lcd.setCursor(0, 1);
  1511.               lcd.print(abs(lum-calibrate));
  1512.               float lumv=(lum*5.000)/1024.000;
  1513.               lcd.setCursor(9, 1);
  1514.               lcd.print("@V");
  1515.               lcd.setCursor(11, 1);
  1516.               lcd.print(lumv);
  1517.               if((abs(lum-calibrate)<150)){
  1518.                 int ser=(9*(abs(lum-calibrate)))/150;
  1519.                 Serial.print(ser);
  1520.               }
  1521.               else{
  1522.                 int ser=9;
  1523.                 Serial.print(ser);
  1524.                  }
  1525.             }
  1526.                      
  1527.                      if(page==3){
  1528.               lcd.setCursor(0,0);
  1529.               lcd.print("Luminosita");
  1530.               lcd.setCursor(11,0);
  1531.               lcd.print("X3");
  1532.               int lum=analogRead(A1)+1;
  1533.               lcd.setCursor(0, 1);
  1534.               lcd.print(abs(lum));
  1535.               float lumv=(lum*5.000)/1025.000;
  1536.               lcd.setCursor(9, 1);
  1537.               lcd.print("@V");
  1538.               lcd.setCursor(11, 1);
  1539.               lcd.print(lumv);
  1540.               if((abs(lum)<50)){
  1541.                 int ser=(9*(abs(lum)))/50;
  1542.                 Serial.print(ser);
  1543.               }
  1544.               else{
  1545.                 int ser=9;
  1546.                 Serial.print(ser);
  1547.                  }
  1548.             }
  1549.              
  1550.               if(page==4){
  1551.               lcd.setCursor(0,0);
  1552.               lcd.print("Luminosita");
  1553.               lcd.setCursor(11,0);
  1554.               lcd.print("X2");
  1555.               int lum=analogRead(A1)+1;
  1556.               lcd.setCursor(0, 1);
  1557.               lcd.print(abs(lum));
  1558.               float lumv=(lum*5.000)/1025.000;
  1559.               lcd.setCursor(9, 1);
  1560.               lcd.print("@V");
  1561.               lcd.setCursor(11, 1);
  1562.               lcd.print(lumv);
  1563.               if((abs(lum)<100)){
  1564.                 int ser=(9*(abs(lum)))/100;
  1565.                 Serial.print(ser);
  1566.               }
  1567.               else{
  1568.                 int ser=9;
  1569.                 Serial.print(ser);
  1570.                  }
  1571.             }
  1572.             if(page==5){
  1573.               lcd.setCursor(0,0);
  1574.               lcd.print("Luminosita");
  1575.               lcd.setCursor(11,0);
  1576.               lcd.print("X1");
  1577.               int lum=analogRead(A1)+1;
  1578.               lcd.setCursor(0, 1);
  1579.               lcd.print(abs(lum-calibrate));
  1580.               float lumv=(lum*5.000)/1025.000;
  1581.               lcd.setCursor(9, 1);
  1582.               lcd.print("@V");
  1583.               lcd.setCursor(11, 1);
  1584.               lcd.print(lumv);
  1585.               if((abs(lum)<200)){
  1586.                 int ser=(9*(abs(lum)))/200;
  1587.                 Serial.print(ser);
  1588.               }
  1589.               else{
  1590.                 int ser=9;
  1591.                 Serial.print(ser);
  1592.                  }
  1593.             }
  1594.            
  1595.            
  1596.            
  1597.              if(page==6){
  1598.               lcd.setCursor(0,0);
  1599.               lcd.print("Luminosita");
  1600.               lcd.setCursor(11,0);
  1601.               lcd.print("Ser");
  1602.               int lum=analogRead(A1)+1;
  1603.               lcd.setCursor(0, 1);
  1604.               lcd.print(abs(lum-calibrate));
  1605.               float lumv=(lum*5.000)/1025.000;
  1606.               lcd.setCursor(4, 1);
  1607.               lcd.print("@V");
  1608.               lcd.setCursor(6, 1);
  1609.               lcd.print(lumv);
  1610.               if(Serial.available() >0){
  1611.                  delay(10);
  1612.                  int lastserial2=(getserial()-1000);
  1613.                  lastserial=lastserial2/2;
  1614.                }
  1615.                lcd.setCursor(11, 1);
  1616.               lcd.print(lastserial);
  1617.               if((abs(lum-calibrate)<lastserial)){
  1618.                 int ser=(9*(abs(lum-calibrate)))/lastserial;
  1619.                 Serial.print(ser);
  1620.               }
  1621.               else{
  1622.                 int ser=9;
  1623.                 Serial.print(ser);
  1624.                  }
  1625.             }
  1626.                        
  1627.                    if (buttonState == HIGH){
  1628.             lcd.clear();
  1629.             delay(200);
  1630.             if(page<=0){
  1631.                 page=maxpage;
  1632.               }
  1633.             else{
  1634.               page--;
  1635.               }
  1636.            }
  1637.          if (buttonState2 == HIGH){
  1638.             lcd.clear();
  1639.             delay(200);
  1640.             if(page>=0){
  1641.               if(page<=maxpage){
  1642.                 page++;
  1643.               }
  1644.               if(page>maxpage){
  1645.                 page=0;
  1646.               }
  1647.               }
  1648.           }
  1649.           if (buttonState3 == HIGH){
  1650.             lcd.clear();
  1651.             delay(200);
  1652.             arg=0;
  1653.             arg2=0;
  1654.             page=0;
  1655.         }  
  1656.         }//if arg 2
  1657.         }//while arg2
  1658.        
  1659.        
  1660.        
  1661.         if(arg2==3){
  1662.         while(arg2 == 3){
  1663.             maxpage=0;
  1664.             buttonState = digitalRead(6);
  1665.             buttonState2 = digitalRead(7);
  1666.             buttonState3 = digitalRead(8);
  1667.  
  1668.             if(page==0){
  1669.               if (Serial.available()) {
  1670.                 delay(10);
  1671.                 lcd.clear();
  1672.                 while (Serial.available() > 0) {
  1673.                 lcd.write(Serial.read());
  1674.                           }
  1675.                   }
  1676.               }
  1677.                        
  1678.                    if (buttonState == HIGH){
  1679.             lcd.clear();
  1680.             delay(200);
  1681.             if(page<=0){
  1682.                 page=maxpage;
  1683.               }
  1684.             else{
  1685.               page--;
  1686.               }
  1687.            }
  1688.          if (buttonState2 == HIGH){
  1689.             lcd.clear();
  1690.             delay(200);
  1691.             if(page>=0){
  1692.               if(page<=maxpage){
  1693.                 page++;
  1694.               }
  1695.               if(page>maxpage){
  1696.                 page=0;
  1697.               }
  1698.               }
  1699.           }
  1700.           if (buttonState3 == HIGH){
  1701.             lcd.clear();
  1702.             delay(200);
  1703.             arg=0;
  1704.             arg2=0;
  1705.             page=0;
  1706.         }  
  1707.         }//if arg 2
  1708.         }//while arg2
  1709.        
  1710.        
  1711.    }//while
  1712.   } //if
  1713.  
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  }// arg <0
  1719. }// loop
RAW Paste Data