Bazooka_V1

#include <Arduino.h>
#include <DFPlayer_Mini_Mp3.h>

#define txPinIR   3   //IR carrier output
#define TSOP 9
#define led_red A0
#define led_green A1
#define led_blue A2


SoftwareSerial mySerial(10, 11); // RX, TX
unsigned long duration;
unsigned long durationold;
String Received = "";

unsigned char carrierFreq = 0; //default
unsigned char period = 0; //calculated once for each signal sent in initSoftPWM
unsigned char periodHigh = 0; //calculated once for each signal sent in initSoftPWM
unsigned char periodLow = 0; //calculated once for each signal sent in initSoftPWM
unsigned long sigTime = 0; //used in mark & space functions to keep track of time
unsigned long sigStart = 0; //used to calculate correct length of existing signal, to handle some repeats


#define NEC_HEX_VALUE 0x20DF22DDUL //UL makes this an unsigned long
#define NEC_BIT_COUNT 24 // header +24 for message
/////////////////////////////////////////////////////////////////////
// MilesTag command pack  (0x...  ...UL)
#define New_GameIM 0x8305E8UL // New Game (Immediate)
#define Explode 0x830BE8UL //Explode
//////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////
const String New_GameIM_rcv = "100000110000010111101000";
const String Admin_Kill_rcv = "100000110000000011101000";
const String Clear_Scores_rcv = "100000110001010011101000";
///////////////////////////////////////////////////


class Elapsed
{
    unsigned long startus, startms;

  public:

    // constructor resets time
    Elapsed () {
      reset ();
    };

    // reset time to now
    void reset () {
      startus = micros ();
      startms = millis ();
    };

    // return Elapsed time in milliseconds
    unsigned long intervalMs () {
      return millis () - startms;
    };

    // return Elapsed time in microseconds
    unsigned long intervalUs () {
      return micros () - startus;
    };

};    // end of class Elapsed


static Elapsed t_1, t_2, t_3, t_bazook, t_flash, t_blink, t_itter;
int blink=0;
int bit = 0;
int loopNr = 0;

void setup() {
  Serial.begin(2000000); // 2MHz- fastest one
  Serial.println("---Ready----");
  Serial.println("\n");
  pinMode(TSOP, INPUT);
  pinMode(txPinIR, OUTPUT);

  mySerial.begin (9600);
  mp3_set_serial (mySerial);  //set softwareSerial for DFPlayer-mini mp3 module
  mp3_set_volume (30);

  pinMode(led_red, OUTPUT);
  pinMode(led_green, OUTPUT);
  pinMode(led_blue, OUTPUT);
  digitalWrite(led_red, 0);
  digitalWrite(led_blue, 0);
  digitalWrite(led_green, 0);

  //mp3_play (1);



}


void initSoftPWM(unsigned char carrierFreq) { // Assumes standard 8-bit Arduino, running at 16Mhz
  //supported values are 30, 33, 36, 38, 40, 56 kHz, any other value defaults to 38kHz
  //we will aim for a  duty cycle of circa 33%

  period =  (1000 + carrierFreq / 2) / carrierFreq;
  periodHigh = (period + 1) / 3;
  periodLow = period - periodHigh;


  switch (carrierFreq) {
    case 30  : //delivers a carrier frequency of 29.8kHz & duty cycle of 34.52%
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 10; //Trim it based on measurementt from Oscilloscope
      break;

    case 33  : //delivers a carrier frequency of 32.7kHz & duty cycle of 34.64%
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 10; //Trim it based on measurementt from Oscilloscope
      break;

    case 36  : //delivers a carrier frequency of 36.2kHz & duty cycle of 35.14%
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 11; //Trim it based on measurementt from Oscilloscope
      break;

    case 40  : //delivers a carrier frequency of 40.6kHz & duty cycle of 34.96%
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 11; //Trim it based on measurementt from Oscilloscope
      break;

    case 56  : //delivers a carrier frequency of 53.8kHz & duty cycle of 40.86%
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 12; //Trim it based on measurementt from Oscilloscope
      //Serial.println(periodHigh);
      //Serial.println(periodLow);

      break;


    case 38  : //delivers a carrier frequency of 37.6kHz & duty cycle of 36.47%
    default :
      periodHigh -= 6; //Trim it based on measurementt from Oscilloscope
      periodLow  -= 11; //Trim it based on measurementt from Oscilloscope
      break;
  }
}

void mark(unsigned int mLen) { //uses sigTime as end parameter
  sigTime += mLen; //mark ends at new sigTime
  unsigned long now = micros();
  unsigned long dur = sigTime - now; //allows for rolling time adjustment due to code execution delays
  if (dur == 0) return;
  while ((micros() - now) < dur) { //just wait here until time is up
    digitalWrite(txPinIR, HIGH);
    if (periodHigh) delayMicroseconds(periodHigh);
    digitalWrite(txPinIR, LOW);
    if (periodLow)  delayMicroseconds(periodLow);
  }
}

void space(unsigned int sLen) { //uses sigTime as end parameter
  sigTime += sLen; //space ends at new sigTime
  unsigned long now = micros();
  unsigned long dur = sigTime - now; //allows for rolling time adjustment due to code execution delays
  if (dur == 0) return;
  while ((micros() - now) < dur) ; //just wait here until time is up
}

