Общение с барометром MS5540 на STM32 (Arduino to STM32)

void init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    /* Enable SPI2 and GPIOB clocks */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); 
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);  
    //SET CS HIGH LEVEL
    GPIO_SetBits(GPIOB,GPIO_Pin_12); // Этот пин не соединен, код просто скопировал со старой наработки  
     
    /*Configure SPI2 pins: SCK, MISO and MOSI*/
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16; // 8Mhz / 16 = 500kHz  
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(SPI2, &SPI_InitStructure);
     
    /* Enable SPI2  */
    SPI_Cmd(SPI2, ENABLE); 
}

void update(void)
{
    uint16_t result1 = 0, inbyte1 = 0,
            result2 = 0, inbyte2 = 0,
            result3 = 0, inbyte3 = 0,
            result4 = 0, inbyte4 = 0;
    
    long c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0, c6 = 0;
    unsigned int presMSB = 0; //first byte of value
    unsigned int presLSB = 0; //last byte of value
    unsigned int D1 = 0;
    
    unsigned int tempMSB = 0; //first byte of value
    unsigned int tempLSB = 0; //last byte of value
    unsigned int D2 = 0;
    
    long UT1 = 0;
    long dT = 0;
    long TEMP = 0;
    long OFF  = 0;
    long SENS = 0;
    long X = 0;
    long PCOMP = 0;
    float TEMPREAL = 0;
    float PCOMPHG = 0;
    
    long T2 = 0;
    float P2 = 0;
    
    resetsensor();
    
    //Calibration word 1
    SEND(0x1D);  //send first byte of command to get calibration word 1
    SEND(0x50); //send second byte of command to get calibration word 1
    setDataMode(SPI_MODE1);
    result1 = SEND(0x00); //send dummy byte to read first byte of word
    result1 = result1 << 8; //shift returned byte
    inbyte1 = SEND(0x00); //send dummy byte to read second byte of word
    result1 = result1 | inbyte1; //combine first and second byte of word
    
    resetsensor();
    
    //Calibration word 2; see comments on calibration word 1
    SEND(0x1D);
    SEND(0x60);
    setDataMode(SPI_MODE1);
    result2 = SEND(0x00);
    result2 = result2 << 8;
    inbyte2 = SEND(0x00);
    result2 = result2 | inbyte2;
 
    resetsensor(); //resets the sensor
 
    //Calibration word 3; see comments on calibration word 1
    SEND(0x1D);
    SEND(0x90);
    setDataMode(SPI_MODE1);
    result3 = SEND(0x00);
    result3 = result3 << 8;
    inbyte3 = SEND(0x00);
    result3 = result3 | inbyte3;
 
    resetsensor(); //resets the sensor
 
    //Calibration word 4; see comments on calibration word 1
    SEND(0x1D);
    SEND(0xA0);
    setDataMode(SPI_MODE1);
    result4 = SEND(0x00);
    result4 = result4 << 8;
    inbyte4 = SEND(0x00);
    result4 = result4 | inbyte4;
 
    //now we do some bitshifting to extract the calibration factors 
    //out of the calibration words;
    c1 = (result1 >> 1) & 0x7FFF;
    c2 = ((result3 & 0x003F) << 6) | (result4 & 0x003F);
    c3 = (result4 >> 6) & 0x03FF;
    c4 = (result3 >> 6) & 0x03FF;
    c5 = ((result1 & 0x0001) << 10) | ((result2 >> 6) & 0x03FF);
    c6 = result2 & 0x003F;
 
    resetsensor(); //resets the sensor
 
    //Pressure:
    SEND(0x0F); //send first byte of command to get pressure value
    SEND(0x40); //send second byte of command to get pressure value
    _delay_ms(35); //wait for conversion end
    setDataMode(SPI_MODE1);
    presMSB = SEND(0x00); //send dummy byte to read first byte of value
    presMSB = presMSB << 8; //shift first byte
    presLSB = SEND(0x00); //send dummy byte to read second byte of value
    D1 = presMSB | presLSB; //combine first and second byte of value
 
    resetsensor(); //resets the sensor  
 
    //Temperature:
    SEND(0x0F); //send first byte of command to get temperature value
    SEND(0x20); //send second byte of command to get temperature value
    _delay_ms(35); //wait for conversion end
    setDataMode(SPI_MODE1);
    tempMSB = SEND(0x00); //send dummy byte to read first byte of value
    tempMSB = tempMSB << 8; //shift first byte
    tempLSB = SEND(0x00); //send dummy byte to read second byte of value
    D2 = tempMSB | tempLSB; //combine first and second byte of value
 
    //calculation of the real values by means of the calibration factors and the maths
    //in the datasheet. const MUST be long
    UT1 = (c5 << 3) + 20224;
    dT = D2 - UT1;
    TEMP = 200 + ((dT * (c6 + 50)) >> 10);
    OFF  = (c2 * 4) + (((c4 - 512) * dT) >> 12);
    SENS = c1 + ((c3 * dT) >> 10) + 24576;
    X = (SENS * (D1 - 7168) >> 14) - OFF;
    PCOMP = ((X * 10) >> 5) + 2500;
    TEMPREAL = TEMP/10;
    PCOMPHG = PCOMP * 750.06 / 10000; // mbar*10 -> mmHg === ((mbar/10)/1000)*750/06*/
 
    /*Serial.print("Real Temperature in C = ");
    Serial.println(TEMPREAL);
 
    Serial.print("Compensated pressure in mbar = ");
    Serial.println(PCOMP);
    Serial.print("Compensated pressure in mmHg = ");
    Serial.println(PCOMPHG);*/
 
    //2-nd order compensation only for T < 20°C or T > 45°C
    
    lcd_clear();
    lcd_set_xy(0, 0);
    sprintf(buff, "M: %ld H: %.1f", PCOMP, PCOMPHG);
    lcd_out(buff);
 
    if (TEMP < 200)
    {
        T2 = (11 * (c6 + 24) * (200 - TEMP) * (200 - TEMP) ) >> 20;
        P2 = (3 * T2 * (PCOMP - 3500) ) >> 14;
    }
    else if (TEMP > 450)
    {
        T2 = (3 * (c6 + 24) * (450 - TEMP) * (450 - TEMP) ) >> 20;
        P2 = (T2 * (PCOMP - 10000) ) >> 13;    
    }
 
    if ((TEMP < 200) || (TEMP > 450))
    {
        const float TEMP2 = TEMP - T2;
        const float PCOMP2 = PCOMP - P2;
 
        float TEMPREAL2 = TEMP2/10;
        float PCOMPHG2 = PCOMP2 * 750.06 / 10000; // mbar*10 -> mmHg === ((mbar/10)/1000)*750/06
 
        /*Serial.print("2-nd Real Temperature in C = ");
        Serial.println(TEMPREAL2);
 
        Serial.print("2-nd Compensated pressure in mbar = ");
        Serial.println(PCOMP2);
        Serial.print("2-nd Compensated pressure in mmHg = ");
        Serial.println(PCOMPHG2);*/
        lcd_set_xy(0, 1);
        sprintf(buff, "M: %ld H: %.1f", PCOMP2, PCOMPHG);
        lcd_out(buff);
    }
}

