import serial
import sys
import time

p = serial.Serial(sys.argv[1], 9600, timeout=10.0)

# Example frame:
# ID is 0x30, PID is 0xF0
# 00 00 55 F0 CA FE D0 0D BA AD BE EF 50

p.break_condition = True
time.sleep(0.002)
p.break_condition = False
p.write([0x55, 0xF0, 0xCA, 0xFE, 0xD0, 0x0D, 0xBA, 0xAD, 0xBE, 0xEF, 0x50])
p.close()

#pragma once
#include <stdint.h>

void lin_slave_init(void);

void lin_slave_send_response(const uint8_t *data, uint8_t length);
void lin_slave_task(void);

//returns the number of bytes to receive or sends its own response
int8_t lin_slave_handle_rx_frame_id_fromISR_EXTERNAL(uint8_t frame_id);

//data[0] contains frame ID
void lin_slave_handle_rx_frame_EXTERNAL(const uint8_t *data, uint8_t length); //provided by the application

#include "lin_slave.h"
#include <stdbool.h>
#include <stm32l0xx.h>

/* This timer is used to measure the length of the break
 * period and then to calculate effective baud of the sync word.
 * The nominal baud is 9600, let's say +/-20%.
 */
#define LIN_TIMER TIM2
#define LIN_UART USART2
#define LIN_BAUD 9600 //nominal speed
#define LIN_BREAK_LENGTH_SYMBOLS 14 //break must be at least this bit times long
#define LIN_BREAK_MIN_LENGTH_TICKS (0.8/*tolerance*/ * LIN_BREAK_LENGTH_SYMBOLS * SYSCLK_Hz / LIN_BAUD)
#define LIN_BAUD_TOLERANCE 0.2

static volatile bool _got_break;
static volatile uint8_t _sync_pulse_count;
static volatile uint8_t _buffer[16];
static volatile uint8_t _buffer_index;
static volatile uint8_t _bytes_to_receive;
static volatile uint8_t _bytes_to_send;
static volatile uint32_t _uart_brr = SYSCLK_Hz / LIN_BAUD; //startup value
static volatile bool _deliver_rx_callback;
static volatile bool _received_length_for_rx_callback;
static volatile uint8_t _last_PID;

void lin_slave_init(void){
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN_Msk | RCC_APB1ENR_USART2EN_Msk; //enable bus clock to the timer and USART

    LIN_UART->BRR = _uart_brr;
    LIN_UART->CR2 = USART_CR2_SWAP; //PCB has RX & TX miswired
    //rest of UART initialization is done after sync word is received

#if 0 //dirty transmit test
    LIN_UART->CR1 =
            USART_CR1_TE_Msk/*transmitter enable*/ |
            USART_CR1_UE_Msk/*USART enable*/;
    LIN_UART->TDR = 0x55;
    while (1){}
#endif

    LIN_TIMER->DIER = TIM_DIER_UIE_Msk; //enable overflow interrupt

    LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer
    LIN_TIMER->PSC = 0; //prescaling is not needed, we want to measure ~15 bit times at 9600baud-20%, that is 31250 ticks
    LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler

    //pins alternate function is done in pins_init()
    //SYSCFG_EXTICR3 is zeros at reset, so PA is the EXTI source
    EXTI->FTSR = EXTI_FTSR_FT9_Msk; //enable PA9 EXTI falling edge
    EXTI->IMR = EXTI_IMR_IM9_Msk; //enable PA9 EXTI interrupt

    NVIC_EnableIRQ(TIM2_IRQn);
    NVIC_EnableIRQ(EXTI4_15_IRQn);
    NVIC_EnableIRQ(USART2_IRQn);
}

void TIM2_IRQHandler(void){ //called when timer overflows (input pulse too long)
    LIN_TIMER->SR = 0; //clear overflow flag (and other flags)
    LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer
    LIN_TIMER->PSC = 0; //prescale by
    LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler

    if (_got_break == false){
        //break period was so long that the timer overflowed - it is okay
        _got_break = true;

        //Reconfigure the timer for total frame timeout, this will reset
        //the state to default in case no bytes arrive after the break
        //Prescaling by 32 gives around ~131ms timeout @16MHz sysclk
        LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer
        LIN_TIMER->PSC = 32; //prescale by
        LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler
        LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/ | TIM_CR1_CEN_Msk; //start the timer

    } else {
        //sync word was so long or the frame timed out, the timer overflowed - reset everything
        _got_break = false;
        _buffer_index = 0;
        _sync_pulse_count = 0;
        _bytes_to_receive = 0;

        LIN_UART->CR1 = 0; //disable UART

        //detect the falling edge of next break period
        EXTI->RTSR = 0; //disable rising edge interrupt
        EXTI->FTSR = EXTI_FTSR_FT9_Msk; //enable falling edge interrupt
    }
}

