ws2812b и arduino Подсветка клавиатуры

Добрый день. Только начал изучать ардуино. Создал подсветку для клавиатуры из светодиодов ws2812b и ардуино на 4 режима и переключаются они одной тактовой кнопкой. Хотел бы вписать матричную клавиатуру на 4 кнопки в скетч и назначить на каждую свой режим, но не получатся. Скетч я прикрепил, который работает с одной кнопкой переключения режимов. Буду очень благодарен за любой совет и пинок в нужном направлении. Скетч совсем не оптимизирован и хотелось бы узнать как можно это сделать, желательно на примере. Спасибо

 

Код (C++):

#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN   8                        // пин кнопки.
   
#define PIXEL_PIN    13                        // к какому пину подключены диоды.

#define PIXEL_COUNT 99                    // количество диодов.

int max_bright = 50;                              // максимальная яркость (0 - 255).

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
bool oldState = HIGH;
int showType = 3;



void setup() {
 
  pinMode(BUTTON_PIN, INPUT_PULLUP);          

  pixels.setBrightness(max_bright);           // ограничить максимальную яркость.
 
}

void loop() {

pixels.show();                                // Запускаем работу пикселей.




                                      //кнопка.

bool newState = digitalRead(BUTTON_PIN);      // Получить текущее состояние кнопки.

 
  if (newState == LOW && oldState == HIGH) {  // Проверьте, не изменилось ли состояние с высокого на низкий (нажмите кнопку).


    delay(20);                                // Кнопка короткой задержки для отмены.

   
    newState = digitalRead(BUTTON_PIN);       // Проверьте, остается ли кнопка ниже после дребезга.
    if (newState == LOW) {
      showType++;




     
      if (showType > 3)                       // поменять колличество вкладок. сейчас их 4 (0-3).
        showType=0;
      startShow(showType);
    }
  }
 
  oldState = newState;
}


