Ferdig morse code

#include <LiquidCrystal.h> //dette er et innebygd biblotek som gjør at Arduino kan kontrollere og styre LCD displayet

#include "string.h"

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // igangsetter bibloteket ved å koble følgende pinner til LCD skjermen.(bruker 6 bit av totalt 8)

//==============================================================================================================================================================

const int buzzer = 13;//setter en constant for pinnenes utgang
const int knapp = 7;//setter en constant for pinnenes utgang

const int dotDelay = 200; //varigheten til buzzer hvor lenge hver "." eller "-" skal vare før den skrurseg av.

//==============================================================================================================================================================

//definerer morsekodene for alphabetet og nummerne
char* letters[] = {
  ".-",     // A
  "-...",   // B
  "-.-.",   // C
  "-..",    // D
  ".",      // E
  "..-.",   // F
  "--.",    // G
  "....",   // H
  "..",     // I
  ".---",   // J
  "-.-",    // K
  ".-..",   // L
  "--",     // M
  "-.",     // N
  "---",    // O
  ".--.",   // P
  "--.-",   // Q
  ".-.",    // R
  "...",    // S
  "-",      // T
  "..-",    // U
  "...-",   // V
  ".--",    // W
  "-..-",   // X
  "-.--",   // Y
  "--.."    // Z
};

char* numbers[] = {
  "-----",   // 1
  ".----",   // 2
  "..---",   // 3
  "...--",   // 4
  "....-",   // 5
  ".....",   // 6
  "-....",   // 7
  "--...",   // 8
  "---..",   // 9
  "----."
};


