Medomet – Včelařství Havelka

Řídící jednotka pro medomet

Před lety jsem si pořídil automatický zvratný medomet, ale nevyhovovala mi jeho řídící jednotka. Čas od času se mi stalo, že při reverzu otáček došlo je sklopení kazet do proti směru otáčení. Toto přikládám rozkmitání kazet při brždění a při změně směru otáček může dojít ke sklopení špatným směrem. Kdyby při reverzu bylo možné nastavit časovou prodlevu pro větší uklidnění kazet, bylo by po problému. Dále mi vadilo, že jednotka je plná pevně nastavených cyklů a pouze jeden je možné uživatelsky nastavit.
Rozhodl jsem si navrhnout vlastní jednotku, která by výše uvedené eliminovala. Když už jsem se pustil do tohoto úkolu, chtěl jsem jednotku, která bude vhodná (téměř) pro všechny typy elektromotorem poháněných medometů. Proč téměř? Jako regulační prvek používám H můstek s čipem BTS7960B a PWM regulaci, z čehož vyplývá, že je možné regulovat pouze stejnosměrné motory a to v rozsahu napětí a proudů podle zvoleného H můstku. I přes toto omezení řídící jednotka umí pracovat v manuálním režimu (L+R), umí ovládat zvratné, ale i radiální a tangenciální medomety. Pro poslední dva typy medometů je použitá stejná procedura vytáčení a označena společně jako radiální.

Použitý HW

Arduino NANO 1 ks
H můstek BTS7960B 1 ks
LCD2004 Displej HD44780, 20 x 4 znaků 1 ks
LCD Sériové rozhraní – IIC/I2C/TWI/SP 1602 1 ks

Stabilizátor napětí osazený na PCB (vše v provedení SMD, hodnoty v závorce uvádí typ pouzdra)

stabilizátor LM2596S (TO263-5) 1 ks
kondenzátor 100uF/25V (0810) 1 ks
kondenzátor 220uF/25V (0810) 1 ks
dioda SS34 (DO214AC) 1 ks
tlumivka DE1209-68uH (DR127) 1 ks
rezistor 3k (M1206) 1 ks
rezistor 1k (M1206) 1 ks
rezistor 10k (M1206) 1 ks

Mechanické díly

membránová klávesnice 4×4 1 ks
kolíková lišta 40pin 2,54mm – přímá, vysoká (potřebuje 16 pinů)
kolíková lišta 40pin 2,54mm – přímá (potřebuje 8 pinů)
plastový distanční sloupek M3 délka 15 mm (vč. matice a šroubku) 4 ks
plastový distanční sloupek M3 délka 7 mm (vč. matice a šroubku) 4 ks
deska PCB (viz. gerber data) 1 ks
box 3D výtisk (horní + dolní) 1+1 ks
plexi kryt displeje 1ks
pouzdro na trubičkové pojistky 5×20 na panel 1ks
pouzdro na trubičkové pojistky 5×20 na panel 1ks
průchodka PG9 2 ks
průchodka PG7 1 ks
kolébkový vypínač do otvoru 20,5 mm 1 ks

Podle datasheetu umí H můstek regulovat napětí 6-27V DC a proud až 43A. Co se týká proudu, byl bych opatrný. Svorkovnice osazená na modulu snese proudy cca 15-20A a samotná deska PCB na tom bude ještě hůře. Ale nezpochybňuji, že samotný čip uvedené proudy zvládá. Nicméně pro běžné medomety je to dostačující.

Na samotné propojení nedoporučuji tzv. „vrabčí hnízdo“, navrhl a nechal jsem si vyrobit PCB, výrobní gerber data přikládám v dokumentaci. Výrobu provedla fy. JLCPCB v Číně. Kvalita je excelentní, cena včetně dopravy cca 10€ za 5 kusů desek (to je minimální výrobní množství). Je potřeba vybrat způsob dopravy, který vyhovuje termínem doručení a cenou.
Samotnou PCB je možné prohlédnout přes gerber wiever, např. Online Gerber Viewer (nutná registrace) Stačí naimportovat ZIP s gerber daty (viz. přiložená dokumentace).

Osazení PCB není složité, doporučuji používat mikropájku s regulací teploty. Osazovací plán je také přiložen v dokumentaci.

Pořadí osazování:

SMD součástky stabilizátoru (po osazení doporučuji samostatně ověřit výstupní napětí stabilizovaného zdroje)
svorkovnice
arduino nano
LCD Sériové rozhraní
konektorový hřebínek pro LCD
LCD2004 Displej
konektorový hřebínek pro klávesnici
H můstek

Pro samotnou zástavbu regulátoru jsem navrhl a vytiskl box na 3D tiskárně, data opět přiložena. Tisk z PETG, do boxu jsem osadil zatavovací závitové vložky M3 a M5. Dále Stop tlačítko, kolébkový vypínač, pojistková pouzdra vel. 5X20 (pro řídící elektroniku) a 6,3×32 (pro motor medometu), kabelové průchodky. Ochranu displeje tvoří plexisklo 35x85x3 mm, zakulacené rohy, vlepené do rámečku boxu (nebo hrany mezi plexi a boxem zatavit na několika bodech pájkou). V horní části boxu je otvor 16 mm pro připojení USB v případě potřeby programování již sestavené jednotky. zaslepit ucpávkou 16 mm (běžně lze koupit). Membránová klávesnice 4×4 se vyrábí s více druhy potisku, použil jsem s tlačítky Start/Stop a funkcemi F1-F4. Lze použít i s jiným potiskem, ve zdrojovém kódu a při zobrazování na LCD se odkazuji na uvedený typ s potisky F1-F4. Vše je zřejmé z fotografií, včetně vnitřního propojení. Hodnota pojistky pro řídící elektroniku je 2A, pro motor medometu je potřeba odpovídající pojistka dle proudu konkrétního motoru. V mém případě 10A.
Svorky bezpečnostního spínače krytu medometu řídící jednotka vyhodnocuje jako rozpínací kontakt.

Po osazení PCB, montáže do boxu a propojení je možné přistoupit k oživování. Pro testování jsem použil zdroj 12V DC a motor „ze šuplíku“ 12V DC. Je to komfortnější, než vše řešit přímo v medárně. Pokud je vše správně a pečlivě osazeno, zapájeno a připojeno, jednotka by měla pracovat na první zapojení. Teoreticky by mohl být problém s adresou řadiče LCD displeje. V programu je nastavena na 0x27. Pokud displej nepracuje správně, je dobré pomocí I2C scaneru (program pro arduino volně k dispozici) a ověřit adresu řadiče, popřípadě upravit v programu. ještě doplňuji, ža na I2C regulátoru je umístěný trimr, kterým se nastavuje úroveň podsvícení. Jumper propojka na řadiči musí být spojena, je přes ni napájeno podsvícení.

Samotný zdrojový kód je poměrně rozsáhlý, obsahuje 11 záložek. Pro přehlednost je dostatečně okomentovaný.

Struktura kódu:

Medomet_ver1.1.ino – knihovny, definice proměnných, setup, smyčka loop
Bargraf.ino – grafické zobrazení hodnoty otáček
Cycle.ino – struktura cyklování vytáčecích procedur
CykleLCD.ino – zobrazování cyklů na LCD
Eeprom.ino – konfigurace eeprom, zápis, čtení, update
Error.ino – chybová logika, validace zadaných hodnot při konfiguraci
Function.ino – výběr programů, navigace
Keypad.ino – obsluha klávesnice 4×4
Menu.ino – navigace menu pro nastavení uživatelských hodnot
StartingBrake.ino – práce s motorem, rozběhová a brzdící logika
Timing.ino – časovaní a práce s časem

Součástí složky se zdrojovým kódem jsou i soubory knihovny časování. Ty jsou upraveny pro jiný způsob zobrazování časů, než v originální knihovně. Pro správnou funkci je třeba použít tuto upravenou knihovnu. S původní knihovnou by časování pracovalo správně, ale zobrazování na LCD by neodpovídalo potřebám řídící jednotky (režim hh:mm:ss je nahrazen mm:ss)

Countimer.cpp
Countimer.h

Ve složce library přikládám funkční knihovny, na které byl zdrojový kód odladěn. Je zde i původní verze knihovny Countimer, používejte ale upravenou verzi se změnou zobrazování časování, viz výše.

Celková struktura kódu:

Medomet_ver1.1.ino


//autor info@vcelarstvihavelka.cz https://vcelarstvihavelka.cz/
// licence Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
// https://creativecommons.org/licenses/by-nc-sa/4.0/
// 2026
// --------------------------------------------
#include  // LCD I2C 20x4  https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
#include "Countimer.h" // časování  https://github.com/inflop/Countimer
#include  // klávesnice   https://github.com/Chris--A/Keypad
#include 

LiquidCrystal_I2C lcd(0x27, 20, 4);
const int LCD_NB_ROWS = 4;
const int LCD_NB_COLUMNS = 13; // znaky bargrafu
//vypis EEprom
byte coll = 0;
byte countE = 0;
byte adressMax = 255;

long AktualMillis;
long SetupMillis = 120; // max. čas v setupu (sekundy)

int RPWM = 5; // pin RPWM
int LPWM = 6; // pin LPWM
int L_EN = 7;
int R_EN = 8;
long vypocet;
byte RezimPrace; // kroky cyklu medometu
byte dir_rot; // směr otáčení 1=left, 2=right
byte accelerate;  //zrychlení 1-9;
byte step; // krok zrychlení na 1 stupeň = 1-5 sec. 
byte acc; // vypocet zrychleni [accelerate * step]

// casovani cyklu
int SlowTime;// cas nizkych otacek [60-300 sec.]
int FastTime;// cas vysokych otacek [60-480 sec.]
int MedTime;// cas středních otacek [výpočet]
int FastTimeNew;// cas vysokych otacek [výpočet]
byte PauseTime;// prodleva při reverzaci otáček [0-20 sec.] [PauseTime * step]

byte rot_speed_low; // nízké otáčky rozsah 15-50 %  NO
byte rot_speed_high;// vysoké otáčky rozsah 30-100 % VO
byte rot_speed_med;// střední otáčky výpočet
float pwm_speed; //vypocet PWM otáčky v %
byte pwm_start; // stratovací otáčky přechod NO a VO
byte need = 0; // stav nouzového zastavení 0 = běžný stav; 1 = práce v nouzovém stavu
byte manual_start; // zakladni otacky manualniho toceni
byte manual_step; // krok zmeny manualniho toceni