void startShow(int i) {
  switch(i){

                          // Общая подцветка клавиатуры.L1
                         
    case 0:

    pixels.setPixelColor(0, pixels.Color(0,0,0)); // L2

   
    pixels.setPixelColor(1, pixels.Color(0,100,255)); // L1

   
    pixels.setPixelColor(2, pixels.Color(0,0,0)); // L3

   
    pixels.setPixelColor(3, pixels.Color(0,100,255)); // MX9

   
    pixels.setPixelColor(4, pixels.Color(0,100,255)); // MX7

   
    pixels.setPixelColor(5, pixels.Color(0,100,255)); // MX5

   
    pixels.setPixelColor(6, pixels.Color(0,100,255)); // MX3

   
    pixels.setPixelColor(7, pixels.Color(0,100,255)); // MX1

   
    pixels.setPixelColor(8, pixels.Color(0,100,255)); // MX2

   
    pixels.setPixelColor(9, pixels.Color(0,100,255)); // MX4

   
    pixels.setPixelColor(10, pixels.Color(0,100,255)); // MX6

   
    pixels.setPixelColor(11, pixels.Color(0,100,255)); // MX8

   
    pixels.setPixelColor(12, pixels.Color(0,100,255)); // MX10

   
    pixels.setPixelColor(13, pixels.Color(0,0,0)); // L4


   
    pixels.setPixelColor(14, pixels.Color(255,0,0)); // ESC

   
    pixels.setPixelColor(15, pixels.Color(0,100,255)); // M1

   
    pixels.setPixelColor(16, pixels.Color(0,100,255)); // M2

   
    pixels.setPixelColor(17, pixels.Color(0,100,255)); // M3

   
    pixels.setPixelColor(18, pixels.Color(0,100,255)); // M4

   
    pixels.setPixelColor(19, pixels.Color(0,100,255)); // M5

   
    pixels.setPixelColor(20, pixels.Color(0,100,255)); // M6

   
    pixels.setPixelColor(21, pixels.Color(0,100,255)); // M7

   
    pixels.setPixelColor(22, pixels.Color(0,100,255)); // M8

   
    pixels.setPixelColor(23, pixels.Color(0,100,255)); // M9

   
    pixels.setPixelColor(24, pixels.Color(0,100,255)); // M10

   
    pixels.setPixelColor(25, pixels.Color(0,100,255)); // M11

   
    pixels.setPixelColor(26, pixels.Color(0,100,255)); // M12

   
    pixels.setPixelColor(27, pixels.Color(0,100,255)); // F12

   
    pixels.setPixelColor(28, pixels.Color(0,100,255)); // F11

   
    pixels.setPixelColor(29, pixels.Color(0,100,255)); // F10

   
    pixels.setPixelColor(30, pixels.Color(0,100,255)); // F9

   
    pixels.setPixelColor(31, pixels.Color(0,100,255)); // F8

   
    pixels.setPixelColor(32, pixels.Color(0,100,255)); // F7

   
    pixels.setPixelColor(33, pixels.Color(0,100,255)); // F6

   
    pixels.setPixelColor(34, pixels.Color(0,100,255)); // F5

   
    pixels.setPixelColor(35, pixels.Color(0,100,255)); // F4

   
    pixels.setPixelColor(36, pixels.Color(0,100,255)); // F3

   
    pixels.setPixelColor(37, pixels.Color(0,100,255)); // F2

   
    pixels.setPixelColor(38, pixels.Color(0,100,255)); // F1


   
    pixels.setPixelColor(39, pixels.Color(215,3,252)); // `

   

    pixels.setPixelColor(40, pixels.Color(0,255,0)); // 1

   

    pixels.setPixelColor(41, pixels.Color(0,255,0)); // 2

   
 
    pixels.setPixelColor(42, pixels.Color(0,255,0)); // 3

     
   
    pixels.setPixelColor(43, pixels.Color(0,255,0)); // 4

   
   
    pixels.setPixelColor(44, pixels.Color(0,255,0)); // 5

     
   
    pixels.setPixelColor(45, pixels.Color(0,255,0)); // 6

   
   
    pixels.setPixelColor(46, pixels.Color(0,255,0)); // 7

     
   
    pixels.setPixelColor(47, pixels.Color(0,255,0)); // 8

     
   
    pixels.setPixelColor(48, pixels.Color(0,255,0)); // 9

     
   
    pixels.setPixelColor(49, pixels.Color(0,255,0)); // 0

     
   
    pixels.setPixelColor(50, pixels.Color(0,255,0)); // -

     
   
    pixels.setPixelColor(51, pixels.Color(0,255,0)); // +

     
   
    pixels.setPixelColor(52, pixels.Color(215,3,252)); // Backspace

     
   
    pixels.setPixelColor(53, pixels.Color(215,3,252)); // \

   
   
    pixels.setPixelColor(54, pixels.Color(255,0,0)); // ]

   
   
    pixels.setPixelColor(55, pixels.Color(255,0,0)); // [

   
   
    pixels.setPixelColor(56, pixels.Color(255,0,0)); // P

   
   
    pixels.setPixelColor(57, pixels.Color(255,0,0)); // O

     
   
    pixels.setPixelColor(58, pixels.Color(255,0,0)); // I

     
   
    pixels.setPixelColor(59, pixels.Color(255,0,0)); // U

   
   
    pixels.setPixelColor(60, pixels.Color(255,0,0)); // Y

   
   
    pixels.setPixelColor(61, pixels.Color(255,0,0)); // T

   
   
    pixels.setPixelColor(62, pixels.Color(255,0,0)); // R

   
   
    pixels.setPixelColor(63, pixels.Color(255,0,0)); // E

   
   
    pixels.setPixelColor(64, pixels.Color(255,0,0)); // W

   
   
    pixels.setPixelColor(65, pixels.Color(255,0,0)); // Q

   
   
    pixels.setPixelColor(66, pixels.Color(215,3,252)); // TAB

   
   
    pixels.setPixelColor(67, pixels.Color(215,3,252)); // CAPSLOCK

   
   
    pixels.setPixelColor(68, pixels.Color(255,0,0)); // A

   
   
    pixels.setPixelColor(69, pixels.Color(255,0,0)); // S

   
   
    pixels.setPixelColor(70, pixels.Color(255,0,0)); // D.

   
   
    pixels.setPixelColor(71, pixels.Color(255,0,0)); // F

   
   
    pixels.setPixelColor(72, pixels.Color(255,0,0)); // G

   
   
    pixels.setPixelColor(73, pixels.Color(255,0,0)); // H

   
   
    pixels.setPixelColor(74, pixels.Color(255,0,0)); // J

   
   
    pixels.setPixelColor(75, pixels.Color(255,0,0)); // K

   
   
    pixels.setPixelColor(76, pixels.Color(255,0,0)); // L

   
   
    pixels.setPixelColor(77, pixels.Color(255,0,0)); // ;.

   
   
    pixels.setPixelColor(78, pixels.Color(255,0,0)); // Moderately bright green color.

   
   
    pixels.setPixelColor(79, pixels.Color(215,3,252)); // ENTER

   
   
    pixels.setPixelColor(80, pixels.Color(215,3,252)); // RIGHT SHIFT

   
   
    pixels.setPixelColor(81, pixels.Color(255,0,0)); // /

   
   
    pixels.setPixelColor(82, pixels.Color(255,0,0)); // .

   
   
    pixels.setPixelColor(83, pixels.Color(255,0,0)); // ,

   
   
    pixels.setPixelColor(84, pixels.Color(255,0,0)); // M
   

   
    pixels.setPixelColor(85, pixels.Color(255,0,0)); // N

   
   
    pixels.setPixelColor(86, pixels.Color(255,0,0)); // B

   
   
    pixels.setPixelColor(87, pixels.Color(255,0,0)); // V

   
   
    pixels.setPixelColor(88, pixels.Color(255,0,0)); // C

   
   
    pixels.setPixelColor(89, pixels.Color(255,0,0)); // X

   
   
    pixels.setPixelColor(90, pixels.Color(255,0,0)); // Z

   
   
    pixels.setPixelColor(91, pixels.Color(215,3,252)); // LEFT SHIFT

   
   
    pixels.setPixelColor(92, pixels.Color(215,3,252)); // CTRL

   
   
    pixels.setPixelColor(93, pixels.Color(215,3,252)); // WINDOWS

   
   
    pixels.setPixelColor(94, pixels.Color(215,3,252)); // ALT

   
   
    pixels.setPixelColor(95, pixels.Color(215,3,252)); // ПРОБЕЛ

   
   
    pixels.setPixelColor(96, pixels.Color(215,3,252)); // ALT

   
   
    pixels.setPixelColor(97, pixels.Color(215,3,252)); // OMEN

   
   
    pixels.setPixelColor(98, pixels.Color(215,3,252)); // Moderately bright green color.

   
   
    pixels.setPixelColor(99, pixels.Color(215,3,252)); // CTRL

   
   
    break;
   
       
    case 1:         //вкладка повторяется, но с разными значениями свечения пикселей
   
       
    case 2:        //вкладка повторяется, но с разными значениями свечения пикселей
 
     
    case 3:        //вкладка повторяется, но с разными значениями свечения пикселей
 
  }
}
 

 