void sendHexNEC(unsigned long sigCode, byte numBits, unsigned char repeats, unsigned char kHz) {

#define NEC_HEADER_MARK 2400
#define NEC_HEADER_SPACE 600
#define NEC_ONE_MARK 1200
#define NEC_ZERO_MARK 600
#define NEC_ONE_SPACE 600
#define NEC_ZERO_SPACE 600
#define NEC_TRAILER_MARK 560

  unsigned long bitMask = (unsigned long) 1 << (numBits - 1); //allows for signal from 1 bit up to 32 bits
  //
  if (carrierFreq != kHz)  initSoftPWM(kHz); //we only need to re-initialise if it has changed from last signal sent

  sigTime = micros(); //keeps rolling track of signal time to avoid impact of loop & code execution delays
  sigStart = sigTime; //remember for calculating first repeat gap (space), must end 108ms after signal starts

  // First send header Mark & Space
  mark(NEC_HEADER_MARK);
  space(NEC_HEADER_SPACE);

  while (bitMask) {
    if (bitMask & sigCode) { //its a One bit
      mark(NEC_ONE_MARK);
      space(NEC_ONE_SPACE);
    }
    else { // its a Zero bit
      mark(NEC_ZERO_MARK);
      space(NEC_ZERO_SPACE);
    }
    bitMask = (unsigned long) bitMask >> 1; // shift the mask bit along until it reaches zero & we exit the while loop
  }
  // Last send NEC Trailer MArk
  // mark(NEC_TRAILER_MARK);


  if (repeats == 0) return; //finished - no repeats
  else if (repeats > 0) { //first repeat must start 108ms after first signal
    space(108000 - (sigTime - sigStart)); //first repeat Header should start 108ms after first signal
    mark(NEC_HEADER_MARK);
    space(NEC_HEADER_SPACE / 2); //half the length for repeats
    mark(NEC_TRAILER_MARK);
  }

  while (--repeats > 0) { //now send any remaining repeats
    space(108000 - NEC_HEADER_MARK - NEC_HEADER_SPACE / 2 - NEC_TRAILER_MARK); //subsequent repeat Header must start 108ms after previous repeat signal
    mark(NEC_HEADER_MARK);
    space(NEC_HEADER_SPACE / 2); //half the length for repeats
    mark(NEC_TRAILER_MARK);
  }

}

void red() {
  digitalWrite(led_red, 0);
  digitalWrite(led_blue, 1);
  digitalWrite(led_green, 1);
}
void blue() {
  digitalWrite(led_red, 1);
  digitalWrite(led_blue, 0);
  digitalWrite(led_green, 1);
}
void green() {
  digitalWrite(led_red, 1);
  digitalWrite(led_blue, 1);
  digitalWrite(led_green, 0);
}
void white() {
  digitalWrite(led_red, 0);
  digitalWrite(led_blue, 0);
  digitalWrite(led_green, 0);
}
void led_off() {
  digitalWrite(led_red, 1);
  digitalWrite(led_blue, 1);
  digitalWrite(led_green, 1);
}


void shootrocket() {

  //led_off();
  delay(50);
  for (int i = 0; i < 5; i++)
  {
    sendHexNEC(Explode, NEC_BIT_COUNT, 1, 56);
    delay(50);
  }

  //red();
  //mp3_play (8);
  delay(1000);
  //led_off();
  Serial.print("rakieta");
}

void testowanie() {
  Serial.println("test");
  for (int i = 0; i < 5000; i++) {
    blue();
    delay(50);
    led_off();
    delay(200);
    sendHexNEC(New_GameIM, NEC_BIT_COUNT, 1, 56);
    delay(100);
    red();
    delay(50);
    led_off();
    delay(200);
    sendHexNEC(New_GameIM, NEC_BIT_COUNT, 1, 56);
    delay(100);
  }
}


void order() {
  String commandline = Serial.readString();
  //Serial.println(commandline);

  if (commandline.startsWith("new game")) {
    Serial.println(F("Sending New Game (Immediate)"));
    sendHexNEC(New_GameIM, NEC_BIT_COUNT, 1, 56);
  }

  if (commandline.startsWith("shoot rockets")) {
    shootrocket();
  }
  if (commandline.startsWith("test")) {
    testowanie();
  }
}

void reloading() {

  if(blink==2){blink=0;}

  if(t_blink.intervalMs()>800){
    if(blink==0){blue();}
    if(blink==1){led_off();}
    blink++;
    t_blink.reset();
    t_itter.reset();
  }

}



void loop() {

  //testowanie();

  duration = pulseIn(TSOP,LOW,5000);
  if(duration != durationold){ //  if new pulse detected do this


    if((Received.length()!=0)||(duration>2000)){

      bit = (log(((duration+50)/600))/(log(2)))+1;

      switch(bit){
        case 0:
          Received="";
          break;
        case 1:
          Received.concat(0);
          break;
        case 2:
          Received.concat(1);
          break;
        case 3:
          Received = "2";
          break;
      }

      if ((Received.length() == 15)&&(Received.startsWith("20") )) //Shoot
      {
        Serial.println("Shoot");
        Serial.println(Received);
        shootrocket();

        Received="";
      }

      if ((Received.length() == 25)&&(Received.startsWith("21") )) //Message
      {
        Serial.println("Message");
        Serial.println(Received);

        Received="";
      }











     durationold = duration;
     }
  }
}