byte mode; // 1 = zvratny, 2 = radialni, 3 = manual R, 4 = manual L
byte menu_mode; //pro urceni mode v nastaveni menu
byte SettingMode = 0; // vstup do menu 0 = NE, 1 = ANO
byte MenuNum; // cislo programu pro editaci

int SafetyKey = 2; //vstup bezp. spínač
byte SafetyKeyMode = 0; // stav vstupu bezp. spínače
byte SafetyStatus = 0;

int i; // konstanta pro rizeni motoru
byte n; // konstanta pro LCD
byte j; // konstanta pro LCD
byte ss = 0; // konstanta info Start - Stop
byte ee = 0; // konstanta pro EEPROM
byte mode_nav;
byte vypis = 0; // vypis hlasek na ser. monitor 0 = NE, 1 = ANO
byte pgm; // listovani programy
byte edit_pgm; // editovany program

byte KeyValue = 0; // ovládání menu

//Keypad
byte Num; // počet cislic v poli znakyKey
int count;  //pocitani cycklu
int cisloKey; // vysledne cislo
byte ZnakKey; // znaky *; #; A; B; C; D;
int NewKey; // prichozi znak z klavesnice
byte konst = 47; // konstanta pro vypocet cisla z Char znaku
const byte ROWS = 4; //řádky
const byte COLS = 4; // sloupce
char hexaKeys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = {3, 4, 9, 10}; //řádky
byte colPins[COLS] = {11, 12, A0, A1}; // sloupce

Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

Countimer tDownSlowTime;
Countimer tDownFastTime;
Countimer tDownPauseTime;

byte DIV_0_OF_5[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000}; // 0 / 5
byte DIV_1_OF_5[8] = { 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000}; // 1 / 5
byte DIV_2_OF_5[8] = { 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000}; // 2 / 5
byte DIV_3_OF_5[8] = { 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100}; // 3 / 5
byte DIV_4_OF_5[8] = { 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100, 0b10100}; // 4 / 5
byte DIV_5_OF_5[8] = { 0b10101, 0b10101, 0b10101, 0b10101, 0b10101, 0b10101, 0b10101, 0b10101}; // 5 / 5
byte Cykl_LCD_off[8] = { 0b11111, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11111}; // 6
byte lock[8] = { 0b01110, 0b10001, 0b10001, 0b10000, 0b11111, 0b11011, 0b11011, 0b11111}; // 7

float percent; // hodnota bargrafu v %

void setup_progressbar() { // definice znaků bargrafu
  lcd.createChar(0, DIV_0_OF_5);
  lcd.createChar(1, DIV_1_OF_5);
  lcd.createChar(2, DIV_2_OF_5);
  lcd.createChar(3, DIV_3_OF_5);
  lcd.createChar(4, DIV_4_OF_5);
  lcd.createChar(5, DIV_5_OF_5);
  lcd.createChar(6, Cykl_LCD_off);
  lcd.createChar(7, lock);
}

void setup() {
  Serial.begin(9600);
  while (!Serial);

  RezimPrace = 0;
  ss = 0;
  mode = 0; // 0 = listovani PGM, 1 = zvratny, 2 = radialni, 3 = manual L, 4 = manual R
  pgm = 1;

  SetupMillis = SetupMillis * 1000; // převod sec. na milisec.
  LCD_head ();
  Keypad(); // čtení klávesnice
  setup_progressbar();

  if (ZnakKey == 65)  { // Menu nastaveni >>> F1
    AktualMillis = millis();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Setup program");
    SettingMode = 1;
    KeyValue = 1;
    delay(2000);
    menu ();
  }
  if (ZnakKey == 66)  { // Nastaveni zrychlení motoru >>> F2
    AktualMillis = millis();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Setup motor");
    SettingMode = 2;
    KeyValue = 1;
    delay(2000);
    Setupmotor ();
  }
  if (ZnakKey == 68)  { // Tovarni nastaveni >>> F4
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Reset settings");
    delay(2000);
    EEPROM.write(200, 255); // priprava pro reset EEPROM
    EepromSetings ();
  }
  for (int i = 5; i < 9; i++) { // nastavení pinu PWM
    pinMode(i, OUTPUT);
  }
  for (int i = 5; i < 9; i++) { // pocatecni stav pinu PWM
    digitalWrite(i, LOW);
  }

}

void loop() {
  if (SettingMode == 0 ) {
    Pgm_select ();
  }
  AktualMillis = millis();
  Keypad(); // čtení klávesnice
  Safety (); // bezp. spínač
  tDownSlowTime.run(); //časovač nizkych otacek
  tDownFastTime.run(); //časovač vysokych otacek
  tDownPauseTime.run(); //časovač pauzy
  menu (); //nastaveni PGM
  Setupmotor (); // nastaveni zrychleni
}

void(* resetFunc) (void) = 0; // SW reset

Bargraf.ino


// bargraf a procenta otáček
// https://www.carnetdumaker.net/articles/faire-une-barre-de-progression-avec-arduino-et-liquidcrystal/
void draw_progressbar(byte percent) {
  // číselný vypis otáček

  if (RezimPrace != 0) {
    lcd.setCursor(14, 0);
    lcd.print(percent);
    lcd.print(F(" %  "));
  }

  // grafický výpis otáček
  lcd.setCursor(7, 3);
  byte nb_columns = map(percent, 0, 100, 0, LCD_NB_COLUMNS * 5);
  for (byte k = 0; k < LCD_NB_COLUMNS; ++k) { if (nb_columns == 0) { // Case vide lcd.write((byte) 0); } else if (nb_columns >= 5) { // Case pleine
      lcd.write(5);
      nb_columns -= 5;

    } else { // Derniére case non vide
      lcd.write(nb_columns);
      nb_columns = 0;
    }
  }
}

void percent_bar () {
  percent = i / 2.55;
  draw_progressbar(percent);
}

Cycle.ino


void Zvratny () { // kompletni cyklus vytaceni zvratneho kose
  int i;
  if ((RezimPrace == 0) && (SafetyStatus == 1) && (mode == 1)) { // Start Nizke otácky R + bezp. spínač
    i = 0;
  }

  if ((RezimPrace == 0) && (SafetyStatus == 0) && (mode == 1)) { // Start Nizke otácky R
    RezimPraceVypis ();
    pwm_speed = rot_speed_low * 2.55;
    pwm_start = 0;
    cykleLCD_Z ();
    dir_rot = 2;
    RezimPrace = 1;
    start_right ();

  }

  if ((RezimPrace == 1) && (SafetyStatus == 0) && (mode == 1))  { // casovani Nizke otácky
    cykleLCD_Z ();
    tDownSlowTime.restart();
  }

  if ((RezimPrace == 2) && (SafetyStatus == 0) && (mode == 1)) { // brzda Nizke otácky R
    pwm_speed = rot_speed_low * 2.55;
    cykleLCD_Z ();
    RezimPrace = 3;
    brake_right ();
  }

  if ((RezimPrace == 3) && (SafetyStatus == 0) && (mode == 1)) { // casovani Prodleva
    cykleLCD_Z ();
    tDownPauseTime.restart();
  }


  if ((RezimPrace == 4) && (SafetyStatus == 0) && (mode == 1)) { // Start Nizke otácky L
    cykleLCD_Z ();
    dir_rot = 1;
    pwm_speed = rot_speed_low * 2.55;
    pwm_start = 0;
    dir_rot = 1;
    RezimPrace = 5;
    start_left ();

  }

  if ((RezimPrace == 5) && (SafetyStatus == 0) && (mode == 1))  { // casovani Nizke otácky
    cykleLCD_Z ();
    tDownSlowTime.restart();
  }


  if ((RezimPrace == 6) && (SafetyStatus == 0) && (mode == 1)) { // Start Vysoke otácky L
    cykleLCD_Z ();
    dir_rot = 1;
    pwm_speed = rot_speed_high * 2.55;
    pwm_start = rot_speed_low * 2.55;
    dir_rot = 1;
    RezimPrace = 7;
    start_left ();

  }

  if ((RezimPrace == 7) && (SafetyStatus == 0) && (mode == 1)) { // casovani Vysoke otácky
    cykleLCD_Z ();
    tDownFastTime.restart();
  }

  if ((RezimPrace == 8) && (SafetyStatus == 0) && (mode == 1)) { // brzda Vysoke otácky L
    cykleLCD_Z ();
    pwm_speed = rot_speed_high * 2.55;
    RezimPrace = 9;
    brake_left ();

  }

  if ((RezimPrace == 9) && (SafetyStatus == 0) && (mode == 1)) { // casovani Prodleva
    cykleLCD_Z ();
    tDownPauseTime.restart();
  }

  if ((RezimPrace == 10) && (SafetyStatus == 0) && (mode == 1)) { // Start Vysoke otácky R
    cykleLCD_Z ();
    dir_rot = 2;
    pwm_speed = rot_speed_high * 2.55;
    pwm_start = 0;
    dir_rot = 2;
    RezimPrace = 11;
    start_right ();

  }

  if ((RezimPrace == 11) && (SafetyStatus == 0) && (mode == 1))  { // casovani Vysoke otácky
    cykleLCD_Z ();
    tDownFastTime.restart();
  }

  if ((RezimPrace == 12) && (SafetyStatus == 0) && (mode == 1)) { // brzda Vysoke otácky R
    cykleLCD_Z ();
    pwm_speed = rot_speed_high * 2.55;
    RezimPrace = 13;
    brake_right ();

  }

  if ((RezimPrace == 13)  && (mode == 1)) { // Konec cyklu
    tDownSlowTime.stop(); //časovač nizkych otacek
    tDownFastTime.stop(); //časovač vysokych otacek
    tDownPauseTime.stop(); //časovač pauzy
    cykleLCD_Z ();
  }
}