Ознакомьтесь с массивами и циклами, это первое, что нужно сделать для написания более простого кода. Процедура startShow впечатляет( 100 светодиодов - 4 режима...
А потом расскажите, что у вас не получается?

 

Добрый день Даниил, первая проблема как раз с массивами и циклами, не понимаю как сократить скетч(тяжело для понимания) Может вы подскажете с чего начать, или пример наглядный приведёте, буду очень признателен. Вторая проблема-это вписать 4 кнопки взамен одной и назначить на каждую своё значение (case 0,1,2,3).

 

Массивы для ардуино.
Мне кажется, что было бы удобнее иметь 3 массива char, для каждого компонента цвета (красный, зеленый, синий).
mas_Rcolor, mas_Gcolor, mas_Bcolor.
Каждый по 100 (от 0 до 99) элементов и перечислить все в шапке.
В теле процедуры startShow запускается цикл.

Код (C++):

цикл i от 0 до 99
pixels.setPixelColor(i,pixels.Color(mas_Rcolor[i],mas_Gcolor[i],mas_Bcolor[i]));

В таком случае придётся описать каждому режиму по 3 массива.

Спойлер: Усложнения

В будущем можно исхитриться и обойтись одним большим массивом

Как вариант, я бы сделал 5ый режим, в котором цвет кнопки зависит от времени работы ардуины. Если подобрать коэффициенты, то будет красиво и не нужно прописывать такие большие массивы

Так вы получите более приятный глазу и ардуине код.

Про кнопки.
Хотелось бы понять: что вы делали, как пытались, как подключали и что не получилось.

Очень рекомендую разобраться с массивами! Не бойтесть пробовать и спрашивать.
Потому что решение с кнопками мне видится тоже через массивы

 

Спасибо!!!!!!!!! Я сейчас домой приеду и разберусь! Вопрос сразу возник. Если я создам массивы по цветам (rgb), то получается, что я могу выбрать только из 3 цветов? Как задать пикселю желтый или фиолетовый цвет? Если я правильно понял, то надо этот пиксель указать в тех массивах, цвета которых при смешивании дадут нужный результат, или надо создать отдельный массив с этим цветом? А про кнопки я позже спрошу и покажу как собирал, но только разберусь с массивами!))

 

