Proyecto de internet , ping pong

International Español Microcontroladores
1

Hola buenas , tengo un problema y es que a la hora de compilar en mi ESP32 con éxito , no se ejecuta nada en la comunicación serial . Alguien puede ayudarme por favor !

2

Los usuarios nuevos no pueden subir archivos , ALGUIEN que pueda echarme una mano y le envío el código , muchas gracias de antemano

3

Para adjuntar el código lee las Normas del Foro, punto 7.
Y edita el título también de acuerdo a las Normas.

5

Moderador:
Por favor, lee las Normas del foro y edita tu código/error usando etiquetas de código.
Ve a edición, luego selecciona todo el código que has publicado, lo cortas y click en </>

image
image829×163 13.4 KB

Edita tmb el título retirando la palabra ayuda.
Mira el punto 5 de las normas sobre cómo poner los títulos en este foro.

Dudo mucho que un usuario no pueda subir código, si fuera asi que puede hacer solo ganarse la queja de un moderador?. Revisa por favor.

8

Si el código lo has cargado tal cual, no sale nada por serial porque sencillamente el puerto serial no está iniciado porque la línea está comentada

  EEPROM.begin(EEPROM_SIZE);
  //Serial.begin(115200);
}

Revisalo, es la última linea de setup()

Agrego: Para subir un código largo como éste, lo cortas en secciones y lo adjuntas en varios posts y listo.

9

Acá tienes la solución.
He agregado unas instrucciones

#define DEBUG 1

#if DEBUG == 1
#define debug(x)      Serial.print(x)
#define debugln(x)    Serial.println(x)
#endif

Eso hace que si DEBUG == 1 se muestren los Serial.print pero si esta en 0 no.
Ahora estaban comentados o sea con

#define DEBUG 0

Si quieres que muestre pones

#define DEBUG 1

todo el código.


//  ESP32 создает Wi-Fi сеть и Веб-страницу, все управление роботом с этой Веб-страницы.
//  Использована плата DOIT ESP32 DEVKIT V1
//  Веб интерфейс создает библиотека ESPUI - https://github.com/s00500/ESPUI
//  Ей для работы надо дополнительно установить библиотеки:
//  ESPAsyncWebserver - https://github.com/me-no-dev/ESPAsyncWebserver
//  ArduinoJson - https://github.com/bblanchon/ArduinoJson
//  AsyncTCP - https://github.com/me-no-dev/AsyncTCP

//  Для управления сервоприводами и ESC надо установить библиотеку
//  ESP32Servo - https://github.com/jkb-git/ESP32Servo


// !!!!!   Работа проверена на этих версиях библиотек   !!!!!
// Arduino IDE 1.8.12
// ESPUI  2.0.0
// ESP32Servo 0.7.1
// ESPAsyncWebServer 1.2.3
// ArduinoJson  6.15.1
// AsyncTCP 1.1.1
// DNSServer 1.1.1
#define DEBUG 1

#if DEBUG == 1
#define debug(x)      Serial.print(x)
#define debugln(x)    Serial.println(x)
#endif

// Подключаем библиотеку Servo, для ESP32 нужна <ESP32Servo.h>
#include <ESP32Servo.h>
// объявляем объекты Servo
Servo Motor_1; //верхний правый двигатель
Servo Motor_2; //верхний левый двигатель
Servo Motor_3; //нижний двигатель
Servo Servo_1; //серво лево-право
Servo Servo_2; //серво выше-ниже
Servo Motor_BallS; //двигатель подачи мячей
//Servo Meshalka_BallS; //серво перемешивания мячей

// Подключаем библиотеку EEPROM, будем сохранять мячи в память
#include <EEPROM.h>
#define EEPROM_SIZE 256
//------------------------------------------------------------------------

// подключения
static const int motorPin1 = 18; //управление верхний правый двигатель 1 pin 18
static const int motorPin2 = 19; //управление верхний левый  двигатель 2 pin 19
static const int motorPin3 = 21; //управление нижний двигатель 3 pin 21
static const int servoPin1 = 27; //управление серво лево-право pin 27
static const int servoPin2 = 26; //управление серво выше-ниже pin 26
static const int motorSPin = 25; //двигатель подачи мячей pin 25 
const int MeshalkaPin = 15; //серво перемешивания мячей pin 15 
int ledPri = 13; // ИК диод приемник pin 13
//------------------------------------------------------------------------

// переменные в программе получаемые с Веб страницы
int N_Ppog = 0; // номер программы 
boolean pusk = false; // true - пуск, false - стоп
int BallS_Speed = 0; // скорость двигателя подачи мячей
boolean STOP_Mehsalka = false; // true - пуск, false - стоп мешалки

 // 1 мяч
int ball_N1 = 1;  // число 1-ых мячей
int Motor1_speed_N1 = 0; //скорость двигателя 1 у 1-ых мячей
int Motor2_speed_N1 = 0; //скорость двигателя 2 у 1-ых мячей
int Motor3_speed_N1 = 0; //скорость двигателя 2 у 1-ых мячей
int ugol_UD_N1 = 50; // угол вылета выше-ниже у 1-ых мячей
int ugol_LR_N1 = 50; // угол вылета лево-право у 1-ых мячей
int random_N1 = 0; // размер случайной добавки к углу вылета лево-право у 1-ых мячей
int pausa_N1 = 0; // размер паузы после 1-го мяча
 // 2 мяч
int ball_N2 = 0;  // число 2-ых мячей (0 - нет)
int Motor1_speed_N2 = 0; //скорость двигателя 1 у 2-ых мячей
int Motor2_speed_N2 = 0; //скорость двигателя 2 у 2-ых мячей
int Motor3_speed_N2 = 0; //скорость двигателя 3 у 2-ых мячей
int ugol_UD_N2 = 50; // угол вылета выше-ниже у 2-ых мячей
int ugol_LR_N2 = 50; // угол вылета лево-право у 2-ых мячей
int random_N2 = 0; // размер случайной добавки к углу вылета лево-право у 2-ых мячей
int pausa_N2 = 0; // размер паузы после 2-го мяча
 // 3 мяч
int ball_N3 = 0;  // число 3-ых мячей (0 - нет)
int Motor1_speed_N3 = 0; //скорость двигателя 1 у 3-ых мячей
int Motor2_speed_N3 = 0; //скорость двигателя 2 у 3-ых мячей
int Motor3_speed_N3 = 0; //скорость двигателя 3 у 3-ых мячей
int ugol_UD_N3 = 50; // угол вылета выше-ниже у 3-ых мячей
int ugol_LR_N3 = 50; // угол вылета лево-право у 3-ых мячей
int random_N3 = 0; // размер случайной добавки к углу вылета лево-право у 3-ых мячей
int pausa_N3 = 0; // размер паузы после 3-го мяча
// 4 мяч
int ball_N4 = 0;  // число 4-ых мячей (0 - нет)
int Motor1_speed_N4 = 0; //скорость двигателя 1 у 4-ых мячей
int Motor2_speed_N4 = 0; //скорость двигателя 2 у 4-ых мячей
int Motor3_speed_N4 = 0; //скорость двигателя 3 у 4-ых мячей
int ugol_UD_N4 = 50; // угол вылета выше-ниже у 4-ых мячей
int ugol_LR_N4 = 50; // угол вылета лево-право у 4-ых мячей
int random_N4 = 0; // размер случайной добавки к углу вылета лево-право у 4-ых мячей
int pausa_N4 = 0; // размер паузы после 4-го мяча
 // 5 мяч 
int ball_N5 = 0;  // число 5-ых мячей (0 - нет)
int Motor1_speed_N5 = 0; //скорость двигателя 1 у 5-ых мячей
int Motor2_speed_N5 = 0; //скорость двигателя 2 у 5-ых мячей
int Motor3_speed_N5 = 0; //скорость двигателя 3 у 5-ых мячей
int ugol_UD_N5 = 50; // угол вылета выше-ниже у 5-ых мячей
int ugol_LR_N5 = 50; // угол вылета лево-право у 5-ых мячей
int random_N5 = 0; // размер случайной добавки к углу вылета лево-право у 5-ых мячей
int pausa_N5 = 0; // размер паузы после 5-го мяча
 // 6 мяч  
int ball_N6 = 0;  // число 6-ых мячей (0 - нет)
int Motor1_speed_N6 = 0; //скорость двигателя 1 у 6-ых мячей
int Motor2_speed_N6 = 0; //скорость двигателя 2 у 6-ых мячей
int Motor3_speed_N6 = 0; //скорость двигателя 3 у 6-ых мячей
int ugol_UD_N6 = 50; // угол вылета выше-ниже у 6-ых мячей
int ugol_LR_N6 = 50; // угол вылета лево-право у 6-ых мячей
int random_N6 = 0; // размер случайной добавки к углу вылета лево-право у 6-ых мячей
int pausa_N6 = 0; // размер паузы после 6-го мяча

// переменные для контроля переменных получаемых с Веб страницы 
// например ограничиваем угол от 0 до 100
 // № программы не больше чем последний CASE (=12)
uint16_t PROG; 
uint16_t text_actual;
uint16_t text_cell;
uint16_t Mem_Cell;
boolean read_Parametrs = false;
boolean read_Memory = false;
boolean load_Memory = false;
boolean save_Memory = false;
 
 // 1 мяч
int B_N1; 
int M1_N1;
int M2_N1;
int M3_N1;
int UUD_N1;
int ULR_N1;
int R_N1;
int P_N1;
 // 2 мяч
int B_N2; 
int M1_N2;
int M2_N2;
int M3_N2;
int UUD_N2;
int ULR_N2;
int R_N2;
int P_N2;
 // 3 мяч
int B_N3; 
int M1_N3;
int M2_N3;
int M3_N3;
int UUD_N3;
int ULR_N3;
int R_N3;
int P_N3;
 // 4 мяч
int B_N4; 
int M1_N4;
int M2_N4;
int M3_N4;
int UUD_N4;
int ULR_N4;
int R_N4;
int P_N4;
 // 5 мяч
int B_N5; 
int M1_N5;
int M2_N5;
int M3_N5;
int UUD_N5;
int ULR_N5;
int R_N5;
int P_N5;
 // 6 мяч
int B_N6; 
int M1_N6;
int M2_N6;
int M3_N6;
int UUD_N6;
int ULR_N6;
int R_N6;
int P_N6;

 // ячейка памяти
int MEMORY_C;

// переменные - параметры мячей считанные из внутренней памяти
 // 1 мяч
int B_N1_MMR; 
int M1_N1_MMR;
int M2_N1_MMR;
int M3_N1_MMR;
int UUD_N1_MMR;
int ULR_N1_MMR;
int R_N1_MMR;
int P_N1_MMR;
 // 2 мяч
int B_N2_MMR; 
int M1_N2_MMR;
int M2_N2_MMR;
int M3_N2_MMR;
int UUD_N2_MMR;
int ULR_N2_MMR;
int R_N2_MMR;
int P_N2_MMR;
 // 3 мяч
int B_N3_MMR; 
int M1_N3_MMR;
int M2_N3_MMR;
int M3_N3_MMR;
int UUD_N3_MMR;
int ULR_N3_MMR;
int R_N3_MMR;
int P_N3_MMR;
 // 4 мяч