void Radialni () { // kompletni cyklus vytaceni radialniho kose

Med_speed (); // výpočet středních otáček

/*
Serial.print("SlowTime :"); //cas nizkych otacek
Serial.println(SlowTime); 
Serial.print("FastTime :"); //cas vysokych otacek
Serial.println(FastTime);
Serial.print("MedTime :"); //cas středních otacek
Serial.println(MedTime); 
Serial.print("FastTimeNew:"); //cas vysokych otacek New
Serial.println(FastTimeNew);

Serial.print("rot_speed_low :"); //nízké otáčky
Serial.println(rot_speed_low); 
Serial.print("rot_speed_high :"); //vysoké otáčky
Serial.println(rot_speed_high); 
Serial.print("rot_speed_med :"); //střední otáčky
Serial.println(rot_speed_med);
*/

  if ((RezimPrace == 0) && (SafetyStatus == 1) && (mode == 2)) { // Start Nizke otácky L + bezp. spínač
    i = 0;
  }

  if ((RezimPrace == 0) && (SafetyStatus == 0) && (mode == 2)) { // Start Nizke otácky L
    cykleLCD_R ();
    dir_rot = 1;
    pwm_speed = rot_speed_low * 2.55;
    pwm_start = 0;
    dir_rot = 1;
    RezimPrace = 1;
    start_left ();

  }

  if ((RezimPrace == 1) && (SafetyStatus == 0) && (mode == 2))  { // casovani Nizke otácky
    cykleLCD_R ();
    tDownSlowTime.restart();
  }
  if ((RezimPrace == 2) && (SafetyStatus == 0) && (mode == 2)) { // Start Vysoke otácky L
    cykleLCD_R ();
    dir_rot = 1;
    pwm_speed = rot_speed_high * 2.55;
    pwm_start = rot_speed_low * 2.55;
    dir_rot = 1;
    RezimPrace = 3;
    start_left ();
  }
  if ((RezimPrace == 3) && (SafetyStatus == 0) && (mode == 2)) { // casovani Vysoke otácky
    cykleLCD_R ();
    tDownFastTime.restart();
  }
  if ((RezimPrace == 4) && (SafetyStatus == 0) && (mode == 2)) { // brzda Vysoke otácky L
    cykleLCD_R ();
    pwm_speed = rot_speed_high * 2.55;
    RezimPrace = 13;
    brake_left ();
  }

  if ((RezimPrace == 13)  && (mode == 2)) { // Konec cyklu
    tDownSlowTime.stop(); //časovač nizkych otacek
    tDownFastTime.stop(); //časovač vysokych otacek
    tDownPauseTime.stop(); //časovač pauzy
    cykleLCD_R ();
  }
}

void Manual_L () { // manualni toceni L
  if ((RezimPrace == 0) && (SafetyStatus == 1) && (mode == 3) ) { // nulovani parametru i pri otevrenem krytu
    i = 0;
  }
  if ((RezimPrace == 0) && (SafetyStatus == 0) && (mode == 3) ) { // Start Nizke otácky L
    Manual_LCD_L ();
    pwm_speed = manual_start * 2.55;
    pwm_start = 0;
    dir_rot = 1;
    RezimPrace = 1;
    start_left ();
  }
  if ((RezimPrace == 1) && (SafetyStatus == 0) && (mode == 3)) { // zmena vypisu LCD
    Manual_LCD_L ();
    RezimPrace = 2;
  }
  if ((RezimPrace == 3) && (SafetyStatus == 0) && (mode == 3)) { // krok +
    pwm_start = i;
    pwm_speed = ((pwm_start / 2.55) + manual_step) * 2.55 ;

    if ( pwm_speed > 254 ) { // prekroceni limitu 100 %
      pwm_speed = 254;
      i = 254;
    }
    dir_rot = 1;
    start_left ();
    RezimPrace = 2;
    Manual_LCD_L ();
  }

  if ((RezimPrace == 4) && (SafetyStatus == 0) && (mode == 3)) { // krok -
    pwm_start = i;
    pwm_speed = ((pwm_start / 2.55) - manual_step) * 2.55 ;

    if ( pwm_speed <= (manual_start * 2.55) ) { // prekroceni limitu startovacich otacek pwm_speed = manual_start * 2.55; i = 254; } dir_rot = 1; slowdown_left (); RezimPrace = 2; Manual_LCD_L (); } if ((RezimPrace == 13) && (mode == 3)) { // Konec cyklu Manual_LCD_L (); } } void Manual_R () { // manualni toceni R if ((RezimPrace == 0) && (SafetyStatus == 1) && (mode == 4) ) { // nulovani parametru i pri otevrenem krytu i = 0; } if ((RezimPrace == 0) && (SafetyStatus == 0) && (mode == 4) ) { // Start Nizke otácky R Manual_LCD_R (); pwm_speed = manual_start * 2.55; pwm_start = 0; dir_rot = 2; RezimPrace = 1; start_right (); } if ((RezimPrace == 1) && (SafetyStatus == 0) && (mode == 4)) { // zmena vypisu LCD Manual_LCD_R (); RezimPrace = 2; } if ((RezimPrace == 3) && (SafetyStatus == 0) && (mode == 4)) { // krok + pwm_start = i; pwm_speed = ((pwm_start / 2.55) + manual_step) * 2.55 ; if ( pwm_speed > 254 ) { // prekroceni limitu 100 %
      pwm_speed = 254;
      i = 254;
    }
    dir_rot = 2;
    start_right ();
    RezimPrace = 2;
    Manual_LCD_R ();
  }

  if ((RezimPrace == 4) && (SafetyStatus == 0) && (mode == 4)) { // krok -
    pwm_start = i;
    pwm_speed = ((pwm_start / 2.55) - manual_step) * 2.55 ;

    if ( pwm_speed <= (manual_start * 2.55) ) { // prekroceni limitu startovacich otacek
      pwm_speed = manual_start * 2.55;
      i = 254;
    }

    dir_rot = 2;
    slowdown_right ();
    RezimPrace = 2;
    Manual_LCD_R ();
  }

  if ((RezimPrace == 13)  && (mode == 4)) { // Konec cyklu
    Manual_LCD_R ();
  }
}

void RezimPraceVypis () {

  Serial.print("PGM :");
  Serial.println(pgm);
  Serial.print("Mode :");
  Serial.println(mode);
  Serial.print("RezimPrace :");
  Serial.println(RezimPrace);
  Serial.print("SS :");
  Serial.println(ss);
  // Serial.print("SettingMode :");
  // Serial.println(SettingMode);
  // Serial.print("HeadMode :");
  // Serial.println(HeadMode);
  Serial.println("---------");

}

CykleLCD.ino


void cykleLCD_Z () { //vypis zvratneho cyklu na LCD

  if ((RezimPrace == 0) && (mode == 1)) { // Start Nizke otácky R
    lcd.clear();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("1. Zrychluji");
    clearLCDLine(2);
    lcd.setCursor(0, 2);
    lcd.print("Cyklus ");
    lcd.setCursor(0, 3);
    lcd.print("Otacky ");
    j = 20;
    Cyklus_LCD_on_full();
  }

  if ((RezimPrace == 1) && (mode == 1)) { // casovani Nizke otácky
    j = 19;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("2. Tocim ");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 2) && (mode == 1)) { // brzda Nizke otácky R
    j = 18;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("3. Brzdim");
    clearLCDLine(1);
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 3) && (mode == 1)) { // casovani Prodleva
    j = 17;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("4. Prodleva");
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas prodlevy ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 4) && (mode == 1)) { // Start Nizke otácky L
    j = 16;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    clearLCDLine(1);
    lcd.setCursor(0, 0);
    lcd.print("5. Zrychluji");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 5) && (mode == 1)) { // casovani Nizke otácky L
    j = 15;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("6. Tocim");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 6) && (mode == 1)) { // Start Vysoke otácky L
    j = 14;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    clearLCDLine(1);
    lcd.setCursor(0, 0);
    lcd.print("7. Zrychluji");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 7) && (mode == 1)) { // casovani Vysoke otácky L
    j = 13;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("8. Tocim");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 8) && (mode == 1)) { // brzda Vysoke otácky L
    j = 12;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("9. Brzdim");
    clearLCDLine(1);
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 9) && (mode == 1)) { // casovani Prodleva
    j = 11;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("10. Prodleva");
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas prodlevy ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 10) && (mode == 1)) { // Start Vysoke otácky R
    j = 10;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    clearLCDLine(1);
    lcd.setCursor(0, 0);
    lcd.print("11. Zrychluji");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 11) && (mode == 1)) { // casovani Vysoke otácky R
    j = 9;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("12. Tocim");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 12) && (mode == 1)) { // brzda Vysoke otácky R
    j = 8;
    Cyklus_LCD_on();
    clearLCDLine(0);
    lcd.setCursor(0, 0);
    lcd.print("13. Brzdim");
    clearLCDLine(1);
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 13) && (mode == 1)) { // Konec cyklu
    j = 20;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("PGM");
    lcd.setCursor(4, 0);
    lcd.print(pgm);
    ModeType ();
    Info_S_S ();
    Pgm_nav ();
    RezimPrace = 0;
  }
} // End LCD Zvratny

void cykleLCD_R () { //vypis Radialniho cyklu na LCD

  if ((RezimPrace == 0) && (mode == 2)) { // Start Nizke otácky L
    lcd.clear();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("1. Zrychluji");
    clearLCDLine(2);
    lcd.setCursor(0, 2);
    lcd.print("Cyklus ");
    lcd.setCursor(0, 3);
    lcd.print("Otacky ");
    j = 12;
    Cyklus_LCD_on_full();
  }

  if ((RezimPrace == 1) && (mode == 2)) { // casovani Nizke otácky L
    j = 11;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("2. Tocim");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 2) && (mode == 2)) { // Start Vysoke otácky L
    j = 10;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    clearLCDLine(1);
    lcd.setCursor(0, 0);
    lcd.print("3. Zrychluji");
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 3) && (mode == 2)) { // casovani Vysoke otácky L
    j = 9;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("4. Tocim");
    percent_bar ();
    clearLCDLine(1);
    lcd.setCursor(0, 1);
    lcd.print("Cas toceni ");
    Cyklus_LCD_off();
  }


  if ((RezimPrace == 4) && (mode == 2)) { // brzda Vysoke otácky L
    j = 8;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("5. Brzdim");
    clearLCDLine(1);
    Cyklus_LCD_off();
  }

  if ((RezimPrace == 13) && (mode == 2)) { // Konec cyklu
    j = 12;
    Cyklus_LCD_on();
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("PGM");
    lcd.setCursor(4, 0);
    lcd.print(pgm);
    ModeType ();
    Info_S_S ();
    Pgm_nav ();
    RezimPrace = 0;
  }
}  // End LCD Radialni