void EXTI4_15_IRQHandler(void){
    //This EXTI ISR is connected to RXD pin.
    //It is used for:
    // * break start detection (when executing the main loop)
    // * break end detection
    // * sync word measurement

    EXTI->PR = EXTI_PR_PIF9_Msk; //clear EXTI interrupt/event flag

    if (_got_break == false){ //we are measuring the break period

        if (EXTI->FTSR & EXTI_FTSR_FT9_Msk){
            //EXTI was configured for falling edge so this is the beginning of the break period
            _sync_pulse_count = 0;
            LIN_TIMER->PSC = 0; //prescale by
            LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler
            LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/ | TIM_CR1_CEN_Msk; //start the timer

            EXTI->FTSR = 0; //disable falling edge interrupt
            EXTI->RTSR = EXTI_RTSR_RT9_Msk; //enable rising edge interrupt

        } else {
            //EXTI was configured for rising edge so this is the end of the break period

            LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer
            uint32_t break_length_ticks = LIN_TIMER->CNT;
            if (break_length_ticks > LIN_BREAK_MIN_LENGTH_TICKS){
                _got_break = true;
            } //else break was too short (or timer overflowed), but _got_break could already be set by timer ISR

            //configure EXTI and timer for sync word measurement (or another break detection)
            LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler

            //start the timer - it can timeout if first sync pulse does not arrive
            LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/ | TIM_CR1_CEN_Msk; //start the timer

            EXTI->RTSR = 0; //disable rising edge interrupt
            EXTI->FTSR = EXTI_FTSR_FT9_Msk; //enable falling edge interrupt
        }

    } else { //we are measuring the sync word, timer is already running

        if (_sync_pulse_count == 0){
            //this is the first low pulse, timer is configured for timeout
            //restart the timer to measure sync length

            LIN_TIMER->PSC = 0; //prescale by
            LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler
            _sync_pulse_count = 1;

            //UART has to be enabled very early to capture PID byte without problems.
            //In the worst case the very first frame will be lost due to baud mismatch.
            LIN_UART->BRR = _uart_brr; //best known baud setting
            LIN_UART->CR1 =
                    USART_CR1_RE_Msk/*receiver enable*/ |
                    USART_CR1_RXNEIE_Msk/*receive buffer not empty interrupt enable*/ |
                    USART_CR1_UE_Msk/*USART enable*/;

            _bytes_to_receive = 2; //try to receive at least the sync and PID bytes
            _buffer_index = 0;

        } else {
            _sync_pulse_count++;

            if (_sync_pulse_count == 5/*includes start bit*/){
                //we got the whole sync word - tune our USART speed and start receiving bytes
                uint32_t sync_word_length_ticks = LIN_TIMER->CNT;

                uint32_t new_uart_brr = sync_word_length_ticks / 8;
                if (
                        (new_uart_brr > ((SYSCLK_Hz / LIN_BAUD)*(1 - LIN_BAUD_TOLERANCE))) &&
                        (new_uart_brr < ((SYSCLK_Hz / LIN_BAUD)*(1 + LIN_BAUD_TOLERANCE)))
                ){
                    _uart_brr = new_uart_brr;
                }

                //Reconfigure the timer for total frame timeout
                //Prescaling by 32 gives around ~131ms timeout @16MHz sysclk
                LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer
                LIN_TIMER->PSC = 32; //prescale by
                LIN_TIMER->EGR = TIM_EGR_UG_Msk; //zero timer & update prescaler
                LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/ | TIM_CR1_CEN_Msk; //start the timer

                EXTI->RTSR = 0; //disable rising edge interrupt
                EXTI->FTSR = 0; //disable falling edge interrupt
            }
        }
    }
}