const char bokstaverTall[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9'};
const String letters2[] = {

//====================================================================================================================================================================
  ".-****",     // A
  "-...**",   // B
  "-.-.**",   // C
  "-..***",    // D
  ".*****",      // E
  "..-.**",   // F
  "--.***",    // G
  "....**",   // H
  "..****",     // I
  ".---**",   // J
  "-.-***",    // K
  ".-..**",   // L
  "--****",     // M
  "-.****",     // N
  "---***",    // O
  ".--.**",   // P
  "--.-**",   // Q
  ".-.***",    // R
  "...***",    // S
  "-*****",      // T
  "..-***",    // U
  "...-**",   // V
  ".--***",    // W
  "-..-**",   // X
  "-.--**",   // Y
  "--..**",   // Z
  "-----*",    // 0
  ".----*",    // 1
  "..---*",    // 2
  "...--*",   // 3
  "....-*",    // 4
  ".....*",    // 5
  "-....*",    // 6
  "--...*",   // 7
  "---..*",    // 8
  "----.*"    // 9

};
const int sizeOfArrays = 36; //setter størrelsen på arrayet(antall forskjellige bokstaver,tegn)

//===============================================================================================================================================================

void setup()
{
  pinMode(buzzer, OUTPUT); //definerer buzzers pinne som en utgang
  pinMode(knapp, INPUT);   //definerer knppens pinne som en inngang
  pinMode(6,INPUT);

  Serial.begin(9600); //Setter serial monitor til 9600.

  lcd.begin(16, 2); //denne forteller hvor mange kolonner og rader displayet vi har består av(16 kolonner og 2 rader)
}

//=============================================================================================================================================================

void loop()
{
  static int SerialReadFlag = 0;          //legger til en funksjon som sier om flagget er nede da er funksjonen lik 0 og hvis flagget er oppe så skal den gjøre noe.
  static unsigned long forrigeTrykk = 0;  //med en unsigned long funksjon kontrollerer vi tiden siden forgje gang trykket inn i en millis funksjon.
  static int forrigeTrykkFlag = 0;        //denne funksjonen foteller når vi faktisk har trykket på knappen hvis ikke er den 0 og det skal ikke skje noe..
  static unsigned long lcdTid = 0;        //foretller hvor lenge skjermen skal være på før den renser skjermen på lcd displayet.

    int pulsType = 0;                // Resetter pulstypen til 0 (1="." og 2="-")
  if(digitalRead(knapp) == 1){       // Når knappen trykkes ned...
    pulsType = lengde();             // ...kjøres funksjonen "lengde()" som returnerer pulstype
    forrigeTrykk = millis();         // setter forgje trykk lik millis for

    forrigeTrykkFlag = 1;            //når vi har trykket inn knappen en kort gang er denne høy og funksjonen starter.
    if(pulsType == 1){               // hvis det har vært et kort trykk på knappen som er det samme som "." så blir buzzer høy og skal pipe
      digitalWrite(buzzer, HIGH);    // og etter 200ms som jeg har satt som dotDelay så setter man buzzeren tilbake til lav tiltilstand og det gjør at buzzeren
      delay(dotDelay);               //og det gjør at buzzeren slutter å pipe.
      digitalWrite(buzzer, LOW);
      Serial.print(".");             // skriver ut "." i serial monitor hvis kort trykk.
    }
    if(pulsType == 2){               //når vi har trykket inn knappen en lang gang er denne høy og funksjonen starter.
      digitalWrite(buzzer, HIGH);    //Et langt trykk på knappen som er det samme som "-" så blir buzzer høy og skal pipe
      delay(dotDelay*3);             //og etter 3*200ms som jeg har satt som dotDelay så setter man buzzeren tilbake til lav tiltilstand og det gjør at buzzeren
      digitalWrite(buzzer, LOW);     //buzzeren slutter å pipe.
      Serial.print("-");             //skriver ut "-" i serial monitor hvis langt trykk.
    }
   }
//===============================================================================================================================================================

  if(millis()-forrigeTrykk >= 3000 && forrigeTrykkFlag == 1){ //hvis tiden mills()-forgjeTrykk er større eller lik 3000ms og forrgjeTrykkFlag er høy
      Serial.println(" ");                                    //så skal den skrive ut mellomrom (" ") både i serial monitor og i lcd displayet.
      lcd.print(" ");
      forrigeTrykkFlag = 0; //setter så flagget til nede for å resette funksjonen slik at den ikke fortsetter å skrive mellomrom.
      }

 //===============================================================================================================================================================

  char ch;
  if (Serial.available())      // venter på data fra serial communication
  {
    lcdTid = millis();
    ch = Serial.read();        // leser vi hver bokstav.


    Serial.print(ch);//printer ut i serial monitor og til lcd displayet bokstavene vi skal sende.
    lcd.print(ch);



    if (ch >= 'a' && ch <= 'z') // hvis små bokstaver
    {
      morseCodeSequence(letters[ch - 'a']);
    }
    else if (ch >= 'A' && ch <= 'Z')    // eller hvis store bokstaver
    {
      morseCodeSequence(letters[ch - 'A']);
    }
    else if (ch >= '0' && ch <= '9')    // eller hvis tall
    {
      morseCodeSequence(numbers[ch - '0']);
    }
    else if (ch == ' ')                // ved mellomrom vent 4*dotDelay som jeg har satt til 200ms
    {
     delay(dotDelay * 4);
    }
    SerialReadFlag = 1;                // hvis SerialReadFlag blir satt til høy så skal den rense lcd displayet hvis det har gått mer enn10 sekunder siden forrige gang
    if(millis()-lcdTid > 10000){       //noe var skrevet.
      lcd.clear();
    }
  } else if (SerialReadFlag == 1){     //hvis serialReadFlag er høy skal den lage mellomrom i serial monitor.
    Serial.println(" ");
    lcd.print(" ");
    SerialReadFlag = 0;                //hvis SerialReadFlag er lav skal den ikke lage noen ting.

  }
  if(millis()-lcdTid<=10000 && millis()-lcdTid>= 5000){ //hvis tiden millis bruker- lcdTiden er mindre eller lik 10s og tiden millis -lcdTid er større eller lik 5s
  lcd.setCursor(0,1);                                   //så skriver den i kolonne 0 rad 2 siden den starter standard i kolonne 0 rad 1.
  }
      if(millis()-lcdTid >= 10000){                     //hvis millis tiden- lcd tiden er større eller lik 10s så den rense lcd skjermen og sette tilbake
      lcd.clear();                                      //lcden i vanlig standard somm er kolonne 0, rad 0.
      lcd.setCursor(0,0);
    }
  if(digitalRead(6) == HIGH)   // hvis knappen en tryket inn så er den høy
  {
    Serial.print(readUserInput()); //printer ut verdien til variabelen charakter.
  }
}
//=====================================================================================================================================================================
//Denne funksjonen blir satt når vi setter pulsType = lengde(); lenger opp. og bestemmer hva funskjonen skal gjøre hvis det er kort trykk eller lang trykk.

int lengde(){
  int startTid;
  int sluttTid;
  int pulsLengde;

  startTid = millis();                // Registrer tiden akkurat nå
  delay(10);                          // Eliminerer klirr når knappen trykkes ned
  while(digitalRead(knapp) == 1){}    // Venter mens knappen er trykket ned
  delay(10);                          // Eliminerer klirr når knappen trykkes opp
  sluttTid = millis();                // Registrer tiden på nytt
  if(sluttTid-startTid < 300){        // Hvis tiden knappen var trykket inn er minde enn 300 (KAN JUSTERES)...
    pulsLengde = 1;                     // ...registreres pulslengden som 1
  }
  else pulsLengde = 2;                // Ellers registreres pulslengden som 2
  return pulsLengde;                  //Returnerer pulsLengden 1 som er kort trykk eller 2 som er lang trykk.
}

//====================================================================================================================================================================
void morseCodeSequence(char* sequence) // denne funskjonen tar inngangen i et array eller "." og "-" og faktisk kaller den prikk eller strek for hvert element i selve
{                                      //arrayet.
   int i = 0;

   while (sequence[i] != NULL)     // sløyfe for hvert elemet i arrayet.
   {
       dotOrDash(sequence[i]);     // sender ut dosh eller dash ("." og "-").
       i++;                        // teller neste element i arrayet. Increment to the next element in the array.
   }
   delay(dotDelay * 3);            // pause mellom hver bokstav som er 3 ganger dot varigheten, dotDelay er 200ms.
}

//==================================================================================================================================================================

//=============================================================================DOT ELLER DASH=======================================================================

void dotOrDash(char dotOrDash) // denne funksjonen ser på utsignalet om det skal være en dot"." eller dash "-"
{
  digitalWrite(buzzer, HIGH); // setter buzzer høy hvis dotOrDash er ".".
  if (dotOrDash == '.')
  {
    delay(dotDelay);          //setter et delay på 200ms.
  }
  else // must be a -         //ellers må det bli en -
  {
    delay(dotDelay * 3);      //som vi setter til 3* "." for å angi lengden til -.
  }
  digitalWrite(buzzer, LOW);  //hvis buzzer er lav
  delay(dotDelay); // pause mellom pipene

}

char readUserInput()
{
  char morseCode[6];               //

  int startTid,sluttTid;           //lager variablene startTid og sluttTid
  int puls;                        //lager variabelen puls
  int count = 0;                   //lager vaiabelen count og setter den lik 0
  boolean finishedLetter = false;  //lager en boolean med en variabel finishedLetter som vi setter til usann.
  boolean finishedDigit = false;   //lager en boolean med en variabel finishedDigit som vi setter til usann.

  while(!finishedLetter)           //lager en while løkke som begynner når IKKE er ferdig å skrive(finishedLetter)
  {
    startTid  = millis();          //Setter startTiden lik millis()
    sluttTid = 0;                  //Setter sluttTiden lik 0.
    puls = 0;                      //setter puls lik 0.

    finishedDigit = false;         //setter finishedDigit lik usann.

    while(!finishedDigit && !finishedLetter) //når finishDigit er sann og den ikke har skrivet ferdig bokstaven skal:
    {
      if(digitalRead(6) == HIGH)   // når knappen er(høy)
      {
        puls = debounce();         //setter puls lik debounce som er en egen funksjon som definerer om det er et kort eller langt trykk
        morseCode[count] = decodePulse(puls);   //****** hva?
        startTid = millis();       //setter startTiden lik millis()
        finishedDigit = true;      //setter finishedDigit sann
      }
      else if (digitalRead(6) == LOW) // hvis ikke setter vi knappen lav og dette skal skje:
      {
        sluttTid = millis();          //setter sluttTid lik millis()
        if(sluttTid-startTid > 1000)  // hvis sluttTid-startTid er mindre enn 1s så setter den at man er ferdig med å skrive??
        {
          finishedLetter = true;
        }
      }
    }
    if(finishedLetter == true || count == 5) //
    {
      for(int j = count; j < 6; j++)
      {
        morseCode[j] = '*';
      }
      finishedLetter = true;
    }
    count++;
  }
  int index = compareMorseCode(morseCode);
  char c = bokstaverTall[index];
  return bokstaverTall[index];
}
//=====================================================================================================================================================================
int debounce()
{
  int startTid;      //lager variabelen startTid
  int sluttTid;      //lager variabelen sluttTid
  int pulsLengde;    //lager variabelen pulsLengde

  startTid = millis();  // setter startTiden lik millis()
  delay(10);            //delay for å forhindre feil
  while(digitalRead(6) == HIGH) {} // dette skal skje når knappen er trykket inn
  delay(10);            //delay for å forhindre feil

  sluttTid = millis();  // sluttTiden er lik millis() når:
  if(sluttTid-startTid < 50 && sluttTid-startTid > 0) // slutttiden er mindre enn 50ms og sluttTiden-startTiden er større en 0 settes pulslengde lik 0
  {                                                   // dette gjør jeg for at jeg skal unngår uønskede trykk.
    pulsLengde = 0;
  }
  else if(sluttTid-startTid < 300 && sluttTid-startTid > 50) // denne sier at når sluttTid -startTid er mindre enn 300ms og sluttTid-startTid er større enn 50
  {                                                          //så setter man pulsLengden lik 1(dette er ".")
    pulsLengde = 1;
  }
  else if (sluttTid-startTid > 300 && sluttTid-startTid < 900) //denne fungerer på samme måte bare større enn 300ms og mindre enn 900ms så setter man
  {                                                            //pulsLengden lik 2(dette er "-").
    pulsLengde = 2;
  }
  else // hvis man holder knappen lenger inne enn 900ms så sender setter man tilstand 3 som gir et "feil" signal.
  {
    pulsLengde = 3;
  }
  return pulsLengde; //returnerer hvilken tilstand den er i.
}
//=====================================================================================================================================================================
char decodePulse(int pulseType)
{
  if(pulseType == 1)
    return '.';
  else if(pulseType == 2)
    return '-';
  else if (pulseType == 3)
    return '*';
}
int compareMorseCode(char morseCode[])
{
  String morseCodeString = "";
  for(int i = 0; i < 6; i++)
  {
    morseCodeString = morseCodeString + morseCode[i];

  }
  for(int i = 0; i < sizeOfArrays; i++)
  {
      if(letters2[i] == morseCodeString)
      {
         return i;
      }
  }
  return 0;
}