void Manual_LCD_L () { //vypis manualniho cyklu L na LCD

  if ((RezimPrace == 0) && (mode == 3)) { // Start Nizke otácky R >>>
    SettingMode = 3;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Manual >>>");
    lcd.setCursor(0, 1);
    lcd.print("Zrychluji");
    lcd.setCursor(0, 3);
    lcd.print("Otacky ");
  }

  if ((RezimPrace == 1) && (mode == 3) && (need == 0)) { // Toceni
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("Manual >>>");
    percent_bar ();
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Tocim");
    lcd.setCursor(17, 1);
    lcd.print("F1+");
    lcd.setCursor(17, 2);
    lcd.print("F2-");
  }

  if ((RezimPrace == 2) && (mode == 3) && (need == 0)) { // Toceni
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Tocim");
  }

  if ((RezimPrace == 3) && (mode == 3) && (need == 0)) { // Zrychleni R
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Zrychluji");
  }

  if ((RezimPrace == 4) && (mode == 3) && (need == 0)) { // Zpomaleni R
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Zpomaluji");
  }

  if ((RezimPrace == 13) && (mode == 3)) { // Konec cyklu
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Manual >>>");
    ss = 0;
    s_s ();
    RezimPrace = 0;
    SettingMode = 0;
  }
}




void Manual_LCD_R () { //vypis manualniho cyklu R na LCD

  if ((RezimPrace == 0) && (mode == 4)) { // Start Nizke otácky R <<<
    SettingMode = 3;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Manual <<<");
    lcd.setCursor(0, 1);
    lcd.print("Zrychluji");
    lcd.setCursor(0, 3);
    lcd.print("Otacky ");
  }

  if ((RezimPrace == 1) && (mode == 4) && (need == 0)) { // Toceni
    clearLCDLine_0 ();
    lcd.setCursor(0, 0);
    lcd.print("Manual <<<");
    percent_bar ();
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Tocim");
    lcd.setCursor(17, 1);
    lcd.print("F1+");
    lcd.setCursor(17, 2);
    lcd.print("F2-");
  }

  if ((RezimPrace == 2) && (mode == 4) && (need == 0)) { // Toceni
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Tocim");
  }

  if ((RezimPrace == 3) && (mode == 4) && (need == 0)) { // Zrychleni R
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Zrychluji");
  }

  if ((RezimPrace == 4) && (mode == 4) && (need == 0)) { // Zpomaleni R
    clearLCDLine_1_16 ();
    lcd.setCursor(0, 1);
    lcd.print("Zpomaluji");
  }

  if ((RezimPrace == 13) && (mode == 4)) { // Konec cyklu
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Manual <<<");
    ss = 0;
    s_s ();
    RezimPrace = 0;
    SettingMode = 0;
  }
}
// End vypis manualniho cyklu R

void clearLCDLine(int line) { // mazani řádku LCD
  lcd.setCursor(0, line);
  for ( n = 0; n < 20; n++)
  {
    lcd.print(" ");
  }
}

void clearLCDLine_0 () { // mazani  LCD řádku 0, pos 0-19
  lcd.setCursor(0, 0);
  for ( n = 0; n < 18; n++)
  {
    lcd.print(" ");
  }
}

void clearLCDLine_1_16 () { // mazani  LCD řádku 1, pos 0-16
  lcd.setCursor(0, 1);
  for ( n = 0; n < 16; n++)
  {
    lcd.print(" ");
  }
}

void Cyklus_LCD_on() {
  lcd.setCursor(j, 2);
  lcd.write(byte(5));
}

void Cyklus_LCD_on_full() {
  for ( n = 7; n < j; n++) {
    lcd.setCursor(n, 2);
    lcd.print((char)255);
  }
}

void Cyklus_LCD_off_full() {
  for ( n = 7; n < j; n++) { lcd.setCursor(n, 2); lcd.write(byte(6)); } } void Cyklus_LCD_off() { lcd.setCursor(j, 2); lcd.write(byte(6)); } void s_s () { // info Start - Stop if ( ss == 0 ) { ss = 1; Info_S_S (); } } void Info_S_S () { // vypis Start - Stop if ( mode > 2 ) {
    Pgm_cyclus_man ();
  }
  if ( mode <= 2 ) {
    Pgm_cyclus ();
  }
  clearLCDLine(2);
  lcd.setCursor(0, 2);
  lcd.print("Start - Stop");
  clearLCDLine(3);
  lcd.setCursor(0, 3);
  lcd.print("Volba programu - F4");
}

Eeprom.ino


void EepromSetings () { // konfigurace eeprom
  int e_num = 255; // 0-255

  int e_xnum = EEPROM.read(200);
  if ( e_xnum != 99) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Konfigurace EEPROM");
    for (int ix = 0; ix < EEPROM.length(); ix++) {
      EEPROM.write(ix, e_num);
    }
    // char
    delay(500);
    EEPROM.write(200, 99);
    EEPROM.write(201, 86);
    EEPROM.write(202, 67);
    EEPROM.write(203, 69);
    EEPROM.write(204, 76);
    EEPROM.write(205, 65);
    EEPROM.write(206, 82);
    EEPROM.write(207, 83);
    EEPROM.write(208, 84);
    EEPROM.write(209, 86);
    EEPROM.write(210, 73);
    EEPROM.write(211, 72);
    EEPROM.write(212, 65);
    EEPROM.write(213, 86);
    EEPROM.write(214, 69);
    EEPROM.write(215, 76);
    EEPROM.write(216, 75);
    EEPROM.write(217, 65);
    EEPROM.write(218, 46);
    EEPROM.write(219, 67);
    EEPROM.write(220, 90);

    // zakladni parametry programu PGM 1-10
    // motor
    EEPROM.write(5, 3); // accelerate 1-9
    EEPROM.write(6, 1); // step 1-5

    //manual R - PGM 1
    EEPROM.write(0, 3); // mode
    EEPROM.write(1, 20); // manual_start
    EEPROM.write(2, 10); // manual_step
    //manual L - PGM 2
    EEPROM.write(10, 4); // mode
    EEPROM.write(11, 20); // manual_start
    EEPROM.write(12, 10); // manual_step

    pgm = 3; //Zvratny 1 - PGM 3 zvrat
    eeprom_write_zvrat ();
    pgm = 4; //Zvratny 2 - PGM 4 zvrat
    eeprom_write_zvrat ();
    pgm = 5; //Zvratny 3 - PGM 5 zvrat
    eeprom_write_zvrat ();
    pgm = 6; //Zvratny 4 - PGM 6 zvrat
    eeprom_write_zvrat ();
    pgm = 7; //radialni 4 - PGM 7 rad
    eeprom_write_rad ();
    pgm = 8; //radialni 4 - PGM 8 rad
    eeprom_write_rad ();
    pgm = 9; //radialni 4 - PGM 9 rad
    eeprom_write_rad ();

    lcd.setCursor(0, 1);
    lcd.print("Reset");
    delay(1000);
    resetFunc(); //reset
  }
  delay(500);
  charr ();
  lcd.setCursor(0, 3);
  delay(500);
}

void charr () { //vypis znaku
  byte e_char = 201; // pos. znaku v eeprom
  byte i_pos = 0;  // pos. znaku LCD
  byte character;  //znak
  for (i_pos = 0; i_pos < 20; i_pos++ ) { character = EEPROM.read(e_char); lcd.setCursor(i_pos, 1); lcd.print((char)character); e_char = e_char + 1; } } void pgm_read () { // cteni parametru cyklu if ( pgm == 1) { // Manual R mode = EEPROM.read(0); manual_start = EEPROM.read(1); manual_step = EEPROM.read(2); RezimPrace = 1; acc_num (); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Manual >>>");
    Pgm_cyclus_man ();
    Info_S_S ();
    Manual_LCD_R ();
  }
  if ( pgm == 2) { // Manual L
    mode = EEPROM.read(10);
    manual_start = EEPROM.read(11);
    manual_step = EEPROM.read(12);
    RezimPrace = 1;
    acc_num ();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Manual <<<");
    Pgm_cyclus_man ();
    Info_S_S ();
    Manual_LCD_L ();
  }
  if ( pgm == 3) { // PGM 3 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 4) { // PGM 4 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 5) { // PGM 5 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 6) { // PGM 6 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 7) { // PGM 7 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 8) { // PGM 8 - Z & R
    pgm_eeprom_read ();
  }
  if ( pgm == 9) { // PGM 9 - Z & R
    pgm_eeprom_read ();
  }
}

void eeprom_update () { // aktualizace EEPROM

  if (SettingMode == 2) { // Motor
    if (EEPROM.read(5) != accelerate) EEPROM.write(5, accelerate);
    if (EEPROM.read(6) != step) EEPROM.write(6, step);
  }
  if (edit_pgm == 1) { // Manual L+R
    if (EEPROM.read(1) != manual_start) EEPROM.write(1, manual_start);
    if (EEPROM.read(2) != manual_step) EEPROM.write(2, manual_step);
    if (EEPROM.read(11) != manual_start) EEPROM.write(11, manual_start);
    if (EEPROM.read(12) != manual_step) EEPROM.write(12, manual_step);
  }
  if (edit_pgm == 3) { // PGM 3
    pgm_eeprom_update ();
  }
  if (edit_pgm == 4) { // PGM 4
    pgm_eeprom_update ();
  }
  if (edit_pgm == 5) { // PGM 5
    pgm_eeprom_update ();
  }
  if (edit_pgm == 6) { // PGM 6
    pgm_eeprom_update ();
  }
  if (edit_pgm == 7) { // PGM 7
    pgm_eeprom_update ();
  }
  if (edit_pgm == 8) { // PGM 8
    pgm_eeprom_update ();
  }
  if (edit_pgm == 9) { // PGM 9
    pgm_eeprom_update ();
  }
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Update EEPROM");
  delay(1000);
  lcd.setCursor(0, 1);
  lcd.print("Reset");
  resetFunc();
}

void Setup_end () { // konec setup
  lcd.clear ();
  lcd.setCursor(0, 0);
  lcd.print("Setup ukoncen");
  delay(1000);
  lcd.setCursor(0, 1);
  lcd.print("Reset");
  resetFunc();
}

