STM32 USART и DS18B20, траблы с приемо-передачей байтов Опции

[iPKM]

Пытаюсь завести DS18B20 на STM32(дискавери) по USART. Работу с 1-wire делаю по апптоуту максима
Проблемы начинаются после инициализации, после того как послали 0xF0 получили 0x0E, что значит датчик наместе, далее посылаем 0xCC и т.п не буду повторять код. вот собственно после передачи всех команд начинаем получать биты температуры, но все время нули вылазят. Я думаю что ошибка возможна в OneWireReadByte() хотя хз. OneWireSendByte() формирует из hex -> bin вроде правильно, к примеру 0xCC в двоичной 1100 1100, OneWireSendByte формирует и отсылает 0011 0011, какбы задом наперед, т.е сначала младшие биты слова потом старшие.

CODE

#include "stm32l1xx.h"
#include "PLL/inc/stm32l1xx_gpio.h"
#include "PLL/inc/stm32l1xx_usart.h"
#include "PLL/inc/stm32l1xx_rcc.h"
void Delay_ms(uint32_t ms)
{
volatile uint32_t nCount;
RCC_ClocksTypeDef RCC_Clocks;
RCC_GetClocksFreq (&RCC_Clocks);

nCount=(RCC_Clocks.HCLK_Frequency/10000)*ms;
for (; nCount!=0; nCount--);
}

void initPereherial()
{
GPIO_InitTypeDef GPIO_InitStructure;

/* Включаем тактирование */
RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOAEN, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

/* USART1 Rx (PA10) вход */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOA, &GPIO_InitStructure);

/* USART1 Tx (PA9) выход */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOA, &GPIO_InitStructure);

/* Конфигурируем порты PA9, PA10 как альтернативную функцию для USART1 */
GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);

}

void UsartInit(int BaudRate)
{
USART_InitTypeDef USART_InitStructure;

/* Настраиваем USART1 */
USART_InitStructure.USART_BaudRate = BaudRate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

/* Включаем USART1 */
USART_Init(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);
}

volatile uint16_t temp[7];

void OneWireSendByte(uint16_t byte)
{
for(int i=0; i<8; i++)
{
if((byte & (1<<i) ) != 0)
{
USART_SendData(USART1, 0xFF);
Delay_ms(1);
}else{
USART_SendData(USART1, 0x00);
}
}
}

uint16_t OneWireReadByte()
{
uint16_t result=0;

for(int i=0; i<8; i++)
{
USART_SendData(USART1, 0xFF);
Delay_ms(1);
}

for(int i=0; i<8; i++)
{
if(USART_ReceiveData(USART1) != 0xFF)
{
result |= (1<<i);
}
}

return result;
}


int main()
{
initPereherial();

UsartInit(9800);
USART_SendData(USART1, 0xF0);


USART_DeInit(USART1);
UsartInit(115200);
OneWireSendByte(0xCC);
OneWireSendByte(0x44);

Delay_ms(750);

USART_DeInit(USART1);
UsartInit(9800);
USART_SendData(USART1, 0xF0);


USART_DeInit(USART1);
UsartInit(115200);
OneWireSendByte(0xCC);
OneWireSendByte(0xBE);


for(int i=0; i<8; i++)
{
temp[i] = OneWireReadByte();
}

}

[iPKM]

Отложил юарт в сторону и попробовал напрямую работать с 1-wire. Сначала сам написал код по дрыганью ножками с указанными задержками по даташиту, в конце концов все равно получаю 0xFF, с горя решил глянуть пример работы с этим датчиком под STM32, нашел в китае один проект, перенёс себе, исправил в некоторых местах вызовы системной библы под свой МК, в этоге теже 0xFF в ответ.
Думал уж датчик голимый, но он ведь отвечает присутствием значит не палёный, хотя хз работает ли в нем сам датчик температуры. если кому интересно код работы с 1-wire из китая:

Код

#include "stm32l1xx.h"
#include "PLL/inc/stm32l1xx_gpio.h"
#include "PLL/inc/stm32l1xx_usart.h"
#include "PLL/inc/stm32l1xx_rcc.h"

#define SKIP_ROM 0xCC
#define CONVERT 0x44
#define READ_TEMP 0xBE

#define DS_PORT GPIOA    
#define DS_PIN GPIO_Pin_5

#define ResetDQ() GPIO_WriteBit(DS_PORT, DS_PIN, Bit_RESET)
#define SetDQ() GPIO_WriteBit(DS_PORT, DS_PIN, Bit_SET)
#define GetDQ() GPIO_ReadInputDataBit(DS_PORT,DS_PIN)

void delay_1ms(uint32_t ms)
{
        volatile uint32_t nCount;
        RCC_ClocksTypeDef RCC_Clocks;
        RCC_GetClocksFreq (&RCC_Clocks);

        nCount=(RCC_Clocks.HCLK_Frequency/10000)*ms;
        for (; nCount!=0; nCount--);
}

void delay_1us(uint32_t us)
{
        SysTick->LOAD=us*9;
    SysTick->CTRL|=0x01;
    while(!(SysTick->CTRL&(1<<16)));
    SysTick->CTRL=0x00000000;
    SysTick->VAL=0x00000000;  
}

void GPIO_init()
{
      RCC_AHBPeriphClockCmd(RCC_AHBENR_GPIOAEN, ENABLE);
      //GPIOA->BSRRL = GPIO_BSRR_BS_5;  
      //GPIOA->BSRRH = GPIO_BSRR_BS_5;    
}
void Init_ds18b20(void)    
{
    SetDQ();
    delay_1us(30);    
    ResetDQ();    
    delay_1us(470);      
    SetDQ();      
    delay_1us(30);    
    while(!GetDQ());    
    delay_1us(450);
    SetDQ();    
}


void DS18B20WriteByte( unsigned char  Dat)
{
    uint8_t i;
    for(i=8;i>0;i--)
    {
        ResetDQ();
        delay_1us(5);

        if(Dat&0x01)    
        SetDQ();
        else
        ResetDQ();

        delay_1us(65);
        SetDQ();
        delay_1us(2);
        Dat>>=1;
    }
}

unsigned char  DS18B20ReadByte(void)
{
     unsigned char  i,Dat;
    SetDQ();
    delay_1us(5);
    for(i=0;i<8;i++)
    {
        Dat>>=1;
        ResetDQ();
        delay_1us(5);
        SetDQ();
        delay_1us(5);

        if(GetDQ())
            Dat|=0x80;
        else
            Dat&=0x7f;
        delay_1us(65);
        SetDQ();
    }
    return Dat;
}

unsigned char  readtemperature(void)
{
     unsigned char  a,b;
    Init_ds18b20();
    DS18B20WriteByte(SKIP_ROM);
    DS18B20WriteByte(CONVERT);
    delay_1ms(750);    

    Init_ds18b20();
    DS18B20WriteByte(SKIP_ROM);
    DS18B20WriteByte(READ_TEMP);    

    a=DS18B20ReadByte();    
    b=DS18B20ReadByte();

    b<<=4;
    b+=(a&=0xf0)>>4;

    return b;
}

volatile int temp[8];

int main()
{
   GPIO_init();
  
  volatile uint8_t value=readtemperature();
}