Да, я это и имел в виду.
Недавно вышла основательная статья про цвет, полистайте её, всем рекомендую.
Основной посыл для вас это то, что цвет состоит из 3ёх компонент. Красного (R), зелёного(G) и синего(B) - такая система имеет название RGB.
Когда вы используете процедуру:

Код (C++):

pixels.setPixelColor(92, pixels.Color(215,3,252)); // CTRL

то светодиод №92 светит красным на 215 из 255 возможных, зелёный на 3/255, а синий на 252/255 и такая комбинация даёт скорее всего фиолетовый цвет.

Спойлер: Фиолетовый

Немного набросаю кода:

Код (C++):

//допустим клавиатура состоит из 3-ёх кнопок
#define PIXEL_COUNT 3    // количество диодов или количество кнопок или количество элементов в массиве
//клавиша                   ALT  N    F1
byte R_part[PIXEL_COUNT] = {215, 255,   0}; //Красная компонента
byte G_part[PIXEL_COUNT] = {3  ,   0, 100}; // Зелёная компонента
byte B_part[PIXEL_COUNT] = {252,   0, 252}; //Синяя компонента
//выбрал тип byte, т.к. в RGB компоненты принимают значения от 0 до 255.
...
//основные процедуры
...
void startShow(int i)
{
    switch(i)
    {
    // Общая подцветка клавиатуры.L1            
        case 0:
            // j - счётчик цикла - он же номер клавиши
            // выбрал тип byte, т.к. у вас кол-во кнопок менее 255
            for (byte j = 0; j < PIXEL_COUNT-1; j = j + 1)//обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
            {
                pixels.setPixelColor(j,pixels.Color(R_part[j],G_part[j],B_part[j]));
            }
        break;
        case 1:       //вкладка повторяется, но с разными значениями свечения пикселей
        case 2:       //вкладка повторяется, но с разными значениями свечения пикселей
        case 3:       //вкладка повторяется, но с разными значениями свечения пикселей
    }
}

PS. могут быть ошибки=)

Спойлер: Усложнения

Боюсь меня будут ругать старшие коллеги, но я вошёл в азарт

Код (C++):

//допустим клавиатура состоит из 3-ёх кнопок
#define PIXEL_COUNT 3    // количество диодов или количество кнопок или количество элементов в массиве
//режим №1 цвета выбрал как у вас
//клавиша                         ALT  N    F1
byte R_part_mode1[PIXEL_COUNT] = {215, 255,   0}; //Красная компонента
byte G_part_mode1[PIXEL_COUNT] = {3  ,   0, 100}; // Зелёная компонента
byte B_part_mode1[PIXEL_COUNT] = {252,   0, 252}; //Синяя компонента
//режим №2 цвета выбрал от балды
//клавиша                         ALT  N    F1
byte R_part_mode2[PIXEL_COUNT] = {255,   0,   0}; //Красная компонента
byte G_part_mode2[PIXEL_COUNT] = {0  , 255, 100}; // Зелёная компонента
byte B_part_mode2[PIXEL_COUNT] = {0  ,   0,   0}; //Синяя компонента