void pgm_eeprom_read () { // nacteni hodnot eeprom pro pgm 3-9
  ee = (pgm - 1) * 10;
  mode = EEPROM.read(ee);
  SlowTime = EEPROM.read(ee + 1);
  FastTime = EEPROM.read(ee + 2);
  PauseTime = EEPROM.read(ee + 3);
  rot_speed_low = EEPROM.read(ee + 4);
  rot_speed_high = EEPROM.read(ee + 5);
  RezimPrace = 0;
  acc_num ();
  lcd.clear ();
  Pgm_select_lcd_print ();
  Pgm_cyclus ();
  Info_S_S ();
  if (mode == 1)   {
    lcd.setCursor(7, 0);
    lcd.print("Zvratny"); // Zvratny
  }
  else if (mode == 2) {
    lcd.setCursor(7, 0);
    lcd.print("Radialni"); // Radialni
  }
}

void pgm_eeprom_update () { // updatet eeprom pro pgm 3-9
  ee = (edit_pgm - 1) * 10;
  if (EEPROM.read(ee) != menu_mode) EEPROM.write(ee, menu_mode);
  if (EEPROM.read(ee + 1) != SlowTime) EEPROM.write(ee + 1, SlowTime);
  if (EEPROM.read(ee + 2) != FastTime) EEPROM.write(ee + 2, FastTime);
  if (EEPROM.read(ee + 3) != PauseTime) EEPROM.write(ee + 3, PauseTime);
  if (EEPROM.read(ee + 4) != rot_speed_low) EEPROM.write(ee + 4, rot_speed_low);
  if (EEPROM.read(ee + 5) != rot_speed_high) EEPROM.write(ee + 5, rot_speed_high);
}

void eeprom_write_zvrat () { // dafault zapis eeprom pro pgm 3-6
  ee = (pgm - 1) * 10;
  EEPROM.write(ee, 1); // mode 1
  EEPROM.write(ee + 1, 1); // SlowTime
  EEPROM.write(ee + 2, 3); // FastTime
  EEPROM.write(ee + 3, 5); // PauseTime
  EEPROM.write(ee + 4, 30); // rot_speed_low
  EEPROM.write(ee + 5, 50); // rot_speed_high
}

void eeprom_write_rad () { // dafault zapis eeprom pro pgm 7-9
  ee = (pgm - 1) * 10;
  EEPROM.write(ee, 2); // mode 2
  EEPROM.write(ee + 1, 1); // SlowTime
  EEPROM.write(ee + 2, 3); // FastTime
  EEPROM.write(ee + 3, 0); // PauseTime
  EEPROM.write(ee + 4, 30); // rot_speed_low
  EEPROM.write(ee + 5, 50); // rot_speed_high

}

void acc_num () { // cteni parametru acc
  accelerate = EEPROM.read(5);
  step = EEPROM.read(6);
}

Error.ino


void Error_1() { // chybova logika Motor
  KeyValue = 0;
  if (accelerate < 1 ) { // accelerate 1-9 Error_End (); } else if (accelerate > 9 )  {
    Error_End ();
  }
  else if (step < 1 ) { // step 1-5 Error_End (); } else if (step > 5 ) {
    Error_End ();
  }
  eeprom_update ();
}

void Error_2() { // chybova logika Manual
  KeyValue = 0;
  if (manual_start < 10 ) { // manual_start 10-50 Error_End (); } else if (manual_start > 50 ) {
    Error_End ();
  }
  else if (manual_step < 5 ) { // manual_step 5/10 Error_End (); } else if (manual_step > 10 ) {
    Error_End ();
  }
  eeprom_update ();
}

void Error_3() { // chybova logika Zvratny a Radialni
  KeyValue = 0;
  if (menu_mode < 1 ) { // mode 2-3 Error_End (); } else if (menu_mode > 2 ) {
    Error_End ();
  }
  else if (SlowTime < 1 ) { // SlowTime 1-5 Error_End (); } else if (SlowTime > 5 ) {
    Error_End ();
  }
  else if (FastTime < 1 ) { // FastTime 1-8 Error_End (); } else if (FastTime > 8 ) {
    Error_End ();
  }
  else if (PauseTime < 0 ) { // PauseTime 0-20 Error_End (); } else if (PauseTime > 20 ) {
    Error_End ();
  }
  else if (rot_speed_low < 15 ) { // rot_speed_low 15-50 Error_End (); } else if (rot_speed_low > 50 ) {
    Error_End ();
  }
  else if (rot_speed_high < 30 ) { // rot_speed_high 30-99 Error_End (); } else if (rot_speed_high > 99 ) {
    Error_End ();
  }
  eeprom_update ();
}

void Error_End () { // end chybové logiky
  lcd.clear ();
  lcd.setCursor(0, 0);
  lcd.print("Chybne zadani hodnot");
  delay(1000);
  Setup_end ();
}

Function.ino


void Pgm_select () { // listovani mezi programy

  if (( pgm == 1) && ( ss == 0)) {  // Manual L
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 2) && ( ss == 0)) {// Manual R
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 3) && ( ss == 0)) { // Zvratny
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 4) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 5) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 6) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 7) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 8) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
  else if (( pgm == 9) && ( ss == 0)) {
    Pgm_select_lcd_print ();
  }
}

void Pgm_nav() { // navigace pri listovani
  if (mode_nav == 0) {
    mode_nav = 1;
    clearLCDLine (1);
    clearLCDLine (2);
    lcd.setCursor(0, 1);
    lcd.print("Vyber program F3  ");
    if (pgm == 1 ) {
      clearLCDLine (3);
      lcd.setCursor(7, 3);
      lcd.print("Listuj >>> F1");
    }
    else if ((pgm > 1 ) && ( pgm < 9 )) {
      clearLCDLine (3);
      lcd.setCursor(0, 3);
      lcd.print("F2 <<< Listuj >>> F1");
    }
  }
}

void Pgm_select_lcd_print () {
  clearLCDLine_0 ();
  lcd.setCursor(0, 0);
  lcd.print("PGM ");
  lcd.setCursor(4, 0);
  lcd.print(pgm);
  ss = 2;
  Pgm_nav ();
}

void Pgm_cyclus () { // Info o parametrech PGM (Z+R)
  lcd.setCursor(0, 1);
  lcd.print("T=  /  min. S=  /  %");
  lcd.setCursor(3, 1);
  lcd.print(SlowTime);
  lcd.setCursor(5, 1);
  lcd.print(FastTime);
  lcd.setCursor(14, 1);
  lcd.print(rot_speed_low);
  lcd.setCursor(17, 1);
  lcd.print(rot_speed_high);
  lcd.setCursor(0, 3);
  lcd.print("Volba programu - F4");
}

void Pgm_cyclus_man () { // Info o parametrech PGM (Man)
  lcd.setCursor(0, 1);
  lcd.print("Start   % Krok   %");
  lcd.setCursor(6, 1);
  lcd.print(manual_start);
  lcd.setCursor(15, 1);
  lcd.print(manual_step);
  lcd.setCursor(0, 3);
  lcd.print("Volba programu - F4");
}

void LCD_head () {
  lcd.begin();
  lcd.backlight();
  lcd.clear();
  EepromSetings (); //konfigurace eeprom
  lcd.print("MEDOMET ver. 1.1");
  delay(2000);
  lcd.clear ();
  lcd.setCursor(0, 0);
  lcd.print("F1 Setup program");
  lcd.setCursor(0, 1);
  lcd.print("F2 Setup motor");
  lcd.setCursor(0, 3);
  lcd.print("F4 Reset settings");
  delay(3000);
  lcd.clear ();
}

Keypad.ino


void Keypad () {
  char customKey = customKeypad.getKey();

  if (customKey) {
    ZnakKey = (customKey);
    switch ((customKey))
    {
      //filtr znaků A-D // F1-F4
      case 65: // A  F1
        A();
        break;
      case 66: // B  F2
        B();
        break;
      case 67: // C  F3
        C();
        break;
      case 68: // D  F4
        D();
        break;
      //filtr znaků * a #
      case 42: // *  Start
      //  Serial.println("Start");
        restart();
        break;
      case 35: // #  Stop
       // Serial.println("Stop");
        pause();
        break;
      default:
        // filtr čísel
        if (customKey) {
          NewKey = (customKey - konst) ; //vypocet cisla z Char (0-9)

          if (NewKey) { // přichází nový znak z klávesnice
            if (count == 0) { // jedná se o první znak ??
              cisloKey = NewKey - 1; // je to první znak, vynuluji vysledneCislo tím, že do něj uložím ten znak
              count++;
            }
            else if (count < (Num)) {
              cisloKey = ((cisloKey * 10) + NewKey) - 1; // je to následující znak, předchozí číslo vynásobím 10ti (tím se posune celé do leva) a přičtu znak
              count++;
            }
            else if (count = Num) {
              cisloKey = cisloKey; // je-li dosazeno poctu pozadovanych znaku, neprovadim zadny vypocet
            }
          }
        }
       // Serial.print("Cislo: ");
       // Serial.println(cisloKey);
    }
  }
}

// === 'A'  'F1' ===
void A() {
  //Serial.println("F1");
  ss = 0;
  manual_acc (); // zrychleni L+R v manualnim rezimu

  if (( mode == 0 ) && ( pgm < 9 ) && (SettingMode == 0 )) { clearLCDLine (0); pgm++; mode_nav = 0; // Serial.print ("PGM+ "); // Serial.println (pgm); } } // === 'B' 'F2' === void B() { // Serial.println("F2"); ss = 0; manual_slow (); // zpomaleni L+R v manualnim rezimu if (( mode == 0 ) && ( pgm > 1 ) && (SettingMode == 0 )) {
    clearLCDLine (0);
    pgm--;
    mode_nav = 0;
   // Serial.print ("PGM-   ");
   // Serial.println (pgm);
  }
}