void USART2_IRQHandler(void){
    if (LIN_UART->ISR & USART_ISR_RXNE_Msk){
        _buffer[_buffer_index] = LIN_UART->RDR;

        if (_buffer_index == 1){
            //this is the frame ID

            _last_PID = _buffer[_buffer_index];
            int8_t status = lin_slave_handle_rx_frame_id_fromISR_EXTERNAL(_buffer[_buffer_index] & 0x3F/*convert PID to ID*/);
            if (status > 0){
                _bytes_to_receive = status + 1/*checksum byte*/ + 1; //second +1 because the variable is immediately decremented
            } else if (status < 0){
                //handler has set up response transmission
                return;
            } else {
                //handler wants to ignore this frame
                goto setup_next_frame_reception;
            }
        }
        _buffer_index++;
        _bytes_to_receive--;

        if ((_bytes_to_receive == 0) && _buffer_index){
            //we have received everything we wanted

            uint32_t checksum = 0;
            //enhanced checksum includes the original PID
            for (uint32_t i = 1/*skip sync byte*/; i < (uint32_t)(_buffer_index - 1/*received checksum byte*/); i++){
                checksum += _buffer[i]; //checksum per LIN spec 2.3.1.5
                if (checksum >= 256){
                    checksum -= 255;
                }
            }
            checksum = ~checksum;
            checksum &= 0xFF; //leave just the LSB
            if (checksum == _buffer[_buffer_index - 1]){

                _buffer[1] &= 0x3F/*convert PID to ID*/;
                _deliver_rx_callback = true;
                _received_length_for_rx_callback = _buffer_index - 1/*sync*/ - 1/*PID*/;

            } else {
        //CRC is invalid, can't do anything
            }
            goto setup_next_frame_reception;
        } //end if ((_bytes_to_receive == 0) && _buffer_index)...

        if (_buffer_index == sizeof(_buffer)){ //overflow
            goto setup_next_frame_reception;
        }

        return;

    } else if (_bytes_to_send){ //this must be the TXEIE interrupt

        LIN_UART->TDR = _buffer[_buffer_index];
        _bytes_to_send--;
        _buffer_index++;
        if (_bytes_to_send == 0){ //disable TXEIE interrupt, enable TC interrupt
            LIN_UART->CR1 =
                    USART_CR1_TE_Msk/*transmitter enable*/ |
                    USART_CR1_TCIE_Msk/*TX complete interrupt enable*/ |
                    USART_CR1_UE_Msk/*USART enable*/;
        }
        return;
    } else { //this must be the TC interrupt - transmission of last byte is done, prepare reception for next frame

        goto setup_next_frame_reception;
    }

    setup_next_frame_reception:
    LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/; //stop the timer

    _got_break = false;
    _buffer_index = 0;
    _sync_pulse_count = 0;
    _bytes_to_receive = 0;
    LIN_UART->CR1 = 0; //disable UART

    //detect the falling edge of next break period
    EXTI->RTSR = 0; //disable rising edge interrupt
    EXTI->FTSR = EXTI_FTSR_FT9_Msk; //enable falling edge interrupt
    EXTI->IMR = EXTI_IMR_IM9_Msk; //enable PA9 EXTI interrupt
}

void lin_slave_send_response(const uint8_t *data, uint8_t length){
    //this function is called by lin_slave_handle_rx_frame_id_fromISR_EXTERNAL() in ISR context

    //stop the timer, we're not waiting for any timeout in this state
    LIN_TIMER->CR1 = TIM_CR1_URS_Msk/*software update does not IRQ*/;

    uint32_t checksum = _last_PID; //enhanced checksum includes the original PID

    uint8_t *dst = (uint8_t*)&(_buffer[0]); //buffer[0] holds the received PID byte
    for (uint32_t i = 0; i < length; i++){
        *dst = data[i];
        dst++;

        checksum += data[i]; //checksum per LIN spec 2.3.1.5
        if (checksum >= 256){
            checksum -= 255;
        }
    }

    *dst = ~checksum;
    _bytes_to_send = length + 1/*checksum*/ + 1;
    _buffer_index = 1;

    LIN_UART->CR1 =
            USART_CR1_TE_Msk/*transmitter enable*/ |
            USART_CR1_UE_Msk/*USART enable*/;

    LIN_UART->TDR = _buffer[0];

    LIN_UART->CR1 =
            USART_CR1_TE_Msk/*transmitter enable*/ |
            USART_CR1_TXEIE_Msk/*TX register empty interrupt enable*/ |
            USART_CR1_UE_Msk/*USART enable*/;

    //now the TX register empty interrupt will transmit rest of the bytes
}

void lin_slave_task(void){
    if (_deliver_rx_callback){
        _deliver_rx_callback = false;

        lin_slave_handle_rx_frame_EXTERNAL(
                (uint8_t*)_buffer + 1/*skip sync*/, //includes the ID
                _received_length_for_rx_callback);
    }
}

__attribute__((weak)) void lin_slave_handle_rx_frame_EXTERNAL(const uint8_t *data __attribute__((unused)), uint8_t length __attribute__((unused))){
    __BKPT(123); //has to be implemented in the application
}

__attribute__((weak)) int8_t lin_slave_handle_rx_frame_id_fromISR_EXTERNAL(uint8_t frame_id __attribute__((unused))){
    __BKPT(123); //has to be implemented in the application
    return 0;
}

int8_t lin_slave_handle_rx_frame_id_fromISR_EXTERNAL(uint8_t frame_id){
    //requests
    switch (frame_id){
    case 10:
        return 2;
    case 33:
        return 4;
    case 0:
    case 49:
        return 8;
    }
    //response
    if (frame_id == GLOBAL_LIN_response_id){
        lin_slave_send_response((const uint8_t*)GLOBAL_LIN_response_buffer, GLOBAL_LIN_response_length);
        int8_t r = -GLOBAL_LIN_response_length;
        GLOBAL_LIN_response_length = 0;
        GLOBAL_LIN_response_id = 0;
        return r;
    }
    return 0;
}