Хорошо, если что - обращайтесь! 🙂 

for (int l=0; l<15; l++)

SetBit(), ClearBit() - стандартные битовые операции. (0x80 >> bit_position) - это операция сдвиг вправо, упрощенно (0x80 >> 1) = В01000000.

5-й режим:

void loop()                     
{    
    LS = 0;
    
    if (flag == 0)
    {
      if (counter < (N_O_S)) {sector_time--;}
      if (counter > (N_O_S)) {sector_time++;}
    }
    
    if (counter == N_O_S) {flag = 1;}
    if ((counter < (N_O_S - TOL)) || (counter > (N_O_S + TOL))) {flag = 0;}
  
    if (end_time < millis())
    {
      end_time = millis() + (random(10,20) * 1000);
      flag=0;
      mode++;
      if (mode == 6) {mode = 1;}
    }
  
    counter = 0;
    if (offset > (N_O_S - 1)) {offset = 0;}
    
    EnableSPI();
 
    while (LS == 0) 
    {
        if (counter < N_O_S) {pointer = counter;} else {pointer = N_O_S - 1;}      
        pointer = pointer + offset;
        if (pointer > (N_O_S - 1)) {pointer = pointer - N_O_S;}
      
        int sector_index = pointer;
        if (sector_index == 0)
        {
            test_counter++;
        }
        
        int led_index = test_counter % 20;        
        if (mode == 5)
        {
            led_index = 19 - led_index;
        }
        
        pointer = pointer * 15;
        
        int cached_bit_1 = GetBit(&test_array, 2 * led_index);
        int cached_bit_2 = GetBit(&test_array, 2 * led_index + 1);
        
        SetBit(&test_array, 2 * led_index);
        SetBit(&test_array, 2 * led_index + 1);
    
        digitalWrite(latchPin, LOW);
        
        switch (mode)
        {
            case 1: 
                for (int l=0; l<15; l++){SendRecSPI(bild_01);}
                break;
            case 2: 
                for (int l=0; l<15; l++){SendRecSPI(bild_02);}
                break;
            case 3: 
                for (int l=0; l<15; l++){SendRecSPI(bild_03);}
                break;
            case 4:
            case 5:            
                for (int l=0; l<15; l++){SendRecSPI(test_array);}
                break;     
        }
        
        digitalWrite(latchPin, HIGH);
        
        if (cached_bit_1 == 0) ClearBit(&test_array, 2 * led_index);
        if (cached_bit_2 == 0) ClearBit(&test_array, 2 * led_index + 1);
        
        counter++;
                                                           
        unsigned long end_micros = micros() + sector_time;                                    
        while ((micros() < end_micros) && (LS == 0)) {}                         
    }  
    
    DisableSPI();
    
    offset = offset + v_offset;
}

SetBit(&test_array, 2 * led_index);
SetBit(&test_array, 2 * led_index + 1);

case 4: for (int l=0; l<15; l++){SendRecSPI(test_array);} на увеличение. а на уменьшение счета как записать???? case 5: for (int l--; l>15; l=0){SendRecSPI(test_array);} так? или это не грамотно??? и как организована процедура настройки вот здесь

void SetBit(uint8_t* ptr, int bit_index)
{
if (bit_index < 0 || bit_index >= 120) return;

int byte_offset = bit_index / 8;
int bit_position = bit_index % 8;

ptr |= (0x80 >> bit_position);
}

void ClearBit(uint8_t* ptr, int bit_index)
{
if (bit_index < 0 || bit_index >= 120) return;

int byte_offset = bit_index / 8;
int bit_position = bit_index % 8;

ptr &= ~(0x80 >> bit_position); //вот здесь записан 0х80 это установка начального бита В10000000 как я поняла. для уменьшения надо это изменить  на В00000001  так мыслю или не правильно???
}

int GetBit(const uint8_t* ptr, int bit_index)
{
if (bit_index < 0 || bit_index >= 120) return 0;

int byte_offset = bit_index / 8;
int bit_position = bit_index % 8;

return (ptr & (0x80 >> bit_position)) ? 1 : 0;
}

int sector_index = pointer;
if (sector_index == 0)
{
    test_counter++;
}

int led_index = test_counter % 20;

sector_index - индекс текущего сектора, когда он равен 0, то инкрементируется счетчик test_counter. Таким образом, test_counter соответствует количеству оборотов, то есть test_counter увеличивается на 1 после полного оборота.

led_index - индекс светодиода, в данном случае от 0 до 19, увеличивается так же на каждый оборот.

Работаем со светодиодами с индексами:

• 2 * led_index
• 2 * led_index + 1

Если led_index = 0, то зажигаем светодиоды 0 и 1 (по схеме они на разных половинах) и так далее для других светодиодов попарно (финальная пара: 38, 39).

Считываем текущее состояние битов:

int cached_bit_1 = GetBit(&test_array, 2 * led_index);
int cached_bit_2 = GetBit(&test_array, 2 * led_index + 1);

В данном случае это не нужно, это актуально, если меняем биты в существующем изображении (массиве), чтобы потом вернуть их к изначальному значению. Выставляем биты в единицу:

SetBit(&test_array, 2 * led_index);
SetBit(&test_array, 2 * led_index + 1);

Как мы выяснили, это будут биты от 0 до 39 (попарно), соответственно эти биты в массиве из 120 бит отвечают за зеленую составляющую.

После цикла сбрасываем измененные биты в случае необходимости:

if (cached_bit_1 == 0) ClearBit(&test_array, 2 * led_index);
if (cached_bit_2 == 0) ClearBit(&test_array, 2 * led_index + 1);

Для примера - чтобы здесь поменять зеленый цвет на другой, можно сделать так:

int led_index = test_counter % 20 + 20;