uint8_t USART_kbhit() {
    if (USART_RX_Empty == USART_RX_Busy) { // Jeżeli bufor jest pusty to zwraca '0'.
        return 0;
    } else {
        return 1;
    }
}

uint8_t USART_getchar() {
    uint8_t tmp;
    if (USART_RX_Empty != USART_RX_Busy) {
        tmp = USART_RxBuf[USART_RX_Busy];
        USART_RX_Busy++;
        if (USART_RX_Busy >= USART_RxBuf_LEN) USART_RX_Busy = 0;
        return tmp;
    } else {
        return 0;
    }
}

uint8_t USART_getline(char *buf) {
    static uint8_t bf[128]; // Zmienna lokalna służąca składowaniu pobranych znaków.
    static uint8_t index = 0;
    int i;
    uint8_t ret;
    while (USART_kbhit()) {
        /*
         * Sprawdzenie czy jest coś w buforze.
         * W przypadku, gdy bufor nie jest pusty to wchodzi do środka 'while'a'
         */
                bf[index] = USART_getchar(); // Pobranie znaku z bufora.

                // USART_fsend(".%06X\n", bf[index]);

                if (((bf[index] == 10) || (bf[index] == 13))) {

                    /*
                     * W powyższym 'ifie' sprawdzamy czy ostatni pobrany znak jest znakiem końca linii / powrotem karetki.
                     * Jeżeli nastąpił koniec linii to przekopiowujemy zawartość zmiennej lokalnej 'bf'
                     *      do bufora 'buf'.
                     */

                    bf[index] = 0;
                    for (i = 0; i <= index; i++) {
                        buf[i] = bf[i]; // Przekopiowanie całej zawartości 'bf' do 'buf'.
                    }
                    ret = index;
                    index = 0;
                    return ret; // Zwracana wartość jest równa długości odebranego strumienia.

                } else {

                    /*
                     * W przypadku, gdy ostatni pobrany znak nie jest znakiem końca linii to indeks jest zwiększany,
                     *      a cały proces jest powtarzany do momentu, aż bufor się nie opróżni.
                     * Jeżeli indeks osiągnął wartośc większą niż wielkość lokalnego bufora to jest on zerowany.
                     */

                    index++;
                    if (index >= 128)
                        index = 0;
                }
            // }
        // }
    }
    return 0;
}

void USART_fsend(char* format, ...) {
    char tmp_rs[128] = {0};
    int i;

    va_list arglist;
    va_start(arglist, format);
    vsprintf(tmp_rs, format, arglist);
    va_end(arglist);
    index_fsend = USART_TX_Empty;

    // Zmodyfikowana funkcja 'fsend', która uwzględnia mój protokół komunikacyjny.
    for (i = 0; i < strlen(tmp_rs); i++) {
            if (tmp_rs[i] == '.' && (tmp_rs[i+7] == 10 || tmp_rs[i+7] == 13)) {
                /*
                 * W powyższym if'ie sprawdzam czy pierwszy znak jest kropką (znak początku ramki), a ostatni kończy się znakiem CR/LF.
                 * W przeciwnym wypadku zaplanowane do wysłania znaki w ogóle nie lądują w buforze.
                 */
                start = i + 1;
                for (int j = 0; j < 6; j++) { // Iteracja do wartości '6', ponieważ moja ramka zakłada sześć bajtów danych.
                    USART_TxBuf[index_fsend] = tmp_rs[start];
                    start++;
                    index_fsend++;
                    if (index_fsend >= USART_TxBuf_LEN)
                        index_fsend = 0;
                }
            }
        }

    __disable_irq();

    if ((USART_TX_Empty == USART_TX_Busy) && (flag == 0)) {
        /*
         * Sprawdzenie czy nadawanie wciąż trwa - jeżeli transmisja trwa to powyższa linijka jest niespełniona.
         * Flaga jest konieczna  - patrz: próba wysłania jednego znaku, tzn.:
         *      po wysłaniu jednego znaku wskaźniki 'EMPTY' i 'BUSY' są takie same i warunek byłby spełniony.
         * Jeżeli flaga == 0 -> przerwania są wyłączone i trzeba przejśc przez ciało 'ifa'.
         * Jeżeli flaga == 1 -> ciało 'ifa' jest pomijane i przechodzę od razu do 'else'.
         */
        USART_TX_Empty = index_fsend;
        uint8_t tmp = USART_TxBuf[USART_TX_Busy]; // Wrzucenie znaku do kolejki.
        USART_TX_Busy++;
        if(USART_TX_Busy >= USART_TxBuf_LEN) USART_TX_Busy = 0;
        /*
         * Oprócz przesłania znaku zostanie również włączone przerwanie od nadawania.
         * Po zakończeniu transmisji wywoływany jest 'callback'.
         */
        HAL_UART_Transmit_IT(&huart2, &tmp, 1);
        flag = 1; // Ustawienie flagi oznacza, że transmisja się rozpoczęła.
    } else {
        USART_TX_Empty = index_fsend;
    }
    __enable_irq(); // Ponownie włącza przerwania.
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart){
    /*
     * Dla wszystkich USARTów w procesorze jest wywoływany jeden callback.
     * Dzięki poniższemu 'ifowi' funkcja jest wołana z adresem USARTa, do którego przyszło przerwanie.
     */
    if (huart == &huart2) {
        if (USART_TX_Empty != USART_TX_Busy) {
            uint8_t tmp = USART_TxBuf[USART_TX_Busy];
            USART_TX_Busy++;
            if (USART_TX_Busy >= USART_TxBuf_LEN) USART_TX_Busy = 0;
            HAL_UART_Transmit_IT(&huart2, &tmp, 1); // Wołam kolejny znak, a za bitem stopu zaczyna się kolejny znak.
        } else {
            flag = 0; // Ustawienie flagi na 0 oznacza: 'nie mam już nic do wysłania - transmisja się zakończyła'.
        }
    }
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
    /*
     * Gdy przerwania są odblokowane i interfejs odbierze znak to wołany jest 'callback'.
     */
    if (huart == &huart2) {
        /*
         * Jeżeli ktoś nam dopisuje coś do bufora to musimy przestawic wskaźnik 'Empty' i to oznacza, że jest już zmienna.
         */
        USART_RX_Empty++;
        if (USART_RX_Empty >= USART_RxBuf_LEN) USART_RX_Empty = 0;
        HAL_UART_Receive_IT(&huart2, &USART_RxBuf[USART_RX_Empty],1);
        }
    }