int B_N4_MMR; 
int M1_N4_MMR;
int M2_N4_MMR;
int M3_N4_MMR;
int UUD_N4_MMR;
int ULR_N4_MMR;
int R_N4_MMR;
int P_N4_MMR;
 // 5 мяч
int B_N5_MMR; 
int M1_N5_MMR;
int M2_N5_MMR;
int M3_N5_MMR;
int UUD_N5_MMR;
int ULR_N5_MMR;
int R_N5_MMR;
int P_N5_MMR;
 // 6 мяч
int B_N6_MMR; 
int M1_N6_MMR;
int M2_N6_MMR;
int M3_N6_MMR;
int UUD_N6_MMR;
int ULR_N6_MMR;
int R_N6_MMR;
int P_N6_MMR;

// вспомогательные переменные
int ball_N = 1; // номер мяча (1 из 6)
int ball_S = 1; //суммарное число мячей
int nBall = 0;  // число шаров для поворота сервы лево-право
int sBall = 0;  // число шаров для рассчета скорости
boolean trg1 = 0; // для счетчика мячей
boolean trg2 = 0; // для сброса счетчика мячей при старте
boolean Pausa_Flag = false; // останов подачи мячей на время паузы
boolean Pausa_Flag_N = false; // флаг фиксации времени начала останова
boolean Flag_balls_change = false; // флаг смены мяча для паузы, чтобы пауза только 1 раз
unsigned long time_Pausa = 0; // переменная для рассчета времени останова
unsigned long time_Schetchik = 0; // переменная для рассчета времени останова счетчика мячей
boolean Flag_balls_Schetchik = false; // флаг для паузы счетчика мячей 

 // промежуточные задания
 // скорость -100 - назад, 0 - стоп, 100 - вперед
 // угол вылета выше-ниже  0 - низ,  50 - середина, 100 - верх
 // угол вылета лево-право 0 - лево, 50 - середина, 100 - право
int Motor1_speed = 0; // промежуточное задание скорость двигателя 1
int Motor2_speed = 0; // промежуточное задание скорость двигателя 2
int Motor3_speed = 0; // промежуточное задание скорость двигателя 3
int ugol_UD = 50; // промежуточное задание угол вылета выше-ниже
int ugol_LR = 50; // промежуточное задание угол вылета лево-право
int random_Ugol = 0; // промежуточное задание случайной добавки к углу вылета лево-право 
int pausa_PRM = 0; // промежуточное задание паузы после вылета мяча

 // фактические задания
int SPD_M1 = 0; // скорость двигателя 1
int SPD_M2 = 0; // скорость двигателя 2
int SPD_M3 = 0; // скорость двигателя 3
int UGL_UD = 50; // угол вылета выше-ниже
int UGL_LR = 50; // угол вылета лево-право
int UGL_random = 0; // случайная добавка к углу вылета лево-право 
boolean random_Flag = true; // для задания случайной добавки к углу вылета лево-право
int UGL_random_R = 0;  // добавка к углу вылета лево-право

//------------------------------------------------------------------------

// здесь создается WI_FI сеть "ESPUI" и страница с IP(192, 168, 4, 1) 
#include <DNSServer.h>
#include <ESPUI.h>

const byte DNS_PORT = 53;
IPAddress apIP(192, 168, 4, 1);
DNSServer dnsServer;

#include <WiFi.h>

const char *ssid = "ESPUI";
const char *password = ""; //здесь можно задать пароль WI-FI

const char *hostname = "espui";
//------------------------------------------------------------------------

// функции получения значений с Веб страницы
//функция ввод числа
void numberCall(Control *sender, int type) { 
  debugln(sender->id); 
  int result = sender->value.toInt();
  switch (sender->id) {
  case 7:
    N_Ppog = result; // здесь получаем номер программы
    break;
  case 12:
    ball_N1 = result; // здесь получаем число 1-ых мячей 
    break; 
  case 13:
    Motor1_speed_N1 = result; // здесь получаем скорость двигателя 1 у 1-ых мячей 
    break;
  case 14:
    Motor2_speed_N1 = result; // здесь получаем скорость двигателя 2 у 1-ых мячей 
    break;
  case 15:
    Motor3_speed_N1 = result; // здесь получаем скорость двигателя 3 у 1-ых мячей 
    break;         
  case 16:
    ugol_UD_N1 = result; // здесь получаем угол вылета выше-ниже у 1-ых мячей 
    break;
  case 17:
    ugol_LR_N1 = result; // здесь получаем угол вылета лево-право у 1-ых мячей 
    break;
  case 18:
    random_N1 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 1-ых мячей 
    break;
  case 19:
    pausa_N1 = result;   // здесь получаем размер паузы после 1-го мяча
    break;
      
  case 20:
    ball_N2 = result; // здесь получаем число 2-ых мячей 
    break; 
  case 21:
    Motor1_speed_N2 = result; // здесь получаем скорость двигателя 1 у 2-ых мячей 
    break;
  case 22:
    Motor2_speed_N2 = result; // здесь получаем скорость двигателя 2 у 2-ых мячей 
    break;
  case 23:
    Motor3_speed_N2 = result; // здесь получаем скорость двигателя 3 у 2-ых мячей 
    break;         
  case 24:
    ugol_UD_N2 = result; // здесь получаем угол вылета выше-ниже у 2-ых мячей 
    break;
  case 25:
    ugol_LR_N2 = result; // здесь получаем угол вылета лево-право у 2-ых мячей 
    break;
  case 26:
    random_N2 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 2-ых мячей 
    break;
  case 27:
    pausa_N2 = result;   // здесь получаем размер паузы после 2-го мяча
    break;
    
  case 28:
    ball_N3 = result; // здесь получаем число 3-ых мячей 
    break; 
  case 29:
    Motor1_speed_N3 = result; // здесь получаем скорость двигателя 1 у 3-ых мячей 
    break;
  case 30:
    Motor2_speed_N3 = result; // здесь получаем скорость двигателя 2 у 3-ых мячей 
    break;
  case 31:
    Motor3_speed_N3 = result; // здесь получаем скорость двигателя 3 у 3-ых мячей 
    break;         
  case 32:
    ugol_UD_N3 = result; // здесь получаем угол вылета выше-ниже у 3-ых мячей 
    break;
  case 33:
    ugol_LR_N3 = result; // здесь получаем угол вылета лево-право у 3-ых мячей 
    break;
  case 34:
    random_N3 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 3-ых мячей 
    break;
  case 35:
    pausa_N3 = result;   // здесь получаем размер паузы после 3-го мяча
    break;
     
  case 36:
    ball_N4 = result; // здесь получаем число 4-ых мячей 
    break; 
  case 37:
    Motor1_speed_N4 = result; // здесь получаем скорость двигателя 1 у 4-ых мячей 
    break;
  case 38:
    Motor2_speed_N4 = result; // здесь получаем скорость двигателя 2 у 4-ых мячей 
    break;
  case 39:
    Motor3_speed_N4 = result; // здесь получаем скорость двигателя 3 у 4-ых мячей 
    break;         
  case 40:
    ugol_UD_N4 = result; // здесь получаем угол вылета выше-ниже у 4-ых мячей 
    break;
  case 41:
    ugol_LR_N4 = result; // здесь получаем угол вылета лево-право у 4-ых мячей 
    break;
  case 42:
    random_N4 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 4-ых мячей 
    break; 
  case 43:
    pausa_N4 = result;   // здесь получаем размер паузы после 4-го мяча
    break;
     
  case 44:
    ball_N5 = result; // здесь получаем число 5-ых мячей 
    break; 
  case 45:
    Motor1_speed_N5 = result; // здесь получаем скорость двигателя 1 у 5-ых мячей 
    break;
  case 46:
    Motor2_speed_N5 = result; // здесь получаем скорость двигателя 2 у 5-ых мячей 
    break;
  case 47:
    Motor3_speed_N5 = result; // здесь получаем скорость двигателя 3 у 5-ых мячей 
    break;         
  case 48:
    ugol_UD_N5 = result; // здесь получаем угол вылета выше-ниже у 5-ых мячей 
    break;
  case 49:
    ugol_LR_N5 = result; // здесь получаем угол вылета лево-право у 5-ых мячей 
    break;
  case 50:
    random_N5 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 5-ых мячей 
    break; 
  case 51:
    pausa_N5 = result;   // здесь получаем размер паузы после 5-го мяча
    break; 

     
  case 52:
    ball_N6 = result; // здесь получаем число 6-ых мячей 
    break; 
  case 53:
    Motor1_speed_N6 = result; // здесь получаем скорость двигателя 1 у 6-ых мячей 
    break;
  case 54:
    Motor2_speed_N6 = result; // здесь получаем скорость двигателя 2 у 6-ых мячей 
    break;
  case 55:
    Motor3_speed_N6 = result; // здесь получаем скорость двигателя 3 у 6-ых мячей 
    break;         
  case 56:
    ugol_UD_N6 = result; // здесь получаем угол вылета выше-ниже у 6-ых мячей 
    break;
  case 57:
    ugol_LR_N6 = result; // здесь получаем угол вылета лево-право у 6-ых мячей 
    break;
  case 58:
    random_N6 = result; // здесь получаем размер случайной добавки к угол вылета лево-право у 6-ых мячей 
    break; 
  case 59:
    pausa_N6 = result;   // здесь получаем размер паузы после 6-го мяча
    break;
        
  case 62:
    Mem_Cell = result; // здесь получаем номер ячейки памяти сохраненных параметров мячей
    break;   
               
   }
  }
//--------------------------------------------------------------------------------

//функция переключатель
void switchExample(Control *sender, int value) {
  boolean result = (value == S_ACTIVE ? true : false);
  switch (sender->id) { 
    case 8:
 pusk = result; // здесь получаем пуск - стоп
     break;
    case 67:
 STOP_Mehsalka =  result;  // здесь получаем пуск - стоп мешалки  
     break;
  }   
}
//---------------------------------------------------------------------------------

// функция слейдер (ползунок)
void slider(Control *sender, int type) {
  debugln(sender->id);
  int sliderValueWithOffset = sender->value.toInt();
   BallS_Speed = sliderValueWithOffset;   // здесь получаем скорость двигателя подачи мячей 
}
//---------------------------------------------------------------------------------------------  

void buttonExample(Control *sender, int type) {
  switch (sender->id) {   
    case 60:
  if (type == B_DOWN){  
     debugln("Status: Start");     
     read_Parametrs = true;
     debugln(read_Parametrs); 
     }
  if (type == B_UP){
      debugln("Status: Stop");
      read_Parametrs = false;
      debugln(read_Parametrs);
      }
    break;
    case 63:
  if (type == B_DOWN){  
     debugln("Status: Start");     
     read_Memory = true;
     debugln(read_Memory); 
     }
  if (type == B_UP){
      debugln("Status: Stop");
      read_Memory = false;
      debugln(read_Memory);
      }
    break;
    case 65:
  if (type == B_DOWN){  
     debugln("Status: Start");     
     load_Memory = true;
     debugln(load_Memory); 
     }
  if (type == B_UP){
      debugln("Status: Stop");
      load_Memory = false;
      debugln(load_Memory);
      }
    break; 
    case 66:
  if (type == B_DOWN){  
     debugln("Status: Start");     
     save_Memory = true;
     debugln(save_Memory); 
     }
  if (type == B_UP){
      debugln("Status: Stop");
      save_Memory = false;
      debugln(save_Memory);
      }
    break;           
  }
}
//---------------------------------------------------------------------------------