// === 'C'  'F3' ===
void C() {
  //Serial.println("F3");
  if (( mode == 0 ) && (SettingMode == 0 )) { // vyber PGM

    if  ( pgm == 1 ) { // Manual >>> R
      pgm_read ();
      Time_function ();
    }
    if  ( pgm == 2 ) {  //Manual <<< L pgm_read (); Time_function (); } if ( pgm == 3 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 4 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 5 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 6 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 7 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 8 ) { //Z & R pgm_read (); Time_function (); } if ( pgm == 9 ) { //Z & R pgm_read (); Time_function (); } Pgm_select (); } if (vypis > 0) {
    RezimPraceVypis ();
  }
}

// === 'D'  'F4' ===
void D() {
 // Serial.println("F4");
  mode = 0;
  mode_nav = 0;
  ss = 0;
  if (SettingMode == 0 ) {
    Pgm_select ();
  }
  if (vypis > 0) {
    RezimPraceVypis ();
  }
}

Menu.ino


void menu () { //nastaveni menu
  if ((AktualMillis >= SetupMillis ) && (KeyValue > 0)) { // casove omezeni Setupu
    Setup_end ();
  }
  if ((SettingMode == 1) && (KeyValue == 1)) { // Edit PGM 1-9
    Num = 1;
    lcd.setCursor(0, 1);
    lcd.print("Vyber program [1-9]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [ ]");
    lcd.setCursor(10, 2);
    lcd.print(edit_pgm);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    edit_pgm = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 2) && (edit_pgm == 1)) { // Manual L+R otacky 10-50%
    Num = 2;
    lcd.setCursor(0, 0);
    lcd.print("Manual");
    lcd.setCursor(0, 1);
    lcd.print("Min.otacky [10-50 %]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [  ]");
    lcd.setCursor(10, 2);
    lcd.print(manual_start);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    manual_start = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 2) && (edit_pgm == 2)) { // Manual R otacky 10-50%
    edit_pgm = 1;
    KeyValue = 2;
    countNum();
  }
  else if ((SettingMode == 1) && (KeyValue == 3) && (edit_pgm == 1)) { // Manual L+R Krok 05-10%
    Num = 2;
    lcd.setCursor(0, 0);
    lcd.print("Manual");
    lcd.setCursor(0, 1);
    lcd.print("Krok.ot. [05/10 %]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [  ]");
    lcd.setCursor(10, 2);
    lcd.print(manual_step);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    manual_step = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 4) && (edit_pgm == 1)) { // update EEPROM
    delay(500);
    Error_2();
  }
  // Edit PGM 3-9
  else if ((SettingMode == 1) && (KeyValue == 2) && (edit_pgm > 2)) { // Typ cyklu toceni
    lcd.setCursor(0, 0);
    lcd.print("Typ cyklu toceni");
    lcd.setCursor(0, 1);
    lcd.print("F1 Zvratny");
    lcd.setCursor(0, 2);
    lcd.print("F2 Radialni");
    KeyValue = 3;
  }
  else if ((SettingMode == 1) && (KeyValue == 3) && (edit_pgm > 2) && (ZnakKey == 65)) { //F1 Zvratny
    menu_mode = 1; //zvratny
    KeyValue = 4;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((SettingMode == 1) && (KeyValue == 3) && (edit_pgm > 2) && (ZnakKey == 66)) { //F2 Radialni
    menu_mode = 2; //Radialni
    KeyValue = 4;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((SettingMode == 1) && (KeyValue == 4) && (edit_pgm > 2)) { // Cas nizkych otacek - SlowTime
    Num = 1;
    lcd.setCursor(0, 0);
    lcd.print("Cas nizkych otacek");
    lcd.setCursor(0, 1);
    lcd.print("[1-5 min.]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [ ]");
    lcd.setCursor(10, 2);
    lcd.print(SlowTime);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    SlowTime = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 5) && (edit_pgm > 2)) { // Cas vysokych otacek - SlowTime
    Num = 1;
    lcd.setCursor(0, 0);
    lcd.print("Cas vysokych otacek");
    lcd.setCursor(0, 1);
    lcd.print("[1-8 min.]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [ ]");
    lcd.setCursor(10, 2);
    lcd.print(FastTime);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    FastTime = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 6) && (edit_pgm > 2) && (menu_mode == 1)) { // prodleva při reverzaci - PauseTime
    Num = 2;
    lcd.setCursor(0, 0);
    lcd.print("Prodleva reverzace");
    lcd.setCursor(0, 1);
    lcd.print("[00-20 sec.]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [  ]");
    lcd.setCursor(10, 2);
    lcd.print(PauseTime);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    PauseTime = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 6) && (edit_pgm > 2) && (menu_mode == 2)) { // prodleva při reverzaci - PauseTime
    KeyValue = 7;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }

  else if ((SettingMode == 1) && (KeyValue == 7) && (edit_pgm > 2)) { // nízké otáčky rozsah 15-50 % - rot_speed_low
    Num = 2;
    lcd.setCursor(0, 0);
    lcd.print("Nizke otacky");
    lcd.setCursor(0, 1);
    lcd.print("[15-50 %]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [  ]");
    lcd.setCursor(10, 2);
    lcd.print(rot_speed_low);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    rot_speed_low = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 8) && (edit_pgm > 2)) { // vysoké otáčky rozsah 30-99 % - rot_speed_high
    Num = 2;
    lcd.setCursor(0, 0);
    lcd.print("Vysoke otacky");
    lcd.setCursor(0, 1);
    lcd.print("[30-99 %]");
    lcd.setCursor(0, 2);
    lcd.print("Nastavit [  ]");
    lcd.setCursor(10, 2);
    lcd.print(rot_speed_high);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    rot_speed_high = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 1) && (KeyValue == 9) && (edit_pgm > 2)) { // konec zadani PGM 3-9
    delay(500);
    lcd.clear ();
    Error_3();
  }
}

void Setupmotor () { // Nastaveni zrychlení motoru
  if ((AktualMillis >= SetupMillis ) && (KeyValue > 0)) { // casove omezeni Setupu
    Setup_end ();
  }
  if ((SettingMode == 2) && (KeyValue == 1)) { // accelerate
    Num = 1;
    lcd.setCursor(0, 0);
    lcd.print("Setup motor");
    lcd.setCursor(0, 1);
    lcd.print("Akcelerace [1-9]");
    lcd.setCursor(0, 2);    
    lcd.print("Nastavit [ ]");
    lcd.setCursor(10, 2);
    lcd.print(accelerate);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    accelerate = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 2) && (KeyValue == 2)) { // step
    Num = 1;
    lcd.setCursor(0, 0);
    lcd.print("Setup motor");  
    lcd.setCursor(0, 1);
    lcd.print("Krok [1-5]");
    lcd.setCursor(0, 2);    
    lcd.print("Nastavit [ ]");
    lcd.setCursor(10, 2);
    lcd.print(step);
    lcd.setCursor(0, 3);
    lcd.print("Potvrdit hodnotu F4");
    step = cisloKey;
    if (ZnakKey == 68)  {
      countNum();
    }
  }
  else if ((SettingMode == 2) && (KeyValue == 3)) { // update EEPROM
    Num = 1; // počet cislic v poli
    delay(500);
    Error_1();
  }
}

void countNum() { // Krokování menu
  if ((count == Num) && (KeyValue == 1)) {
    KeyValue = 2;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 2)) {
    KeyValue = 3;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 3)) {
    KeyValue = 4;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 4)) {
    KeyValue = 5;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 5)) {
    KeyValue = 6;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 6)) {
    KeyValue = 7;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 7)) {
    KeyValue = 8;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
  else if ((count == Num) && (KeyValue == 8)) {
    KeyValue = 9;
    count = 0;
    cisloKey = 0;
    LCD_clear ();
  }
}

void LCD_clear () {
  lcd.clear();
}

StartingBrake.ino