//выбрал тип byte, т.к. в RGB компоненты принимают значения от 0 до 255.
...
//основные процедуры
...
void startShow(int i)
{
    switch(i)
    {
    // Общая подцветка клавиатуры.L1            
        case 0: //режим №1
            // j - счётчик цикла - он же номер клавиши
            // выбрал тип byte, т.к. у вас кол-во кнопок менее 255
            for (byte j = 0; j < PIXEL_COUNT-1; j = j + 1)//обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
            {
                pixels.setPixelColor(j,pixels.Color(R_part_mode1[j],G_part_mode1[j],B_part_mode1[j]));
            }
        break;
        case 1: //режим №2
            for (byte j = 0; j < PIXEL_COUNT-1; j = j + 1)//обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
            {
                pixels.setPixelColor(j,pixels.Color(R_part_mode2[j],G_part_mode2[j],B_part_mode2[j]));
            }
        break;
        case 2:       //вкладка повторяется, но с разными значениями свечения пикселей
        case 3:       //вкладка повторяется, но с разными значениями свечения пикселей
    }
}

Более элегантное решение (на мой взгляд)

Код (C++):

//допустим клавиатура состоит из 3-ёх кнопок
#define PIXEL_COUNT 3    // количество диодов или количество кнопок или количество элементов в массиве
#define MODE_COUNT 2    // количество режимов
//                                    |   режим №1  |   режим №2   |
//клавиша                             |ALT  N    F1 | ALT  N    F1 |
byte R_part[PIXEL_COUNT*MODE_COUNT] = {215, 255,   0, 255,   0,   0}; //Красная компонента
byte G_part[PIXEL_COUNT*MODE_COUNT] = {  3,   0, 100,   0, 255, 100}; // Зелёная компонента
byte B_part[PIXEL_COUNT*MODE_COUNT] = {252,   0, 252,   0,   0,   0}; //Синяя компонента
//выбрал тип byte, т.к. в RGB компоненты принимают значения от 0 до 255.
...
//основные процедуры
...
void startShow(int i) //i - номер режима свечения
{
    for (byte j = 0; j < PIXEL_COUNT-1; j = j + 1)//обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
    {
        pixels.setPixelColor(j,pixels.Color(R_part[j+PIXEL_COUNT*i],G_part[j+PIXEL_COUNT*i],B_part[j+PIXEL_COUNT*i]));
    }
}

И ещё вариант есть используя двумерные (многомерные) массивы.
Один индекс это номер клавиши, а второй индекс это номер режима.

 

PS. могут быть ошибки=)


[/SPOILER][/QUOTE]
Добрый День Даниил, Поздравляю вас с днем победы в великой отечественной войне!!! Я бы, хотел заранее извиниться перед вами, что отвлекаю ваше внимание, но в связи с тем, что у меня категорически не хватает времени на обучение и нет возможности консультироваться у кого либо, в этой области, то я ссылаюсь на ваше компетентное мнение.Мне очень тяжело дается понимание программирования, да же на начальном уровне. Вам бы, не составило труда, проверить мои знания на понимание каждой функции прописанной в первоначальном скетче (который я скину в этом сообщении)? Мне бы, стало гораздо яснее, узичать и понимать значения на моем примере скетча. у каждой функции и действия я оставил комментарий о том как я понимаю эти строки. Прошу поправить меня, там где я не правильно понял и написал ересь))). С уважение к вам и вашему желаю, просветить недоросля. Спасибо!

Код (C++):

#include <Adafruit_NeoPixel.h>                // подгружаем библиотеку

#define BUTTON_PIN   8                        // пин кнопки.

#define PIXEL_PIN    13                       // пин диодов.

#define PIXEL_COUNT 99                        // количество диодов.

int max_bright = 50;                          // максимальная яркость (0 - 255).

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);  // здесь я говорю что Adafruit_NeoPixel pixels будет называться-(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800) ???????????????????

bool oldState = HIGH;                         //Логический тип данных, что делает ?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
int showType = 3;                             //при нажатии кнопки запускается 3 вкладка ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????


// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void setup()
{
  pinMode(BUTTON_PIN, INPUT_PULLUP);          //кнопка начинает принимать значение (при нажатии, контакт замыкается и сигнал поступает на 8 пин) ?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????

  pixels.setBrightness(max_bright);           // запускаем переменную - (pixels.setBrightness) и начинает действовать ограничения по свечению - (int max_bright) = 50   ??????????????????????????????????????????????????????
}


// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop()
{
pixels.show();                                // Запускаем работу пикселей  ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
//---------------------------------------------------------------------------------------кнопка----------------------------------------------------------------------------------------------------
bool newState = digitalRead(BUTTON_PIN);      // Получить текущее состояние кнопки.
                               
                                              //зашита от дребезга кнопки.

    if (newState == LOW && oldState == HIGH)     // Если новое положение кнопки равно 0 и старое положение = 1 (дребезг), то запускается зарержка 20 милсек, то есть зашита от дребезга
  {
       delay(20);                                // Кнопка короткой задержки.
    newState = digitalRead(BUTTON_PIN);          // новое положенеие = считать положение кнопки.

    if (newState == LOW)                         // если новое положение = 0 то запустить показывать
    {
      showType++;                                // то запустить-показывать вкладку котороя должна работать

    if (showType > 3)                            // если включается вкладка больше (а их 4(от 0 до 3)
        showType=0;                              // то показывать вкладку 0
      startShow(showType);                       // и тогда запустить эту вкладку
    }
  }
// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  oldState = newState;             // Старое положение светодиодо (pixels.show() = новому положению (pixels.show()), то есть постоянно повторяется при нажатии кнопки?????????????????????????????????????????????????????????
}


// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void startShow(int i)                 // процедура не цикличного (одного) запуска int i (какое значение этой переменной)??????????????????????????????????????????????????????????????????????????????????????????????????????
{
  switch(i)                           // оператор switch сравнивает значение переменной (?) со значением, определенном в операторах case 0,1,2,3 (ниже)
{

//______________________________________________________________________________Общая подцветка клавиатуры.L1_____________________________________________________________________________________________
                     
    case 0:
// и т.д.................................

 

Если вам интересно,как это пока выглядит-проект над которым вы мне помогаете (а точнее, вы все доводите до ума и помогаете мне разобраться). То вот фотки. первая функция подсвечивает кнопки для напечатывания текста, вторая, третья и четвертая- подсвечивают горячие клавиши в рабочих программах.

 

Они интрактивны? Например, нажимаю alt и загораются кнопки которые с ней в паре работают.

 

Добры вечер, к сожалению не интерактивные кнопки. Я нажимаю одну кнопку (которую вынес отдельно на клавиатуру) и загораются клавиши нужным цветом из 4 режимов. Сейчас я хочу заменить в скетче одну кнопку на четыре, что бы удобнее переключать режимы. А идею которую вы подали— очень крутая. Не думал об этом. Но тогда надо будет сделать так, что бы ардуино считывала зажатие alt на клавиатуре и передавала это светодиодам . Попробую это сделать, как только с кнопками в скетче разберусь и интегрирую их в клавиатуру(ввернем левом углу на фото)

 

Леонардо может отслеживать нажатые кнопки.

 

Здравствуйте. Спасибо за поздравления и вас с прошедшим=)

Спойлер: оффтоп

Не унижайтесь извинениями, спрашивать и узнавать что-то новое совершенно естественно и, я нахожу, правильным. (Для этого и создан форум?).
Времени ни у кого нет=) поэтому, чтобы не иметь проблем, то есть большая статья "как правильно задавать вопросы?", которая делает упор на то, что человек должен сам пытаться разрешить проблему - она же его=)
Успехов!

Логическая переменная - булева алгебра, она используется в логических выражениях для ветвления кода (if, while, for...).

Код (C++):

int showType =3;

В шапке программы это означает, что при включении переменная showType будет равна "3", если смотреть код далее, то при нажатии на кнопку после всех проверок showType станет равна 4 и в этом режиме загорятся светодиоды.

Про работу светодиодов адафруит написано тут [англ.] Процедура Show активизирует те цвета, которые вы им послали. (Я бы эту процедуру выполнил бы 1 раз в процедуре setup и каждый раз в конце startShow, в loop затратно)

Код (C++):

      startShow(showType);                       // и тогда запустить эту вкладку

Я бы написал комментарий так: "и запустить процедуру startShow, у которой аргумент showType"
Это ответит на вопрос ниже:

