Justinberger

Buzzer2021.ino

Jul 25th, 2021
771
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <SPI.h>
  2. #include <Ethernet.h>
  3.  
  4. // Enter a MAC address and IP address for your controller below.
  5. // The IP address will be dependent on your local network:
  6. byte mac[] = {
  7.     0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
  8. IPAddress ip(169, 254, 173, 3);
  9.  
  10. // Initialize the Ethernet server library
  11. // with the IP address and port you want to use
  12. // (port 80 is default for HTTP):
  13. EthernetServer server(80);
  14.  
  15. /*
  16.  ************************************************
  17.  ************** MAKEY MAKEY *********************
  18.  ************************************************
  19.  
  20.  /////////////////////////////////////////////////
  21.  /////////////HOW TO EDIT THE KEYS ///////////////
  22.  /////////////////////////////////////////////////
  23.  - Edit keys in the settings.h file
  24.  - that file should be open in a tab above (in Arduino IDE)
  25.  - more instructions are in that file
  26.  
  27.  //////////////////////////////////////////////////
  28.  ///////// MaKey MaKey FIRMWARE v1.4.1 ////////////
  29.  //////////////////////////////////////////////////
  30.  by: Eric Rosenbaum, Jay Silver, and Jim Lindblom
  31.  MIT Media Lab & Sparkfun
  32.  start date: 2/16/2012
  33.  current release: 7/5/2012
  34.  */
  35.  
  36. /////////////////////////
  37. // DEBUG DEFINITIONS ////
  38. /////////////////////////
  39. //#define DEBUG
  40. //#define DEBUG2
  41. //#define DEBUG3
  42. //#define DEBUG_TIMING
  43. //#define DEBUG_MOUSE
  44. //#define DEBUG_TIMING2
  45.  
  46. ////////////////////////
  47. // DEFINED CONSTANTS////
  48. ////////////////////////
  49.  
  50. #define BUFFER_LENGTH 3 // 3 bytes gives us 24 samples
  51. #define NUM_INPUTS 8    // 8 on the front
  52. //#define TARGET_LOOP_TIME 694   // (1/60 seconds) / 24 samples = 694 microseconds per sample
  53. //#define TARGET_LOOP_TIME 758  // (1/55 seconds) / 24 samples = 758 microseconds per sample
  54. //#define TARGET_LOOP_TIME 744  // (1/56 seconds) / 24 samples = 744 microseconds per sample
  55. #define TARGET_LOOP_TIME 833 // (1/50 seconds) / 24 samples = 833 microseconds per sample
  56. //#define TARGET_LOOP_TIME 847  // (1/44 seconds) / 24 samples = 817 microseconds per sample
  57.  
  58. #define ledPin1 42
  59. #define ledPin2 43
  60. #define ledPin3 44
  61. #define ledPin4 45
  62. #define ledPin5 46
  63. #define ledPin6 47
  64. #define PIN_BUZZER 48
  65. #define PIN_BUZZER1 49
  66.  
  67. // Pin Numbers
  68. // input pin numbers for kickstarter production board
  69. int pinNumbers[NUM_INPUTS] = {
  70.     A0,
  71.     A1,
  72.     A2,
  73.     A3,
  74.     A4,
  75.     A5,
  76.     A8,
  77.     A9,
  78. };
  79.  
  80. ///////////////////////////
  81. // NOISE CANCELLATION /////
  82. ///////////////////////////
  83. #define SWITCH_THRESHOLD_OFFSET_PERC 2 // number between 1 and 49                                                                           \
  84.                                         // larger value protects better against noise oscillations, but makes it harder to press and release \
  85.                                         // recommended values are between 2 and 20                                                           \
  86.                                         // default value is 5
  87.  
  88. #define SWITCH_THRESHOLD_CENTER_BIAS 30 //90 // number between 1 and 99                                                \
  89.                                         // larger value makes it easier to "release" keys, but harder to "press"  \
  90.                                         // smaller value makes it easier to "press" keys, but harder to "release" \
  91.                                         // recommended values are between 30 and 70                               \
  92.                                         // 50 is "middle" 2.5 volt center                                         \
  93.                                         // default value is 55                                                    \
  94.                                         // 100 = 5V (never use this high)                                         \
  95.                                         // 0 = 0 V (never use this low
  96.  
  97. /////////////////////////
  98. // STRUCT ///////////////
  99. /////////////////////////
  100. typedef struct
  101. {
  102.   byte pinNumber;
  103.   byte measurementBuffer[BUFFER_LENGTH];
  104.   boolean oldestMeasurement;
  105.   byte bufferSum;
  106.   boolean pressed;
  107.   boolean prevPressed;
  108. } MakeyMakeyInput;
  109.  
  110. MakeyMakeyInput inputs[NUM_INPUTS];
  111.  
  112. ///////////////////////////////////
  113. // VARIABLES //////////////////////
  114. ///////////////////////////////////
  115. int bufferIndex = 0;
  116. byte byteCounter = 0;
  117. byte bitCounter = 0;
  118. int pressThreshold;
  119. int releaseThreshold;
  120. boolean inputChanged;
  121.  
  122. // input status LED pin numbers
  123. const int inputLED = 13;
  124. byte ledCycleCounter = 0;
  125.  
  126. // timing
  127. int loopTime = 0;
  128. int prevTime = 0;
  129. int loopCounter = 0;
  130.  
  131. // jeu
  132. int Equipe = 0;
  133. int valeur;
  134. int score_equipe1;
  135. int score_equipe2;
  136. int score_equipe3;
  137. int score_equipe4;
  138. int score_equipe5;
  139. int score_equipe6;
  140. byte equipe1;
  141. byte equipe2;
  142. byte equipe3;
  143. byte equipe4;
  144. byte equipe5;
  145. byte equipe6;
  146. boolean mequipe1;
  147. boolean mequipe2;
  148. boolean mequipe3;
  149. boolean mequipe4;
  150. boolean mequipe5;
  151. boolean mequipe6;
  152. unsigned long prevMillis = 0;
  153. unsigned long prevMillis1 = 0;
  154. unsigned long prevMillis2 = 0;
  155. int tvalval;
  156. int temps;
  157. String resultat;
  158. float ton = 0.1;
  159. int reponse = 5000;
  160. byte NEquipe;
  161. byte Penalite;
  162.  
  163. ///////////////////////////
  164. // FUNCTIONS //////////////
  165. ///////////////////////////
  166. void initializeArduino();
  167. void initializeInputs();
  168. void initializeEthernet();
  169. void updateMeasurementBuffers();
  170. void updateBufferSums();
  171. void updateBufferIndex();
  172. void updateInputStates();
  173. void jeu();
  174. void webserver();
  175.  
  176. //////////////////////
  177. // SETUP /////////////
  178. //////////////////////
  179. void setup()
  180. {
  181.   Serial.begin(9600);
  182.   initializeArduino();
  183.   initializeInputs();
  184.  
  185.   while (!Serial)
  186.   {
  187.     ; // wait for serial port to connect. Needed for Leonardo only
  188.   }
  189.  
  190.   // start the Ethernet connection and the server:
  191.   Ethernet.begin(mac, ip);
  192.   server.begin();
  193.   Serial.print("server is at ");
  194.   Serial.println(Ethernet.localIP());
  195.  
  196.   pinMode(ledPin1, OUTPUT);
  197.   pinMode(ledPin2, OUTPUT);
  198.   pinMode(ledPin3, OUTPUT);
  199.   pinMode(ledPin4, OUTPUT);
  200.   pinMode(ledPin5, OUTPUT);
  201.   pinMode(ledPin6, OUTPUT);
  202.  
  203.   pinMode(PIN_BUZZER, OUTPUT);
  204.   pinMode(PIN_BUZZER1, OUTPUT);
  205. }
  206.  
  207. ////////////////////
  208. // MAIN LOOP ///////
  209. ////////////////////
  210. void loop()
  211. {
  212.   updateMeasurementBuffers();
  213.   updateBufferSums();
  214.   updateBufferIndex();
  215.   updateInputStates();
  216.   jeu();
  217.   webserver();
  218. }
  219.  
  220. //////////////////////////
  221. // INITIALIZE ARDUINO
  222. //////////////////////////
  223. void initializeArduino()
  224. {
  225. #ifdef DEBUG
  226.   Serial.begin(9600); // Serial for debugging
  227. #endif
  228.   /* Set up input pins
  229.    DEactivate the internal pull-ups, since we're using external resistors */
  230.   for (int i = 0; i < NUM_INPUTS; i++)
  231.   {
  232.     pinMode(pinNumbers[i], INPUT);
  233.     digitalWrite(pinNumbers[i], LOW);
  234.   }
  235.  
  236.   //  pinMode(inputLED, OUTPUT);
  237.  
  238. #ifdef DEBUG
  239.   delay(4000); // allow us time to reprogram in case things are freaking out
  240. #endif
  241. }
  242.  
  243. ///////////////////////////
  244. // INITIALIZE INPUTS
  245. ///////////////////////////
  246. void initializeInputs()
  247. {
  248.  
  249.   float thresholdPerc = SWITCH_THRESHOLD_OFFSET_PERC;
  250.   float thresholdCenterBias = SWITCH_THRESHOLD_CENTER_BIAS / 50.0;
  251.   float pressThresholdAmount = (BUFFER_LENGTH * 8) * (thresholdPerc / 100.0);
  252.   float thresholdCenter = ((BUFFER_LENGTH * 8) / 2.0) * (thresholdCenterBias);
  253.   pressThreshold = int(thresholdCenter + pressThresholdAmount);
  254.   releaseThreshold = int(thresholdCenter - pressThresholdAmount);
  255.  
  256. #ifdef DEBUG
  257.   Serial.println(pressThreshold);
  258.   Serial.println(releaseThreshold);
  259. #endif
  260.  
  261.   for (int i = 0; i < NUM_INPUTS; i++)
  262.   {
  263.     inputs[i].pinNumber = pinNumbers[i];
  264.  
  265.     for (int j = 0; j < BUFFER_LENGTH; j++)
  266.     {
  267.       inputs[i].measurementBuffer[j] = 0;
  268.     }
  269.     inputs[i].oldestMeasurement = 0;
  270.     inputs[i].bufferSum = 0;
  271.  
  272.     inputs[i].pressed = false;
  273.     inputs[i].prevPressed = false;
  274.  
  275. #ifdef DEBUG
  276.     Serial.println(i);
  277. #endif
  278.   }
  279. }
  280.  
  281. ///////////////////////////
  282. // INITIALIZE EThERNET
  283. ///////////////////////////
  284.  
  285. void initializeEthernet()
  286.  
  287. {
  288. }
  289.  
  290. //////////////////////////////
  291. // UPDATE MEASUREMENT BUFFERS
  292. //////////////////////////////
  293. void updateMeasurementBuffers()
  294. {
  295.  
  296.   for (int i = 0; i < NUM_INPUTS; i++)
  297.   {
  298.  
  299.     // store the oldest measurement, which is the one at the current index,
  300.     // before we update it to the new one
  301.     // we use oldest measurement in updateBufferSums
  302.     byte currentByte = inputs[i].measurementBuffer[byteCounter];
  303.     inputs[i].oldestMeasurement = (currentByte >> bitCounter) & 0x01;
  304.  
  305.     // make the new measurement
  306.     boolean newMeasurement = digitalRead(inputs[i].pinNumber);
  307.  
  308.     // invert so that true means the switch is closed
  309.     newMeasurement = !newMeasurement;
  310.  
  311.     // store it
  312.     if (newMeasurement)
  313.     {
  314.       currentByte |= (1 << bitCounter);
  315.     }
  316.     else
  317.     {
  318.       currentByte &= ~(1 << bitCounter);
  319.     }
  320.     inputs[i].measurementBuffer[byteCounter] = currentByte;
  321.   }
  322. }
  323.  
  324. ///////////////////////////
  325. // UPDATE BUFFER SUMS
  326. ///////////////////////////
  327. void updateBufferSums()
  328. {
  329.  
  330.   // the bufferSum is a running tally of the entire measurementBuffer
  331.   // add the new measurement and subtract the old one
  332.  
  333.   for (int i = 0; i < NUM_INPUTS; i++)
  334.   {
  335.     byte currentByte = inputs[i].measurementBuffer[byteCounter];
  336.     boolean currentMeasurement = (currentByte >> bitCounter) & 0x01;
  337.     if (currentMeasurement)
  338.     {
  339.       inputs[i].bufferSum++;
  340.     }
  341.     if (inputs[i].oldestMeasurement)
  342.     {
  343.       inputs[i].bufferSum--;
  344.     }
  345.   }
  346. }
  347.  
  348. ///////////////////////////
  349. // UPDATE BUFFER INDEX
  350. ///////////////////////////
  351. void updateBufferIndex()
  352. {
  353.   bitCounter++;
  354.   if (bitCounter == 8)
  355.   {
  356.     bitCounter = 0;
  357.     byteCounter++;
  358.     if (byteCounter == BUFFER_LENGTH)
  359.     {
  360.       byteCounter = 0;
  361.     }
  362.   }
  363. }
  364. ///////////////////////////
  365. // UPDATE INPUT STATES
  366. ///////////////////////////
  367. void updateInputStates()
  368. {
  369.   inputChanged = false;
  370.   for (int i = 0; i < NUM_INPUTS; i++)
  371.   {
  372.     inputs[i].prevPressed = inputs[i].pressed; // store previous pressed state (only used for mouse buttons)
  373.     if (inputs[i].pressed)
  374.     {
  375.       if (inputs[i].bufferSum < releaseThreshold)
  376.       {
  377.         inputChanged = true;
  378.         inputs[i].pressed = false;
  379.       }
  380.     }
  381.     else if (!inputs[i].pressed)
  382.     {
  383.       if (inputs[i].bufferSum > pressThreshold)
  384.       { // input becomes pressed
  385.         inputChanged = true;
  386.         inputs[i].pressed = true;
  387.       }
  388.     }
  389.   }
  390. #ifdef DEBUG3
  391.   if (inputChanged)
  392.   {
  393.     Serial.println("change");
  394.   }
  395. #endif
  396. }
  397.  
  398. void jeu()
  399. {
  400.   //// Touches equipes ////
  401.   if (Equipe == 0)
  402.   {
  403.     for (int i = 0; i < 6; i++)
  404.     {
  405.       if (inputs[i].pressed)
  406.       {
  407.         Equipe = i + 1;
  408.         tone(PIN_BUZZER, 2637 * ton, 400);
  409.         tone(PIN_BUZZER1, 2637 * ton, 400);
  410.         Serial.println((String) "Equipe : " + Equipe);
  411.         if ((millis() - prevMillis) > 5000 && Equipe != 0)
  412.         {
  413.           prevMillis = millis();
  414.         }
  415.       }
  416.     }
  417.   }
  418.   temps = millis() - prevMillis;
  419.  
  420.   // Pénalité si jamais une equipe buzzer pendant le temps de réponse d'une autre //
  421.   if (temps >= 2000 && temps <= 4900)
  422.   {
  423.     for (int i = 0; i < 6; i++)
  424.     {
  425.       if (inputs[i].pressed)
  426.       {
  427.         Penalite++;
  428.         NEquipe = i + 1;
  429.  
  430.         Serial.println((String) "Equipe : " + Equipe + "-1");
  431.         if ((millis() - prevMillis1) > 500 && Equipe != 0)
  432.         {
  433.           prevMillis1 = millis();
  434.           Penalite = 0;
  435.         }
  436.         if (NEquipe != Equipe && Penalite == 1)
  437.         {
  438.           tone(PIN_BUZZER, 2637 * ton, 400);
  439.           tone(PIN_BUZZER1, 2637 * ton, 400);
  440.           if (NEquipe == 1)
  441.           {
  442.             --score_equipe1;
  443.           }
  444.           if (NEquipe == 2)
  445.           {
  446.             --score_equipe2;
  447.           }
  448.           if (NEquipe == 3)
  449.           {
  450.             --score_equipe3;
  451.           }
  452.           if (NEquipe == 4)
  453.           {
  454.             --score_equipe4;
  455.           }
  456.           if (NEquipe == 5)
  457.           {
  458.             --score_equipe5;
  459.           }
  460.           if (NEquipe == 6)
  461.           {
  462.             --score_equipe6;
  463.           }
  464.         }
  465.       }
  466.     }
  467.   }
  468.  
  469.   if (temps >= 4900 && temps <= 5000 && Equipe != 0)
  470.   {
  471.     Serial.println("Remise en jeu");
  472.     resultat = "";
  473.     Equipe = 0;
  474.     Serial.println((String) "Equipe : " + Equipe);
  475.  
  476.     tone(PIN_BUZZER, 2637 * ton, 300);
  477.     tone(PIN_BUZZER1, 2637 * ton, 300);
  478.     Serial.println("sonnerie");
  479.     delay(200);
  480.     Serial.println("sonnerie1");
  481.     tone(PIN_BUZZER, 1975 * ton, 400);
  482.     tone(PIN_BUZZER1, 1975 * ton, 400);
  483.   }
  484.  
  485.   //___________________________________________________________________EQUIPE 1______________//
  486.   if (Equipe == 1)
  487.   {
  488.     digitalWrite(ledPin1, HIGH);
  489.     resultat = "EQUIPE 1";
  490.     equipe1 = score_equipe1 + valeur;
  491.     mequipe1 = 1;
  492.     mequipe2 = 0;
  493.     mequipe3 = 0;
  494.     mequipe4 = 0;
  495.     mequipe5 = 0;
  496.     mequipe6 = 0;
  497.   }
  498.   //___________________________________________________________________EQUIPE 2______________//
  499.   else if (Equipe == 2)
  500.   {
  501.     digitalWrite(ledPin2, HIGH);
  502.     resultat = "EQUIPE 2";
  503.     equipe2 = score_equipe2 + valeur;
  504.     mequipe1 = 0;
  505.     mequipe2 = 1;
  506.     mequipe3 = 0;
  507.     mequipe4 = 0;
  508.     mequipe5 = 0;
  509.     mequipe6 = 0;
  510.   }
  511.   //___________________________________________________________________EQUIPE 3______________//
  512.   else if (Equipe == 3)
  513.   {
  514.     digitalWrite(ledPin3, HIGH);
  515.     resultat = "EQUIPE 3";
  516.     equipe3 = score_equipe3 + valeur;
  517.     mequipe1 = 0;
  518.     mequipe2 = 0;
  519.     mequipe3 = 1;
  520.     mequipe4 = 0;
  521.     mequipe5 = 0;
  522.     mequipe6 = 0;
  523.   }
  524.  
  525.   //___________________________________________________________________EQUIPE 4______________//
  526.   else if (Equipe == 4)
  527.   {
  528.     digitalWrite(ledPin4, HIGH);
  529.     resultat = "EQUIPE 4";
  530.     equipe4 = score_equipe4 + valeur;
  531.     mequipe1 = 0;
  532.     mequipe2 = 0;
  533.     mequipe3 = 0;
  534.     mequipe4 = 1;
  535.     mequipe5 = 0;
  536.     mequipe6 = 0;
  537.   }
  538.  
  539.   //___________________________________________________________________EQUIPE 5______________//
  540.   else if (Equipe == 5)
  541.   {
  542.     digitalWrite(ledPin5, HIGH);
  543.     resultat = "EQUIPE 5";
  544.     equipe5 = score_equipe5 + valeur;
  545.     mequipe1 = 0;
  546.     mequipe2 = 0;
  547.     mequipe3 = 0;
  548.     mequipe4 = 0;
  549.     mequipe5 = 1;
  550.     mequipe6 = 0;
  551.   }
  552.   //___________________________________________________________________EQUIPE 6______________//
  553.   else if (Equipe == 6)
  554.   {
  555.     digitalWrite(ledPin6, HIGH);
  556.     resultat = "EQUIPE 6";
  557.     equipe6 = score_equipe6 + valeur;
  558.     mequipe1 = 0;
  559.     mequipe2 = 0;
  560.     mequipe3 = 0;
  561.     mequipe4 = 0;
  562.     mequipe5 = 0;
  563.     mequipe6 = 1;
  564.   }
  565.  
  566.   else
  567.   {
  568.     digitalWrite(ledPin1, LOW);
  569.     digitalWrite(ledPin2, LOW);
  570.     digitalWrite(ledPin3, LOW);
  571.     digitalWrite(ledPin4, LOW);
  572.     digitalWrite(ledPin5, LOW);
  573.     digitalWrite(ledPin6, LOW);
  574.   }
  575.  
  576.   //// Touches calcul de la valeur et validation ////
  577.   if (inputs[6].pressed || inputs[7].pressed)
  578.   {
  579.     tvalval++;
  580.     if ((millis() - prevMillis2) > 500)
  581.     {
  582.       prevMillis2 = millis();
  583.       tvalval = 0;
  584.     }
  585.  
  586.     /// Calcul de la valeur de la question ////
  587.     if (tvalval == 1 && inputs[6].pressed)
  588.     {
  589.       valeur++;
  590.       if (valeur > 5)
  591.       {
  592.         valeur = -1;
  593.       }
  594.       Serial.println((String) "Valeur : " + valeur);
  595.     }
  596.  
  597.     ////Validation de la réponse
  598.     if (tvalval == 1 && inputs[7].pressed)
  599.     {
  600.       if (mequipe1 == 1)
  601.       {
  602.         score_equipe1 = equipe1;
  603.         mequipe1 = 0;
  604.         valeur = 0;
  605.       }
  606.       if (mequipe2 == 1)
  607.       {
  608.         score_equipe2 = equipe2;
  609.         mequipe2 = 0;
  610.         valeur = 0;
  611.       }
  612.       if (mequipe3 == 1)
  613.       {
  614.         score_equipe3 = equipe3;
  615.         mequipe3 = 0;
  616.         valeur = 0;
  617.       }
  618.       if (mequipe4 == 1)
  619.       {
  620.         score_equipe4 = equipe4;
  621.         mequipe4 = 0;
  622.         valeur = 0;
  623.       }
  624.       if (mequipe5 == 1)
  625.       {
  626.         score_equipe5 = equipe5;
  627.         mequipe3 = 0;
  628.         valeur = 0;
  629.       }
  630.       if (mequipe6 == 1)
  631.       {
  632.         score_equipe6 = equipe6;
  633.         mequipe6 = 0;
  634.         valeur = 0;
  635.       }
  636.       Serial.println((String) "Score equipe 1 : " + score_equipe1);
  637.       Serial.println((String) "Score equipe 2 : " + score_equipe2);
  638.       Serial.println((String) "Score equipe 3 : " + score_equipe3);
  639.       Serial.println((String) "Score equipe 4 : " + score_equipe4);
  640.       Serial.println((String) "Score equipe 5 : " + score_equipe5);
  641.       Serial.println((String) "Score equipe 6 : " + score_equipe6);
  642.     }
  643.   }
  644. }
  645.  
  646. void webserver()
  647. {
  648.  
  649.   //Serveur WEB
  650.   // listen for incoming clients
  651.   EthernetClient client = server.available();
  652.   if (client)
  653.   {
  654.     //    Serial.println("new client");
  655.     // an http request ends with a blank line
  656.     boolean currentLineIsBlank = true;
  657.     while (client.connected())
  658.     {
  659.       if (client.available())
  660.       {
  661.         char c = client.read();
  662.         //  Serial.write(c); //permet d'afficher tous les paramètres du client qui se connectes if you've gotten to the end of the line (received a newline character) and the line is blank, the http request has ended, so you can send a reply
  663.         if (c == '\n' && currentLineIsBlank)
  664.         {
  665.           // send a standard http response header
  666.           client.println("HTTP/1.1 200 OK");
  667.           client.println("Content-Type: text/html");
  668.           client.println("Connection: close"); // the connection will be closed after completion of the response
  669.           client.println("Refresh: 0.01");     // refresh the page automatically every 0.01 sec
  670.           client.println();
  671.           client.println("<!DOCTYPE HTML>");
  672.           client.println("<html>");
  673.           client.println("    <head>");
  674.           client.println("        <title>Blind test</title>");
  675.           client.println("        <style type=text/css>");
  676.           client.println("            h1 {font-family: courier, courier-new, serif;");
  677.           client.println("                font-size: 32pt;");
  678.           client.println("                color: blue;");
  679.           client.println("                border-bottom: 2px solid blue;}");
  680.           client.println("            p1 {font-family: arial, verdana, sans-serif;");
  681.           client.println("                font-size: 24pt;");
  682.           client.println("                color: #00FF00;");
  683.           client.println("                font-weight: bold;}"); //Style Gras
  684.           client.println("            table{font-family: arial, verdana, sans-serif;");
  685.           client.println("                font-size: 20pt;");
  686.           client.println("                margin: auto;");
  687.           client.println("                text-align: center;}");
  688.           client.println("            td {border: 1px solid #333;}");
  689.           client.println("                thead,");
  690.           client.println("            tfoot {background-color: #333;");
  691.           client.println("                   color: #fff;}");
  692.           client.println("        </style>");
  693.           client.println("    </head>");
  694.           client.println("    <body>");
  695.           client.println("        <h1>Blind Test</h1>");
  696.  
  697.           ////////////////////////////////////////////////////////////////////////////////////////////////////////
  698.           client.println((String) "        <p1>" + resultat + "</p1>");
  699.           client.println("        <br><br>");
  700.           client.println((String) "        <p1>Question &agrave;</p1>");
  701.           client.println((String) "        <p1>" + valeur + " points</p1>");
  702.           client.println("        <br><br><br><br><br><br>");
  703.           ////////////////////////////////////////////////////////////////////////////////////////////////////////
  704.           //___________________________________________________________________Affichage du score______________//
  705.  
  706.           client.println("<table>");
  707.           client.println("    <thead>");
  708.           client.println("        <tr>");
  709.           client.println("            <th colspan=6>Score</th>");
  710.           client.println("        </tr>");
  711.           client.println("    </thead>");
  712.           client.println("        <tr>");
  713.           client.println("            <td>. Equipe 1 .</td>");
  714.           client.println("            <td>. Equipe 2 .</td>");
  715.           client.println("            <td>. Equipe 3 .</td>");
  716.           client.println("            <td>. Equipe 4 .</td>");
  717.           client.println("            <td>. Equipe 5 .</td>");
  718.           client.println("            <td>. Equipe 6 .</td>");
  719.           client.println("        </tr>");
  720.           client.println("        <tr>");
  721.           client.println((String) "            <td>" + score_equipe1 + "</td>");
  722.           client.println((String) "            <td>" + score_equipe2 + "</td>");
  723.           client.println((String) "            <td>" + score_equipe3 + "</td>");
  724.           client.println((String) "            <td>" + score_equipe4 + "</td>");
  725.           client.println((String) "            <td>" + score_equipe5 + "</td>");
  726.           client.println((String) "            <td>" + score_equipe6 + "</td>");
  727.           client.println("        </tr>");
  728.           client.println("</table>");
  729.           client.println("</body>");
  730.           client.println("</html>");
  731.           break;
  732.         }
  733.         if (c == '\n')
  734.         {
  735.           // you're starting a new line
  736.           currentLineIsBlank = true;
  737.         }
  738.         else if (c != '\r')
  739.         {
  740.           // you've gotten a character on the current line
  741.           currentLineIsBlank = false;
  742.         }
  743.       }
  744.     }
  745.     // give the web browser time to receive the data
  746.     // delay(1);
  747.     // close the connection:
  748.     client.stop();
  749.   }
  750. }
RAW Paste Data