void setup()   {                
 // здесь все к WI-FI
    ESPUI.setVerbosity(Verbosity::VerboseJSON);
#if defined(ESP32)
  WiFi.setHostname(hostname);
#else
  WiFi.hostname(hostname);
#endif
  // try to connect to existing network
  WiFi.begin(ssid, password);
  {
    uint8_t timeout = 10;
    // Wait for connection, 5s timeout
    do {
      delay(500);
      timeout--;
    } while (timeout && WiFi.status() != WL_CONNECTED);

    // not connected -> create hotspot
    if (WiFi.status() != WL_CONNECTED) {
      WiFi.mode(WIFI_AP);
      WiFi.softAPConfig(apIP, apIP, IPAddress(255, 255, 255, 0));
      WiFi.softAP(ssid);
      timeout = 5;
      do {
        delay(500);
        timeout--;
      } while (timeout);
    }
  }

  dnsServer.start(DNS_PORT, "*", apIP); 
  // здесь блоки ESPUI формирующие Веб страницу
  // здесь вкладки мячей 1 - 6
  uint16_t tab1 = ESPUI.addControl( ControlType::Tab, "BALL 1", "BALL 1" );
  uint16_t tab2 = ESPUI.addControl( ControlType::Tab, "BALL 2", "BALL 2" );
  uint16_t tab3 = ESPUI.addControl( ControlType::Tab, "BALL 3", "BALL 3" );
  uint16_t tab4 = ESPUI.addControl( ControlType::Tab, "BALL 4", "BALL 4" );
  uint16_t tab5 = ESPUI.addControl( ControlType::Tab, "BALL 5", "BALL 5" );
  uint16_t tab6 = ESPUI.addControl( ControlType::Tab, "BALL 6", "BALL 6" );
  uint16_t tab7 = ESPUI.addControl( ControlType::Tab, "MEMORY", "MEMORY" );
  // общие блоки ESPUI
  PROG = ESPUI.addControl( ControlType::Number, "PROGRAMM", "0", ControlColor::Peterriver, Control::noParent, &numberCall ); // id 07
  ESPUI.switcher("PUSK", &switchExample, ControlColor::None, false); // id 08
  ESPUI.slider("BALLS SPEED", &slider, ControlColor::Emerald, 20); // id 09
  // здесь вкладка BALL 1 
  B_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 :", "1", ControlColor::Peterriver, tab1, &numberCall ); // id 12
  M1_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 1 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 13
  M2_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 2 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 14
  M3_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 3 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 15
  UUD_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 SERVO UP-DOWN", "50", ControlColor::Peterriver, tab1, &numberCall ); // id 16
  ULR_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 SERVO LEFT-RIGHT", "50", ControlColor::Peterriver, tab1, &numberCall ); // id 17
  R_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 RANDOM LEFT-RIGHT", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 18
  P_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 PAUSA", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 19
  // здесь вкладка BALL 2 
  B_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 :", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 20
  M1_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 1 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 21
  M2_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 2 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 22
  M3_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 3 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 23
  UUD_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 SERVO UP-DOWN", "50", ControlColor::Turquoise, tab2, &numberCall ); // id 24
  ULR_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 SERVO LEFT-RIGHT", "50", ControlColor::Turquoise, tab2, &numberCall ); // id 25
  R_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 RANDOM LEFT-RIGHT", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 26 
  P_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 PAUSA", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 27   
  // здесь вкладка BALL 3 
  B_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 :", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 28
  M1_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 MOTOR 1 SPEED", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 29
  M2_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 MOTOR 2 SPEED", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 30
  M3_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 MOTOR 3 SPEED", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 31
  UUD_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 SERVO UP-DOWN", "50", ControlColor::Wetasphalt, tab3, &numberCall ); // id 32
  ULR_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 SERVO LEFT-RIGHT", "50", ControlColor::Wetasphalt, tab3, &numberCall ); // id 33
  R_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 RANDOM LEFT-RIGHT", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 34
  P_N3 = ESPUI.addControl( ControlType::Number, "BALL 3 PAUSA", "0", ControlColor::Wetasphalt, tab3, &numberCall ); // id 35
   // здесь вкладка BALL 4 
  B_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 :", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 36
  M1_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 MOTOR 1 SPEED", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 37
  M2_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 MOTOR 2 SPEED", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 38
  M3_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 MOTOR 3 SPEED", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 39
  UUD_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 SERVO UP-DOWN", "50", ControlColor::Turquoise, tab4, &numberCall ); // id 40
  ULR_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 SERVO LEFT-RIGHT", "50", ControlColor::Turquoise, tab4, &numberCall ); // id 41
  R_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 RANDOM LEFT-RIGHT", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 42
  P_N4 = ESPUI.addControl( ControlType::Number, "BALL 4 PAUSA", "0", ControlColor::Turquoise, tab4, &numberCall ); // id 43
   // здесь вкладка BALL 5 
  B_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 :", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 44
  M1_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 MOTOR 1 SPEED", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 45
  M2_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 MOTOR 2 SPEED", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 46
  M3_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 MOTOR 3 SPEED", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 47
  UUD_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 SERVO UP-DOWN", "50", ControlColor::Peterriver, tab5, &numberCall ); // id 48
  ULR_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 SERVO LEFT-RIGHT", "50", ControlColor::Peterriver, tab5, &numberCall ); // id 49
  R_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 RANDOM LEFT-RIGHT", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 50
  P_N5 = ESPUI.addControl( ControlType::Number, "BALL 5 PAUSA", "0", ControlColor::Peterriver, tab5, &numberCall ); // id 51
  // здесь вкладка BALL 6 
  B_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 :", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 52
  M1_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 MOTOR 1 SPEED", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 53
  M2_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 MOTOR 2 SPEED", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 54 
  M3_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 MOTOR 3 SPEED", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 55
  UUD_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 SERVO UP-DOWN", "50", ControlColor::Wetasphalt, tab6, &numberCall ); // id 56
  ULR_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 SERVO LEFT-RIGHT", "50", ControlColor::Wetasphalt, tab6, &numberCall ); // id 57 
  R_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 RANDOM LEFT-RIGHT", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 58 
  P_N6 = ESPUI.addControl( ControlType::Number, "BALL 6 PAUSA", "0", ControlColor::Wetasphalt, tab6, &numberCall ); // id 59
  // здесь вкладка MEMORY 
  ESPUI.addControl(ControlType::Button, "Reading current Parametrs", "READ", ControlColor::Peterriver, tab7, &buttonExample);  // id 60
  text_actual = ESPUI.addControl( ControlType::Label, "Current Parametrs:", "0",ControlColor::Emerald, tab7 );  // id 61
  MEMORY_C = ESPUI.addControl( ControlType::Number, "Memory Cell", "1", ControlColor::Alizarin, tab7, &numberCall );  // id 62
  ESPUI.addControl(ControlType::Button, "Reading from Memory", "READ", ControlColor::Peterriver, tab7, &buttonExample);  // id 63
  text_cell = ESPUI.addControl( ControlType::Label, "Parametrs in Memory:", "0",ControlColor::Emerald, tab7 );  // id 64
  ESPUI.addControl( ControlType::Button, "Load from Memory", "LOAD", ControlColor::Wetasphalt, tab7, &buttonExample );  // id 65
  ESPUI.addControl( ControlType::Button, "Save to Memory", "SAVE", ControlColor::Wetasphalt, tab7, &buttonExample );  // id 66
  //ESPUI.switcher("PUSK MESHALKA", &switchExample, ControlColor::None, true); // id 67
  ESPUI.addControl( ControlType::Switcher, "STOP MESHALKA", "", ControlColor::Sunflower, tab7, &switchExample ); // id 67
  
  ESPUI.jsonUpdateDocumentSize = 6000;
  ESPUI.jsonInitialDocumentSize = 32000;

  ESPUI.begin(". Tennis Robot .");
  
 //--------------------------------------------------------------------------------------------------------------

 // инициализируем вход ИК диода приемника 
  pinMode(ledPri, INPUT); 
  
  // инициализируем моторы и серво
  Motor_1.attach(motorPin1);
  Motor_2.attach(motorPin2);
  Motor_3.attach(motorPin3);
  Motor_BallS.attach(motorSPin);
  Servo_1.attach(servoPin1);
  Servo_2.attach(servoPin2);
  Servo_1.write(90);  // устанавливаем сервопривод лево-право в серединное положение
  Servo_2.write(90);  // устанавливаем сервопривод выше-ниже в серединное положение
  Motor_1.writeMicroseconds(1480); //устанавливаем скорость верхнего правого ESC = 0
  Motor_2.writeMicroseconds(1480); //устанавливаем скорость верхнего левого ESC = 0
  Motor_3.writeMicroseconds(1480); //устанавливаем скорость нижнего ESC = 0
  Motor_BallS.writeMicroseconds(1080); //устанавливаем скорость двигатель подачи мячей = 0
  ledcSetup(15, 1024, 8);
  ledcAttachPin(MeshalkaPin, 15);
  delay (3000); // пауза для настройки  ESC
  EEPROM.begin(EEPROM_SIZE);
  //Serial.begin(115200);
}
//-------------------------------------------------------------------------------------------------------