Код (C++):

void startShow(int i)                 // процедура не цикличного (одного) запуска int i (какое значение этой переменной)??????????

И на всякий случай ссылка для почитать про функции и более обширная статья.

 

Спасибо за подробное объяснение, по вашим примерам выкладываю скетч ниже (позже попробую воспользоваться примером "более элегантное решение", приведенным вами выше.

Код (C++):

#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN    8

#define PIXEL_PIN     13

#define PIXEL_COUNT   99  

#define MODE_COUNT    2

int max_bright = 50;

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 3;

//                         режим L1
//      КЛАВИШИ                     L2,  L1,  L3, Mx9, Mx7  Mx5  Mx3  Mx1  Mx2  Mx4  Mx6  Mx8  Mx10  L4  ESC   M1   M2   M3   M4   M5   M6   M7   M8   M9  M10  M11  M12  F12  F11  F10   F9   F8   F7   F6   F5   F4   F3   F2   F1    ё    1    2    3    4    5    6    7    8    9    0    -    =  Bac    \    Ъ    Х    P    O    I    U    Y    T    R    E    W    Q  TAB  CAP    A    S    D    F    G    H    J    K    L    Ж    Э  ENT SHIF    /    >    <    M    N    B    V    C    X    Z SHIF  CTRL  WIN  ALT1  ALT2  OM1  OM2  CTRL
byte R_part_mode1[PIXEL_COUNT] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 255,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 215,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 215, 215, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 215, 215, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 215, 215, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 215,  215, 215,  215,  215, 215, 215,  215};
byte G_part_mode1[PIXEL_COUNT] = {   0, 100,   0, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,   0,   0, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,   3, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,   3,   3,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   3,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   3,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3,    3,   3,    3,    3,   3,   3,    3};            
byte B_part_mode1[PIXEL_COUNT] = {   0, 255,   0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,   0,   0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 252,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252,  252, 252,  252,  252, 252, 252,  252};          

//                         режим L2
//      КЛАВИШИ                     L2,  L1,  L3, Mx9, Mx7  Mx5  Mx3  Mx1  Mx2  Mx4  Mx6  Mx8  Mx10  L4  ESC   M1   M2   M3   M4   M5   M6   M7   M8   M9  M10  M11  M12  F12  F11  F10   F9   F8   F7   F6   F5   F4   F3   F2   F1    ё    1    2    3    4    5    6    7    8    9    0    -    =  Bac    \    Ъ    Х    P    O    I    U    Y    T    R    E    W    Q  TAB  CAP    A    S    D    F    G    H    J    K    L    Ж    Э  ENT SHIF    /    >    <    M    N    B    V    C    X    Z SHIF  CTRL  WIN  ALT1  ALT2  OM1  OM2  CTRL
byte R_part_mode2[PIXEL_COUNT] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 255,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 215,   0,   0,   0,   0,   0, 215,   0,   0,   0,   0,   0,   0, 215, 215, 255, 255, 255, 255, 255, 255, 255,  30,  30, 255, 255, 255, 215, 215,   0,   0,   0,   0, 255, 255, 255, 255, 255, 255, 255, 215, 215, 255, 255, 255, 255, 255, 255,  30,  30, 255, 255, 215,  215, 215,  215,  215, 215, 215,  215};
byte G_part_mode2[PIXEL_COUNT] = { 255,   0,   0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,   0,   0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   3, 255, 255, 255, 255, 255,   3, 255, 255, 255, 255, 255, 255,   3,   3,   0,   0,   0,   0,   0,   0,   0, 197, 197,   0,   0,   0,   3,   3, 255, 255, 255, 255,   0,   0,   0,   0,   0,   0,   0,   3,   3,   0,   0,   0,   0,   0,   0, 197, 197,   0,   0,   3,    3,   3,    3,    3,   3,   3,    3};            
byte B_part_mode2[PIXEL_COUNT] = {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252,   0,   0,   0,   0,   0, 252,   0,   0,   0,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0,   0, 255, 255,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 252, 252,   0,   0,   0,   0,   0,   0, 255, 255,   0,   0, 252,  252, 252,  252,  252, 252, 252,  252};