void resetsensor(void)
{
    setDataMode(SPI_MODE0);
    SEND(0x15);
    SEND(0x55);
    SEND(0x40);
}
 
void setDataMode(uint8_t mode) // эквивалент ардуино варианта
{
    SPI_Cmd(SPI2, DISABLE);
    
    // Хотел заюзать свитч, но опять же где то слышал что он сложнее чем IF
    if(mode == SPI_MODE0)
    {
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    }
    else if(mode == SPI_MODE1)
    {
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    }
    else if(mode == SPI_MODE2)
    {
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    }
    else if(mode == SPI_MODE3)
    {
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    }
 
    SPI_Init(SPI2, &SPI_InitStructure);
    SPI_Cmd(SPI2, ENABLE);
}
 
uint16_t SEND(uint16_t data)
{
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(SPI2, data);
    
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
    return SPI_I2S_ReceiveData(SPI2);
}

while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);

void SEND(const bool* data, uint8_t sz)
{
    uint8_t i;
    uint8_t size = sz;
    
    for (i = 0; i < 3; i++) // START
    {
        GPIO_SetBits(GPIOB, BAR_DIN);
        GPIO_SetBits(GPIOB, BAR_SCLK);
        
        _delay_us(25);      
        GPIO_ResetBits(GPIOB, BAR_SCLK);        
        _delay_us(25);
    }
    
    while (sz)
    {
        if (data[size - sz--])
            GPIO_SetBits(GPIOB, BAR_DIN);
        else
            GPIO_ResetBits(GPIOB, BAR_DIN);
 
        GPIO_SetBits(GPIOB, BAR_SCLK);
        _delay_us(25);
        GPIO_ResetBits(GPIOB, BAR_SCLK);
        _delay_us(25);
    }
    
    for (i = 0; i < 3; i++) // STOP
    {
        GPIO_ResetBits(GPIOB, BAR_DIN);
        
        GPIO_SetBits(GPIOB, BAR_SCLK);
        _delay_us(25);
        GPIO_ResetBits(GPIOB, BAR_SCLK);        
        _delay_us(25);
    }
}
 
void RECV(bool* recv, uint8_t wait, uint8_t sz)
{
    uint8_t size = sz;
    GPIO_SetBits(GPIOB, BAR_SCLK);
    _delay_us(25);
    GPIO_ResetBits(GPIOB, BAR_SCLK);
    _delay_us(25);
 
    if (wait > 0)
        _delay_ms(wait);
    
    while (sz)
    {
        _delay_us(25);
        GPIO_ResetBits(GPIOB, BAR_SCLK);
        
        recv[size - sz--] = GPIO_ReadInputDataBit(GPIOB, BAR_DOUT);
        _delay_us(25);
        GPIO_SetBits(GPIOB, BAR_SCLK);
    }
}

void init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    
    GPIO_InitStructure.GPIO_Pin = BAR_SCLK | BAR_DIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
 
    GPIO_InitStructure.GPIO_Pin = BAR_DOUT;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
}

const bool data[] = { false, true, false, true, false, true };
bool recv[16];
memset(recv, NULL, 16);
 
init();
SEND(data, 6);
RECV(recv, 0, 16);

while(!GPIO_ReadInputDataBit(GPIOB, BAR_DOUT));