void start_right () { //  prave otacky + zrychleni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  i = pwm_start;
  while (i <= pwm_speed) { i++; Safety (); Keypad(); // čtení klávesnice if ( need == 1 ) { RezimPrace = 0; break; } analogWrite(LPWM, i); if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}


void start_left () { // leve otacky + zrychleni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  i = pwm_start;
  while (i <= pwm_speed) { i++; Keypad(); if ( need == 1 ) { RezimPrace = 0; break; } analogWrite(RPWM, i); if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}

void brake_right () { // prave brzdeni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  if (i <= 0) { // vypnutí brzdy po nouzovém zastavení pwm_speed = 0; } i = pwm_speed ; while ( i > 0) {
    i--;
    Keypad();
    if ( need == 1 ) {
      RezimPrace = 0;
      break;
    }
    analogWrite(LPWM, i);
    if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}

void brake_left () { // leve brzdeni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  if (i <= 0) { // vypnutí brzdy po nouzovém zastavení pwm_speed = 0; } i = pwm_speed ; while ( i > 0) {
    i--;
    Keypad();
    if ( need == 1 ) {
      RezimPrace = 0;
      break;
    }
    analogWrite(RPWM, i);
    if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}


void slowdown_left () { // leve zpomaleni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  if (i <= 0) { // vypnutí brzdy po nouzovém zastavení pwm_speed = 0; } i = pwm_start; while ( i >= pwm_speed) {
    i--;
    Keypad();
    if ( need == 1 ) {
      RezimPrace = 0;
      break;
    }
    analogWrite(RPWM, i);
    if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}

void slowdown_right () { // prave zpomaleni
  digitalWrite(R_EN, HIGH);
  digitalWrite(L_EN, HIGH);
  if (vypis > 0) {
    RezimPraceVypis ();
  }
  acc = (step * accelerate) / 0.255 ;
  if (i <= 0) { // vypnutí brzdy po nouzovém zastavení pwm_speed = 0; } i = pwm_start; while ( i >= pwm_speed) {
    i--;
    Keypad();
    if ( need == 1 ) {
      RezimPrace = 0;
      break;
    }
    analogWrite(LPWM, i);
    if (vypis > 0) {
    }
    Safety_speed ();
    percent_bar ();
    delay(acc);
  }
}

void instant_braking () { // nouzová brzda
  if ((dir_rot == 2) && ( i > 0 )) { // nouzová brzda R
    need = 1;
    digitalWrite(R_EN, HIGH);
    digitalWrite(L_EN, HIGH);
    if (vypis > 0) {
      RezimPraceVypis ();
    }
    if (( mode > 0 ) && ( mode < 3 )) { clearLCDLine_0 (); lcd.setCursor(0, 0); lcd.print("Brzdim"); } if (( mode > 2 ) && ( mode < 5 )) { clearLCDLine_1_16 (); lcd.setCursor(0, 1); lcd.print("Brzdim"); } acc = (step * accelerate) / 0.255 ; for ( i; i >= 0; i--) {
      analogWrite(LPWM, i);
      if (vypis > 0) {
      }
      percent_bar ();
      delay(acc);
    }
    i = 0;
    RezimPrace = 13;
    if (mode == 1) {
      Zvratny ();
    }
    if (mode == 2) {
      Radialni ();
    }
    if (mode == 4) {

      Manual_R ();
    }
  }

  if ((dir_rot == 1) && ( i > 0 )) { // nouzová brzda L
    need = 1;
    digitalWrite(R_EN, HIGH);
    digitalWrite(L_EN, HIGH);
    if (vypis > 0) {
      RezimPraceVypis ();
    }
    if (( mode > 0 ) && ( mode < 3 )) { clearLCDLine_0 (); lcd.setCursor(0, 0); lcd.print("Brzdim"); } if (( mode > 2 ) && ( mode < 5 )) { clearLCDLine_1_16 (); lcd.setCursor(0, 1); lcd.print("Brzdim"); } acc = (step * accelerate) / 0.255 ; for ( i; i >= 0; i--) {
      analogWrite(RPWM, i);
      if (vypis > 0) {
      }
      percent_bar ();
      delay(acc);
    }
    i = 0;
    RezimPrace = 13;
    if (mode == 1) {
      Zvratny ();
    }
    if (mode == 2) {

      Radialni ();
    }
    if (mode == 3) {
      Manual_L ();
    }
  }
}

void Safety () { // stav bezp. spínače
  SafetyKeyMode = digitalRead(SafetyKey);
  if ((SafetyKeyMode == LOW) && (RezimPrace != 0))  { // bezp. spinac rozepnut pri cylku
    SafetyStatus = 1;
    lcd.setCursor(19, 0);
    lcd.write(byte(7));
    Serial.print("safety :");
    Serial.println(SafetyKeyMode);
    pause ();
  }
  else if (SafetyKeyMode == HIGH) { // bezp. spinac sepnut
    SafetyStatus = 0;
    need = 0;
    lcd.setCursor(19, 0);
    lcd.print(" ");
  }
  else if ((SafetyKeyMode == LOW) && (RezimPrace == 0))  { // bezp. spinac rozepnut pri klidu
    SafetyStatus = 1;
    lcd.setCursor(19, 0);
    lcd.write(byte(7));
  }
}

void Safety_speed () { // bezp. spinac - zastaveni toceni
  SafetyKeyMode = digitalRead(SafetyKey);
  if ((SafetyKeyMode == LOW) && (RezimPrace == 0))   { // bezp. spinac - zastaveni toceni
    lcd.setCursor(13, 1);
    lcd.print("Stop   ");
    lcd.setCursor(19, 0);
    lcd.write(byte(7));
    instant_braking ();
  }
}
void ModeType () { // vypis typu vytaceciho cyklu
  if ((mode == 1) && (RezimPrace == 13))  {
    lcd.setCursor(7, 0);
    lcd.print("Zvratny"); // Zvratny
  }
  else if ((mode == 2 && (RezimPrace == 13))) {
    lcd.setCursor(7, 0);
    lcd.print("Radialni"); // Radialni
  }
  else if ((mode == 3 && (RezimPrace == 13))) {
    lcd.setCursor(7, 0);
    lcd.print("Manual <<<"); // Manual L } else if ((mode == 4 && (RezimPrace == 13))) { lcd.setCursor(7, 0); lcd.print("Manual >>>"); // Manual L R
  }
}

void manual_acc () { // zrychleni L+R v manualnim rezimu
  if ((RezimPrace == 2) && (SafetyStatus == 0))  { // L
    if ((mode == 3) && (need == 0)) {
      if ( i <= 255 ) {
        RezimPrace = 3;
        Manual_LCD_L ();
        Manual_L ();
      }
    }

    if ((mode == 4) && (need == 0)) { // R
      if ( i <= 255 ) {
        RezimPrace = 3;
        Manual_LCD_R ();
        Manual_R ();
      }
    }
  }
}

void manual_slow () { // zpomaleni L+R v manualnim rezimu
  if ((RezimPrace == 2) && (SafetyStatus == 0) && (mode == 3)) { // L
    RezimPrace = 4;
    Manual_LCD_L ();
    Manual_L ();
  }

  if ((RezimPrace == 2) && (SafetyStatus == 0) && (mode == 4)) { // R
    RezimPrace = 4;
    Manual_LCD_R ();
    Manual_R ();
  }
}

Timing.ino


void tDownSlowTimeComplete() {//konec casu nizkych otacek

  if ((RezimPrace == 1) && (mode == 1)) { // zvratny
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 2;
    RezimPraceVypis ();
    Zvratny ();
  }
  if ((RezimPrace == 1) && (mode == 2)) { // radialni
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 2;
    RezimPraceVypis ();
    Radialni ();
  }
  if ((RezimPrace == 5) && (mode == 1)) {
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 6;
    RezimPraceVypis ();
    Zvratny ();
  }
}

void tDownFastTimeComplete() // konec casu vysokych otacek
{
  if ((RezimPrace == 7) && (mode == 1)) { // zvratny
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 8;
    RezimPraceVypis ();
    Zvratny ();
  }
  if ((RezimPrace == 3) && (mode == 2)) { // radialni
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 4;
    RezimPraceVypis ();
    Radialni ();
  }
  if ((RezimPrace == 11) && (mode == 1)) {
    lcd.setCursor(12, 1);
    lcd.print("00:00");
    RezimPrace = 12;
    RezimPraceVypis ();
    Zvratny ();
  }
}

void tDownPauseTimeComplete() { //konec prodlevy při reverzaci otáček
  if ((RezimPrace == 3) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print("00:00");
    RezimPrace = 4;
    RezimPraceVypis ();
    Zvratny ();
  }
  if ((RezimPrace == 9) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print("00:00");
    RezimPrace = 10;
    RezimPraceVypis ();
    Zvratny ();
  }
}

void Print_tDownSlowTime() { //cas nizkych otacek [1-5 min.]
  if ((RezimPrace == 1) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownSlowTime.getCurrentTime());
  }
  if ((RezimPrace == 1) && (mode == 2)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownSlowTime.getCurrentTime());
  }
  if ((RezimPrace == 5) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownSlowTime.getCurrentTime());
  }
}

void Print_tDownFastTime() { // cas vysokych otacek [1-8 min.]
  if ((RezimPrace == 7) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownFastTime.getCurrentTime());
  }

  if ((RezimPrace == 3) && (mode == 2)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownFastTime.getCurrentTime());
  }

  if ((RezimPrace == 11) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownFastTime.getCurrentTime());
  }

}

void Print_tDownPauseTime() { //prodleva při reverzaci otáček

  if ((RezimPrace == 3) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownPauseTime.getCurrentTime());
  }

  if ((RezimPrace == 9) && (mode == 1)) {
    lcd.setCursor(13, 1);
    lcd.print(tDownPauseTime.getCurrentTime());
  }
}

void restart() { //'*' - restart časování
  int i;

  if ((SafetyStatus == 0) && (mode == 1)) { // bezp. spinac sepnut - kryt zavreny, zvratny
    RezimPraceVypis ();
    Zvratny ();
  }
  if ((SafetyStatus == 0) && (mode == 2)) { // bezp. spinac sepnut - kryt zavreny, radialni
    RezimPraceVypis ();
    Radialni ();
  }
  if ((SafetyStatus == 0) && (mode == 3)) { // bezp. spinac sepnut - kryt zavreny, manual L

    i = 0;
    RezimPrace = 0;
    RezimPraceVypis ();
    Manual_L ();
  }
  if ((SafetyStatus == 0) && (mode == 4)) { // bezp. spinac sepnut - kryt zavreny, manual R
    i = 0;
    RezimPrace = 0;
    RezimPraceVypis ();
    Manual_R ();
  }
}

void pause() { //'#' - pausa časování

  // Stop časovače
  tDownSlowTime.stop();
  tDownFastTime.stop();
  tDownPauseTime.stop();

  if ((RezimPrace == 3) && (SafetyStatus == 0) && (mode == 1)) { // zastaveni pri casove prodleve 1
    lcd.setCursor(13, 1);
    lcd.print("Stop   ");
    delay (1000);
    RezimPrace = 13;
    cykleLCD_Z ();
  }

  else if ((RezimPrace == 9) && (SafetyStatus == 0) && (mode == 1)) { // zastaveni pri casove prodleve 2
    lcd.setCursor(13, 1);
    lcd.print("Stop   ");
    delay (1000);
    RezimPrace = 13;
    cykleLCD_Z ();
  }

  if ((RezimPrace == 3) && (SafetyStatus == 1) && (mode == 1)) { // bezp. spinac pri casove prodleve 1
    lcd.setCursor(13, 1);
    lcd.print("Stop  ");
    delay (1000);
    RezimPrace = 13;
    cykleLCD_Z ();
  }

  else if ((RezimPrace == 9) && (SafetyStatus == 1) && (mode == 1)) { // bezp. spinac pri casove prodleve 2
    lcd.setCursor(13, 1);
    lcd.print("Stop  ");
    delay (1000);
    RezimPrace = 13;
    cykleLCD_Z ();
  }

  if (mode == 3) { // zastaveni pri manualnim L
    instant_braking ();
  }

  else if (mode == 4) { // zastaveni pri manualnim R
    instant_braking ();
  }

  if ((SafetyStatus == 0) && (mode > 0) && (mode < 3)) { // zastaveni pri casovani
    lcd.setCursor(13, 1);
    lcd.print("Stop   ");
    instant_braking ();
  }

  if (SafetyStatus == 1) { // bezp. spinac zastaveni pri casovani
    lcd.setCursor(13, 1);
    lcd.print("Stop    ");
    instant_braking ();
  }
}

void Time_function () { // ovladani casovacu
  // Odpočítávací časovač nizkych otacek [1-5 min.]
  tDownSlowTime.setCounter(0, (SlowTime), 0, tDownSlowTime.COUNT_DOWN, tDownSlowTimeComplete);
  tDownSlowTime.setInterval(Print_tDownSlowTime, 1000);

  // Odpočítávací časovač vysokych otacek [1-8 min.]
  tDownFastTime.setCounter(0, (FastTime), 0,  tDownFastTime.COUNT_DOWN, tDownFastTimeComplete);
  tDownFastTime.setInterval(Print_tDownFastTime, 1000);

  // Odpočítávací časovač pauzy při reverzu otáček [0-20 sec.]
  tDownPauseTime.setCounter(0, 0, (PauseTime), tDownPauseTime.COUNT_DOWN, tDownPauseTimeComplete);
  tDownPauseTime.setInterval(Print_tDownPauseTime, 1000);
}


void Med_speed () { // // výpočet středních otáček, čas + otáčky
float Med_Time = ((FastTime * 60)/2)/60;
MedTime = Med_Time;
FastTimeNew = FastTime - MedTime;
rot_speed_med = ((rot_speed_high - rot_speed_low)/2) + rot_speed_low;  
}

