/*
=================Переменные
static int a          статическая переменная. видна только внутри функции, но не уничтожается при перезапуске
volatile int b = 10;  для прерываний. хранится в ОЗУ, а не регистре
const float pi = 3.14;

byte         0..255
int          -32768..32767
word         0..65635
long         -2147483648..2147483647
float        -3.4028235E+38..3.4028235E+38
char         -128..127 (AVR), 0.. 255 (esp)     Символ (код символа) из таблицы ASCII
String       строка
bool         0 1 true false
void         пустой тип для функции не возвращающей значения

UINT8_MAX – 255                           1 байт = 8 бит = 256
INT8_MAX – 127                            1 байт = 8 бит = 256
UINT16_MAX – 65 535                       2 байта = 16 бит = 65 536
INT16_MAX – 32 767                        2 байта = 16 бит = 65 536
UINT32_MAX– 4 294 967 295                 4 байта = 32 бита = 4 294 967 296
INT32_MAX – 2 147 483 647                 4 байта = 32 бита = 4 294 967 296
UINT64_MAX – 18 446 744 073 709 551 615   8 байт = 64 бита
INT64_MAX – 9 223 372 036 854 775 807     8 байт = 64 бита 

преобразование типов
byte val = 10;
// byte передаём функции, ожидающей int
sendVal((int)val);

=====================массивы
int pins[5];
int num[]={1,2,3,4,5};
int message[]="how are you";

=====================УСЛОВИЯ
if(x==10 && y<=10){y++}else{y--}

switch(val)
  {
    case 5:
      x+=10;
      break;
    default:
      x+=1;
    break;
  }

=====================ЦИКЛЫ
for(int i=0; i<10 ; i++)
{
  x++;
  ...
}

while(x<10){y++}

do{y++}while(x)

=====================ФУНКЦИИ
  Функция, которая ничего не принимает и ничего не возвращает
byte a, b;
int c;
void setup() {
  a = 10; b = 20;
  sumFunction();}
void sumFunction() {
  c = a + b;}

  Функция, которая ничего не принимает и возвращает результат
byte a, b;
int c;
void setup() {
  a = 10; b = 20;
  c = sumFunction();}
int sumFunction() {
  return (a + b);}

  Функция, которая принимает аргументы и возвращает результат
byte a, b;
int c;
void setup() {
  a = 10; b = 20;
  c = sumFunction(a, b);}
int sumFunction(byte paramA, byte paramB) {
  return (paramA + paramB);}

  Функция, которая меняет значение переменных(указатели)
void setup() {
  int a = 10;
  incr(a);}
void incr(int& var) {
  var += 10;}

  Функция, которая принимает два числа, склеивает их в строку через запятую и возвращает
String toStr(int val1, float val2) {
  return (String)val1 + ", " + val2;}
При вызове Serial.println(toStr(10, 3.14)) увидим в мониторе порта 10, 3.14

  Передача массива в функцию (Pro)
int c;
int myArray[] = {100, 30, 890, 645, 251, 645, 821, 325};
void setup() {
  // передаём сам массив и его размер в БАЙТАХ
  c = sumFunction(myArray, sizeof(myArray));}
int sumFunction(int *intArray, int arrSize) {
  int sum = 0;  // переменная для суммирования
  arrSize = arrSize / sizeof(int);  // находим размер массива, разделив его вес одного элемента
  for (byte i = 0; i < arrSize; i++) {
    sum += intArray[i]; }
  return sum;}

  Макро-функции
#define sum(x, y) ((x)+(y))
void setup() {
  byte a = 10;  byte b = 20;
  byte c = sum(a, b);
  int d = sum(500, 900);}
Ещё можно “переносить строку” для более комфортного создания макро-функций, перенос делается при помощи обратного слэша – \
#define printWords()        \
  Serial.print("Hello, ");  \
  Serial.print("World");    \
  Serial.println("!");
void setup() {
  Serial.begin(9600);
  printWords();
}

  Функция, которая принимает любое кол-во аргументов (Pro) !!!!! не пепегруженная фуекция
void func(int num, ...) {
  va_list valist;                      // создание
  va_start(valist, num);               // инициализация
  for (int i = 0; i < num; i++) {
    Serial.print(va_arg(valist, int)); // доступ
    Serial.print(','); }
  va_end(valist);                      // очистка
  Serial.println();}


===================ОПЕРАТОРЫ
min(x,y)          возвращает меньшее из
max(x,y)          
abs(x)            модуль х
constrain(x,a,b)  ограничиваеи х от а до b
map(x,a,b,na,nb)  транспонирование из диапазона а-б в na-nb
sq(x)             x^2
sqrt(x)           корень
pow(x,y)          х в степени у

====================GPIO
void setup()
{
  pinMode(pin,mode);

  value=digitalRead(pin);
  digitalWrite(pin,value);

  value=analogRead(pin); 0..1023
  analogWrite(pin,value); 0..255 + ШИМ на цифровую ногу
}

====================Serial
Serial.begin(speed)
Serial.end()
Serial.available() Возвращает количество байт, находящихся в буфере приёма и доступных для чтения.
Serial.availableForWrite() Возвращает количество байт, которые можно записать в буфер последовательного порта, не блокируя при этом функцию записи.
Serial.write(val), Serial.write(buf, len) Отправляет данные как байт (см. таблицу ASCII), то есть отправив 88 вы получите букву X
Serial.print(val), Serial.print(val, format) BIN/OCT/DEC/HEX //Serial.print(1.23456, 2); // вывод "1.23"
Serial.flush() Ожидает окончания передачи данных.
Serial.peek() Возвращает текущий байт с края буфера, не убирая его из буфера. При вызове Serial.read() будет считан тот же байт, но из буфера уже уберётся.
Serial.read() Читает и возвращает крайний символ из буфера.
Serial.setTimeout(time) Устанавливает time (миллисекунды) таймаут ожидания приёма данных для следующих ниже функций. По умолчанию равен 1000 мс (1 секунда).
Serial.find(target), Serial.find(target, length) Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту.
Serial.findUntil(target, terminal) Читает данные из буфера и ищет набор символов target (тип char) либо терминальную строку terminal. Ожидает окончания передачи по таймауту, либо завершает приём после чтения terminal.
Serial.readBytes(buffer, length)
Serial.readBytesUntil(character, buffer, length)
Serial.readString()
Serial.readStringUntil(terminator)
Serial.parseInt(), Serial.parseInt(skipChar)
Serial.parseFloat()


void yield() {это делается в паузах delay}

unsigned long currentTime;         // Переменная текущего времени
if (millis() - currentTime > 1000) // Если время контроллера millis, больше переменной на 1000, то запускаем условие if
  { 
    currentTime = millis();        // Приравниваем переменную текущего времени к времени контроллера, чтобы через 1000мс опять сработал наш цикл.
                                   //здесь любое действие.
  }

*/



void setup() {
  Serial.begin(9600);
  //Serial.setTimeout(50);
  Serial.println("i have " + String(50) + " apples");
  for (byte i = 0; i < 16; i++)
  { // i от 0 до 16
  Serial.print(i);      // степень
  Serial.print("\t");   // табуляция
  Serial.println(round(pow(2, i))); // 2 в степени i
  }
  while(millis()<1000)
    {
      Serial.print("millis ");
      Serial.print("\t");
      Serial.print(millis());
      Serial.print("\t");
      Serial.println(byte(millis()));
    }

}
int val=0;
void loop() {
  if (Serial.available()) {
    val = Serial.parseInt();
    Serial.print(val);
    
  }
}

/* ТАймер на милис
int counter = 0;      // замена i
uint32_t timer = 0;   // переменная таймера
#define T_PERIOD 100  // период переключения
void loop() {
  
  if (millis() - timer >= T_PERIOD) { // таймер на millis()
    timer = millis(); // сброс
    // действие с counter - наш i-ый светодиод например
    counter++;  // прибавляем счётчик
    if (counter > 30) counter = 0;  // закольцовываем изменение
  }
  
}
*/