void loop() { 
 
  dnsServer.processNextRequest(); // запуск ESPUI

 if (read_Parametrs == true) {
    // строки для отображения текущих параметров мячей
  String X1 = "1B-" + String(ball_N1) + ", 1M1-" + String(Motor1_speed_N1)
  + ", 1M2-" + String(Motor2_speed_N1) + ", 1M3-" + String(Motor3_speed_N1) 
  + ", 1UD-" + String(ugol_UD_N1) + ", 1LR-" + String(ugol_LR_N1)
  + ", 1R-" + String(random_N1);
  String X2 =  " 2B-" + String(ball_N2) + ", 2M1-" + String(Motor1_speed_N2)
  + ", 2M2-" + String(Motor2_speed_N2) + ", 2M3-" + String(Motor3_speed_N2) 
  + ", 2UD-" + String(ugol_UD_N2) + ", 2LR-" + String(ugol_LR_N2)
  + ", 2R-" + String(random_N2);
  String X3 = " 3B-" + String(ball_N3) + ", 3M1-" + String(Motor1_speed_N3)
  + ", 3M2-" + String(Motor2_speed_N3) + ", 3M3-" + String(Motor3_speed_N3) 
  + ", 3UD-" + String(ugol_UD_N3) + ", 3LR-" + String(ugol_LR_N3)
  + ", 3R-" + String(random_N3);
  String X4 = " 4B-" + String(ball_N4) + ", 4M1-" + String(Motor1_speed_N4)
  + ", 4M2-" + String(Motor2_speed_N4) + ", 4M3-" + String(Motor3_speed_N4) 
  + ", 4UD-" + String(ugol_UD_N4) + ", 4LR-" + String(ugol_LR_N4)
  + ", 4R-" + String(random_N4);
  String X5 = " 5B-" + String(ball_N5) + ", 5M1-" + String(Motor1_speed_N5)
  + ", 5M2-" + String(Motor2_speed_N5) + ", 5M3-" + String(Motor3_speed_N5) 
  + ", 5UD-" + String(ugol_UD_N5) + ", 5LR-" + String(ugol_LR_N5)
  + ", 5R-" + String(random_N5); 
  String X6 = " 6B-" + String(ball_N6) + ", 6M1-" + String(Motor1_speed_N6)
  + ", 6M2-" + String(Motor2_speed_N6) + ", 6M3-" + String(Motor3_speed_N6) 
  + ", 6UD-" + String(ugol_UD_N6) + ", 6LR-" + String(ugol_LR_N6)
  + ", 6R-" + String(random_N6);
  ESPUI.print(text_actual, X1 + X2 + X3 + X4 + X5 + X6 );
 }

 if (read_Memory == true) {

     // адреса в памяти с 00 по 41 по два адреса на параметр
     // 1-ые мячи
     B_N1_MMR   = EEPROM.read(0 + 42*(Mem_Cell -1)); 
     M1_N1_MMR  = EEPROM.read(1 + 42*(Mem_Cell -1)) - 100; 
     M2_N1_MMR  = EEPROM.read(2 + 42*(Mem_Cell -1)) - 100; 
     M3_N1_MMR  = EEPROM.read(3 + 42*(Mem_Cell -1)) - 100; 
     UUD_N1_MMR = EEPROM.read(4 + 42*(Mem_Cell -1)); 
     ULR_N1_MMR = EEPROM.read(5 + 42*(Mem_Cell -1));
     R_N1_MMR   = EEPROM.read(6 + 42*(Mem_Cell -1)); 
     // 2-ые мячи
     B_N2_MMR   = EEPROM.read(7 + 42*(Mem_Cell -1)); 
     M1_N2_MMR  = EEPROM.read(8 + 42*(Mem_Cell -1)) - 100; 
     M2_N2_MMR  = EEPROM.read(9 + 42*(Mem_Cell -1)) - 100; 
     M3_N2_MMR  = EEPROM.read(10 + 42*(Mem_Cell -1)) - 100; 
     UUD_N2_MMR = EEPROM.read(11 + 42*(Mem_Cell -1)); 
     ULR_N2_MMR = EEPROM.read(12 + 42*(Mem_Cell -1));
     R_N2_MMR   = EEPROM.read(13 + 42*(Mem_Cell -1)); 
     // 3-и мячи
     B_N3_MMR   = EEPROM.read(14 + 42*(Mem_Cell -1)); 
     M1_N3_MMR  = EEPROM.read(15 + 42*(Mem_Cell -1)) - 100; 
     M2_N3_MMR  = EEPROM.read(16 + 42*(Mem_Cell -1)) - 100; 
     M3_N3_MMR  = EEPROM.read(17 + 42*(Mem_Cell -1)) - 100; 
     UUD_N3_MMR = EEPROM.read(18 + 42*(Mem_Cell -1)); 
     ULR_N3_MMR = EEPROM.read(19 + 42*(Mem_Cell -1));
     R_N3_MMR   = EEPROM.read(20 + 42*(Mem_Cell -1)); 
     // 4-ые мячи
     B_N4_MMR   = EEPROM.read(21 + 42*(Mem_Cell -1)); 
     M1_N4_MMR  = EEPROM.read(22 + 42*(Mem_Cell -1)) - 100; 
     M2_N4_MMR  = EEPROM.read(23 + 42*(Mem_Cell -1)) - 100; 
     M3_N4_MMR  = EEPROM.read(24 + 42*(Mem_Cell -1)) - 100; 
     UUD_N4_MMR = EEPROM.read(25 + 42*(Mem_Cell -1)); 
     ULR_N4_MMR = EEPROM.read(26 + 42*(Mem_Cell -1));
     R_N4_MMR   = EEPROM.read(27 + 42*(Mem_Cell -1)); 
     // 5-ые мячи
     B_N5_MMR   = EEPROM.read(28 + 42*(Mem_Cell -1)); 
     M1_N5_MMR  = EEPROM.read(29 + 42*(Mem_Cell -1)) - 100; 
     M2_N5_MMR  = EEPROM.read(30 + 42*(Mem_Cell -1)) - 100; 
     M3_N5_MMR  = EEPROM.read(31 + 42*(Mem_Cell -1)) - 100; 
     UUD_N5_MMR = EEPROM.read(32 + 42*(Mem_Cell -1)); 
     ULR_N5_MMR = EEPROM.read(33 + 42*(Mem_Cell -1));
     R_N5_MMR   = EEPROM.read(34 + 42*(Mem_Cell -1)); 
     // 6-ые мячи
     B_N6_MMR   = EEPROM.read(35 + 42*(Mem_Cell -1)); 
     M1_N6_MMR  = EEPROM.read(36 + 42*(Mem_Cell -1)) - 100; 
     M2_N6_MMR  = EEPROM.read(37 + 42*(Mem_Cell -1)) - 100; 
     M3_N6_MMR  = EEPROM.read(38 + 42*(Mem_Cell -1)) - 100; 
     UUD_N6_MMR = EEPROM.read(39 + 42*(Mem_Cell -1)); 
     ULR_N6_MMR = EEPROM.read(40 + 42*(Mem_Cell -1));
     R_N6_MMR   = EEPROM.read(41 + 42*(Mem_Cell -1));        
    
    String M1 = "1B-" + String(B_N1_MMR) + ", 1M1-" + String(M1_N1_MMR)
    + ", 1M2-" + String(M2_N1_MMR) + ", 1M3-" + String(M3_N1_MMR) 
    + ", 1UD-" + String(UUD_N1_MMR) + ", 1LR-" + String(ULR_N1_MMR)
    + ", 1R-" + String(R_N1_MMR);
    String M2 = " 2B-" + String(B_N2_MMR) + ", 2M1-" + String(M1_N2_MMR)
    + ", 2M2-" + String(M2_N2_MMR) + ", 2M3-" + String(M3_N2_MMR) 
    + ", 2UD-" + String(UUD_N2_MMR) + ", 2LR-" + String(ULR_N2_MMR)
    + ", 2R-" + String(R_N2_MMR);  
    String M3 = " 3B-" + String(B_N3_MMR) + ", 3M1-" + String(M1_N3_MMR)
    + ", 3M2-" + String(M2_N3_MMR) + ", 3M3-" + String(M3_N3_MMR) 
    + ", 3UD-" + String(UUD_N3_MMR) + ", 3LR-" + String(ULR_N3_MMR)
    + ", 3R-" + String(R_N3_MMR);
    String M4 = " 4B-" + String(B_N4_MMR) + ", 4M1-" + String(M1_N4_MMR)
    + ", 4M2-" + String(M2_N4_MMR) + ", 4M3-" + String(M3_N4_MMR) 
    + ", 4UD-" + String(UUD_N4_MMR) + ", 4LR-" + String(ULR_N4_MMR)
    + ", 4R-" + String(R_N4_MMR);
    String M5 = " 5B-" + String(B_N5_MMR) + ", 5M1-" + String(M1_N5_MMR)
    + ", 5M2-" + String(M2_N5_MMR) + ", 5M3-" + String(M3_N5_MMR) 
    + ", 5UD-" + String(UUD_N5_MMR) + ", 5LR-" + String(ULR_N5_MMR)
    + ", 5R-" + String(R_N5_MMR);
    String M6 = " 6B-" + String(B_N6_MMR) + ", 6M1-" + String(M1_N6_MMR)
    + ", 6M2-" + String(M2_N6_MMR) + ", 6M3-" + String(M3_N6_MMR) 
    + ", 6UD-" + String(UUD_N6_MMR) + ", 6LR-" + String(ULR_N6_MMR)
    + ", 6R-" + String(R_N6_MMR);
    
   ESPUI.print(text_cell, M1 + M2 + M3 + M4 + M5 + M6 );       
 }  

if (load_Memory == true) {
 // 1 мяч 
  ball_N1 = B_N1_MMR;  // число1-ых мячей
  ESPUI.updateControlValue(B_N1, String(ball_N1)); 
  Motor1_speed_N1 = M1_N1_MMR; //скорость двигателя 1 у 1-ых мячей
  ESPUI.updateControlValue(M1_N1, String(Motor1_speed_N1));
  Motor2_speed_N1 = M2_N1_MMR; //скорость двигателя 2 у 1-ых мячей
  ESPUI.updateControlValue(M2_N1, String(Motor2_speed_N1));
  Motor3_speed_N1 = M3_N1_MMR; //скорость двигателя 3 у 1-ых мячей
  ESPUI.updateControlValue(M3_N1, String(Motor3_speed_N1));
  ugol_UD_N1 = UUD_N1_MMR; // угол вылета выше-ниже у 1-ых мячей
  ESPUI.updateControlValue(UUD_N1, String(ugol_UD_N1));
  ugol_LR_N1 = ULR_N1_MMR; // угол вылета лево-право у 1-ых мячей
  ESPUI.updateControlValue(ULR_N1, String(ugol_LR_N1));
  random_N1 = R_N1_MMR; // размер случайной добавки к углу вылета лево-право у 1-ых мячей
  ESPUI.updateControlValue(R_N1, String(random_N1));
 // 2 мяч
  ball_N2 = B_N2_MMR;  // число 2-ых мячей (0 - нет)
  ESPUI.updateControlValue(B_N2, String(ball_N2));
  Motor1_speed_N2 = M1_N2_MMR; //скорость двигателя 1 у 2-ых мячей
  ESPUI.updateControlValue(M1_N2, String(Motor1_speed_N2));
  Motor2_speed_N2 = M2_N2_MMR; //скорость двигателя 2 у 2-ых мячей
  ESPUI.updateControlValue(M2_N2, String(Motor2_speed_N2));
  Motor3_speed_N2 = M3_N2_MMR; //скорость двигателя 3 у 2-ых мячей
  ESPUI.updateControlValue(M3_N2, String(Motor3_speed_N2));
  ugol_UD_N2 = UUD_N2_MMR; // угол вылета выше-ниже у 2-ых мячей
  ESPUI.updateControlValue(UUD_N2, String(ugol_UD_N2));
  ugol_LR_N2 = ULR_N2_MMR; // угол вылета лево-право у 2-ых мячей
  ESPUI.updateControlValue(ULR_N2, String(ugol_LR_N2));
  random_N2 = R_N2_MMR; // размер случайной добавки к углу вылета лево-право у 2-ых мячей
  ESPUI.updateControlValue(R_N2, String(random_N2));
 // 3 мяч
  ball_N3 = B_N3_MMR;  // число 3-ых мячей (0 - нет)
  ESPUI.updateControlValue(B_N3, String(ball_N3));
  Motor1_speed_N3 = M1_N3_MMR; //скорость двигателя 1 у 3-ых мячей
  ESPUI.updateControlValue(M1_N3, String(Motor1_speed_N3));
  Motor2_speed_N3 = M2_N3_MMR; //скорость двигателя 2 у 3-ых мячей
  ESPUI.updateControlValue(M2_N3, String(Motor2_speed_N3));
  Motor3_speed_N3 = M3_N3_MMR; //скорость двигателя 3 у 3-ых мячей
  ESPUI.updateControlValue(M3_N3, String(Motor3_speed_N3));
  ugol_UD_N3 = UUD_N3_MMR; // угол вылета выше-ниже у 3-ых мячей
  ESPUI.updateControlValue(UUD_N3, String(ugol_UD_N3));
  ugol_LR_N3 = ULR_N3_MMR; // угол вылета лево-право у 3-ых мячей
  ESPUI.updateControlValue(ULR_N3, String(ugol_LR_N3));
  random_N3 = R_N3_MMR; // размер случайной добавки к углу вылета лево-право у 3-ых мячей
  ESPUI.updateControlValue(R_N3, String(random_N3));
// 4 мяч
  ball_N4 = B_N4_MMR;  // число 4-ых мячей (0 - нет)
  ESPUI.updateControlValue(B_N4, String(ball_N4));
  Motor1_speed_N4 = M1_N4_MMR; //скорость двигателя 1 у 4-ых мячей
  ESPUI.updateControlValue(M1_N4, String(Motor1_speed_N4));
  Motor2_speed_N4 = M2_N4_MMR; //скорость двигателя 2 у 4-ых мячей
  ESPUI.updateControlValue(M2_N4, String(Motor2_speed_N4));
  Motor3_speed_N4 = M3_N4_MMR; //скорость двигателя 3 у 4-ых мячей
  ESPUI.updateControlValue(M3_N4, String(Motor3_speed_N4));
  ugol_UD_N4 = UUD_N4_MMR; // угол вылета выше-ниже у 4-ых мячей
  ESPUI.updateControlValue(UUD_N4, String(ugol_UD_N4));
  ugol_LR_N4 = ULR_N4_MMR; // угол вылета лево-право у 4-ых мячей
  ESPUI.updateControlValue(ULR_N4, String(ugol_LR_N4));
  random_N4 = R_N4_MMR; // размер случайной добавки к углу вылета лево-право у 4-ых мячей
  ESPUI.updateControlValue(R_N4, String(random_N4));
 // 5 мяч 
  ball_N5 = B_N5_MMR;  // число 5-ых мячей (0 - нет)
  ESPUI.updateControlValue(B_N5, String(ball_N5));
  Motor1_speed_N5 = M1_N5_MMR; //скорость двигателя 1 у 5-ых мячей
  ESPUI.updateControlValue(M1_N5, String(Motor1_speed_N5));
  Motor2_speed_N5 = M2_N5_MMR; //скорость двигателя 2 у 5-ых мячей
  ESPUI.updateControlValue(M2_N5, String(Motor2_speed_N5));
  Motor3_speed_N5 = M3_N5_MMR; //скорость двигателя 3 у 5-ых мячей
  ESPUI.updateControlValue(M3_N5, String(Motor3_speed_N5));
  ugol_UD_N5 = UUD_N5_MMR; // угол вылета выше-ниже у 5-ых мячей
  ESPUI.updateControlValue(UUD_N5, String(ugol_UD_N5));
  ugol_LR_N5 = ULR_N5_MMR; // угол вылета лево-право у 5-ых мячей
  ESPUI.updateControlValue(ULR_N5, String(ugol_LR_N5));
  random_N5 = R_N5_MMR; // размер случайной добавки к углу вылета лево-право у 5-ых мячей
  ESPUI.updateControlValue(R_N5, String(random_N5));
 // 6 мяч  
  ball_N6 = B_N6_MMR;  // число 6-ых мячей (0 - нет)
  ESPUI.updateControlValue(B_N6, String(ball_N6));
  Motor1_speed_N6 = M1_N6_MMR; //скорость двигателя 1 у 6-ых мячей
  ESPUI.updateControlValue(M1_N6, String(Motor1_speed_N6));
  Motor2_speed_N6 = M2_N6_MMR; //скорость двигателя 2 у 6-ых мячей
  ESPUI.updateControlValue(M2_N6, String(Motor2_speed_N6));
  Motor3_speed_N6 = M3_N6_MMR; //скорость двигателя 3 у 6-ых мячей
  ESPUI.updateControlValue(M3_N6, String(Motor3_speed_N6));
  ugol_UD_N6 = UUD_N6_MMR; // угол вылета выше-ниже у 6-ых мячей
  ESPUI.updateControlValue(UUD_N6, String(ugol_UD_N6));
  ugol_LR_N6 = ULR_N6_MMR; // угол вылета лево-право у 6-ых мячей
  ESPUI.updateControlValue(ULR_N6, String(ugol_LR_N6));
  random_N6 = R_N6_MMR; // размер случайной добавки к углу вылета лево-право у 6-ых мячей
  ESPUI.updateControlValue(R_N6, String(random_N6));
}

if (save_Memory == true) {
   // адреса в памяти с 00 по 83 по два адреса на параметр
     // 1-ые мячи
     EEPROM.write((0 + 42*(Mem_Cell -1)), ball_N1);   
     EEPROM.write((1 + 42*(Mem_Cell -1)), (Motor1_speed_N1 + 100)); 
     EEPROM.write((2 + 42*(Mem_Cell -1)), (Motor2_speed_N1 + 100));  
     EEPROM.write((3 + 42*(Mem_Cell -1)), (Motor3_speed_N1 + 100));
     EEPROM.write((4 + 42*(Mem_Cell -1)), ugol_UD_N1); 
     EEPROM.write((5 + 42*(Mem_Cell -1)), ugol_LR_N1); 
     EEPROM.write((6 + 42*(Mem_Cell -1)), random_N1);
     // 2-ые мячи
     EEPROM.write((7 + 42*(Mem_Cell -1)), ball_N2);   
     EEPROM.write((8 + 42*(Mem_Cell -1)), (Motor1_speed_N2 + 100)); 
     EEPROM.write((9 + 42*(Mem_Cell -1)), (Motor2_speed_N2 + 100));  
     EEPROM.write((10 + 42*(Mem_Cell -1)), (Motor3_speed_N2 + 100));
     EEPROM.write((11 + 42*(Mem_Cell -1)), ugol_UD_N2); 
     EEPROM.write((12 + 42*(Mem_Cell -1)), ugol_LR_N2); 
     EEPROM.write((13 + 42*(Mem_Cell -1)), random_N2);
     // 3-и мячи
     EEPROM.write((14 + 42*(Mem_Cell -1)), ball_N3);   
     EEPROM.write((15 + 42*(Mem_Cell -1)), (Motor1_speed_N3 + 100)); 
     EEPROM.write((16 + 42*(Mem_Cell -1)), (Motor2_speed_N3 + 100));  
     EEPROM.write((17 + 42*(Mem_Cell -1)), (Motor3_speed_N3 + 100));
     EEPROM.write((18 + 42*(Mem_Cell -1)), ugol_UD_N3); 
     EEPROM.write((19 + 42*(Mem_Cell -1)), ugol_LR_N3); 
     EEPROM.write((20 + 42*(Mem_Cell -1)), random_N3); 
     // 4-ые мячи
     EEPROM.write((21 + 42*(Mem_Cell -1)), ball_N4);   
     EEPROM.write((22 + 42*(Mem_Cell -1)), (Motor1_speed_N4 + 100)); 
     EEPROM.write((23 + 42*(Mem_Cell -1)), (Motor2_speed_N4 + 100));  
     EEPROM.write((24 + 42*(Mem_Cell -1)), (Motor3_speed_N4 + 100));
     EEPROM.write((25 + 42*(Mem_Cell -1)), ugol_UD_N4); 
     EEPROM.write((26 + 42*(Mem_Cell -1)), ugol_LR_N4); 
     EEPROM.write((27 + 42*(Mem_Cell -1)), random_N4);
     // 5-ые мячи
     EEPROM.write((28 + 42*(Mem_Cell -1)), ball_N5);   
     EEPROM.write((29 + 42*(Mem_Cell -1)), (Motor1_speed_N5 + 100)); 
     EEPROM.write((30 + 42*(Mem_Cell -1)), (Motor2_speed_N5 + 100));  
     EEPROM.write((31 + 42*(Mem_Cell -1)), (Motor3_speed_N5 + 100));
     EEPROM.write((32 + 42*(Mem_Cell -1)), ugol_UD_N5); 
     EEPROM.write((33 + 42*(Mem_Cell -1)), ugol_LR_N5); 
     EEPROM.write((34 + 42*(Mem_Cell -1)), random_N5);
     // 6-ые мячи
     EEPROM.write((35 + 42*(Mem_Cell -1)), ball_N6);   
     EEPROM.write((36 + 42*(Mem_Cell -1)), (Motor1_speed_N6 + 100)); 
     EEPROM.write((37 + 42*(Mem_Cell -1)), (Motor2_speed_N6 + 100));  
     EEPROM.write((38 + 42*(Mem_Cell -1)), (Motor3_speed_N6 + 100));
     EEPROM.write((39 + 42*(Mem_Cell -1)), ugol_UD_N6); 
     EEPROM.write((40 + 42*(Mem_Cell -1)), ugol_LR_N6); 
     EEPROM.write((41 + 42*(Mem_Cell -1)), random_N6);

    EEPROM.commit();     
}

  
// № программы не больше чем последний CASE (=12)
if ( N_Ppog > 12 ) {
  N_Ppog = 12;
  ESPUI.updateControlValue(PROG, String(N_Ppog));  
}
else if ( N_Ppog < 0 ) {
  N_Ppog = 0; 
  ESPUI.updateControlValue(PROG, String(N_Ppog)); 
}

// контроль параметров мячей, если значения вне диапазона
 // 1-ый мяч
 // число мячей от 1 до 20
if ( ball_N1 > 20 ) {
  ball_N1 = 20;
  ESPUI.updateControlValue(B_N1, String(ball_N1));  
}
else if ( ball_N1 < 0 ) {
  ball_N1 = 0; 
  ESPUI.updateControlValue(B_N1, String(ball_N1)); 
}
// если сумма всех мячей равна 0
if ( ball_S == 0 ) {
  ball_N1 = 1; // присваиваем число первых мячей = 1
  ESPUI.updateControlValue(B_N1, String(ball_N1));  
}
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N1 > 100 ) {
  Motor1_speed_N1 = 100;
  ESPUI.updateControlValue(M1_N1, String(Motor1_speed_N1));  
}
else if ( Motor1_speed_N1 < -80 ) {
  Motor1_speed_N1 = -80; 
  ESPUI.updateControlValue(M1_N1, String(Motor1_speed_N1)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N1 > 100 ) {
  Motor2_speed_N1 = 100;
  ESPUI.updateControlValue(M2_N1, String(Motor2_speed_N1));  
}
else if ( Motor2_speed_N1 < -80 ) {
  Motor2_speed_N1 = -80; 
  ESPUI.updateControlValue(M2_N1, String(Motor2_speed_N1)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N1 > 100 ) {
  Motor3_speed_N1 = 100;
  ESPUI.updateControlValue(M3_N1, String(Motor3_speed_N1));  
}
else if ( Motor3_speed_N1 < -80 ) {
  Motor3_speed_N1 = -80; 
  ESPUI.updateControlValue(M3_N1, String(Motor3_speed_N1)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N1 > 100 ) {
  ugol_UD_N1 = 100;
  ESPUI.updateControlValue(UUD_N1, String(ugol_UD_N1));  
}
else if ( ugol_UD_N1 < 0 ) {
  ugol_UD_N1 = 0; 
  ESPUI.updateControlValue(UUD_N1, String(ugol_UD_N1)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N1 > 100 ) {
  ugol_LR_N1 = 100;
  ESPUI.updateControlValue(ULR_N1, String(ugol_LR_N1));  
}
else if ( ugol_LR_N1 < 0 ) {
  ugol_LR_N1 = 0; 
  ESPUI.updateControlValue(ULR_N1, String(ugol_LR_N1)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N1 > 100 ) {
  random_N1 = 100;
  ESPUI.updateControlValue(R_N1, String(random_N1));  
}
else if ( random_N1 < 0 ) {
  random_N1 = 0; 
  ESPUI.updateControlValue(R_N1, String(random_N1)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N1 > 10000 ) {
  pausa_N1 = 10000;
  ESPUI.updateControlValue(P_N1, String(pausa_N1));  
}
else if ( pausa_N1 < 0 ) {
  pausa_N1 = 0; 
  ESPUI.updateControlValue(P_N1, String(pausa_N1)); 
}

 // 2-ой мяч
 // число мячей от 0 до 20
if ( ball_N2 > 20 ) {
  ball_N2 = 20;
  ESPUI.updateControlValue(B_N2, String(ball_N2));  
}
else if ( ball_N2 < 0 ) {
  ball_N2 = 0; 
  ESPUI.updateControlValue(B_N2, String(ball_N2)); 
}  
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N2 > 100 ) {
  Motor1_speed_N2 = 100;
  ESPUI.updateControlValue(M1_N2, String(Motor1_speed_N2));  
}
else if ( Motor1_speed_N2 < -80 ) {
  Motor1_speed_N2 = -80; 
  ESPUI.updateControlValue(M1_N2, String(Motor1_speed_N2)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N2 > 100 ) {
  Motor2_speed_N2 = 100;
  ESPUI.updateControlValue(M2_N2, String(Motor2_speed_N2));  
}
else if ( Motor2_speed_N2 < -80 ) {
  Motor2_speed_N2 = -80; 
  ESPUI.updateControlValue(M2_N2, String(Motor2_speed_N2)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N2 > 100 ) {
  Motor3_speed_N2 = 100;
  ESPUI.updateControlValue(M3_N2, String(Motor3_speed_N2));  
}
else if ( Motor3_speed_N2 < -80 ) {
  Motor3_speed_N2 = -80; 
  ESPUI.updateControlValue(M3_N2, String(Motor3_speed_N2)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N2 > 100 ) {
  ugol_UD_N2 = 100;
  ESPUI.updateControlValue(UUD_N2, String(ugol_UD_N2));  
}
else if ( ugol_UD_N2 < 0 ) {
  ugol_UD_N2 = 0; 
  ESPUI.updateControlValue(UUD_N2, String(ugol_UD_N2)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N2 > 100 ) {
  ugol_LR_N2 = 100;
  ESPUI.updateControlValue(ULR_N2, String(ugol_LR_N2));  
}
else if ( ugol_LR_N2 < 0 ) {
  ugol_LR_N2 = 0; 
  ESPUI.updateControlValue(ULR_N2, String(ugol_LR_N2)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N2 > 100 ) {
  random_N2 = 100;
  ESPUI.updateControlValue(R_N2, String(random_N2));  
}
else if ( random_N2 < 0 ) {
  random_N2 = 0; 
  ESPUI.updateControlValue(R_N2, String(random_N2)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N2 > 10000 ) {
  pausa_N2 = 10000;
  ESPUI.updateControlValue(P_N2, String(pausa_N2));  
}
else if ( pausa_N2 < 0 ) {
  pausa_N2 = 0; 
  ESPUI.updateControlValue(P_N2, String(pausa_N2)); 
}



 // 3-ий мяч
 // число мячей от 0 до 20
if ( ball_N3 > 20 ) {
  ball_N3 = 20;
  ESPUI.updateControlValue(B_N3, String(ball_N3));  
}
else if ( ball_N3 < 0 ) {
  ball_N3 = 0; 
  ESPUI.updateControlValue(B_N3, String(ball_N3)); 
} 
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N3 > 100 ) {
  Motor1_speed_N3 = 100;
  ESPUI.updateControlValue(M1_N3, String(Motor1_speed_N3));  
}
else if ( Motor1_speed_N3 < -80 ) {
  Motor1_speed_N3 = -80; 
  ESPUI.updateControlValue(M1_N3, String(Motor1_speed_N3)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N3 > 100 ) {
  Motor2_speed_N3 = 100;
  ESPUI.updateControlValue(M2_N3, String(Motor2_speed_N3));  
}
else if ( Motor2_speed_N3 < -80 ) {
  Motor2_speed_N3 = -80; 
  ESPUI.updateControlValue(M2_N3, String(Motor2_speed_N3)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N3 > 100 ) {
  Motor3_speed_N3 = 100;
  ESPUI.updateControlValue(M3_N3, String(Motor3_speed_N3));  
}
else if ( Motor3_speed_N3 < -80 ) {
  Motor3_speed_N3 = -80; 
  ESPUI.updateControlValue(M3_N3, String(Motor3_speed_N3)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N3 > 100 ) {
  ugol_UD_N3 = 100;
  ESPUI.updateControlValue(UUD_N3, String(ugol_UD_N3));  
}
else if ( ugol_UD_N3 < 0 ) {
  ugol_UD_N3 = 0; 
  ESPUI.updateControlValue(UUD_N3, String(ugol_UD_N3)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N3 > 100 ) {
  ugol_LR_N3 = 100;
  ESPUI.updateControlValue(ULR_N3, String(ugol_LR_N3));  
}
else if ( ugol_LR_N3 < 0 ) {
  ugol_LR_N3 = 0; 
  ESPUI.updateControlValue(ULR_N3, String(ugol_LR_N3)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N3 > 100 ) {
  random_N3 = 100;
  ESPUI.updateControlValue(R_N3, String(random_N3));  
}
else if ( random_N3 < 0 ) {
  random_N3 = 0; 
  ESPUI.updateControlValue(R_N3, String(random_N3)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N3 > 10000 ) {
  pausa_N3 = 10000;
  ESPUI.updateControlValue(P_N3, String(pausa_N3));  
}
else if ( pausa_N3 < 0 ) {
  pausa_N3 = 0; 
  ESPUI.updateControlValue(P_N3, String(pausa_N3)); 
}



 // 4-ый мяч
 // число мячей от 0 до 20
if ( ball_N4 > 20 ) {
  ball_N4 = 20;
  ESPUI.updateControlValue(B_N4, String(ball_N4));  
}
else if ( ball_N4 < 0 ) {
  ball_N4 = 0; 
  ESPUI.updateControlValue(B_N4, String(ball_N4)); 
}
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N4 > 100 ) {
  Motor1_speed_N4 = 100;
  ESPUI.updateControlValue(M1_N4, String(Motor1_speed_N4));  
}
else if ( Motor1_speed_N4 < -80 ) {
  Motor1_speed_N4 = -80; 
  ESPUI.updateControlValue(M1_N4, String(Motor1_speed_N4)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N4 > 100 ) {
  Motor2_speed_N4 = 100;
  ESPUI.updateControlValue(M2_N4, String(Motor2_speed_N4));  
}
else if ( Motor2_speed_N4 < -80 ) {
  Motor2_speed_N4 = -80; 
  ESPUI.updateControlValue(M2_N4, String(Motor2_speed_N4)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N4 > 100 ) {
  Motor3_speed_N4 = 100;
  ESPUI.updateControlValue(M3_N4, String(Motor3_speed_N4));  
}
else if ( Motor3_speed_N4 < -80 ) {
  Motor3_speed_N4 = -80; 
  ESPUI.updateControlValue(M3_N4, String(Motor3_speed_N4)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N4 > 100 ) {
  ugol_UD_N4 = 100;
  ESPUI.updateControlValue(UUD_N4, String(ugol_UD_N4));  
}
else if ( ugol_UD_N4 < 0 ) {
  ugol_UD_N4 = 0; 
  ESPUI.updateControlValue(UUD_N4, String(ugol_UD_N4)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N4 > 100 ) {
  ugol_LR_N4 = 100;
  ESPUI.updateControlValue(ULR_N4, String(ugol_LR_N4));  
}
else if ( ugol_LR_N4 < 0 ) {
  ugol_LR_N4 = 0; 
  ESPUI.updateControlValue(ULR_N4, String(ugol_LR_N4)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N4 > 100 ) {
  random_N4 = 100;
  ESPUI.updateControlValue(R_N4, String(random_N4));  
}
else if ( random_N4 < 0 ) {
  random_N4 = 0; 
  ESPUI.updateControlValue(R_N4, String(random_N4)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N4 > 10000 ) {
  pausa_N4 = 10000;
  ESPUI.updateControlValue(P_N4, String(pausa_N4));  
}
else if ( pausa_N4 < 0 ) {
  pausa_N4 = 0; 
  ESPUI.updateControlValue(P_N4, String(pausa_N4)); 
}

 
 // 5-ый мяч
 // число мячей от 0 до 20
if ( ball_N5 > 20 ) {
  ball_N5 = 20;
  ESPUI.updateControlValue(B_N5, String(ball_N5));  
}
else if ( ball_N5 < 0 ) {
  ball_N5 = 0; 
  ESPUI.updateControlValue(B_N5, String(ball_N5)); 
} 
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N5 > 100 ) {
  Motor1_speed_N5 = 100;
  ESPUI.updateControlValue(M1_N5, String(Motor1_speed_N5));  
}
else if ( Motor1_speed_N5 < -80 ) {
  Motor1_speed_N5 = -80; 
  ESPUI.updateControlValue(M1_N5, String(Motor1_speed_N5)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N5 > 100 ) {
  Motor2_speed_N5 = 100;
  ESPUI.updateControlValue(M2_N5, String(Motor2_speed_N5));  
}
else if ( Motor2_speed_N5 < -80 ) {
  Motor2_speed_N5 = -80; 
  ESPUI.updateControlValue(M2_N5, String(Motor2_speed_N5)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N5 > 100 ) {
  Motor3_speed_N5 = 100;
  ESPUI.updateControlValue(M3_N5, String(Motor3_speed_N5));  
}
else if ( Motor3_speed_N5 < -80 ) {
  Motor3_speed_N5 = -80; 
  ESPUI.updateControlValue(M3_N5, String(Motor3_speed_N5)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N5 > 100 ) {
  ugol_UD_N5 = 100;
  ESPUI.updateControlValue(UUD_N5, String(ugol_UD_N5));  
}
else if ( ugol_UD_N5 < 0 ) {
  ugol_UD_N5 = 0; 
  ESPUI.updateControlValue(UUD_N5, String(ugol_UD_N5)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N5 > 100 ) {
  ugol_LR_N5 = 100;
  ESPUI.updateControlValue(ULR_N5, String(ugol_LR_N5));  
}
else if ( ugol_LR_N5 < 0 ) {
  ugol_LR_N5 = 0; 
  ESPUI.updateControlValue(ULR_N5, String(ugol_LR_N5)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N5 > 100 ) {
  random_N5 = 100;
  ESPUI.updateControlValue(R_N5, String(random_N5));  
}
else if ( random_N5 < 0 ) {
  random_N5 = 0; 
  ESPUI.updateControlValue(R_N5, String(random_N5)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N5 > 10000 ) {
  pausa_N5 = 10000;
  ESPUI.updateControlValue(P_N5, String(pausa_N5));  
}
else if ( pausa_N5 < 0 ) {
  pausa_N5 = 0; 
  ESPUI.updateControlValue(P_N5, String(pausa_N5)); 
}


 // 6-ой мяч
 // число мячей от 0 до 20
if ( ball_N6 > 20 ) {
  ball_N6 = 20;
  ESPUI.updateControlValue(B_N6, String(ball_N6));  
}
else if ( ball_N6 < 0 ) {
  ball_N6 = 0; 
  ESPUI.updateControlValue(B_N6, String(ball_N6)); 
} 
 // мотор 1 скорость от -80 до 100
if ( Motor1_speed_N6 > 100 ) {
  Motor1_speed_N6 = 100;
  ESPUI.updateControlValue(M1_N6, String(Motor1_speed_N6));  
}
else if ( Motor1_speed_N6 < -80 ) {
  Motor1_speed_N6 = -80; 
  ESPUI.updateControlValue(M1_N6, String(Motor1_speed_N6)); 
}
 // мотор 2 скорость от -80 до 100
if ( Motor2_speed_N6 > 100 ) {
  Motor2_speed_N6 = 100;
  ESPUI.updateControlValue(M2_N6, String(Motor2_speed_N6));  
}
else if ( Motor2_speed_N6 < -80 ) {
  Motor2_speed_N6 = -80; 
  ESPUI.updateControlValue(M2_N6, String(Motor2_speed_N6)); 
}
 // мотор 3 скорость от -80 до 100
if ( Motor3_speed_N6 > 100 ) {
  Motor3_speed_N6 = 100;
  ESPUI.updateControlValue(M3_N6, String(Motor3_speed_N6));  
}
else if ( Motor3_speed_N6 < -80 ) {
  Motor3_speed_N6 = -80; 
  ESPUI.updateControlValue(M3_N6, String(Motor3_speed_N6)); 
}
 // угол выше-ниже от 0 до 100
if ( ugol_UD_N6 > 100 ) {
  ugol_UD_N6 = 100;
  ESPUI.updateControlValue(UUD_N6, String(ugol_UD_N6));  
}
else if ( ugol_UD_N6 < 0 ) {
  ugol_UD_N6 = 0; 
  ESPUI.updateControlValue(UUD_N6, String(ugol_UD_N6)); 
}
 // угол лево-право от 0 до 100
if ( ugol_LR_N6 > 100 ) {
  ugol_LR_N6 = 100;
  ESPUI.updateControlValue(ULR_N6, String(ugol_LR_N6));  
}
else if ( ugol_LR_N6 < 0 ) {
  ugol_LR_N6 = 0; 
  ESPUI.updateControlValue(ULR_N6, String(ugol_LR_N6)); 
}
 // добавка рандом к углу лево-право от 0 до 100
if ( random_N6 > 100 ) {
  random_N6 = 100;
  ESPUI.updateControlValue(R_N6, String(random_N6));  
}
else if ( random_N6 < 0 ) {
  random_N6 = 0; 
  ESPUI.updateControlValue(R_N6, String(random_N6)); 
}
 // задержка после вылета мяча от 0 до 10000 милли сек
if ( pausa_N6 > 10000 ) {
  pausa_N6 = 10000;
  ESPUI.updateControlValue(P_N6, String(pausa_N6));  
}
else if ( pausa_N6 < 0 ) {
  pausa_N6 = 0; 
  ESPUI.updateControlValue(P_N6, String(pausa_N6)); 
}


 // контроль ячейки памяти от 1 до 5
if ( Mem_Cell > 5 ) {
  Mem_Cell = 5;
  ESPUI.updateControlValue(MEMORY_C, String(Mem_Cell));  
}
else if ( Mem_Cell < 1 ) {
  Mem_Cell = 1; 
  ESPUI.updateControlValue(MEMORY_C, String(Mem_Cell)); 
}


  ball_S = ball_N1 + ball_N2 + ball_N3 + ball_N4 + ball_N5 + ball_N6; //суммарное заданное число мячей

   // считаем число пролетевших мячей по ИК диоду
 //когда мяч перекрывает ИК диод - digitalRead(ledPri) = LOW
if (digitalRead(ledPri) == LOW) { 
  trg1 = false;
  } 
if ((digitalRead(ledPri) == HIGH) && (trg1 == false) && (Flag_balls_Schetchik == false)) 
  {
  trg1 = true; nBall = nBall + 1; sBall = sBall + 1; 
  random_Flag = true; // взводим флаг для задания случайной добавки к углу вылета лево-право
  Flag_balls_change = true; // взводим флаг смены мяча для паузы
  time_Schetchik = millis(); // фиксируем время срабатывания датчика пролета мяча
  Flag_balls_Schetchik = true; // взводим флаг для паузы счетчика мячей 
  }
if ((Flag_balls_Schetchik == true) && ((millis() - time_Schetchik) > 400))  // если прошло 400 мсек
  {
  Flag_balls_Schetchik = false; // сбрасываем флаг для паузы счетчика мячей
  }
 
 // обнуляем счетчики мячей при старте
if (pusk == false) {
    trg2 = false;
  } 
if ((pusk == true) && (trg2 == false)) {
  trg2 = true; nBall = 0; sBall = 0; 
  Pausa_Flag = false; // и флаг паузы сбрасываем
 }  

 // присваиваем задание скорости двигателей и углов в зависимости от счетчика числа мячей
  // для 1-ых мячей
  if (sBall < ball_N1){
    Motor1_speed = Motor1_speed_N1; Motor2_speed = Motor2_speed_N1; Motor3_speed = Motor3_speed_N1; 
    ugol_UD = ugol_UD_N1; ugol_LR = ugol_LR_N1; random_Ugol = random_N1; pausa_PRM = pausa_N1;
    } 
  // для 2-ых мячей  
  if ((sBall >= ball_N1) && (sBall < (ball_N1 + ball_N2))) {
    Motor1_speed = Motor1_speed_N2; Motor2_speed = Motor2_speed_N2; Motor3_speed = Motor3_speed_N2; 
    ugol_UD = ugol_UD_N2; ugol_LR = ugol_LR_N2; random_Ugol = random_N2; pausa_PRM = pausa_N2;
    }
  // для 3-ых мячей  
  if ((sBall >= (ball_N1 + ball_N2)) && (sBall < (ball_N1 + ball_N2 +ball_N3))) {
    Motor1_speed = Motor1_speed_N3; Motor2_speed = Motor2_speed_N3; Motor3_speed = Motor3_speed_N3; 
    ugol_UD = ugol_UD_N3; ugol_LR = ugol_LR_N3; random_Ugol = random_N3; pausa_PRM = pausa_N3;
    }
  // для 4-ых мячей  
  if ((sBall >= (ball_N1+ball_N2+ball_N3)) && (sBall < (ball_N1+ball_N2+ball_N3+ball_N4))) {
    Motor1_speed = Motor1_speed_N4; Motor2_speed = Motor2_speed_N4; Motor3_speed = Motor3_speed_N4; 
    ugol_UD = ugol_UD_N4; ugol_LR = ugol_LR_N4; random_Ugol = random_N4; pausa_PRM = pausa_N4;
    }
  // для 5-ых мячей  
  if ((sBall >= (ball_N1+ball_N2+ball_N3+ball_N4)) && (sBall < (ball_N1+ball_N2+ball_N3+ball_N4+ball_N5))) {
    Motor1_speed = Motor1_speed_N5; Motor2_speed = Motor2_speed_N5; Motor3_speed = Motor3_speed_N5; 
    ugol_UD = ugol_UD_N5; ugol_LR = ugol_LR_N5; random_Ugol = random_N5; pausa_PRM = pausa_N5;
    } 
  // для 6-ых мячей  
  if ((sBall >= (ball_N1+ball_N2+ball_N3+ball_N4+ball_N5)) && (sBall < ball_S)) {
    Motor1_speed = Motor1_speed_N6; Motor2_speed = Motor2_speed_N6; Motor3_speed = Motor3_speed_N6; 
    ugol_UD = ugol_UD_N6; ugol_LR = ugol_LR_N6; random_Ugol = random_N6; pausa_PRM = pausa_N6;
    }       
    
  // если все заданные мячи пролетели,   
  if (sBall == ball_S){
    sBall = 0;           //  то обнуляем счетчик мячей 
    }

 // от N_Ppog ("PROGRAMM") управляем двигателями и сервоприводами
 switch (N_Ppog) {

   // 0-ая программа, здесь только то что задали с Веб страницы, по кругу 
   case  0:   
          SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
          UGL_UD = ugol_UD; UGL_LR = ugol_LR; UGL_random = random_Ugol; 
       break; 
       
  // с 1-ой по 5-ую, параметры мячей заданы, с Веб страницы игнорируются
  // выбираем программу, нажимаем пуск и все 
  // это потом 
  // с 1-ой по 5-ую, повороты лево-право прописаны, остальное Веб страницы 
   case  1: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =   0; } // 1-ый мяч влево  
            if (nBall == 1) {UGL_LR = 100; } // 2-ой мяч вправо
            if (nBall >= 2) {nBall = 0;}     // далее по кругу   
       break;
   case  2: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  10; } // 1-ый мяч влево  
            if (nBall == 1) {UGL_LR =  90; } // 2-ой мяч вправо
            if (nBall >= 2) {nBall = 0;}     // далее по кругу 
       break;
   case  3:             
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  20; } // 1-ый мяч влево  
            if (nBall == 1) {UGL_LR =  80; } // 2-ой мяч вправо
            if (nBall >= 2) {nBall = 0;}     // далее по кругу 
       break;
   case  4: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  30; } // 1-ый мяч влево  
            if (nBall == 1) {UGL_LR =  70; } // 2-ой мяч вправо
            if (nBall >= 2) {nBall = 0;}     // далее по кругу  
       break;
   case  5: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR = 100; } // 1-ый мяч вправо  
            if (nBall == 1) {UGL_LR =   0; } // 2-ой мяч влево
            if (nBall >= 2) {nBall = 0;}     // далее по кругу  
       break;

   // с 6-ой по 12-ую, повороты лево-право прописаны, остальное Веб страницы    
   case  6: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  90; } // 1-ый мяч вправо  
            if (nBall == 1) {UGL_LR =  10; } // 2-ой мяч влево
            if (nBall >= 2) {nBall = 0;}     // далее по кругу 
       break;
   case  7: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  80; } // 1-ый мяч вправо  
            if (nBall == 1) {UGL_LR =  20; } // 2-ой мяч влево
            if (nBall >= 2) {nBall = 0;}     // далее по кругу 
       break;
   case  8:             
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  70; } // 1-ый мяч вправо  
            if (nBall == 1) {UGL_LR =  30; } // 2-ой мяч влево
            if (nBall >= 2) {nBall = 0;}     // далее по кругу 
       break;
   case  9: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR = 100; } // 1-ый мяч вправо  
            if (nBall == 1) {UGL_LR =  50; } // 2-ой мяч середина
            if (nBall >= 2) {nBall = 0;}     // далее по кругу
       break;
   case  10: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =   0; } // 1-ый мяч влево  
            if (nBall == 1) {UGL_LR =  50; } // 2-ой мяч середина
            if (nBall >= 2) {nBall = 0;}     // далее по кругу
       break;
   case  11: 
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  20; }       // 1-ый мяч влево
            if (nBall == 1) {UGL_LR =  20; }       // 2-ой мяч влево
            if (nBall == 2) {UGL_LR =  80; }       // 3-ий мяч вправо
            if (nBall >= 3) {nBall = 0;}           // далее по кругу
       break;
   case  12:             
            SPD_M1 = Motor1_speed; SPD_M2 = Motor2_speed; SPD_M3 = Motor3_speed; 
            UGL_UD = ugol_UD; UGL_random = random_Ugol;
            if (nBall == 0) {UGL_LR =  80; }       // 1-ый мяч вправо
            if (nBall == 1) {UGL_LR =  80; }       // 2-ой мяч вправо
            if (nBall == 2) {UGL_LR =  20; }       // 3-ий мяч влево
            if (nBall >= 3) {nBall = 0;}           // далее по кругу
       break;                        
}

// добавляем к углу поворота лево-право случайную добавку
// к левому углу прибавляем, от правого отнимаем
if (random_Flag == true) {
  UGL_random_R = random(0, UGL_random);
  random_Flag = false;
}
if (UGL_LR < 50) {
  UGL_LR = UGL_LR + UGL_random_R;
  // проверяем выход за диапазон
  if (UGL_LR > 100) {
    UGL_LR = 100;
  }
 }
 else {
  UGL_LR = UGL_LR - UGL_random_R;
  // проверяем выход за диапазон
  if (UGL_LR < 0) {
    UGL_LR = 0;
  }  
 }
// маштабируем команду на серво лево-право, с Веб страницы получаем 0-100
// 0 - лево, 50 - середина, 100 - право
// для моего ствола 10 - лево, 80 - середина, 170 - право
// и посылаем команду на серво
Servo_1.write(map(UGL_LR, 0, 100, 10, 170));

// маштабируем команду на серво выше-ниже, с Веб страницы получаем 0-100
// 0 - верх, 100 - низ
// для моего ствола 0 - верх, 180 - низ
// и посылаем команду на серво
Servo_2.write(map(UGL_UD, 0, 100, 5, 175));

int BallS_Speed_Pausa; // объявляем переменную для скорости мячей с паузой
if (pausa_PRM > 0)  // если есть пауза
  {
    BallS_Speed_Pausa = BallS_Speed - pausa_PRM/15; // уменьшаем пропорционально скорость
  }
else {
  BallS_Speed_Pausa = BallS_Speed;  // иначе скорость не меняем
}

if (BallS_Speed_Pausa < 1) // если скорость уменьшилась до останова
  {
    BallS_Speed_Pausa = BallS_Speed; // скорость не меняем
    if (Flag_balls_change == true) //// если есть смена мяча
    {
    Pausa_Flag = true; // будем останов делать на время паузы
    }
  }
  
int zadanie_speed_Balls; 
if (BallS_Speed_Pausa > 0)
  {
    zadanie_speed_Balls = 1121 + BallS_Speed_Pausa; 
  }
    else { 
     zadanie_speed_Balls = 1080;
    } 

int zadanie_speed_1;
if (SPD_M1 > 0) {
  zadanie_speed_1 = 1507 + SPD_M1 * 4;
}
else if (SPD_M1 < 0) {
  zadanie_speed_1 = 1442 + SPD_M1 * 4;
}
else {
  zadanie_speed_1 = 1480;
}
int zadanie_speed_2;
if (SPD_M2 > 0) {
  zadanie_speed_2 = 1507 + SPD_M2 * 4;
}
else if (SPD_M2 < 0) {
  zadanie_speed_2 = 1442 + SPD_M2 * 4;
}
else {
  zadanie_speed_2 = 1480;
}
int zadanie_speed_3;
if (SPD_M3 > 0) {
  zadanie_speed_3 = 1507 + SPD_M3 * 4;
}
else if (SPD_M3 < 0) {
  zadanie_speed_3 = 1442 + SPD_M3 * 4;
}
else {
  zadanie_speed_3 = 1480;
}


// посылаем команду на ESC если pusk = true
 if (pusk == true){
  Motor_1.writeMicroseconds(zadanie_speed_1);
  Motor_2.writeMicroseconds(zadanie_speed_2);
  Motor_3.writeMicroseconds(zadanie_speed_3);

  if (Pausa_Flag == true)  // если есть останов на время паузы
  {
    if (Pausa_Flag_N == false) {
      time_Pausa = millis(); // фиксируем время останова
      Pausa_Flag_N = true;  // взводим промежуточный флаг
      }
    if ((millis() - time_Pausa) > pausa_PRM) { // если прошло время паузы
      Pausa_Flag = false;   // сбрасываем флаг паузы
      Pausa_Flag_N = false; // сбрасываем промежуточный флаг
      Flag_balls_change = false; // сбрасываем флаг смены мяча для паузы
    }
  } 
  if (Pausa_Flag == true) {
    Motor_BallS.writeMicroseconds(1080);
  }
  else {
    Motor_BallS.writeMicroseconds(zadanie_speed_Balls);
  }
  }
  if ((pusk == true)  &&  (STOP_Mehsalka == false)){
     ledcWrite(15, 160);
    }
  else {
    ledcWrite(15, 0);
     }  

// посылаем стоп на ESC если pusk = false
 if (pusk == false){
  Motor_1.writeMicroseconds(1480); // скорость ESC - 0
  Motor_2.writeMicroseconds(1480); // скорость ESC - 0
  Motor_3.writeMicroseconds(1480); // скорость ESC - 0
  Motor_BallS.writeMicroseconds(1080); // этот без реверса
  ledcWrite(15, 0);
 }
}
11

Me pregunto para que meterse con algo tan complejo si no sabes nada de arduino?

Traduce todo el ruso al español y al menos yo te responderé.

13

Amigo, te resolví el problema de Serial.println (en realidad fue @anon90500195 pero yo te puse el código listo para que pudieras correrlo) no me digas que no te di solución.

Lo que te dije es cierto, el proyecto es complejo. Y sabes poco de arduino. Eso es obvio, si no ves un //Serial.print como responsable del problema entones?
No lo digo para burlarme, lo digo porque el programa es complicado.

Pero luego pides que interpretemos un código de 1000 lineas lleno de comentarios en ruso.
Tomate el trabajo de traducirlo y si no bueno. No se. Yo no lo haré pero hay mucha gente en el foro.

15

Buenas !!

A ver si alguien puede ayudarme , tengo una problema y es que , no consigo que me acabe de reconocer desde el id 1 , hasta el id 7 , se compila correctamente , sale todo en la pagina web . Pero en el monitor serial , no me encuentra (**) el llamamiento a la función .

(**)
15:58:39.433 -> WS rec: tabvalue:undefined:2
15:58:39.433 -> WS recognised ID: 2
15:58:39.433 -> No callback found for ID 2

Os dejo un ejemplo del texto para que podais interpretar donde podria estar el error. Muchas gracias !


dnsServer.start(DNS_PORT, "*", apIP); 
  // aquí están los bloques ESPUI que forman la página web
  // Aquí están las pestañas de las bolas 1 - 6
  uint16_t tab1 = ESPUI.addControl( ControlType::Tab, "BALL 1", "BALL 1" ); // id 01
  uint16_t tab2 = ESPUI.addControl( ControlType::Tab, "BALL 2", "BALL 2" ); // id 02
  uint16_t tab3 = ESPUI.addControl( ControlType::Tab, "BALL 3", "BALL 3" ); // id 03
  uint16_t tab4 = ESPUI.addControl( ControlType::Tab, "BALL 4", "BALL 4" ); // id 04
  uint16_t tab5 = ESPUI.addControl( ControlType::Tab, "BALL 5", "BALL 5" ); // id 05
  uint16_t tab6 = ESPUI.addControl( ControlType::Tab, "BALL 6", "BALL 6" ); // id 06
  uint16_t tab7 = ESPUI.addControl( ControlType::Tab, "MEMORY", "MEMORY" ); // id 07
  // bloques ESPUI comunes
  PROG = ESPUI.addControl( ControlType::Number, "PROGRAMM", "0", ControlColor::Peterriver, Control::noParent, &numberCall ); // id 08
  ESPUI.switcher("PUSK", &switchExample, ControlColor::None, false); // id 09
  ESPUI.slider("BALLS SPEED", &slider, ControlColor::Emerald, 20); // id 10
  // aquí está la pestaña de BALL 1 
  B_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 :", "1", ControlColor::Peterriver, tab1, &numberCall ); // id 12
  M1_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 1 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 13
  M2_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 2 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 14
  M3_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 MOTOR 3 SPEED", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 15
  UUD_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 SERVO UP-DOWN", "50", ControlColor::Peterriver, tab1, &numberCall ); // id 16
  ULR_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 SERVO LEFT-RIGHT", "50", ControlColor::Peterriver, tab1, &numberCall ); // id 17
  R_N1 = ESPUI.addControl( ControlType::Number, "BALL 1 RANDOM LEFT-RIGHT", "0", ControlColor::Peterriver, tab1, &numberCall ); // id 18
  // aquí está la pestaña de BALL 2 
  B_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 :", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 19
  M1_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 1 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 20
  M2_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 2 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 21
  M3_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 MOTOR 3 SPEED", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 22
  UUD_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 SERVO UP-DOWN", "50", ControlColor::Turquoise, tab2, &numberCall ); // id 23
  ULR_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 SERVO LEFT-RIGHT", "50", ControlColor::Turquoise, tab2, &numberCall ); // id 24
  R_N2 = ESPUI.addControl( ControlType::Number, "BALL 2 RANDOM LEFT-RIGHT", "0", ControlColor::Turquoise, tab2, &numberCall ); // id 25
16

Su publicacion se MUEVE a su ubicacion actual ya que es mas adecuada.

17

Ya te dije en el otro tema que el código se adjunta según Normas del foro, punto 7.
¿Puedes editar tu post y hacerlo correctamente?

18

Moderador:
Por favor, lee las Normas del foro
Si posteas en el foro en inglés usa idioma inglés para expresarte.
Si escribes en español debes usar el foro Arduino en español.
Ademas un doble posteo porque hay un hilo activo en el foro en español.
Estas sancionado con un 1 de baneo por posteo cruzado.

19

enviame tu correo, yo hice mi version del robot

20

@borisgraell El foro es público, por lo tanto también lo son las consultas y las respuestas.
Si quieres colaborar, ¿qué mejor que publicar tu código aquí así sirve de ayuda a otros interesados?

21

EDITADO@gmail.com @borisgraell

Moderador: no se pertimen correos personales en el foro público.
Por privado informa lo que desees.
Lee las normas.

22

Hola buenas. Pudiste realizar el robot? me gustaría hacerlo. tenés la lista de materiales? gracias

23

Hey, could you share it here if possible? if not here is my email- xxxxxxxx@gmail.com Please guide us it will help immensely.

Thanks & Regards

Moderador:
Dos cosas:

  1. No se permite inglés en este foro. traduce por favor.
  2. No se permiten email en el foro. Usa el canal privado. Si así lo deseas.
24

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.