Nebudu se zabývat popisování práce s prostředím Arduino IDE, práci s knihovnami a postupem připojení jednotky k PC. Tyto základní znalosti by měl zvládat každý, kdo se do stavby jednotky pustí. Po úspěšné kompilaci a nakopírování kódu do flash paměti arduina proběhne otestování eeprom paměti, přemazání jejího obsahu a konfigurace defaultního nastavení, následuje automatický restart.

Zobrazí se úvodní obrazovka s autorstvím a verzí SW, následuje možnost nastavení:

F1 setup program (nastavení jednotlivých programů)
F2 setup motor (nastavení rozběhové a brzdné křivky motoru)
F4 reset setings (seten hodnot EEPROM paměti do původních hodnot)

Při potřebě vstoupit do některého z nastavení je třeba během tohoto zobrazení stisknout odpovídající klávesu a držet ji, dokud se nezobrazí potřebné menu. Při zadávání jakéhokoliv nastavení je třeba toto provést do 2 minut, po překročení časového limitu dojde k restartu bez uložení dat.
Pokud nevyberete některou položku z menu (během 2 sec.), automaticky se přepne na první program s možností výběru dalších programů.

Řídící jednotka má 9 programů:

PGM 1 : Manual >>>
PGM 2: Manual <<<
PGM 3 – 9 je možné konfigurovat dle potřeby, v defaulním nastavením je PGM 3-6 zvratný, PGM 7-9 radiální. U programů 3-9 lze změnit jak typ (zvratný/radiální), tak parametry točení. Výběr programů se provádí pomocí kláves F1 a F2 s potvrzením výběru F3.

Otáčky jsou uvedeny v procentech z maximálních otáček motoru. Toto určuje krokování PWM regulace. Při zadávání potřebné hodnoty je na displeji zobrazený formát čísla (jeden nebo dva znaky) a povolený rozsah hodnot. Na konci editačního cyklu proběhne kontrola zadaných hodnot validátorem a pokud je některá mimo povolený rozsah, upozorní na toto a proběhne restart bez uložení do eeprom paměti. Zadávání času je v celých minutách.

Poznámka:
Při zobrazování hodnoty otáček v % se hodnota na LCD může lišit od skutečnosti o zobrazený údaj 1 %. Toto je dáno zaokrouhlením výsledného výpočtu krokování PWM regulace. Ta probíhá v 256 krocích a výsledek nemusí plně odpovídat požadovanému krokování. Na funkci a otáčky toto nemá vliv.

Po restartu/zapnutí je možné vstoupit do menu nastavení (viz. výše) a nastavit parametry programu.

Nastavení manuálního programu:

vyber program [1-2]
potvrď F4
minimální otáčky [10-50] %
potvrď F4
krok otáček [05-10] %
potvrď F4
kontrola nastavených hodnot, uložení do eeprom, restart

Nastavení zvratného programu:

• vyber program [3-9]
• potvrď F4
• typ programu
◦ F1 zvratný
• čas nízkých otáček [1-5] min.
• potvrď F4
• čas vysokých otáček [1-8] min.
• potvrď F4
• časová prodleva při reverzaci [00 – 20]sec.
• potvrď F4
• nízké otáčky [15-50] %
• potvrď F4
• vysoké otáčky [30-99] %
• potvrď F4
• kontrola nastavených hodnot, uložení do eeprom, restart

Nastavení radiálního programu:

• vyber program [3-9]
• potvrď F4
• typ programu
◦ F2 radiální
• čas nízkých otáček [1-5] min.
• potvrď F4
• čas vysokých otáček [1-8] min.
• potvrď F4
• nízké otáčky [15-50] %
• potvrď F4
• vysoké otáčky [30-99] %
• potvrď F4
• kontrola nastavených hodnot, uložení do eeprom, restart

Průběh manuálních programů:

• Start – rozběh motoru
• zrychlení na startovací otáčky
• F1 zvyšování otáček
• F2 snižování otáček
• Stop – brždění motoru a zastavení

Průběh zvratných programů:

• Start – rozběh motoru
• zrychlení na nízké otáčky
• čas nízkých otáček
• brždění
• časová prodleva
• reverzace
• zrychlení na nízké otáčky
• čas nízkých otáček
• zrychlení na vysoké otáčky
• čas vysokých otáček
• brždění
• reverzace
• zrychlení na vysoké otáčky
• čas vysokých otáček
• brždění
• zastavení motoru, konec zvratného cyklu

Průběh radiálních programů:

• Start – rozběh motoru
• zrychlení na nízké otáčky
• čas nízkých otáček
• zrychlení na vysoké otáčky
• čas vysokých otáček
• brždění
• zastavení motoru, konec zvratného cyklu

Po výběru programu se zobrazí jeho parametry.

Manuální programy – startovací otáčky (na tyto otáčky zrychlí po stisku klávesy Start) a krokování otáček (zvyšování nebo snižování pomocí kláves F1 a F2). Zastavení proběhne stiskem klávesy Stop.

Zvratné programy – hodnota T =X/Y min. ukazuje časy nízkých a vysokých otáček. Hodnota S=X/Y % zobrazuje hodnoty nízkých a vysokých otáček.
Celkový čas u zvratného programu = 2x čas nízkých otáček + 2x čas vysokých otáček + časová prodleva + časy zrychlování a brždění.
Program se spustí stiskem klávesy Start a po jeho ukončení automaticky zastaví a čeká na další spuštění.

Radiální programy – hodnota T =X/Y min. ukazuje časy nízkých a vysokých otáček. Hodnota S=X/Y % zobrazuje hodnoty nízkých a vysokých otáček.
Celkový čas u zvratného programu = 1x čas nízkých otáček + 1x čas vysokých otáček + časy zrychlování a brždění.
Program se spustí stiskem klávesy Start a po jeho ukončení automaticky zastaví a čeká na další spuštění.

V průběhu jakéhokoliv programu lze zastavit jeho průběh stiskem klávesy Stop, jeho průběh je resetován a při dalším spuštění začne od začátku. Dále se program ukončí a resetuje jeho průběh otevřením krytu medometu, respektive rozepnutím bezpečnostního spínače. Tento spínač musí mít rozpínací kontakty, tzn. při otevření krytu dojde k jejich rozepnutí. V pravém horním rohu displeje se zobrazí ikona odemknutého zámku.

Při průběhu automatických programů se zobrazuje:

číslo kroku, název kroku a případně jeho hodnota
Zbývající čas aktuálního kroku
Průběh cyklu
Plný segment displeje = kroky, které budou vykonány
Prázdný segment displeje = již vykonané kroky
Grafické zobrazení hodnoty otáček

Setup motoru

Toto nastavení se spouští klávesou F2 při startu řídící jednotky. Má za za úkol nastavit rozběhovou a brzdnou křivku motoru. Otáčky nelze spustit nebo zastavit okamžitě, musí mít vzestupnou nebo sestupnou křivku.

Výpočet zrychlení (nebo zpomalení) se získá z počtu kroků a jejich časové délky.

Počet kroků 1-5
Akcelerace 1-9

Čím vyšší hodnoty, tím pomalejší rozběh a naopak. Jaká hodnota nejlépe vyhovuje konkrétnímu medometu je potřeba vyzkoušet metodou pokus – omyl. Začít na vyšších hodnotách a postupně hledat optimální nastavení. Průběh zrychlení nemá zcela lineární průběh, ale probíhá po malých skocích. U radiálních (a tangenciálních) medometů bude vhodnější pomalejší průběh (fyzicky jsem netestoval, nemám takové medomety k dispozici). U zvratných medometů je vhodnější mírně agresivnější průběh, aby při rozběhu došlo ke sklopení kazet správným směrem, rozumné cuknutí je žádoucí.

Přiložený graf ukazuje, průběh zrychlení na 30 % otáček.

Červená rampa:

krok = 2
akcelerace = 5

Modrá rampa

krok = 5
akcelerace = 9

Z grafu je zřejmé, jak průběh práce s motorem probíhá.

Vnitřní zapojení

Přívod napájení na svorky B+ a B- Jeden vodič napojit přes Stop tlačítko).
Paralelně připojit svorky Vcc a GND Vodič Vcc připojit přes hlavní vypínač a pojistku vel. 5×20 0,3A. Toto je napájení elektroniky. Pozor, vodič GND je datově propojen vnitřně přes PCB, takže ho na pojistku a vypínač nelze připojit. Na svorky M+ a M- připojit motor medometu. Jeden vodič motoru připojit přes pojistku vel. 6,3×32. Hodnotu pojistky podle použitého motoru a jeho odběru. Na svorky Saf připojit bezpečnostní spínač krytu medometu. Pokud medomet tento spínač na krytu nemá (nebo nemáte potřebu ho používat), svorky Saf musí být propojené (což z bezpečnostních důvodů nedoporučuji).
Vodiče napájení a motoru o průřezu 1,0 mm², ostatní 0,5 mm². Proud běžných medometů se pohybuje v řádu jednotek ampér, při rozběhu může krátkodobě překročit 10A.

Použité zdroje:

www.dratek.cz

www.navody.dratek.cz

E-shop pro bastlíře | LaskaKit

www.tme.eu/cz

Kompletní výrobní podklady ke staženi na vcelarstvihavelka.cz/data/Medomet_ver_1.1.zip
Pro případnou diskuzi jsem založil téma na www.vcelarskeforum.cz

Upozornění:

Toto je návod, jak jsem navrhl, naprogramoval a sestrojil řídící jednotku pro svůj medomet a svoji potřebu. Nenesu žádnou odpovědnost za případné škody na majetku, zdraví a životě, pokud někdo podle tohoto návodu řídící jednotku vyrobí a použije.

Licence:

Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International

Tato licence vyžaduje, aby uživatelé uváděli autora jako zdroj. Umožňuje uživatelům materiál distribuovat, remixovat, přizpůsobovat a rozvíjet v jakémkoli médiu nebo formátu, pouze pro nekomerční účely. Pokud materiál upravují nebo přizpůsobují jiní, musí si upravený materiál licencovat za stejných podmínek.

NC Povoleno je pouze nekomerční využití vaší práce. Nekomerční znamená, že není primárně určeno k obchodní výhodě nebo finanční kompenzaci.
SA Adaptace musí být sdíleny za stejných podmínek. Viz listina vlastnictví