API tools faq
paste
Advertisement
Guest User

lasertagV3.0

a guest
May 12th, 2015
227
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 69.31 KB | None | 0 0
raw download clone embed print report
  1. #include <Wire.h>
  2. #include <LiquidCrystal_I2C.h>
  3. #include <EEPROM.h>
  4. #include <EasyTransfer.h>
  5. #include <SPI.h> // Pour la gestion du port SPI
  6. #include <Mirf.h> // Pour la gestion de la communication
  7. #include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
  8. #include <MirfHardwareSpiDriver.h> // Pour la communication SPI hardware (revient à utiliser SPI.h mais avec une surcouche en plus)
  9. //create two objects
  10.  
  11. EasyTransfer ETin, ETout;
  12.  
  13. struct RECEIVE_DATA_STRUCTURE{
  14.   //put your variable definitions here for the data you want to receive
  15.   //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
  16.   boolean triggerbutton;
  17.   boolean checktransmit;
  18.   unsigned long ballerx;
  19.   int overheatrx;
  20.   unsigned long tagread;
  21. };
  22.  
  23. struct SEND_DATA_STRUCTURE{
  24.   //put your variable definitions here for the data you want to receive
  25.   //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
  26.   int idjoueurtx;
  27.   int idteamtx;
  28.   int rpmtx;
  29.   int fireselecttx;
  30.   int bursttx;
  31.   boolean muzzletx;
  32.   int overheattx;
  33.   int degatstx;
  34.   boolean fireon;
  35.   int sendballe;
  36.   unsigned long loadtag;
  37. };
  38.  
  39. //give a name to the group of data
  40. RECEIVE_DATA_STRUCTURE rxdata;
  41. SEND_DATA_STRUCTURE txdata;
  42.  
  43. //Definition des broche
  44. //0 RX
  45. //1 TX
  46. #define maxchargeur 400
  47. #define pinreset 5
  48. #define ledhit 15
  49. #define wtsound 18//Et 19A voir
  50. #define keypin 2//config hc-05
  51. #define statusBT 3
  52. #define bouton0 29
  53. #define boutonMode 28
  54. #define bouton2 27
  55. #define bouton3 26
  56. #define bouton4 25
  57. #define bouton5 24
  58. #define bouton6 23
  59. #define bouton7 22
  60. #define pinbat A8
  61. #define vibreur1 A9
  62. #define vibreur2 A10
  63.  
  64. //Variable de jeu
  65. unsigned char idjoueur = 1; //1 a 99
  66. unsigned char idteam = 1; //1 a 4
  67. boolean friendlyfire = 0; //Tir amie
  68. int ballemax = 20; //De 0=illimité a 250
  69. int rpm = 1; //de 250 a 850 par pas de 50
  70. unsigned char fireselect = 1; //0 = Semi auto 1 = auto
  71. unsigned char burstmode = 3;//2-3-4-5-6
  72. boolean muzzle = 1; //muzzle flash on, off
  73. unsigned char overheat = 50;//Temp°C max du canon (1°C/seconde)
  74.  
  75. unsigned int numberhit = 0;//nombre de kill du joueur
  76. boolean respawnauto = 1; //Respawn automatique
  77. unsigned char respawnmax = 1; // 0 = illimité a 250
  78. unsigned char delayrespawn = 0; //10 - 180s par pas de 5s
  79.  
  80. unsigned char timemax = 20; //Compte a rebours plage de 0 = inactif a 240min(4h)
  81.  
  82. int pdv = 0;
  83. int pdvmax = 100; //1 - 500
  84. int bouclier = 0;
  85. int boucliermax = 100; //1 - 500
  86. unsigned char delaydoctor = 120; //Temps autorisé d'intervention du medecin de 0 = interdit a 180 seconde
  87.  
  88. boolean reuppdv = 1; //Activation récuperation des pdv automatique
  89. unsigned char reuppdvtime = 30; //fréquence de récuperation des pdv en seconde 1 - 120s
  90. unsigned char reuppdvper = 5;  //nombre de point récupéré par cycle 1 - 30pdv
  91. unsigned char reuppdvmax = 50; //Max de point de vie récuperable automatiquement 1 - 100pdv
  92.  
  93. boolean startauto = 1;
  94. unsigned char startdelay = 10; //0 - 240s
  95. unsigned char hitdelay = 0; // 0 - 20s temps d'incativité après un tir non mortel
  96. unsigned char degatsrecue = 0;
  97.  
  98. unsigned char timehitled = 120; //Durée d'alluma max des hit led de 1 a 240s
  99.  
  100. boolean backshoot = 1;
  101. char dirhit = 0;
  102. boolean headshoot = 0;
  103.  
  104. boolean zombie = 0;
  105.  
  106. //Variable systéme
  107. unsigned long timeconnect;
  108. boolean BTconnect;
  109. boolean TransmitBT;
  110.  
  111. boolean inmenuedit = 0;
  112. unsigned char menu = 1;
  113. boolean settingsok = 0;
  114. unsigned char choixdegats = 0; //index des degats (menu config) convertir en hex pour tx
  115.  
  116. boolean nooverheat = 1;
  117. boolean freezelcd = 0;
  118. unsigned long lastfreeze;
  119. unsigned long delaymille1;
  120. unsigned long delaymille2;
  121. unsigned long start = 0;
  122. boolean startsync = 0;
  123. boolean hitledzombie = 0;
  124. int time = 0;
  125. unsigned char heure = 0;
  126. unsigned char minute = 0;
  127. unsigned char seconde = 0;
  128. boolean fin = 1;
  129.  
  130. unsigned int timertone = 0;  // timer counter used for frequency
  131. unsigned int counttone = 0;  // counter for the lenght
  132. unsigned int resettone[] = {0,0,0,0,0,0,0,0,0,0};  // reset value for above timer   sound_freq = 40000 / (reset*2)
  133. unsigned int lenghttone[] = {0,0,0,0,0,0,0,0,0,0}; // wanted lenght of tone
  134. unsigned char indextone = 0;
  135.  
  136. char valdegats[] = {1,2,4,5,7,10,15,17,20,25,30,35,40,50,75,100};
  137. unsigned long lastview = 0;
  138. unsigned long lastmaj = 0;
  139. boolean waitdoc;
  140. unsigned long timedoc;
  141. boolean spawnbox;
  142. unsigned long counthitled;
  143. unsigned long lastup;
  144. int reuppdvcount;
  145. unsigned char appuielong;
  146. float niveau_batterie;
  147. unsigned int prcent_batt;
  148. boolean backlightlcd = 1;
  149. boolean backlightoff;
  150. unsigned long lastbacklight;
  151. boolean osdchange = 1;
  152.  
  153. unsigned int typenrf = 0;
  154. unsigned int donneenrf1 = 0;
  155. unsigned int donneenrf2 = 0;
  156. byte datareceive[6];//Variable de reception nrf 4 octet
  157. byte datasend[6]; //Variable envoie nrf 4 octet
  158.  
  159. int joueurcheck;
  160. long tagcheck;
  161. int ballecheck;
  162.  
  163. long currenttag = 0;
  164. int Nballe = 0;
  165. boolean tagstore = 0;
  166. int newid = 0;
  167. unsigned long chargeur[maxchargeur];
  168.  
  169. //Stockage des score
  170. unsigned int score[60];
  171.  
  172. //clonage
  173. unsigned char cloneteam = 0;
  174. boolean goclone;
  175.  
  176. //Valeur EEprom
  177. #define idjoueurAddr 10
  178. #define idteamAddr 20
  179. #define friendlyfireAddr 30
  180. #define balleAddr 40
  181. #define rpmAddr 50
  182. #define fireselectAddr 60
  183. #define burstmodeAddr 70
  184. #define muzzleAddr 80
  185. #define overheatAddr 90
  186.  
  187. #define respawnmaxAddr 100
  188. #define respawnautoAddr 110
  189. #define delayrespawnAddr 120
  190.  
  191. #define timeAddr 130
  192.  
  193. #define pdvAddr 140
  194. #define bouclierAddr 150
  195. #define delaydoctorAddr 160
  196.  
  197. #define reuppdvAddr 170
  198. #define reuppdvtimeAddr 180
  199. #define reuppdvperAddr 190
  200. #define reuppdvmaxAddr 200
  201.  
  202. #define startautoAddr 210
  203. #define startdelayAddr 220
  204. #define hitdelayAddr 230
  205.  
  206. #define choixdegatAddr 250
  207. #define timehitledAddr 260
  208. #define backshootAddr 270
  209. #define dirhitAddr 280
  210. #define zombieAddr 290
  211.      
  212. LiquidCrystal_I2C lcd(0x27,16,2);  // set the LCD address to 0x27 for a 16 chars and 2 line display
  213.  
  214. #define sbi(port,bit) (port)|=(1<<(bit))
  215. #define CLR(x,y) (x&=(~(1<<y)))
  216. #define SET(x,y) (x|=(1<<y))
  217.  
  218. // TX_RX const
  219. #define STATE_IDLE     2
  220. #define STATE_MARK     3
  221. #define STATE_SPACE    4
  222. #define STATE_STOP     5
  223. #define STATE_HDR     6
  224. #define MARK  0
  225. #define SPACE 1
  226.  
  227. //RX
  228. char tempidCodeJ;
  229. boolean dircapteur;
  230. boolean rxRead;
  231. boolean rxRead1;                                      //Capteur 1
  232. boolean rxRead2;                                       //Capteur 2
  233. boolean rxRead3;                                      //Capteur 3
  234. boolean rxRead4;                                       //Capteur 4
  235.  
  236. int rxState = STATE_IDLE;    // sets the state of the receiver to idle (default)
  237. unsigned int rxTimer;        // state timer, counts 25uS ticks.
  238. unsigned long rxData;    // result will be stored here
  239.  
  240. //Raw Analysis
  241. int rawData[49];
  242. int rawIndex = 0;
  243.  
  244. void setup(){
  245.   //Config NRF
  246.    Mirf.csnPin = 53;
  247.    Mirf.cePin = 10;
  248.  
  249.    Mirf.spi = &MirfHardwareSpi;
  250.    Mirf.init();
  251.    Mirf.channel = 99; // utilisation canal 0 pour communiquer (128 canaux disponible, de 0 à 127)
  252.    Mirf.payload = 6; //
  253.    Mirf.configRegister(RF_SETUP, 0x26); // 250 Kb/s et 0 dBm (puissance maximum)
  254.   // Mirf.configRegister(CONFIG, 0xa);
  255.    Mirf.config();
  256.    delay(10);
  257.    
  258.   //Lecture de l'eeprom
  259.   idjoueur = EEPROM.read(idjoueurAddr);
  260.   idteam = EEPROM.read(idteamAddr);
  261.   friendlyfire = EEPROM.read(friendlyfireAddr);
  262.   ballemax = EEPROM.read(balleAddr);
  263.   rpm = EEPROM.read(rpmAddr)*10;
  264.   fireselect = EEPROM.read(fireselectAddr);
  265.   burstmode = EEPROM.read(burstmodeAddr);
  266.   muzzle = EEPROM.read(muzzleAddr);
  267.   overheat = EEPROM.read(overheatAddr);
  268.   respawnmax = EEPROM.read(respawnmaxAddr);
  269.   respawnauto = EEPROM.read(respawnautoAddr);
  270.   delayrespawn = EEPROM.read(delayrespawnAddr);
  271.   timemax = EEPROM.read(timeAddr);
  272.   pdvmax = EEPROM.read(pdvAddr)*10;
  273.   boucliermax = EEPROM.read(bouclierAddr)*10;
  274.   delaydoctor = EEPROM.read(delaydoctorAddr);
  275.   reuppdv = EEPROM.read(reuppdvAddr);  
  276.   reuppdvtime = EEPROM.read(reuppdvtimeAddr);  
  277.   reuppdvper = EEPROM.read(reuppdvperAddr);  
  278.   reuppdvmax = EEPROM.read(reuppdvmaxAddr);  
  279.   startauto = EEPROM.read(startautoAddr);
  280.   startdelay = EEPROM.read(startdelayAddr);
  281.   hitdelay = EEPROM.read(hitdelayAddr);
  282.   choixdegats = EEPROM.read(choixdegatAddr);
  283.   timehitled = EEPROM.read(timehitledAddr);
  284.   backshoot = EEPROM.read(backshootAddr);
  285.   dirhit = EEPROM.read(dirhitAddr);
  286.   zombie = EEPROM.read(zombieAddr);
  287.  
  288.   if(idjoueur > 50 || ballemax > 250 || respawnmax > 250 || pdvmax > 500 || boucliermax > 500 || delaydoctor > 130 || startdelay == 0){
  289.     //Si on a des valeur incohérente on vide la mémoire
  290.     save(1);
  291.   }
  292.  
  293.  pinMode(pinreset, OUTPUT);
  294.  pinMode(ledhit, OUTPUT);
  295.  pinMode(statusBT, INPUT);
  296.  digitalWrite(ledhit, LOW);  
  297.  pinMode(keypin, OUTPUT);
  298.  pinMode(boutonMode, INPUT);
  299.  pinMode(pinbat ,INPUT);
  300.  pinMode(wtsound, OUTPUT);      //Buzzer pin
  301.  digitalWrite(wtsound, LOW);   //Buzzer
  302.   //Initialisation de l"ecran
  303.   lcd.init();    
  304.   defCarSpeciaux();  
  305.   lcd.backlight();
  306.   lcd.setCursor(0,0);
  307.   lcd.print(F("Laser Tag System"));
  308.   lcd.setCursor(4,1);
  309.   lcd.print(F("FR V2.1"));
  310.   startBt();
  311.  
  312.   boolean etatboutonmode = digitalRead(boutonMode);
  313.   boolean etatbouton0 = digitalRead(bouton0);
  314.  
  315.  
  316.    //Accés au menu Edition  
  317.      if(etatbouton0 == LOW){    
  318.         inmenuedit = 1;
  319.         lcd.clear();
  320.         lcd.setCursor(0,0);
  321.         lcd.print(F("  Menu config   "));
  322.      }
  323.      if(etatboutonmode == LOW){
  324.         inmenuedit = 2;  
  325.         lcd.clear();
  326.         lcd.setCursor(0,0);
  327.         lcd.print(F("  Clone Menu   ")) ;
  328.      }
  329.       delay(700);
  330.       lcd.clear();
  331.    
  332.    
  333.    
  334.    //-------
  335.   //  PWM  
  336.   //-------
  337.  
  338.   pinMode(6, INPUT); //set up pin for receiving
  339.   digitalWrite(6, LOW);
  340.   pinMode(7, INPUT); //set up pin for receiving
  341.   digitalWrite(7, LOW);
  342.   pinMode(8, INPUT); //set up pin for receiving
  343.   digitalWrite(8, LOW);
  344.   pinMode(9, INPUT); //set up pin for receiving
  345.   digitalWrite(9, LOW);
  346.  
  347.   TCCR2A = _BV(WGM21) | _BV(WGM20);
  348.   TCCR2B = _BV(WGM22) | _BV(CS21);
  349.  
  350.   OCR2A = 49;
  351.   OCR2B = 24;
  352.   TIMSK2 |= _BV(TOIE2); //activate interrupt on overflow (TOV flag, triggers at OCR2A)
  353.    
  354.   //Easy transfer
  355.   //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc.
  356.    ETin.begin(details(rxdata), &Serial);
  357.    ETout.begin(details(txdata), &Serial);
  358.  
  359. }
  360. void startBt(){
  361.  
  362.     Serial.begin(38400);
  363.   digitalWrite(keypin, HIGH);
  364.   digitalWrite(pinreset, LOW);
  365.   delay(10);
  366.   digitalWrite(pinreset, HIGH);
  367.   delay(500);
  368.   Serial.print("AT+UART=19200,0,0\r\n");
  369.   delay(1000);
  370.   Serial.print("AT+ROLE=1\r\n");
  371.   delay(1000);
  372.   Serial.print("AT+INIT\r\n");
  373.   delay(1000);
  374.   Serial.print("AT+CMODE=1\r\n");
  375.   delay(1000);
  376.   Serial.print("AT+CLASS=0\r\n");
  377.   delay(500);
  378.   Serial.begin(19200);
  379.   digitalWrite(keypin, LOW);
  380.   digitalWrite(pinreset, LOW);
  381.   delay(10);
  382.   digitalWrite(pinreset, HIGH);
  383.  
  384. }
  385. void loop(){
  386.  
  387.    if(inmenuedit == 1){
  388.          menuedit();
  389.    }
  390.    else if(inmenuedit == 2){
  391.          clonemenu();
  392.    }
  393.    else if(BTconnect == 0 && inmenuedit == 0){
  394.         TransmitBT = 0;
  395.         rxdata.checktransmit = 0;
  396.         lcd.backlight();
  397.         backlightlcd = 1;
  398.         osdchange = 1;
  399.         lcd.setCursor(0,0);
  400.         lcd.print(F("   CONNEXION    ")) ;
  401.         lcd.setCursor(0,1);
  402.         lcd.print(F("    LANCEUR     ")) ;
  403.         lastbacklight = millis()/1000;
  404.       if(millis()/1000 > timeconnect + 30){
  405.         startBt();
  406.         timeconnect = millis()/1000;
  407.       }
  408.    }else if(BTconnect == 1){  
  409.      if(rxdata.checktransmit == 0 || TransmitBT == 0){
  410.        ETout.sendData();
  411.        delay(10);
  412.        transmitBt();
  413.        TransmitBT = 1;
  414.      }
  415.      else{
  416.        game();
  417.      }    
  418.    }
  419.    //Statut connection bluetooth
  420.    if(digitalRead(statusBT) == HIGH){
  421.     BTconnect = 1;
  422.    }
  423.    else{
  424.     BTconnect = 0;
  425.    }
  426. }
  427.  
  428. void game(){
  429. //NRF SEND TEST LOOP
  430.  //nrfsend(5, 49, 49, 0);
  431.  //delay(1000);
  432.  
  433.  if(settingsok == 0){
  434.  // Configure reciving NRF address.
  435.  byte transmetteur[] = {11,22,33,44,idjoueur};
  436.  Mirf.setRADDR(transmetteur);
  437.  settingsok = 1;
  438. }
  439.  IRreceive();
  440.  nrfreceive();
  441.  if(startauto == 0 && startsync == 0){
  442.    lcd.setCursor(0,0);
  443.    lcd.print(F("Attente du droit"));
  444.    lcd.setCursor(0,1);
  445.    lcd.print(F("    d'engager   "));
  446.  }
  447.  if(startdelay != 0 &&(startauto == 1 || startsync == 1)){
  448.    lcd.setCursor(0,0);
  449.    lcd.print(F("Engagement dans "));
  450.    lcd.setCursor(0,1);
  451.    lcd.print(printtolcd(startdelay,1));
  452.    lcd.print("       ");  
  453.    delay(1000);
  454.    
  455.    if(startdelay <= 1){
  456.      playtone(2000, 400, 0);
  457.      txdata.fireon = 1;
  458.      fin = 0;
  459.       if(zombie == 1 && idteam == 0){
  460.         txdata.fireselecttx = 2;
  461.         txdata.rpmtx = 250;
  462.         txdata.degatstx = 5;//=10pts
  463.         pdv = 200;
  464.         bouclier = 200;
  465.         respawnmax = 1;
  466.         idteam = 0;
  467.         txdata.idteamtx = 0;
  468.         ETout.sendData();
  469.       }else{
  470.        pdv = pdvmax;
  471.        bouclier = boucliermax;
  472.        ETout.sendData();
  473.       }
  474.      start = millis();
  475.      lastbacklight = millis()/1000;  
  476.      lcd.clear();
  477.    }else{
  478.      playtone(2700, 40, 0);
  479.    }
  480.    startdelay --;
  481.  }
  482.  if(startdelay == 0){//La partie demarre  
  483.    if(fin != 1){
  484.        //Gestion backlight
  485.        if(backlightlcd == 1){
  486.          lcd.backlight();
  487.          backlightoff = 0;
  488.        }else if(backlightlcd == 0 && backlightoff == 0){
  489.          backlightoff = 1;
  490.          lcd.noBacklight();
  491.        }
  492.      //AnalyseRFID
  493.      if(rxdata.tagread > 0){      
  494.        backlightlcd = 1;
  495.        lastbacklight = millis()/1000;
  496.        if(currenttag > 0 && currenttag == chargeur[newid] >> 12){
  497.         // chargeur[newid] = (currenttag << 12) |(rxdata.ballerx);//On stocke le dernier etat du chargeur avant de traiter le nouveaux
  498.        }
  499.        currenttag = rxdata.tagread;
  500.        /*
  501.        Serial.println("-------------");
  502.        Serial.println("L'analyse recoit le tag :");
  503.        Serial.println(currenttag);      
  504.        */
  505.        for(int c=0;c <= maxchargeur;c++){
  506.         if(chargeur[c] != 0){
  507.           if((chargeur[c] >> 12) == currenttag){
  508.             if((chargeur[c] & 0xFFF) > 0){
  509.            Nballe = (chargeur[c] & 0xFFF);
  510.             }else{
  511.               Nballe = byte(000000000000);
  512.             }
  513.            tagstore = 1;
  514.            newid = c;
  515.            /*
  516.            Serial.println("l'id trouver est :");
  517.            Serial.println(newid);
  518.             Serial.println("le tag est déjà stocker,raw code :");
  519.             Serial.println(chargeur[c],BIN);
  520.             Serial.print(chargeur[c] >> 12);
  521.             Serial.print("  ");
  522.             Serial.print(chargeur[c] & 0xFFF);
  523.             Serial.println("--------------");
  524.             */
  525.            break;
  526.           }
  527.         }
  528.         if(chargeur[c] == NULL){
  529.          newid = c;
  530.          break;
  531.         }
  532.        }
  533.        
  534.        if(tagstore == 1){
  535.         checkchargeur(currenttag, Nballe);
  536.         tagstore = 0;
  537.        }else{
  538.          chargeur[newid] = (currenttag << 12) | (ballemax);
  539.          Nballe = ballemax;
  540.          checkchargeur(currenttag, Nballe);
  541.        }
  542.        txdata.loadtag = currenttag;
  543.        txdata.sendballe = Nballe;
  544.        rxdata.tagread = 0;
  545.        
  546.        ETout.sendData();
  547.          
  548.        txdata.sendballe = -1;
  549.        lastmaj = millis();
  550.      }
  551.      if(waitdoc != 1){
  552.       osd();
  553.      }
  554.      
  555.      //Allumage osd
  556.      boolean etatboutonmode = digitalRead(boutonMode);
  557.      if(etatboutonmode == LOW){
  558.        backlightlcd = 1;
  559.        lastbacklight = millis()/1000;
  560.        freezelcd = 1;
  561.        osdchange = 1;
  562.        delaymille2 = 0;
  563.        lastfreeze = millis()/1000;
  564.        lcd.setCursor(0,1);
  565.        niveau_batterie = analogRead(pinbat);
  566.        
  567.        niveau_batterie = (niveau_batterie/227.5) - 2.5;//227.5 = 1024/4.5v
  568.        if(niveau_batterie >= 0){
  569.          niveau_batterie = 100*niveau_batterie;
  570.        }else{
  571.          niveau_batterie = 0;
  572.        }
  573.        
  574.        prcent_batt = niveau_batterie;
  575.        lcd.write((uint8_t) 4);//Batt
  576.        lcd.print(printtolcd(prcent_batt,0));
  577.        lcd.print(F("%"));
  578.        switch(idteam){
  579.          case 0:
  580.            lcd.print(F(" Rouge "));
  581.          break;
  582.          case 1:
  583.            lcd.print(F(" Bleu  "));
  584.          break;
  585.          case 2:
  586.            lcd.print(F(" Jaune "));
  587.          break;
  588.          case 3:
  589.            lcd.print(F(" Vert  "));
  590.          break;
  591.         }
  592.         lcd.print(printtolcd(numberhit,0));
  593.         lcd.print(F("K"));
  594.        }
  595.  //Selecteur de tir 2s sur bouton mode
  596.  boolean etatbouton0 = digitalRead(bouton0);
  597.  
  598.  if(etatbouton0 == LOW){
  599.    if(zombie == 0 || idteam != 0){
  600.      playtone(1500, 25, 0);
  601.      if(txdata.fireselecttx < 2){
  602.        fireselect ++;
  603.        txdata.fireselecttx = fireselect;
  604.        ETout.sendData();
  605.      }
  606.      else{
  607.        fireselect = 0;
  608.        txdata.fireselecttx = fireselect;
  609.        ETout.sendData();
  610.        appuielong = 0;
  611.      }
  612.    }
  613.    delay(300);
  614.  }
  615.    if(waitdoc == 1){
  616.      osdchange = 1;
  617.       if((millis()/1000 > timedoc+delaydoctor) || delaydoctor == 0){
  618.         //le medecin n'est pas arriver le joueur perd une vie
  619.         if(respawnmax != 1){
  620.           if(respawnauto == 1){
  621.             lcd.setCursor(0,0);
  622.             lcd.print(F("    RESPAWN     "));
  623.             int i = 0;
  624.             while(i < delayrespawn){
  625.               lcd.print(printtolcd(delayrespawn - i,1));
  626.               lcd.print(F("          "));
  627.               delay(1000);
  628.               i ++;
  629.             }
  630.             if(respawnmax != 0){
  631.             respawnmax --;
  632.             }
  633.             pdv = pdvmax;
  634.             bouclier = boucliermax;
  635.             //prepare for next data
  636.             for(rawIndex=0; rawIndex<49; rawIndex++){ //clear rawData array
  637.            
  638.               rawData[rawIndex] = 0;  
  639.             }
  640.             rxData = 0;
  641.             rawIndex = 0;
  642.             rxState = STATE_IDLE;    // sets the state of the receiver to idle (default)
  643.  
  644.             digitalWrite(ledhit, LOW);
  645.             lastbacklight = millis()/1000;
  646.             if(zombie == 1 && idteam != 0){
  647.               txdata.fireselecttx = 2;
  648.               txdata.rpmtx = 250;
  649.               txdata.degatstx = 5;
  650.               pdv = 200;
  651.               bouclier = 200;
  652.               respawnmax = 1;
  653.               txdata.idteamtx = 0;
  654.               idteam = 0;
  655.             }
  656.             txdata.fireon = 1;
  657.             waitdoc = 0;
  658.             ETout.sendData();      
  659.             freezelcd = 0;
  660.             fin = 0;
  661.           }else{
  662.            spawnbox = 1;
  663.            lcd.setCursor(0,0);
  664.            lcd.print(F("    ATTENTE     "));
  665.            lcd.setCursor(0,1);
  666.            lcd.print(F("    RESPAWN     "));
  667.            waitdoc = 0;
  668.            counthitled = millis()/1000;
  669.           }
  670.         }else{
  671.            lcd.setCursor(0,0);
  672.            lcd.print(F("      GAME      "));
  673.            lcd.setCursor(0,1);
  674.            lcd.print(F("      OVER      "));
  675.            waitdoc = 0;
  676.            counthitled = millis()/1000;
  677.         }
  678.       }
  679.       else{
  680.       lcd.setCursor(0,1);
  681.       lcd.print(F("      "));
  682.       if((timedoc+delaydoctor) - (millis()/1000) < 100 && ((timedoc+delaydoctor) - (millis()/1000) >= 10)){lcd.print(F("0"));}
  683.       if((timedoc+delaydoctor) - (millis()/1000) < 10){lcd.print(F("00"));}
  684.       lcd.print((timedoc+delaydoctor) - (millis()/1000));
  685.       lcd.print(F("       "));
  686.       }
  687.    }
  688.    //reuppdv
  689.    if(reuppdv == 1){
  690.       //Re up vie
  691.       if(millis()/1000 > (lastup+reuppdvtime)){
  692.         if((pdv + reuppdvper) < pdvmax){
  693.           if((reuppdvcount+reuppdvper) <= reuppdvmax){
  694.             pdv += reuppdvper;
  695.             reuppdvcount += reuppdvper;
  696.           }
  697.           else{
  698.             pdv += reuppdvmax - reuppdvcount;
  699.           }
  700.         }
  701.         else{
  702.           pdv = pdvmax;
  703.         }
  704.         lastup = millis()/1000;
  705.         osdchange = 1;
  706.       }
  707.    }
  708.   if((millis()/1000) >= counthitled +timehitled && counthitled != 0){
  709.  
  710.     digitalWrite(ledhit, LOW); //surveillance hit led
  711.     counthitled = 0;
  712.   }
  713.  }
  714. }
  715. }
  716. void osd(){
  717.    if(osdchange == 1){
  718.      //PDV
  719.      lcd.setCursor(0,0);
  720.      lcd.write((uint8_t) 2);//pdv
  721.      lcd.print(printtolcd(pdv,0));
  722.      
  723.      //bouclier
  724.      lcd.setCursor(4,0);
  725.      lcd.write((uint8_t) 3);//bouclier
  726.      lcd.print(printtolcd(bouclier,0));
  727.      
  728.      //Respawn
  729.      lcd.setCursor(12,0);
  730.      lcd.write((uint8_t) 5);//respawn
  731.      if(respawnmax > 0){
  732.        lcd.print(printtolcd(respawnmax,0));
  733.      }
  734.      else{
  735.        lcd.print(F("Inf"));
  736.      }
  737.    }
  738.    //Extinction backlight lcd
  739.    if(millis()/1000 >= lastbacklight + 2.5){
  740.     backlightlcd = 0;
  741.    }
  742.    //MAJ munition
  743.  
  744.     if(millis() >= lastmaj + 500){
  745.        ETin.receiveData();
  746.        lastmaj = millis();
  747.        /*
  748.          Serial.println("---------------");
  749.          Serial.println("Etat recue par lanceur :");
  750.          Serial.print(rxdata.ballerx >> 12);
  751.          Serial.print("  ");
  752.          Serial.println(rxdata.ballerx & 0xFFF);
  753.          Serial.println("MAJ du chargeur avec :");
  754.          Serial.print(chargeur[newid] >> 12);
  755.          Serial.print("  ");
  756.          Serial.println(chargeur[newid] & 0xFFF);
  757.          Serial.println("---------------");
  758.          */
  759.        if(currenttag > 0 && (rxdata.ballerx >> 12) == chargeur[newid] >> 12){
  760.          
  761.  
  762.         chargeur[newid] = rxdata.ballerx;
  763.        }
  764.     }
  765.    //Led Zombie  & overheat
  766.      if(millis() >= lastview + 250){
  767.        lastview = millis();
  768.        if(zombie == 1 && idteam == 0){
  769.          hitledzombie = !hitledzombie;
  770.          digitalWrite(ledhit,hitledzombie);
  771.        }
  772.      }
  773.    if(millis()/1000 >= delaymille1 + 1 && txdata.fireon == 1){
  774.       lcd.setCursor(8,0);
  775.       lcd.write((uint8_t) 0);//balle
  776.       /*
  777.       Serial.println("-------------");
  778.       Serial.print("Affichage recue :");
  779.       Serial.println(rxdata.ballerx & 0xFFF);
  780.       Serial.println("--------------");
  781.       */
  782.       lcd.print(printtolcd((rxdata.ballerx & 0xFFF),0));
  783.  
  784.       delaymille1 = millis()/1000;
  785.     }
  786.    
  787.    if(rxdata.overheatrx > overheat){
  788.     freezelcd = 1;
  789.     osdchange = 1;
  790.     backlightlcd = 1;
  791.     nooverheat = 0;
  792.     lcd.setCursor(0,1);
  793.    
  794.     lcd.print(F("   SURCHAUFFE   "));
  795.     lastbacklight = millis()/1000;
  796.     lastfreeze = millis()/1000;
  797.    }
  798.    if(nooverheat == 0 && rxdata.overheatrx < overheat){  
  799.     txdata.fireon = 1;
  800.     nooverheat = 1;
  801.     ETout.sendData();  
  802.    }
  803.    
  804.    if(millis()/1000 >= lastfreeze + 1.5){
  805.       freezelcd = 0;
  806.    }
  807.    if(freezelcd == 0 && osdchange == 1){
  808.      //Pseudo
  809.      lcd.setCursor(10,1);
  810.      lcd.print(realname(idjoueur));
  811.      lcd.print(F(" "));
  812.      
  813.      //Minuteur et affichage sequenciel
  814.       if(fin == 0){
  815.         if(timemax == 0){
  816.           lcd.setCursor(0,1);
  817.           lcd.print(F("0o:o0     "));
  818.         }
  819.       }
  820.       osdchange = 0;
  821.    }
  822.    if(timemax != 0 && fin == 0 && freezelcd == 0){
  823.  
  824.     time = (timemax - (((millis()-start) / 1000) / 60)) - 1;
  825.     seconde = ((millis()-start) / 1000) % 60;
  826.    
  827.     minute = time % 60;
  828.     heure = time / 60;
  829.  
  830.       if(millis()/1000 >= delaymille2 + 1){
  831.         lcd.setCursor(0,1);
  832.         lcd.print(F("0"));
  833.         lcd.print(heure);
  834.         lcd.print(F("h"));
  835.         if(minute < 10){
  836.           lcd.print(F("0"));
  837.         }
  838.         lcd.print(minute);
  839.         lcd.print(F("m"));
  840.         if(59-seconde < 10){
  841.           lcd.print(F("0"));
  842.         }
  843.         lcd.print(59-seconde);
  844.         lcd.print(F("s "));
  845.        
  846.         delaymille2 = millis()/1000;
  847.       }
  848.     }
  849.   //Minuteur et affichage sequenciel
  850.   if(timemax != 0){
  851.     if(heure <= 0 && minute <= 0 && 59-seconde < 1){
  852.       lcd.clear();
  853.       lcd.setCursor(0,0);
  854.       lcd.backlight();
  855.       freezelcd = 1;
  856.       osdchange = 1;
  857.       backlightlcd = 1;
  858.       lcd.print(F("Partie terminee "));
  859.       fin = 1;
  860.       txdata.fireon = 0;
  861.       ETout.sendData();      
  862.     }
  863.   }
  864. }
  865. void IRreceive(){
  866.     // COMPUTE INCOMING DATA
  867.   if(rxState == STATE_STOP){          // DATA! a STOP has been issued meaning there's something to compute
  868.         for(rawIndex = 0; rawIndex < 49; rawIndex++){    
  869.           if(rawIndex % 2 == 0){ //even positions, no spaces        
  870.             if(rawIndex == 0 && !match_hdr(rawData[rawIndex])) {  //first position (hdr)
  871.               break;
  872.             }
  873.             else if(rawIndex != 0) { //not the hdr
  874.            
  875.               if(match_one(rawData[rawIndex])) rxData = (rxData << 1) | 1;
  876.               else if(match_zero(rawData[rawIndex])) rxData <<= 1;
  877.               else{
  878.                 break;
  879.               }
  880.             }
  881.           }
  882.           else{  //odd positions, spaces        
  883.             if(rawData[rawIndex] == 0) break;
  884.             else if(!match_zero(rawData[rawIndex])){
  885.              break;
  886.             }        
  887.           }
  888.           //Serial.print(" ");
  889.           //Serial.print(rawData[rawIndex]);
  890.         }
  891.          //Serial.println("");
  892.          //Serial.println(rxData,HEX);
  893.          
  894.       if(rxData==0 || rawIndex<29){      // if check failed  
  895.           //Near miss        
  896.       }
  897.       else{
  898.          //Code valide
  899.          if(rawIndex == 29){
  900.            //Si c'est un tir standard :
  901.            if(fin != 1 && waitdoc == 0){
  902.              receivehit((rxData & 48) >> 4,  (rxData & 0x1FC0) >> 6, valdegats[(rxData & 15)]);
  903.            }
  904.          }
  905.          if(rawIndex == 49){
  906.             //Commande et message
  907.             backlightlcd = 1;
  908.            lastbacklight = millis()/1000;
  909.            freezelcd = 1;
  910.            osdchange = 1;
  911.            delaymille2 = 0;
  912.            lastfreeze = millis()/1000;
  913.             switch((rxData & 0x10000) >> 16){
  914.                case 0:
  915.                 //Add health
  916.                 if(pdv + ((rxData & 0xFF00) >> 8) <= pdvmax){
  917.                   pdv += ((rxData & 0xFF00) >> 8);
  918.                 }
  919.                 else{
  920.                   pdv = pdvmax;
  921.                 }
  922.                break;
  923.                case 1:
  924.                 //Add spawn
  925.                 respawnmax += ((rxData & 0xFF00) >> 8);
  926.                break;
  927.                case 2:
  928.                 //Add Armor
  929.                 if(bouclier + ((rxData & 0xFF00) >> 8) <= boucliermax){
  930.                   bouclier += ((rxData & 0xFF00) >> 8);
  931.                 }
  932.                 else{
  933.                   bouclier = boucliermax;
  934.                 }
  935.                break;
  936.                case 3:
  937.                 //Command
  938.                 switch((rxData & 0xFF00) >> 8){
  939.                    case 0:
  940.                     //Admin kill
  941.                    break;
  942.                    case 1:
  943.                     //Pause
  944.                    break;
  945.                    case 2:
  946.                     //Start game
  947.                    break;
  948.                    case 4:
  949.                     //Respawn
  950.                    break;
  951.                    case 5:
  952.                     //New game(fast)
  953.                    break;
  954.                    case 7:
  955.                     //End game
  956.                    break;
  957.                    case 8:
  958.                     //Reset clock
  959.                    break;
  960.                    case 11:
  961.                     //Explode joueur (explosion)
  962.                    break;
  963.                    case 12:
  964.                     //New game(ready)
  965.                    break;
  966.                    case 13:
  967.                     //Full health
  968.                    break;
  969.                    case 15:
  970.                     //Full Armor
  971.                    break;
  972.                    case 20:
  973.                     //Clear score
  974.                    break;
  975.                    case 21:
  976.                     //Test sensos
  977.                    break;
  978.                    case 22:
  979.                     //stun player (étourdir)
  980.                    break;
  981.                    case 23:
  982.                     //Disarm player
  983.                    break;                
  984.                 }
  985.             }
  986.          }
  987.       }
  988.      
  989.       //prepare for next data
  990.       for(rawIndex=0; rawIndex<49; rawIndex++){ //clear rawData array    
  991.         rawData[rawIndex] = 0;  
  992.       }
  993.      
  994.       rxData = 0;
  995.       rawIndex = 0;
  996.       rxState = STATE_IDLE;  // sets the state of the receiver to idle (default)
  997.   }
  998. }
  999. void receivehit(char tempteam, char tempidCodeJ, char tempdegats){
  1000.        
  1001.         if(tempteam != idteam || friendlyfire == 1 || tempidCodeJ >= 57 ){               // no friendly fire
  1002.            
  1003.             // apply damage, transmitted as half
  1004.  
  1005.             if(tempidCodeJ != idjoueur){
  1006.               lcd.backlight();
  1007.               backlightlcd = 1;
  1008.               freezelcd = 1;
  1009.               osdchange = 1;
  1010.               lcd.setCursor(0,0);
  1011.               //Mode dir OFF
  1012.               if(dirhit == 0){
  1013.                 lcd.print(F("     Tir de     "));
  1014.               }
  1015.               //Mode Gilet+Tete
  1016.               if(dirhit == 1){
  1017.                 if(dircapteur == 0){
  1018.                   lcd.print(F("  Tir Gilet de  "));
  1019.                 }
  1020.                 else if(dircapteur == 1){
  1021.                   if(headshoot == 1){
  1022.                     tempdegats = 500;//Degats headshoot a 100%
  1023.                   }  
  1024.                   lcd.print(F("  Tir Tete de   "));
  1025.                 }  
  1026.               }
  1027.               //Mode Gilet AV+AR
  1028.               if(dirhit >= 2){
  1029.                 if(dircapteur == 0){
  1030.                   lcd.print(F("Tir Gilet AV de "));
  1031.                 }
  1032.                 else if(dircapteur == 1){
  1033.                   lcd.print(F("Tir Gilet AR de "));
  1034.                 }  
  1035.               }
  1036.               //Mode Gilet AV+AR+TETE
  1037.               if(dirhit == 3){
  1038.                 if(dircapteur == 2){
  1039.                   if(headshoot == 1){
  1040.                     tempdegats = 500;//Degats headshoot a 100%
  1041.                   }  
  1042.                   lcd.print(F("   Tir Tete     "));
  1043.                 }
  1044.               }  
  1045.               //Mode Full  
  1046.               if(dirhit == 4){
  1047.                 if(dircapteur == 2){
  1048.                   if(headshoot == 1){
  1049.                     tempdegats = 500;//Degats headshoot a 100%
  1050.                   }                
  1051.                   lcd.print(F("Tir Tete AV de  "));
  1052.                 }
  1053.                 else if(dircapteur == 3){
  1054.                   if(headshoot == 1){
  1055.                     tempdegats = 500;//Degats headshoot a 100%
  1056.                   }  
  1057.                   lcd.print(F("Tir Tete AR de  "));
  1058.                 }
  1059.               }
  1060.  
  1061.               lcd.setCursor(0,1);
  1062.               lcd.print("     ");
  1063.               lcd.print(realname(tempidCodeJ));
  1064.               lcd.print("      ");
  1065.                        
  1066.              
  1067.               if(tempdegats >= bouclier){
  1068.                 if(pdv > tempdegats - bouclier){
  1069.                   pdv -= (tempdegats - bouclier);//Le joueur ne prend qu'une partie du tir
  1070.                   playerhit(0,tempidCodeJ);
  1071.                 }
  1072.                 else{
  1073.                   pdv = 0;//Le joueur perd tout ses pdv
  1074.                   playerhit(1,tempidCodeJ);
  1075.                 }
  1076.                 bouclier = 0;//Le bouclier est détruit
  1077.               }
  1078.               if(tempdegats < bouclier){
  1079.                 bouclier -= tempdegats;//Le bouclier absorbe le tir
  1080.                 playerhit(0,tempidCodeJ);
  1081.               }
  1082.             }          
  1083.         }
  1084. }
  1085. void playerhit(int dead,int tempidCodeJNRF){
  1086.  
  1087.   reuppdvcount = 0;
  1088.   txdata.fireon = 0;
  1089.   ETout.sendData();
  1090.   if(dead == 0){
  1091.     if(dirhit >= 2){
  1092.        if(dircapteur == 0 || dircapteur == 2){
  1093.         digitalWrite(vibreur1, HIGH);
  1094.       }else if(dircapteur == 1 || dircapteur == 3){
  1095.         digitalWrite(vibreur2, HIGH);
  1096.       }
  1097.     }
  1098.     digitalWrite(ledhit, HIGH);
  1099.     //Transmission de l'info au tireur
  1100.     if(backshoot == 1){
  1101.       nrfsend(5, tempidCodeJNRF, idjoueur, 0);
  1102.     }
  1103.     playtone(3500, 160, 0);
  1104.     digitalWrite(vibreur1, LOW);
  1105.     digitalWrite(vibreur2, LOW);
  1106.     delay(hitdelay*1000+100);
  1107.     digitalWrite(ledhit, LOW);
  1108.    
  1109.     txdata.fireon = 1;
  1110.     lastbacklight = millis()/1000;
  1111.     ETout.sendData();  
  1112.     lastup = millis()/1000;
  1113.   }else{
  1114.     //Transmission de l'info au tireur
  1115.     if(backshoot == 1){
  1116.       nrfsend(5, tempidCodeJNRF, idjoueur, 1);
  1117.     }
  1118.     delay(50);
  1119.     numberhit ++;
  1120.     //fin = 1;
  1121.     if(zombie == 1 && idteam != 0){
  1122.       delayrespawn = 30;
  1123.       delaydoctor = 10;
  1124.     }
  1125.     playtone(3500, 2500, 0);
  1126.     if(dirhit >= 2){
  1127.        if(dircapteur == 0 || dircapteur == 2){
  1128.         digitalWrite(vibreur1, HIGH);
  1129.       }else if(dircapteur == 1 || dircapteur == 3){
  1130.         digitalWrite(vibreur2, HIGH);
  1131.       }
  1132.     }
  1133.     digitalWrite(ledhit, HIGH);
  1134.     delay(600);
  1135.     digitalWrite(vibreur1, LOW);
  1136.     digitalWrite(vibreur2, LOW);
  1137.     if(delaydoctor > 0){
  1138.       lcd.setCursor(0,0);
  1139.       lcd.print(F("  ATTENTE DOC   "));
  1140.       lcd.setCursor(0,1);
  1141.       timedoc = millis()/1000;
  1142.     }
  1143.     waitdoc = 1;
  1144.   }
  1145.   score[tempidCodeJNRF] ++;
  1146. }
  1147. void  checkchargeur(long tag,int ballenrf){
  1148.   for(int jAll = 0; jAll<59;jAll++){
  1149.    nrfsend((idjoueur & 0xFF) << 8 | (8 & 0x00FF), jAll, (tag & 0xFFFF), ballenrf << 4 | ((tag >> 16) & 0x000F ));
  1150.   }
  1151. }
  1152. void nrfsend(int type,  int destinataire, int valdata1 ,int valdata2){
  1153.       Serial.println(type);
  1154.       Serial.println(destinataire);
  1155.       Serial.println(valdata1);
  1156.       Serial.println(valdata2);
  1157.       byte dest[] = {11,22,33,44,destinataire};
  1158.       Mirf.setTADDR((byte *)dest);      
  1159.        
  1160.        datasend[0] = type & 0xFF; //1ème octet    
  1161.        datasend[1] = (type & 0xFF00) >> 8; //2ème octet    
  1162.        datasend[2] = valdata1 & 0xFF; // 1er octet
  1163.        datasend[3] = (valdata1 & 0xFF00) >> 8; // 2ème octet  
  1164.        datasend[4] = valdata2 & 0xFF; // 1er octet
  1165.        datasend[5] = (valdata2 & 0xFF00) >> 8; // 2ème octet  
  1166.        Mirf.send(datasend);
  1167.      
  1168.       while(Mirf.isSending()){
  1169.        delay(5);
  1170.       }
  1171.      
  1172. }
  1173. void nrfreceive(){
  1174.     if(Mirf.dataReady()) {
  1175.      //Si bug remettre c trois variable en long
  1176.       Mirf.getData(datareceive); // récupére 6 octets
  1177.       typenrf = datareceive[0];
  1178.       joueurcheck = datareceive[1];
  1179.       donneenrf1 = datareceive[2] + (datareceive[3] << 8);
  1180.       donneenrf2 = datareceive[4] + (datareceive[5] << 8);
  1181.      
  1182.       Serial.println(" ");
  1183.       Serial.print(" type : ");
  1184.       Serial.println(typenrf, DEC);
  1185.       Serial.print("donnee1 : ");
  1186.       Serial.println(donneenrf1, DEC);
  1187.       Serial.print("donnee2 : ");
  1188.       Serial.println(donneenrf2, DEC);
  1189.       Serial.println(" ");
  1190.      
  1191.         //Commande
  1192.         if((typenrf) < 50){
  1193.           switch(typenrf){
  1194.             case 5:
  1195.               if(backshoot == 1 && fin == 0){
  1196.                 //Comfirmation de tir
  1197.                 lcd.backlight();
  1198.                 backlightlcd = 1;
  1199.                 freezelcd = 1;
  1200.                 osdchange = 1;
  1201.                 lcd.setCursor(0,1);
  1202.                 lcd.print(F("  "));
  1203.                 lcd.print(realname(donneenrf1));
  1204.                 if(donneenrf2 == 0){
  1205.                 lcd.print(F(" toucher "));
  1206.                 }else{
  1207.                 lcd.print(F(" mort    "));
  1208.                 }
  1209.                 lastbacklight = millis()/1000;
  1210.                 lastfreeze = millis()/1000;
  1211.               }
  1212.             break;
  1213.             case 6:
  1214.               if(startauto == 0 && startsync == 0){
  1215.                 //Signal depart syncroniser
  1216.                 startsync = 1;
  1217.                 lcd.clear();
  1218.               }
  1219.             break;
  1220.             case 7:
  1221.               if(fin == 0){
  1222.                playerhit(1,51);
  1223.               }
  1224.             break;
  1225.             case 8:
  1226.               //check chargeur
  1227.               tagcheck = (datareceive[4] & 0x0F);
  1228.               tagcheck = (tagcheck << 16) + donneenrf1;
  1229.              
  1230.               ballecheck = donneenrf2 >> 4;
  1231.              
  1232.               for(int Cc=0;Cc <= maxchargeur;Cc++){
  1233.                 if(chargeur[Cc] != 0){
  1234.                   if((chargeur[Cc] >> 12) == tagcheck){
  1235.                     if((chargeur[Cc] & 0xFFF) < ballecheck){
  1236.                       //tag trouver MAJ necessaire
  1237.                       nrfsend(9, joueurcheck, (chargeur[Cc] & 0xFFF), 0);
  1238.                     }
  1239.                   }
  1240.                 }
  1241.               }
  1242.             break;
  1243.             case 9:
  1244.               //MAJ chargeur recue
  1245.               if(donneenrf1 < (rxdata.ballerx & 0xFFF)){
  1246.                 txdata.sendballe = donneenrf1;
  1247.                 ETout.sendData();
  1248.                 delay(5);
  1249.                 txdata.sendballe = -1;
  1250.               }
  1251.             break;  
  1252.           }            
  1253.         }else{
  1254.           if(donneenrf1 == idteam || donneenrf1 == 4){
  1255.             switch(typenrf >> 8){
  1256.             case 50:
  1257.                  friendlyfire = donneenrf2;
  1258.                  EEPROM.write(friendlyfireAddr, friendlyfire);
  1259.             break;
  1260.             case 51:
  1261.                  ballemax = donneenrf2;
  1262.                  EEPROM.write(balleAddr, ballemax);
  1263.             break;
  1264.             case 52:
  1265.                 rpm = donneenrf2;
  1266.                 EEPROM.write(rpmAddr, rpm);
  1267.             break;
  1268.             case 53:
  1269.                 fireselect = donneenrf2;
  1270.                 EEPROM.write(fireselectAddr, fireselect);
  1271.             break;
  1272.             case 54:
  1273.                 burstmode = donneenrf2;
  1274.                 EEPROM.write(burstmodeAddr, burstmode);
  1275.             break;
  1276.             case 55:
  1277.                 muzzle = donneenrf2;
  1278.                 EEPROM.write(muzzleAddr, muzzle);
  1279.             break;
  1280.             case 56:
  1281.                 overheat = donneenrf2;
  1282.                 EEPROM.write(overheatAddr,overheat);
  1283.             break;
  1284.             case 57:
  1285.                 respawnmax = donneenrf2;
  1286.                 EEPROM.write(respawnmaxAddr, respawnmax);
  1287.             break;
  1288.             case 58:
  1289.                 respawnauto = donneenrf2;
  1290.                 EEPROM.write(respawnautoAddr, respawnauto);
  1291.             break;
  1292.             case 59:
  1293.                 delayrespawn = donneenrf2;
  1294.                 EEPROM.write(delayrespawnAddr, delayrespawn);
  1295.             break;
  1296.             case 60:
  1297.                 timemax = donneenrf2;
  1298.                 EEPROM.write(timeAddr, timemax);
  1299.             break;
  1300.             case 61:
  1301.                 pdvmax = donneenrf2;
  1302.                 EEPROM.write(pdvAddr, pdvmax);
  1303.             break;
  1304.             case 62:
  1305.                 boucliermax = donneenrf2;
  1306.                 EEPROM.write(bouclierAddr, boucliermax);
  1307.             break;
  1308.             case 63:
  1309.                 delaydoctor = donneenrf2;
  1310.                 EEPROM.write(delaydoctorAddr, delaydoctor);
  1311.             break;
  1312.             case 64:
  1313.                 reuppdv = donneenrf2;
  1314.                 EEPROM.write(reuppdvAddr, reuppdv);
  1315.             break;
  1316.             case 65:
  1317.                 reuppdvtime = donneenrf2;
  1318.                 EEPROM.write(reuppdvtimeAddr, reuppdvtime);
  1319.             break;
  1320.             case 66:
  1321.                 reuppdvper = donneenrf2;
  1322.                 EEPROM.write(reuppdvperAddr, reuppdvper);
  1323.             break;        
  1324.             case 67:
  1325.                 reuppdvmax = donneenrf2;
  1326.                 EEPROM.write(reuppdvmaxAddr, reuppdvmax);
  1327.             break;
  1328.             case 68:
  1329.                 startauto = donneenrf2;
  1330.                 EEPROM.write(startautoAddr, startauto);
  1331.             break;
  1332.             case 69:
  1333.                 startdelay = donneenrf2;
  1334.                 EEPROM.write(startdelayAddr, startdelay);
  1335.             break;
  1336.             case 70:
  1337.                 hitdelay = donneenrf2;
  1338.                 EEPROM.write(hitdelayAddr, hitdelay);
  1339.             break;
  1340.             case 71:
  1341.                 choixdegats = donneenrf2;
  1342.                 EEPROM.write(choixdegatAddr, choixdegats);
  1343.             break;
  1344.             case 72:
  1345.                 timehitled = donneenrf2;
  1346.                 EEPROM.write(timehitledAddr, timehitled);
  1347.             break;
  1348.             case 73:
  1349.                 backshoot = donneenrf2;
  1350.                 EEPROM.write(backshootAddr, backshoot);
  1351.             break;
  1352.             case 74:
  1353.                 dirhit = donneenrf2;
  1354.                 EEPROM.write(dirhitAddr, dirhit);
  1355.             break;
  1356.             case 75:
  1357.                 zombie = donneenrf2;
  1358.                 EEPROM.write(zombieAddr, zombie);
  1359.             break;
  1360.           }
  1361.         }
  1362.       }
  1363.     }
  1364. }
  1365. void transmitBt(){
  1366.   //Le lanceur n'a pas les info donc on lui envoie
  1367.   txdata.idjoueurtx = idjoueur;
  1368.   txdata.idteamtx = idteam;
  1369.   txdata.rpmtx = rpm;
  1370.   txdata.fireselecttx = fireselect;
  1371.   txdata.bursttx = burstmode;
  1372.   txdata.muzzletx = muzzle;
  1373.   txdata.overheattx = overheat;
  1374.   txdata.degatstx = choixdegats;
  1375.  
  1376.   ETout.sendData();
  1377.   lcd.setCursor(0,0);
  1378.   lcd.print(F("  Transmission  "));
  1379.   lcd.setCursor(0,1);
  1380.   lcd.print(F("   au lanceur   "));
  1381.   playtone(3900, 20, 0);
  1382.   ETin.receiveData();
  1383.   delay(200);
  1384.   osdchange = 1;
  1385. }
  1386. void clonemenu(){
  1387.   boolean etatboutonmode = digitalRead(boutonMode);
  1388.   boolean etatbouton0 = digitalRead(bouton0);
  1389.     delay(100);
  1390.    
  1391.     if(etatbouton0 == LOW && goclone == 0){
  1392.       if(cloneteam == 5){
  1393.         inmenuedit = 0;
  1394.         lcd.clear();
  1395.       }
  1396.       else{
  1397.         goclone = 1;
  1398.       }
  1399.     }
  1400.     if(goclone == 1){
  1401.       lcd.clear();
  1402.       lcd.setCursor(0,0);
  1403.       lcd.print(F("Clonage en cours"));
  1404.     //On commence le clonage
  1405.     for(int j=0;j < 50;j++){
  1406.      nrfsend(50, j, cloneteam, friendlyfire);
  1407.      delay(5);
  1408.      nrfsend(51, j, cloneteam, ballemax);
  1409.      delay(5);
  1410.      nrfsend(52, j, cloneteam, rpm);
  1411.      delay(5);
  1412.      nrfsend(53, j, cloneteam, fireselect);
  1413.      delay(5);
  1414.      nrfsend(54, j, cloneteam, burstmode);
  1415.      delay(5);
  1416.      nrfsend(55, j, cloneteam, muzzle);
  1417.      delay(5);
  1418.      nrfsend(56, j, cloneteam, overheat);
  1419.      delay(5);
  1420.      nrfsend(57, j, cloneteam, respawnmax);
  1421.      delay(5);
  1422.      nrfsend(58, j, cloneteam, respawnauto);
  1423.      delay(5);
  1424.      nrfsend(59, j, cloneteam, delayrespawn);
  1425.      delay(5);
  1426.      nrfsend(60, j, cloneteam, timemax);
  1427.      delay(5);
  1428.      nrfsend(61, j, cloneteam, pdvmax);
  1429.      delay(5);
  1430.      nrfsend(62, j, cloneteam, boucliermax);
  1431.      delay(5);
  1432.      nrfsend(63, j, cloneteam, delaydoctor);
  1433.      delay(5);
  1434.      nrfsend(64, j, cloneteam, reuppdv);
  1435.      delay(5);
  1436.      nrfsend(65, j, cloneteam, reuppdvtime);
  1437.      delay(5);
  1438.      nrfsend(66, j, cloneteam, reuppdvper);
  1439.      delay(5);
  1440.      nrfsend(67, j, cloneteam, reuppdvmax);
  1441.      delay(5);
  1442.      nrfsend(68, j, cloneteam, startauto);
  1443.      delay(5);
  1444.      nrfsend(69, j, cloneteam, startdelay);
  1445.      delay(5);
  1446.      nrfsend(70, j, cloneteam, hitdelay);
  1447.      delay(5);
  1448.      nrfsend(71, j, cloneteam, choixdegats);
  1449.      delay(5);
  1450.      nrfsend(72, j, cloneteam, timehitled);
  1451.      delay(5);
  1452.      nrfsend(73, j, cloneteam, backshoot);
  1453.      delay(5);
  1454.      nrfsend(74, j, cloneteam, dirhit);
  1455.      delay(5);
  1456.      nrfsend(75, j, cloneteam, zombie);
  1457.      delay(5);
  1458.      lcd.setCursor(7,1);
  1459.      lcd.print(j*2);
  1460.      lcd.print(F("%"));
  1461.     }
  1462.     lcd.setCursor(0,1);
  1463.     lcd.print(F("Clonage terminee"));
  1464.     delay(1000);
  1465.     goclone = 0;
  1466.   }
  1467.   else{
  1468.     lcd.setCursor(0,0);
  1469.     lcd.print(F("    Cloner :    "));
  1470.     if(etatboutonmode == LOW){
  1471.       if(cloneteam < 5){
  1472.         cloneteam ++;
  1473.       }
  1474.       else{
  1475.         cloneteam = 0;
  1476.       }
  1477.       delay(200);
  1478.     }
  1479.     lcd.setCursor(0,1);
  1480.     switch(cloneteam){
  1481.      case 0:
  1482.        lcd.print(F("      Rouge     "));
  1483.      break;
  1484.      case 1:
  1485.        lcd.print(F("      Bleu      "));
  1486.      break;
  1487.      case 2:
  1488.        lcd.print(F("      Jaune     "));
  1489.      break;
  1490.      case 3:
  1491.        lcd.print(F("      Vert      "));
  1492.      break;
  1493.      case 4:
  1494.        lcd.print(F("     Toutes     "));
  1495.      break;
  1496.      case 5:
  1497.        lcd.print(F("      Exit      "));
  1498.      break;
  1499.     }
  1500.   }
  1501. }
  1502. void menuedit(){
  1503.    boolean etatboutonmode = digitalRead(boutonMode);
  1504.    boolean etatbouton0 = digitalRead(bouton0);
  1505.    
  1506.    if(etatbouton0 == LOW){
  1507.     //Appuis sur le bouton tir
  1508.     if(menu < 31){
  1509.     menu ++;
  1510.    }else{
  1511.      menu = 1;
  1512.    }
  1513.     delay(200);
  1514.     lcd.clear();
  1515.     etatbouton0 = LOW;
  1516.   }
  1517.   switch(menu){
  1518.     case 1:  //Id joueur
  1519.       lcd.setCursor(0,0);
  1520.       lcd.print(F("   ID Joueur    "));
  1521.       if(idjoueur == 0){
  1522.         idjoueur = 0;
  1523.       }
  1524.         if(etatboutonmode == LOW){
  1525.           //Trigger préssé
  1526.           if(idjoueur < 49){
  1527.             idjoueur ++;
  1528.           }else{
  1529.             idjoueur = 0;
  1530.           }
  1531.           etatboutonmode = HIGH;
  1532.           delay(70);  
  1533.         }
  1534.       lcd.setCursor(4,1);
  1535.       if(idjoueur < 10){
  1536.         lcd.print(F("0"));
  1537.       }
  1538.       lcd.print(idjoueur);
  1539.       lcd.print(F(" "));
  1540.       lcd.print(realname(idjoueur));
  1541.     break;
  1542.     case 2:  //ID team
  1543.       lcd.setCursor(0,0);
  1544.       lcd.print(F("     Equipe     "));
  1545.       if(idteam == 0){
  1546.         idteam = 0;
  1547.       }
  1548.         if(etatboutonmode == LOW){
  1549.           //Trigger préssé
  1550.           if(idteam < 3){
  1551.             idteam ++;
  1552.           }else{
  1553.             idteam = 0;
  1554.           }
  1555.           etatboutonmode = HIGH;
  1556.           delay(150);  
  1557.         }
  1558.       lcd.setCursor(0,1);
  1559.         switch(idteam){
  1560.          case 0:
  1561.            lcd.print(F("     Rouge      "));
  1562.          break;
  1563.          case 1:
  1564.            lcd.print(F("     Bleu       "));
  1565.          break;
  1566.          case 2:
  1567.            lcd.print(F("     Jaune      "));
  1568.          break;
  1569.          case 3:
  1570.            lcd.print(F("     Vert       "));
  1571.          break;
  1572.         }
  1573.     break;
  1574.     case 3:  //Friendly fire
  1575.       lcd.setCursor(0,0);
  1576.       lcd.print(F("    Tir amie    "));
  1577.         if(etatboutonmode == LOW){
  1578.           //Trigger préssé
  1579.           if(friendlyfire < 1){
  1580.             friendlyfire = 1;
  1581.           }else{
  1582.             friendlyfire = 0;
  1583.           }
  1584.           etatboutonmode = HIGH;
  1585.           delay(200);  
  1586.         }
  1587.       lcd.setCursor(6,1);
  1588.       if(friendlyfire == 1){
  1589.         lcd.print(F("On "));
  1590.       }else{
  1591.         lcd.print(F("off"));
  1592.       }    
  1593.     break;
  1594.     case 4:  //Qte de balle
  1595.       lcd.setCursor(0,0);
  1596.       lcd.print(F("Balle par Charge"));
  1597.         if(etatboutonmode == LOW){
  1598.           //Trigger préssé
  1599.           if(ballemax < 250){
  1600.           ballemax ++;
  1601.           }else{
  1602.             ballemax = 0;
  1603.           }
  1604.           etatboutonmode = HIGH;
  1605.           delay(100);  
  1606.         }
  1607.       if(ballemax == 0){
  1608.         lcd.setCursor(4,1);
  1609.         lcd.print(F("Infini "));
  1610.       }else{
  1611.         lcd.setCursor(0,1);
  1612.         lcd.print(F("    "));
  1613.         lcd.print(printtolcd(ballemax,0));
  1614.         lcd.print(F("/250   "));
  1615.       }
  1616.     break;
  1617.     case 5:  //RPM
  1618.       lcd.setCursor(0,0);
  1619.       lcd.print(F("      RPM       "));
  1620.         if(rpm < 250){
  1621.           rpm = 650;
  1622.         }
  1623.         if(etatboutonmode == LOW){
  1624.           //Trigger préssé
  1625.           if(rpm < 800){
  1626.           rpm += 50;
  1627.           }else{
  1628.             rpm = 250;
  1629.           }
  1630.           etatboutonmode = HIGH;
  1631.           delay(150);  
  1632.         }
  1633.       lcd.setCursor(6,1);
  1634.       lcd.print(rpm);
  1635.     break;
  1636.     case 6:  //Fire select
  1637.       lcd.setCursor(0,0);
  1638.       lcd.print(F("Selecteur de tir"));
  1639.         if(etatboutonmode == LOW){
  1640.           //Trigger préssé
  1641.           if(fireselect < 2){
  1642.             fireselect ++;
  1643.           }else{
  1644.             fireselect = 0;
  1645.           }
  1646.           etatboutonmode = HIGH;
  1647.           delay(200);  
  1648.         }
  1649.       lcd.setCursor(0,1);
  1650.       if(fireselect == 2){
  1651.         lcd.print(F("   Semi-auto    "));
  1652.       }else if(fireselect == 1){
  1653.         lcd.print(F("     Burst      "));  
  1654.       }else{
  1655.         lcd.print(F("   Full Auto    "));
  1656.       }    
  1657.     break;
  1658.     case 7:  //Burst mode
  1659.       lcd.setCursor(0,0);
  1660.       lcd.print(F("   Burst mode   "));
  1661.  
  1662.         if(etatboutonmode == LOW){
  1663.           //Trigger préssé
  1664.           if(burstmode < 6){
  1665.             burstmode ++;
  1666.           }else{
  1667.             burstmode = 2;
  1668.           }
  1669.           etatboutonmode = HIGH;
  1670.           delay(200);  
  1671.         }
  1672.       lcd.setCursor(7,1);
  1673.       lcd.print(burstmode);
  1674.     break;
  1675.     case 8:  //Muzzle
  1676.       lcd.setCursor(0,0);
  1677.       lcd.print(F("   Muzzle led   "));
  1678.         if(etatboutonmode == LOW){
  1679.           //Trigger préssé
  1680.           if(muzzle < 1){
  1681.             muzzle = 1;
  1682.           }else{
  1683.             muzzle = 0;
  1684.           }
  1685.           etatboutonmode = HIGH;
  1686.           delay(200);  
  1687.         }
  1688.       lcd.setCursor(6,1);
  1689.       if(muzzle == 1){
  1690.         lcd.print(F("On "));
  1691.       }else{
  1692.         lcd.print(F("off"));
  1693.       }    
  1694.     break;
  1695.     case 9:  //Overheat
  1696.       lcd.setCursor(0,0);
  1697.       lcd.print(F("Overheat Temp C "));
  1698.         if(etatboutonmode == LOW){
  1699.           //Trigger préssé
  1700.           if(overheat < 160){
  1701.           overheat ++;
  1702.           }else{
  1703.             overheat = 49;
  1704.           }
  1705.           etatboutonmode = HIGH;
  1706.           delay(100);  
  1707.         }
  1708.       if(overheat == 49){
  1709.         lcd.setCursor(4,1);
  1710.         lcd.print(F("  Off    "));
  1711.       }else{
  1712.       lcd.setCursor(4,1);
  1713.       lcd.print(printtolcd(overheat,0));
  1714.       lcd.print(F("/160   "));
  1715.       }
  1716.     break;
  1717.     case 10:  //Respawn max
  1718.       lcd.setCursor(0,0);
  1719.       lcd.print(F("      Vies      "));
  1720.         if(etatboutonmode == LOW){
  1721.           //Trigger préssé
  1722.           if(respawnmax < 250){
  1723.           respawnmax ++;
  1724.           }else{
  1725.             respawnmax = 0;
  1726.           }
  1727.           etatboutonmode = HIGH;
  1728.           delay(100);  
  1729.         }
  1730.       if(respawnmax == 0){
  1731.         lcd.setCursor(4,1);
  1732.         lcd.print(F(" Infini "));
  1733.       }else{
  1734.       lcd.setCursor(0,1);
  1735.       lcd.print(F("    "));
  1736.       lcd.print(printtolcd(respawnmax,0));
  1737.       lcd.print(F("/250   "));
  1738.       }
  1739.     break;
  1740.     case 11:  //Respawn automatique
  1741.       lcd.setCursor(0,0);
  1742.       lcd.print(F("   Spawn auto   "));
  1743.         if(etatboutonmode == LOW){
  1744.           //Trigger préssé
  1745.           if(respawnauto < 1){
  1746.             respawnauto = 1;
  1747.           }else{
  1748.             respawnauto = 0;
  1749.           }
  1750.           etatboutonmode = HIGH;
  1751.           delay(200);  
  1752.         }
  1753.       lcd.setCursor(6,1);
  1754.       if(respawnauto == 1){
  1755.         lcd.print(F("On "));
  1756.       }else{
  1757.         lcd.print(F("off"));
  1758.       }  
  1759.     break;
  1760.     case 12:  //Delay respawn
  1761.       lcd.setCursor(0,0);
  1762.       lcd.print(F("  Delai Spawn   "));
  1763.       if(delayrespawn < 10){
  1764.         delayrespawn = 10;
  1765.       }
  1766.         if(etatboutonmode == LOW){
  1767.           //Trigger préssé
  1768.           if(delayrespawn < 180){
  1769.             delayrespawn += 5;
  1770.           }else{
  1771.             delayrespawn = 10;
  1772.           }
  1773.           etatboutonmode = HIGH;
  1774.           delay(150);  
  1775.         }
  1776.       lcd.setCursor(4,1);
  1777.       lcd.print(printtolcd(delayrespawn,0));
  1778.       lcd.print(F("/180s "));
  1779.     break;  
  1780.     case 13:  //game time
  1781.       lcd.setCursor(0,0);
  1782.       lcd.print(F("  Duree partie  "));
  1783.         if(etatboutonmode == LOW){
  1784.           //Trigger préssé
  1785.           if(timemax < 240){
  1786.             timemax += 1;
  1787.           }else{
  1788.             timemax = 0;
  1789.           }
  1790.           etatboutonmode = HIGH;
  1791.           delay(100);  
  1792.         }
  1793.      
  1794.       if(timemax == 0){
  1795.         lcd.setCursor(3,1);
  1796.         lcd.print(F("  Infini   "));
  1797.       }else{
  1798.       lcd.setCursor(3,1);
  1799.       lcd.print(printtolcd(timemax,0));
  1800.       lcd.print(F("/240min"));
  1801.       }
  1802.     break;
  1803.     case 14:  //pdv
  1804.       lcd.setCursor(0,0);
  1805.       lcd.print(F("  Point de vie   "));
  1806.       if(pdvmax == 0){
  1807.         pdvmax = 100;
  1808.       }
  1809.         if(etatboutonmode == LOW){
  1810.           //Trigger préssé
  1811.           if(pdvmax < 500){
  1812.             pdvmax += 10;
  1813.           }else{
  1814.             pdvmax = 10;
  1815.           }
  1816.           etatboutonmode = HIGH;
  1817.           delay(100);  
  1818.         }
  1819.       lcd.setCursor(4,1);
  1820.       lcd.print(printtolcd(pdvmax,0));
  1821.       lcd.print(F("/500   "));
  1822.     break;  
  1823.     case 15:  //Armure
  1824.       lcd.setCursor(0,0);
  1825.       lcd.print(F("     Armure     "));
  1826.         if(etatboutonmode == LOW){
  1827.           //Trigger préssé
  1828.           if(boucliermax < 500){
  1829.             boucliermax += 10;
  1830.           }else{
  1831.             boucliermax = 0;
  1832.           }
  1833.           etatboutonmode = HIGH;
  1834.           delay(100);  
  1835.         }
  1836.       lcd.setCursor(4,1);
  1837.       lcd.print(printtolcd(boucliermax,0));
  1838.       lcd.print(F("/500   "));
  1839.     break;    
  1840.     case 16:  //Delay medecin
  1841.       lcd.setCursor(0,0);
  1842.       lcd.print(F(" Delai medecin  "));
  1843.         if(etatboutonmode == LOW){
  1844.           //Trigger préssé
  1845.           if(delaydoctor < 180){
  1846.             delaydoctor ++;
  1847.           }else{
  1848.             delaydoctor = 0;
  1849.           }
  1850.           etatboutonmode = HIGH;
  1851.           delay(100);  
  1852.         }
  1853.       lcd.setCursor(3,1);
  1854.       if(delaydoctor == 0){
  1855.         lcd.print(F("   Off  "));
  1856.       }else{
  1857.         lcd.setCursor(3,1);
  1858.         lcd.print(printtolcd(delaydoctor,0));
  1859.         lcd.print(F("/180s "));
  1860.       }
  1861.     break;
  1862.     case 17:  //recup pdv
  1863.       lcd.setCursor(0,0);
  1864.       lcd.print(F(" Recup auto pdv "));
  1865.         if(etatboutonmode == LOW){
  1866.           //Trigger préssé
  1867.           if(reuppdv < 1){
  1868.             reuppdv = 1;
  1869.           }else{
  1870.             reuppdv = 0;
  1871.           }
  1872.           etatboutonmode = HIGH;
  1873.           delay(200);  
  1874.         }
  1875.       lcd.setCursor(6,1);
  1876.       if(reuppdv == 1){
  1877.         lcd.print(F("On "));
  1878.       }else{
  1879.         lcd.print(F("off"));
  1880.       }    
  1881.     break;
  1882.     case 18:  //Delay avant recup pdv
  1883.       lcd.setCursor(0,0);
  1884.       lcd.print(F("Delai recup pdv "));
  1885.         if(etatboutonmode == LOW){
  1886.           //Trigger préssé
  1887.           if(reuppdvtime < 120){
  1888.             reuppdvtime ++;
  1889.           }else{
  1890.             reuppdvtime = 1;
  1891.           }
  1892.           etatboutonmode = HIGH;
  1893.           delay(100);  
  1894.         }
  1895.  
  1896.       lcd.setCursor(4,1);
  1897.       lcd.print(printtolcd(reuppdvtime,0));
  1898.       lcd.print(F("/120s "));
  1899.     break;
  1900.     case 19:  //pdv par cycle recup auto
  1901.       lcd.setCursor(0,0);
  1902.       lcd.print(F(" Nbr pdv recup  "));
  1903.         if(etatboutonmode == LOW){
  1904.           //Trigger préssé
  1905.           if(reuppdvper < 30){
  1906.             reuppdvper ++;
  1907.           }else{
  1908.             reuppdvper = 1;
  1909.           }
  1910.           etatboutonmode = HIGH;
  1911.           delay(150);  
  1912.         }
  1913.       lcd.setCursor(3,1);
  1914.       lcd.print(printtolcd(reuppdvper,0));
  1915.       lcd.print(F("/30pdv"));
  1916.     break;
  1917.     case 20:  //pdv max recup auto
  1918.       lcd.setCursor(0,0);
  1919.       lcd.print(F(" Max pdv recup  "));
  1920.         if(etatboutonmode == LOW){
  1921.           //Trigger préssé
  1922.           if(reuppdvmax < 100){
  1923.             reuppdvmax ++;
  1924.           }else{
  1925.             reuppdvmax = 1;
  1926.           }
  1927.           etatboutonmode = HIGH;
  1928.           delay(100);  
  1929.         }
  1930.       lcd.setCursor(3,1);
  1931.       lcd.print(printtolcd(reuppdvmax,0));
  1932.       lcd.print(F("/100pdv"));
  1933.     break;
  1934.     case 21:  //Start auto
  1935.       lcd.setCursor(0,0);
  1936.       lcd.print(F(" Demarrage auto "));
  1937.         if(etatboutonmode == LOW){
  1938.           //Trigger préssé
  1939.           if(startauto < 1){
  1940.             startauto = 1;
  1941.           }else{
  1942.             startauto = 0;
  1943.           }
  1944.           etatboutonmode = HIGH;
  1945.           delay(200);  
  1946.         }
  1947.       lcd.setCursor(6,1);
  1948.       if(startauto == 1){
  1949.         lcd.print(F("On "));
  1950.       }else{
  1951.         lcd.print(F("off"));
  1952.       }    
  1953.     break;
  1954.     case 22:  //délais debut de partie
  1955.       lcd.setCursor(0,0);
  1956.       lcd.print(F("  Start delais  "));
  1957.         if(etatboutonmode == LOW){
  1958.           //Trigger préssé
  1959.           if(startdelay < 240){
  1960.             startdelay ++;
  1961.           }else{
  1962.             startdelay = 1;
  1963.           }
  1964.           etatboutonmode = HIGH;
  1965.           delay(100);  
  1966.         }
  1967.       lcd.setCursor(4,1);
  1968.       lcd.print(printtolcd(startdelay,0));
  1969.       lcd.print(F("/240s "));
  1970.     break;
  1971.     case 23:  //hit delay
  1972.       lcd.setCursor(0,0);
  1973.       lcd.print(F("Handicap de tir"));
  1974.         if(etatboutonmode == LOW){
  1975.           //Trigger préssé
  1976.           if(hitdelay < 20){
  1977.             hitdelay ++;
  1978.           }else{
  1979.             hitdelay = 0;
  1980.           }
  1981.           etatboutonmode = HIGH;
  1982.           delay(150);  
  1983.         }
  1984.       lcd.setCursor(4,1);
  1985.  
  1986.       if(hitdelay == 0){
  1987.         lcd.print(F("  Off   "));
  1988.       }else{
  1989.       lcd.setCursor(5,1);
  1990.       lcd.print(printtolcd(hitdelay,0));
  1991.       lcd.print(F("/20s "));
  1992.       }
  1993.     break;
  1994.     case 24:  //degats
  1995.       lcd.setCursor(0,0);
  1996.       lcd.print(F("     Degats     "));
  1997.         if(etatboutonmode == LOW){
  1998.           //Trigger préssé
  1999.           if(choixdegats < 15){
  2000.             choixdegats ++;
  2001.           }else{
  2002.             choixdegats = 0;
  2003.           }
  2004.           etatboutonmode = HIGH;
  2005.           delay(150);  
  2006.         }
  2007.       lcd.setCursor(4,1);
  2008.       lcd.print(printtolcd(valdegats[choixdegats],0));
  2009.       lcd.print(F("/100   "));
  2010.      
  2011.     break;
  2012.     case 25:  //max hit delay
  2013.       lcd.setCursor(0,0);
  2014.       lcd.print(F("  Max hit led   "));
  2015.       if(timehitled == 0){
  2016.         timehitled = 120;
  2017.       }
  2018.         if(etatboutonmode == LOW){
  2019.           //Trigger préssé
  2020.           if(timehitled < 240){
  2021.             timehitled ++;
  2022.           }else{
  2023.             timehitled = 1;
  2024.           }
  2025.           etatboutonmode = HIGH;
  2026.           delay(100);  
  2027.         }
  2028.       lcd.setCursor(4,1);
  2029.       lcd.print(printtolcd(timehitled,0));
  2030.       lcd.print(F("/240s "));
  2031.     break;
  2032.     case 26:  //Info nrf joueur hit
  2033.       lcd.setCursor(0,0);
  2034.       lcd.print(F("  Info RF hit   "));
  2035.         if(etatboutonmode == LOW){
  2036.           //Trigger préssé
  2037.           if(backshoot < 1){
  2038.             backshoot = 1;
  2039.           }else{
  2040.             backshoot = 0;
  2041.           }
  2042.           etatboutonmode = HIGH;
  2043.           delay(200);  
  2044.         }
  2045.       lcd.setCursor(6,1);
  2046.       if(backshoot == 1){
  2047.         lcd.print(F("On "));
  2048.       }else{
  2049.         lcd.print(F("off"));
  2050.       }    
  2051.     break;
  2052.     case 27:  //Info direction hit
  2053.       lcd.setCursor(0,0);
  2054.       lcd.print(F("  Info Sens hit "));
  2055.         if(etatboutonmode == LOW){
  2056.          //Trigger préssé
  2057.           if(dirhit < 3){
  2058.             dirhit ++;
  2059.           }else{
  2060.             dirhit = 0;
  2061.           }
  2062.           etatboutonmode = HIGH;
  2063.           delay(150);  
  2064.         }
  2065.       lcd.setCursor(0,1);
  2066.       if(dirhit == 0){
  2067.         lcd.print(F("      Off       "));
  2068.       }else if(dirhit == 1){
  2069.         lcd.print(F("   Gilet+Tete   "));
  2070.       }else if(dirhit == 2){
  2071.         lcd.print(F("   GiletAV+AR   "));
  2072.       }else if(dirhit == 3){
  2073.         lcd.print(F("GiletAV+AR+Tete "));
  2074.       }else{
  2075.         lcd.print(F("      Full      "));
  2076.       }    
  2077.     break;
  2078.     case 28: //Headshoot
  2079.       lcd.setCursor(0,0);
  2080.       lcd.print(F("Head shoot 100% "));
  2081.         if(etatboutonmode == LOW){
  2082.           //Trigger préssé
  2083.           if(headshoot < 1){
  2084.             headshoot = 1;
  2085.           }else{
  2086.             headshoot = 0;
  2087.           }
  2088.           etatboutonmode = HIGH;
  2089.           delay(200);  
  2090.         }
  2091.       lcd.setCursor(6,1);
  2092.       if(headshoot == 1){
  2093.         lcd.print(F("On "));
  2094.       }else{
  2095.         lcd.print(F("off"));
  2096.       }    
  2097.     break;
  2098.     case 29:  //Zombie
  2099.       lcd.setCursor(0,0);
  2100.       lcd.print(F("     Zombie     "));
  2101.         if(etatboutonmode == LOW){
  2102.           //Trigger préssé
  2103.           if(zombie < 1){
  2104.             zombie = 1;
  2105.           }else{
  2106.             zombie = 0;
  2107.           }
  2108.           etatboutonmode = HIGH;
  2109.           delay(200);  
  2110.         }
  2111.       lcd.setCursor(6,1);
  2112.       if(zombie == 1){
  2113.         lcd.print(F("On "));
  2114.       }else{
  2115.         lcd.print(F("off"));
  2116.       }    
  2117.     break;
  2118.     case 30:  //RAZ config
  2119.       lcd.setCursor(0,0);
  2120.       lcd.print(F("      RAZ       "));
  2121.         if(etatboutonmode == LOW){
  2122.           //Trigger préssé                  
  2123.           save(1);
  2124.           delay(5);
  2125.           inmenuedit = 0;
  2126.           transmitBt();
  2127.           lcd.clear();
  2128.           }
  2129.           etatboutonmode = HIGH;
  2130.           delay(200);  
  2131.     break;
  2132.     case 31:  //Exit config
  2133.       lcd.setCursor(0,0);
  2134.       lcd.print(F("  Save & Exit   "));
  2135.         if(etatboutonmode == LOW){
  2136.           //Trigger préssé                  
  2137.           save(0);
  2138.           delay(5);
  2139.           inmenuedit = 0;
  2140.           lcd.clear();
  2141.           }
  2142.           etatboutonmode = HIGH;
  2143.           delay(200);  
  2144.     break;
  2145.   }
  2146. }
  2147. String printtolcd(int valeur_lcd, boolean addspace){
  2148.  String retour_valeur_lcd;
  2149.  if(valeur_lcd < 10){
  2150.    retour_valeur_lcd = "00";
  2151.  }
  2152.  if(valeur_lcd >= 10 && valeur_lcd < 100){
  2153.    retour_valeur_lcd = "0";
  2154.  }
  2155.  if(addspace == 1){
  2156.    lcd.setCursor(0,1);
  2157.    retour_valeur_lcd = "      " + retour_valeur_lcd;
  2158.  }
  2159.  retour_valeur_lcd = retour_valeur_lcd + String(valeur_lcd);
  2160.  
  2161.  return retour_valeur_lcd;
  2162. }
  2163.  
  2164. void defCarSpeciaux(){
  2165.     byte deadC[8] = {
  2166.     B00000,
  2167.     B01010,
  2168.     B00000,
  2169.     B00000,
  2170.     B01110,
  2171.     B10001,
  2172.     B00000,
  2173.     B00000
  2174.   };  
  2175.   lcd.createChar(1, deadC);
  2176.   byte respawnC[8] = {
  2177.     B00000,
  2178.     B01111,
  2179.     B01111,
  2180.     B01000,
  2181.     B01000,
  2182.     B01000,
  2183.     B11100,
  2184.     B00000
  2185.   };  
  2186.   lcd.createChar(5, respawnC);
  2187.   byte balleC[8] = {
  2188.     B01110,
  2189.     B11111,
  2190.     B11111,
  2191.     B11111,
  2192.     B11111,
  2193.     B11111,
  2194.     B01110,
  2195.     B11111
  2196.   };
  2197.   lcd.createChar(0, balleC);
  2198.  
  2199.   byte pdvC[8] = {
  2200.     B00000,
  2201.     B01010,
  2202.     B11111,
  2203.     B11111,
  2204.     B01110,
  2205.     B00100,
  2206.     B00000,
  2207.     B00000
  2208.   };
  2209.   lcd.createChar(2, pdvC);
  2210.  
  2211.   byte shieldC[8] = {
  2212.     B01111,
  2213.     B01110,
  2214.     B11100,
  2215.     B11110,
  2216.     B01100,
  2217.     B01000,
  2218.     B10000,
  2219.     B00000
  2220.   };
  2221.   lcd.createChar(3, shieldC);
  2222.  
  2223.     byte batC[8] = {
  2224.     B01110,
  2225.     B11111,
  2226.     B10001,
  2227.     B11111,
  2228.     B10001,
  2229.     B11111,
  2230.     B10001,
  2231.     B11111
  2232.   };
  2233.   lcd.createChar(4, batC);
  2234. }
  2235. void save(int raz){
  2236.   if(raz == 1){
  2237.     idjoueur = 0;
  2238.     idteam = 0;
  2239.     friendlyfire = 0;
  2240.     ballemax = 30;
  2241.     rpm = 450;
  2242.     fireselect = 0;
  2243.     burstmode = 3;
  2244.     muzzle = 1;
  2245.     overheat = 49;
  2246.     respawnauto = 1;
  2247.     respawnmax = 0;
  2248.     delayrespawn = 10;
  2249.     timemax = 0;
  2250.     pdvmax = 100;
  2251.     boucliermax = 50;
  2252.     delaydoctor = 30;
  2253.     reuppdv = 0;
  2254.     reuppdvtime = 30;
  2255.     reuppdvper = 5;
  2256.     reuppdvmax = 50;
  2257.     startauto = 1;
  2258.     startdelay = 5;
  2259.     hitdelay = 1;
  2260.     choixdegats = 12;
  2261.     timehitled = 120;
  2262.     backshoot = 1;
  2263.     dirhit = 0;
  2264.     zombie = 0;
  2265.   }
  2266.  
  2267.     EEPROM.write(idjoueurAddr, idjoueur);
  2268.     EEPROM.write(idteamAddr, idteam);
  2269.     EEPROM.write(friendlyfireAddr, friendlyfire);
  2270.     EEPROM.write(balleAddr, ballemax);
  2271.     EEPROM.write(rpmAddr, rpm/10);
  2272.     EEPROM.write(fireselectAddr, fireselect);
  2273.     EEPROM.write(burstmodeAddr, burstmode);
  2274.     EEPROM.write(muzzleAddr, muzzle);
  2275.     EEPROM.write(overheatAddr, overheat);
  2276.     EEPROM.write(respawnmaxAddr, respawnmax);
  2277.     EEPROM.write(respawnautoAddr, respawnauto);
  2278.     EEPROM.write(delayrespawnAddr, delayrespawn);
  2279.     EEPROM.write(timeAddr, timemax);
  2280.     EEPROM.write(pdvAddr, pdvmax/10);
  2281.     EEPROM.write(bouclierAddr, boucliermax/10);
  2282.     EEPROM.write(delaydoctorAddr, delaydoctor);
  2283.     EEPROM.write(reuppdvAddr, reuppdv);
  2284.     EEPROM.write(reuppdvtimeAddr, reuppdvtime);
  2285.     EEPROM.write(reuppdvperAddr, reuppdvper);
  2286.     EEPROM.write(reuppdvmaxAddr, reuppdvmax);
  2287.     EEPROM.write(startautoAddr, startauto);
  2288.     EEPROM.write(startdelayAddr, startdelay);
  2289.     EEPROM.write(hitdelayAddr, hitdelay);
  2290.     EEPROM.write(choixdegatAddr, choixdegats);
  2291.     EEPROM.write(timehitledAddr, timehitled);
  2292.     EEPROM.write(backshootAddr, backshoot);
  2293.     EEPROM.write(dirhitAddr, dirhit);
  2294.     EEPROM.write(zombieAddr, zombie);
  2295.  
  2296. }
  2297. void playtone(int frequence, int length, int numnote){
  2298.     lenghttone[numnote] = length / 0.017;            //lenghttone specifies duration in number of ticks (25us) milliseconde = lengthtone * 0.025
  2299.     resettone[numnote] = 56000 / (frequence * 2);                // play hit sound. freq_son = 40000 / (reset * 2)
  2300. }
  2301. String realname(int idname){
  2302.  String name;
  2303.  switch(idname){
  2304.     case 0:
  2305.         name = "Eagle";
  2306.     break;
  2307.     case 1:
  2308.         name = "Joker";
  2309.     break;
  2310.     case 2:
  2311.         name = "Raven";
  2312.     break;
  2313.     case 3:
  2314.         name = "Sarge";
  2315.     break;
  2316.     case 4:
  2317.         name = "Angel";
  2318.     break;
  2319.     case 5:
  2320.         name = "Cosmo";
  2321.     break;
  2322.     case 6:
  2323.         name = "Gecko";
  2324.     break;
  2325.     case 7:
  2326.         name = "Blaze";
  2327.     break;
  2328.     case 8:
  2329.         name = "Camo";
  2330.     break;
  2331.     case 9:
  2332.         name = "Fury";
  2333.     break;
  2334.     case 10:
  2335.         name = "Flash";
  2336.     break;
  2337.     case 11:
  2338.         name = "Gizmo";
  2339.     break;
  2340.     case 12:
  2341.         name = "Homer";
  2342.     break;
  2343.     case 13:
  2344.         name = "Storm";
  2345.     break;
  2346.     case 14:
  2347.         name = "Habit";
  2348.     break;
  2349.     case 15:
  2350.         name = "Click";
  2351.     break;
  2352.     case 16:
  2353.         name = "Ronin";
  2354.     break;
  2355.     case 17:
  2356.         name = "Lucky";
  2357.     break;
  2358.     case 18:
  2359.         name = "Radar";
  2360.     break;
  2361.     case 19:
  2362.         name = "Blade";
  2363.     break;
  2364.     case 20:
  2365.         name = "Ninja";
  2366.     break;
  2367.     case 21:
  2368.         name = "Magic";
  2369.     break;
  2370.     case 22:
  2371.         name = "Gonzo";
  2372.     break;
  2373.     case 23:
  2374.         name = "Cobra";
  2375.     break;
  2376.     case 24:
  2377.         name = "Pappy";
  2378.     break;
  2379.     case 25:
  2380.         name = "Rambo";
  2381.     break;
  2382.     case 26:
  2383.         name = "Snake";
  2384.     break;
  2385.     case 27:
  2386.         name = "Audie";
  2387.     break;
  2388.     case 28:
  2389.         name = "Sting";
  2390.     break;
  2391.     case 29:
  2392.         name = "Zeena";
  2393.     break;
  2394.     case 30:
  2395.         name = "Bugsy";
  2396.     break;
  2397.     case 31:
  2398.         name = "Viper";
  2399.     break;
  2400.     case 32:
  2401.         name = "Jewel";
  2402.     break;
  2403.     case 33:
  2404.         name = "Genie";
  2405.     break;
  2406.     case 34:
  2407.         name = "Logan";
  2408.     break;
  2409.     case 35:
  2410.         name = "Razor";
  2411.     break;
  2412.     case 36:
  2413.         name = "Slick";
  2414.     break;
  2415.     case 37:
  2416.         name = "Venom";
  2417.     break;
  2418.     case 38:
  2419.         name = "Rocky";
  2420.     break;
  2421.     case 39:
  2422.         name = "Saber";
  2423.     break;
  2424.     case 40:
  2425.         name = "Crush";
  2426.     break;
  2427.     case 41:
  2428.         name = "Titan";
  2429.     break;
  2430.     case 42:
  2431.         name = "Orbit";
  2432.     break;
  2433.     case 43:
  2434.         name = "Vixen";
  2435.     break;
  2436.     case 44:
  2437.         name = "Tank";
  2438.     break;
  2439.     case 45:
  2440.         name = "Rogue";
  2441.     break;
  2442.     case 46:
  2443.         name = "Sheik";
  2444.     break;
  2445.     case 47:
  2446.         name = "Gizmo";
  2447.     break;
  2448.     case 48:
  2449.         name = "Siren";
  2450.     break;
  2451.     case 49:
  2452.         name = "Dozer";
  2453.     break;
  2454.     case 50:
  2455.         name = "Micro";
  2456.     break;
  2457.     case 51:
  2458.         name = "LgtMG";
  2459.     break;
  2460.     case 52:
  2461.         name = "HvyMG";
  2462.     break;
  2463.     case 53:
  2464.         name = "ZOOKA";
  2465.     break;
  2466.     case 54:
  2467.         name = "ROCKT";
  2468.     break;
  2469.     case 55:
  2470.         name = "GRNDE";
  2471.     break;
  2472.     case 56:
  2473.         name = "CLYMR";
  2474.     break;
  2475.     case 57:
  2476.         name = "MINE";
  2477.     break;
  2478.     case 58:
  2479.         name = "BOMB";
  2480.     break;
  2481.     case 59:
  2482.         name = "NUKE";
  2483.     break;
  2484.  }
  2485.  return name;
  2486. }
  2487.  
  2488. //ISR ROUTINE
  2489.  
  2490. ISR(TIMER2_OVF_vect, ISR_BLOCK){
  2491.  
  2492.     //TONE GENERATION
  2493.  
  2494.   if(resettone[indextone] > 0){
  2495.     timertone++;
  2496.     counttone++;
  2497.     if(timertone == resettone[indextone]){
  2498.       sbi(PIND,3);
  2499.       timertone = 0;
  2500.       if(counttone >= lenghttone[indextone] && lenghttone[indextone] != 0){
  2501.         resettone[indextone] = 0;
  2502.         counttone = 0;
  2503.         CLR(PORTD,3) ;
  2504.         if(indextone < sizeof(resettone)){
  2505.           indextone ++;
  2506.         }
  2507.         else{
  2508.           indextone = 0;
  2509.         }
  2510.       }
  2511.     }  
  2512.   }
  2513.   else if(indextone > 0){ indextone = 0; }
  2514.  
  2515. //RECEPTION
  2516.        
  2517.         rxRead1 = (PINH & B00001000) >> 3; //aka read pin 6 (PH3), the fast way AV
  2518.         rxRead2 = (PINH & B00010000) >> 4; //aka read pin 7 (PH4), the fast way AR
  2519.         rxRead3 = (PINH & B00100000) >> 5; //aka read pin 8 (PH4), the fast way AR
  2520.         rxRead4 = (PINH & B01000000) >> 6; //aka read pin 9 (PH4), the fast way AR
  2521.        
  2522.        
  2523.         rxTimer++;
  2524.         if(rxState == STATE_IDLE){    
  2525.           if(dirhit >= 2){
  2526.             if(rxRead4 == MARK){
  2527.               dircapteur = 3;
  2528.               rxTimer = 0;
  2529.               rxState = STATE_MARK;  // transmission begins, check HDR (header)
  2530.             }
  2531.             if(rxRead3 == MARK){
  2532.               dircapteur = 2;
  2533.               rxTimer = 0;
  2534.               rxState = STATE_MARK;  // transmission begins, check HDR (header)
  2535.             }
  2536.           }
  2537.           if(dirhit >= 1){
  2538.             if(rxRead2 == MARK){
  2539.               dircapteur = 1;
  2540.               rxTimer = 0;
  2541.               rxState = STATE_MARK;  // transmission begins, check HDR (header)
  2542.             }
  2543.           }
  2544.           if(rxRead1 == MARK){
  2545.             dircapteur = 0;
  2546.             rxTimer = 0;
  2547.             rxState = STATE_MARK;  // transmission begins, check HDR (header)
  2548.           }
  2549.         }
  2550.        
  2551.         switch(dircapteur){
  2552.           case 0:
  2553.             rxRead = rxRead1;
  2554.           break;
  2555.           case 1:
  2556.             rxRead = rxRead2;
  2557.           break;
  2558.           case 2:
  2559.             rxRead = rxRead3;
  2560.           break;
  2561.           case 3:
  2562.             rxRead = rxRead4;
  2563.           break;
  2564.         }
  2565.  
  2566.  
  2567.         switch (rxState) { //check current state of rx message CAPTEUR 1
  2568.           case STATE_MARK: // timing MARK
  2569.             if (rxRead == SPACE){   // MARK ended, record time
  2570.               rawData[rawIndex] = rxTimer;
  2571.               rawIndex++;
  2572.  
  2573.               rxTimer = 0;
  2574.               rxState = STATE_SPACE;
  2575.             }
  2576.           break;
  2577.           case STATE_SPACE: // timing SPACE
  2578.             if (rxRead == MARK){   // MARK ended, record time
  2579.  
  2580.               rawData[rawIndex] = rxTimer;
  2581.               rawIndex++;
  2582.  
  2583.               rxTimer = 0;
  2584.               rxState = STATE_MARK;
  2585.             }
  2586.             else if(rxTimer > 34) {
  2587.               rxState = STATE_STOP;
  2588.  
  2589.             }
  2590.           break;
  2591.         }
  2592. }
  2593.  
  2594. boolean match_hdr(int timer){
  2595.  
  2596.   if(timer > 86 && timer < 106) return true;
  2597.   return false;
  2598. }
  2599.  
  2600. boolean match_one(int timer){
  2601.  
  2602.   if(timer > 38 && timer < 58) return true;
  2603.   return false;
  2604. }
  2605.  
  2606. boolean match_zero(int timer){
  2607.  
  2608.   if(timer > 14 && timer < 34) return true;
  2609.   return false;
  2610. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!