Я нічого не знаю про ці мікросхеми, але у функції indOut, очевидно, виконуються такі операції:
IndikatorReset; //схоже, ініціалізація - підготовка для виставлення стану

далі для кожного LEDу:
INDCLK_HIGH;
INDDATA_LOW; або INDDATA_HIGH; - залежно від номеру; схоже, перше відповідає за вимикання, а друге - за вмикання
INDCLK_LOW;

і один раз
INDLATCH_HIGH;
INDLATCH_LOW; - схоже, це дає команду "виконати" попереднє виставлення.

Тобто у цьому зразку коду обов'язково виставляються усі LEDи для того, щоб засвітити лише один. Що вам треба - то це змінити умову перемикання. Замість

        if (i != numberLed - 1)

потрібна інша умова - яка перевірятиме, чи має горіти i-й LED (у загальному списку).
Спробуйте так:

/*перед циклом*/
uint32_t led_map[32*kilkIndPlat];
for(u32 i=0;i<32*kilkIndPlat;++i)
  led_map[i] = 0;
/*цикл*/
while (1)
    {
        /*тут виставляєте led_map як вам треба*/
        ...

        cnt++;
        if (cnt > kilkIndPlat * 32)
        {
            cnt = 1;
        }
        
        indOut(led_map, 32*kilkIndPlat); // Засвітка світлодіодів
    }

void setled(bool state, u32 numPlt, u32 numLed) //готує для виставлення LED-ів
{
    led_map[32*numPlt+numLed] = state;
}
void indOut(uint8_t leds[], u32 size) //виводить led-и
{
    IndikatorReset;
    for (int i = 0; i < size; i++)
    {
        INDCLK_HIGH;
        
        if (leds[i])
        {
            INDDATA_HIGH;
        }
        else
        {
            INDDATA_LOW;
        }
        INDCLK_LOW;
    }

    INDLATCH_HIGH;
    INDLATCH_LOW;
}

Ну і в циклі тепер треба буде виставити кілька LED-ів перед викликом indOut.

Наліпив слідуючий г..код. За допомогою цієї функції, я можу виводити 32х бітне число в любу плату, та коли виводжу число, скажімо в третю плату то світлодіоди вмикаються замітно повільніше ніж в першу. Це зумовлено послідовним прогоном кожного біта в гирлянду мікросхем. Як би так зробити, щоб заганяти кожен раз, скажімо 160 біт (32 * 5 плат), а виводити тільки потрібні? Тобто навіть коли підключені тільки дві плати, то все одно проганяти 160 біт. Так це буде повільніше але з однаковою швидкістю.

void indOut(u32 numPLT, u32 data)
{
    IndikatorReset; // зкинути всі мікросхеми

    for (int i = 0; i < (numPLT * 32) + 1; i++)
    {
        INDCLK_HIGH; // клоки
        if ((data & 0x80000000) == 0x00)
        {
            INDDATA_LOW; // дані
        }
        else
        {
            INDDATA_HIGH;
        }

        INDCLK_LOW;
        data = (data << 1);
    }
    INDLATCH_HIGH;// вивід
    INDLATCH_LOW;
}

Ще раз: в оригінальному коді готується завжди kilkIndPlat * 32 + 1 значень перед виведенням; а у вас numPLT * 32 + 1. Як ви основний цикл змінили?
І чому там +1? Куди останній виклик іде? Чи перший? Таки перший, там з cnt=1 починається.

• Виводити кожен раз всі. Зробити буфер-образ «екрану», приблизно як пропонував koala, але не витрачаючи зайві байти RAM, у мікроконтролерах це не прийнято :-)
• «Помітно повільніше» — щось занадто … Оптимізація хоч якась увімкнена? Бо навіть HAL не повинен був аж так уповільнити.

Отже, має бути щось таке

/*перед циклом*/
uint32_t led_buffer[board_count];

void clear_buffer(void)
{
    for (unsigned board = 0; i < board_count; ++board)
        led_buffer[board] = 0;
}

/* pixel_n -- номер піксела у всій лінійці плат 0 .. (32*board_count - 1) */
void set_pixel(unsigned pixel_n, bool state)
{
    uint32_t *pword = &led_map[pixel_n / 32];
    uint32_t mask = 1UL << (pixel_n % 32);

    if (state)
        *pword |= mask;
    else
        *pword &= ~mask;
}

/* Зсув даних для однієї плати */
void shift_one_board(uint32_t data)
{
    for (unsigned bit = 0; bit  < 32; ++bit)  {
        INDCLK_LOW;
        
        if (data & 0x80000000)
            INDDATA_HIGH;
        else
            INDDATA_LOW;

        INDCLK_HIGH;
        data <<= 1;
    }
}

/* 
 * Оновлюємо всю лінійку плат
 * Схему не бачив, але судячи з усього, починати треба зі старшої плати.
 */
void refresh_screen(void)
{
    INDLATCH_LOW;    // storage reg теж по фронту, технічно він і не latch

    for (unsigned board = 0; board < board_count; ++board)
        shift_one_board(led_buffer[borad_count - 1 - i]);

    INDLATCH_HIGH;
}

До речі, про «від … до …»
Можна, якщо потрібно, зробити таку річ — вихід останньої плати подати назад на вхід мікроконтролера.
При ініціалізації модуля зробити таке
• reset всім регістрам, скрізь 0.
• Записувати у регістри зсуву 1 допоки на вході не з'явиться 1 (строб перезапису у регістр зберігання не видавати, щоб не блимнути світлодіодами). Рахувати такти.
• Знову reset.
Таким чином можна дізнатися кількість підключених плат і наступний вивід робити під таку кількість плат для оптимізації часу.
Залежно від організації проекту або обмежити led_buffer[] «достатньо великим» числом (наприклад, 10 плат) і встановити це як обмеження для використання, або після з'ясування кількості плат отримувати пам'ять по malloc.
board_count тоді стає змінною, а не константою.
Якщо led_buffer[] зробити типу uint8_t і відповідно змінити всі інші функції, board_count перейменувати у hc595_count чи щось таке, то цей модуль працюватиме хоч з тими готовими платами по чотири регістри, хоч з якоюсь спеціально зробленою системою з сімома.

Так, звісно. Я утримався від чисто стильових порад, бо й так багато написав.
Від do { ... } while (0) у цьому місці втриматися не міг, бо це вже не просто стиль, а гігієна

Коли вмикаю оптимізацію, нічого не працює (.

Увімкнути високий рівень на DATA
Дригати CKL до тих пір доки мк не побачить високий рівень на вході.
Якщо отримав 1 то кількість відправлених біт ділити на 32.
далі виліт з циклу.

Таким чином я фактично рахую кількість плат на яких по 32 діоди.

Це погана ознака, десь щось у коді зроблено геть неправильно.