void setup()
{
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  pixels.setBrightness(max_bright);

  pixels.show();
}


// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop()
{                                  //
//---------------------------------------------------------------------------------------кнопка----------------------------------------------------------------------------------------------------
bool newState = digitalRead(BUTTON_PIN);         //

    if (newState == LOW && oldState == HIGH)     //
  {
       delay(20);                                //
    newState = digitalRead(BUTTON_PIN);          //
 
    if (newState == LOW)                         //
    {
      showType++;                                //

    if (showType > 3)                            //
        showType=0;                              //
      startShow(showType);                       //
    }
  }
// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  oldState = newState;                           //
}


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

void startShow(int i)          //
{
  switch (i)              
  {
    //...........................................................Общая подцветка клавиатуры.L1.................................................................
    case 0:                                            //режим №1
  pixels.show();

      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1) //обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode1[j], G_part_mode1[j], B_part_mode1[j]));
      }
      break;

//.......................................................................3DsMax.L2............................................................................
    case 1:                                            //режим №2
   
  pixels.show();
      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode2[j], G_part_mode2[j], B_part_mode2[j]));
      }
      break;
  }
}

 

Если я вас правильно понял, то это действие будет меньше занимать оперативной памяти ? Получается, скетч запускает один раз пиксели в Setup и каждый раз при включении нужной вкладки? Pixels.show()-прописал в setup и перед началом запуска каждой вкладки(на картинках ниже показал)

 

Я учту это, правда в клавиатуре у меня уж очень мало место для Леонардо. Получилось засунуть в корпус, только Nano

 

по поводу кнопок.

Сейчас у меня стоит одна кнопка подведенная к 8 пину. Хочу использовать 4 клавиши из готовой мембранной клавиатуры( на фото ниже), для переключения режимов.Из 12 клавиш оставлю 4, остальные отрежу. Подключал ее к пинам D4 и D6 - это строки, D7,D8- Это столбцы(фото ниже). Использовал библиотеку <Keypad.h> . Эти 4 мембранные клавиши я буду подсовывать под 4 клавиши клавиатуры в левом, верхнем углу (Фото ниже).Колхоз полный, но других вариантов которые работали, не вижу.

 

Сделал, и скидываю скетч который работает, но клавиши нажатые в независимой последовательности, переключают вкладки поочередно. То есть мне надо привязать каждую клавишу к отдельной вкладке так, чтобы при нажатии L1 срабатывал первые режим, а при нажатии L4- четвертый.

Код (C++):

void setup()
{

  pixels.setBrightness(max_bright);

  pixels.show();
}


// ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void loop()
{char key = keypad.getKey();
  if (key)
  {
    showType++;                                //
    if (showType > 3)                            //
        showType=0;                              //
      startShow(showType);
  }
}


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

void startShow(int i)          //
{

  switch (i)              
  {
    //...........................................................Общая подцветка клавиатуры.L1.................................................................
    case 0:                                            //режим №1
  pixels.show();

      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1) //обратите внимание на PIXEL_COUNT-1 (в массиве номера начинается с нуля)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode1[j], G_part_mode1[j], B_part_mode1[j]));
      }
      break;

//.......................................................................3DsMax.L2............................................................................
    case 1:                                            //режим №2
     
  pixels.show();
      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode2[j], G_part_mode2[j], B_part_mode2[j]));
      }
      break;

//.......................................................................3DsMax.L3............................................................................
     case 2:                                            //режим №3
     
  pixels.show();
      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode3[j], G_part_mode3[j], B_part_mode3[j]));
      }
      break;
//...............................................................Photoshop и другие проги.L4.................................................................
       case 3:                                            //режим №4
     
  pixels.show();
      for (byte j = 0; j < PIXEL_COUNT - 1; j = j + 1)
      {
        pixels.setPixelColor(j, pixels.Color(R_part_mode4[j], G_part_mode4[j], B_part_mode4[j]));
      }
      break;
  }
}

 

Зачем перед? Почему каждой? можно 1 раз вызвать до или после switch.

Не понял проблемы с клавиатурой. Там же просто запрашиваете какая клавиша нажата и в соответствии ей выбираете режим свечения.