Ваше программное обеспечение отлично справляется с поставленной задачей, но оно также блокирует некоторые полезные и важные функции. Для наилучшего использования сайта, пожалуйста, найдите время, чтобы отключить ваш AdBlocker.

STM32F4VE DS18B20 USART Keil

Опубликовано stm32 - чт, 01/09/2020 - 13:28

Плата STM32F4VE  с микроконтроллером и популярный датчик измерения температуры DS18B20Не буду переписывать то, что есть в интернете - остановлюсь только на важных моментах которые необходимы для запуска этого датчика.  Начнем с его подключения ножки представлены ниже на фото из документации

1661

Схемы включения бывают двух типов :

1. С тремя задействованными ножками .

GND (ножка 1)  - > DQ выход (он же вход ) (ножка 2)  -> Vdd (3.3v) (ножка 3)   - т.е. когда все включено по отдельности. См. ниже.

1663

 

2. С двумя задействованными ножками.

GND(ножка 1)+ Vdd (3.3v)(ножка 3) -> DQ выход (он же вход ) (ножка 2) - т.е. "+" и "-" соединяем, а сигнальный  DQ - отдельно.

1662

Зачем это нужно ? Второй способ явно экономнее т.к. отсутствует дополнительный провод .. и когда датчиков на шине много это конечно плюс.. но не надо забывать и о питании датчика и вполне возможно, что самому дальнему датчику (например в 30 метрах от источника питания)  уже будет не получить 3V3 ..  Вообщем стоит, конечно сначала определиться со схемой, а потом выбирать. 

Я выберу пункт 1.

Далее ...

Еще одним основным и важным пунктом является подтяжка сигнальной линии DQ (ножка 2) . Вот этот момент см. ниже - мы должны соединить DQ с "+" питания.

1664

На этом все. Остальное можно найти самостоятельно в документации к DS18B20.

Итак приступим ..

1. Берем датчик и припаиваем к нему провода и сопротивление (не красиво это всего лишь эксперимент ..)

1649

GND (левый провод на фото выше) датчика подключаем к GND платы

DQ (cредний провод на на фото выше) подключаем к PB1 платы

+3V3 ( правый провод на фото выше) датчика подключаем к +3V3 платы

2. Подключаем все к плате STM32F4VE и получаем следующее

1665

После того как подключили датчик - нужно определиться куда мы будем отправлять показания.

Варианта два :

1. переходник USART - USB - > PC (например этот FT232RL или этот CP210X)  и программа терминала (например  PuTTY.exe) 

2. Дисплей (например  5110)

Предлагаю сначала 1 после 2.

Итак USART - USB - > PC я остановился на CP210X (компактный, удобный). 

Подключаем следующим образом 

 TX  (CP210X )         ->   PA3 (STM32F4VE)

 RX (CP210X )         ->     PA2 (STM32F4VE)

 GND  (CP210X )    ->    GND (STM32F4VE)

Но понимая,  что пока мы не будем принимать данные от PC и GND у нас общая между PC и программатором и платой ТО нам нужно только один (на фото ниже их два) провод -   

RX (CP210X )         ->     PA2 (STM32F4VE

1666

Один из важных моментов!!

На фото см. выше - отсутствует провод питания платы ..но светодиод светиться ... объясняю .. 

В этом примере буду использовать программатор ULINK 2. Он переделан мною так чтобы питание на плату к которой он подключен приходило с него. В данном случае это плата  STM32F4VE

На этом подключение можно закончить и перейти к программированию микроконтроллера ....

Проект будем создавать в Keil uVision5 версии V5.29.0.0.

Я не буду расписывать по строчно как создать проект и добавить в него нужные библиотеки. Это я описал в статье - Первый проект на STM32F407VEНо чтобы упростить я сделал готовый пустой проект. Его можно скачать - ссылка на ZIP архив.    В интернете много сайтов с примерами по подключению датчика DS18B20. И придумывать "велосипед" смысла нет.  На основании разных примеров давайте адаптируем этот датчик к плате STM32F4VE

Итак .. 

Вложенный архив, содержит проект в котором настроены порты для платы  STM32F4VE это кнопки, светодиоды, временные задержки, USART. Проект для проверки и использования его как базового для выше представленной платы.

Кто не может скачать или есть желание все сделать самому - ниже приведу листинг основных файлов в архиве:

Файл main.c - основной файл

Содержимое файла:

#include "main.h"
//*******************************************************

int main(void)
{    
   SysTick_Config(SystemCoreClock / 1000);
    //  Настраиваем порты
     GPIO_init();
   //  Настраиваем кнопки установленные на плате    
     button_ini();
    //
    // Настраиваем связь 
    USART2_Configuration();
    //
    while (1)
     {      
     if (BUTTON_k1 == 0) 
         {
          GPIO_ResetBits(GPIOA, GPIO_Pin_6); //Подаем «0» на PA6 
          }
         else 
          {
         GPIO_SetBits(GPIOA, GPIO_Pin_6); //Подаем «1» на PA6

           }                        
         if (BUTTON_k0 == 0) 
          {
         GPIO_ResetBits(GPIOA, GPIO_Pin_7); //Подаем «0» на PA7
           }    
              else 
          {
           GPIO_SetBits(GPIOA, GPIO_Pin_7); //Подаем «1» на PA6

           }        

         }    
    
}

***************************************************************************************************

Файл main.h

Содержимое файла:

#ifndef MAIN_H
#define MAIN_H

#include "port_ini.h"
#include "stm32f4xx.h" 
//#include "serial.h"


 // Переопределим на более удобные названия
 
#define BUTTON_k1 GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_3)
#define BUTTON_k0 GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_4)


#endif

**************************************************************************************************

Файл  port_ini.c

Содержимое файла:

uint16_t delay_count;  // переменная

#define    DWT_CYCCNT    *(volatile unsigned long *)0xE0001004
#define    DWT_CONTROL   *(volatile unsigned long *)0xE0001000
#define    SCB_DEMCR     *(volatile unsigned long *)0xE000EDFC

// Прерывание - ЭТО ОБЯЗАТЕЛЬНО!!  
         
void SysTick_Handler(void)
{
if (delay_count > 0)
       {
    delay_count --;
       } 
}         

// Задержка Микро

void delay_us(uint32_t us)   // Микро секунды 10-6
{
    int32_t us_count_tick =  us * (SystemCoreClock/1000000);
    SCB_DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT_CYCCNT  = 0;
    DWT_CONTROL |= DWT_CTRL_CYCCNTENA_Msk; 
    while(DWT_CYCCNT < us_count_tick);
    DWT_CONTROL &= ~DWT_CTRL_CYCCNTENA_Msk;
    
}
// Задержка МиЛи

void delay_ms(uint32_t ms) // МиЛи секунды 10-3
{
    int32_t ms_count_tick =  ms * (SystemCoreClock/1000);
    SCB_DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
    DWT_CYCCNT  = 0;
    DWT_CONTROL|= DWT_CTRL_CYCCNTENA_Msk; 
    while(DWT_CYCCNT < ms_count_tick);
    DWT_CONTROL &= ~DWT_CTRL_CYCCNTENA_Msk;
   } 
// Задержка в виде обычного цикла 

void sdelay_ms(uint16_t delay_temp) 
   {
   delay_count = delay_temp;
   while (delay_count)
 {
  };
}

// Конфигурируем порты для управления светодиодами встроенными в плату

void GPIO_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;                                                        // создаем структуру
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);     // включаем тактирования порта В
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);     // включаем тактирование порта А
    
    //  Настройка порта под светодиод -> выход PB0  
                      
     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1; 
     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; 
     GPIO_Init(GPIOB, &GPIO_InitStructure);
        
    // Светодиод на плате подключенный к порту выход РА 6 
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;    
      GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
      GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
      GPIOA->ODR ^= GPIO_Pin_6;
      GPIO_Init(GPIOA, &GPIO_InitStructure);
 
    // Светодиод на плате подключенный к порту выход РА 7     
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
      GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;    
      GPIOA->ODR ^= GPIO_Pin_7;
      GPIO_Init(GPIOA, &GPIO_InitStructure);
   
}

// Конфигурируем порты для управления кнопками встроенными в плату
     void button_ini(void)
         {
     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE,ENABLE);     // включаем тактирование порта А
     
      GPIO_InitTypeDef init_button;  

// Кнопка на плате подключенная к порту РЕ 3 
      init_button.GPIO_Pin = GPIO_Pin_3;    
      init_button.GPIO_Mode = GPIO_Mode_IN; 
      init_button.GPIO_Speed = GPIO_Low_Speed ;  
      init_button.GPIO_PuPd = GPIO_PuPd_UP;    
       GPIO_Init(GPIOE, &init_button); 
             
   // Кнопка на плате подключенная к порту РЕ 4
      init_button.GPIO_Pin = GPIO_Pin_4;
      init_button.GPIO_Mode = GPIO_Mode_IN; 
      init_button.GPIO_Speed = GPIO_Low_Speed ;
      init_button.GPIO_PuPd = GPIO_PuPd_UP;
      GPIO_Init(GPIOE, &init_button);
         }                                                                                                                                                                                                                                                                                                                                                                                              
// Конфигурируем USART2 

    
      void USART2_Configuration(void)
     { 
    //  USART2 у которого:
  //  USART2 TX - PA2  - см. выше
  //  USART2 RX - PA3  - см. выше
        GPIO_InitTypeDef  GPIO_InitStructure;   // Создаем структуру порта
        USART_InitTypeDef USART_InitStructure;  // Создаем структуру USART2
        RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); //Включаем тактирование порта              RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); //Включаем тактирование порта USART2    
    
     // Можно сделать одной строчкой работает и так и так
    //  RCC_APB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_APB1Periph_USART2,ENABLE);
    
      GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2); //Подключаем PA3 к TX USART2
      GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2); //Подключаем PA2 к RX USART2
    
    //Конфигурируем PA2 как альтернативную функцию -> TX UART2.
      GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    //Конфигурируем PA3 как альтернативную функцию -> RX UART. 
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
      GPIO_Init(GPIOA, &GPIO_InitStructure);
            
    // Конфигурируем настройки USART2 
      USART_InitStructure.USART_BaudRate = 115200; //Скорость обмена 115200 бод
      USART_InitStructure.USART_WordLength = USART_WordLength_8b; //Длина слова 8 бит
      USART_InitStructure.USART_StopBits = USART_StopBits_1; //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; //Включен передатчик и приемник USART2
      // Можно задать настройки по умолчанию строкой
      // USART_StructInit(&USART_InitStructure);

      USART_Init(USART2, &USART_InitStructure);  // Инициализируем структуру
      USART_Cmd(USART2, ENABLE); //Включаем UART
   
}

****************************************************************************************************

Файл port_ini.h  

Содержимое файла:

#ifndef PORT_INI_H
#define PORT_INI_H

#include "stm32f4xx.h" 

void GPIO_init(void); 
void button_ini(void);
void delay_ms(uint32_t ms);
void delay_us(uint32_t us);
void USART2_Configuration(void);

#endif

******************************************************************************************************

Мои проект находятся на на диске D:\

Если все нормально открылось то 

Project -> Rebuild all target files - > все должно пройти нормально и проект собраться 

Окно Build Output

*****************************************************************************************************

Rebuild started: Project: 407_ve
*** Using Compiler 'V5.06 update 6 (build 750)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
Rebuild target 'Target 1'
compiling port_ini.c...
compiling stm32f4xx_gpio.c...
compiling main.c...
assembling startup_stm32f407xx.s...
compiling stm32f4xx_rcc.c...
compiling stm32f4xx_usart.c...
compiling system_stm32f4xx.c...
linking...
Program Size: Code=1796 RO-data=424 RW-data=24 ZI-data=1632  
".\Objects\407_ve.axf" - 0 Error(s), 0 Warning(s).
Build Time Elapsed:  00:00:03

*****************************************************************************************************

Далее прошиваем плату используя тот программатор который есть в наличии.

Я буду использовать ULINK 2.

ПРИ ПОСЛЕДУЮЩЕЙ ОПЕРАЦИИ СОТРЕТСЯ ВСЕ ТО ЧТО БЫЛО РАНЕЕ ЗАПИСАНО В МИКРОКОНТРОЛЛЕР!!! если желания стирать нет то дальше можно не читать...

Для тех кто продолжает делаем

Flash - > Erase

Процесс длиться секунд 20 у меня на ULINK 2.

После этого Окно Build Output

*******************************************************************************************

Full Chip Erase Done.
Flash Erase finished 13:02:04

*******************************************************************************************

И дальше прошиваем микроконтроллер 

Flash - > Download  или  F8

Если все нормально то в окне Build Output будет

*******************************************************************************************

Load "D:\\Keil_pj\\407\\Objects\\407_ve.axf" 
Erase Done.
Programming Done.
Verify OK.
Application running ...
Flash Load finished at 13:08:30

********************************************************************************************

После получения сообщения о прошивке микроконтроллера  - проверяем ..

На плате  

1. Нажимаем кнопку K0 - при этом должен загореться светодиод D3

2. Нажимаем кнопку K1 - при этом должен загореться D2

Если видим как светодиоды реагируют на кнопки - двигаемся дальше ...  

Следующим пунктом необходимо определиться в каком режиме будет работать вход у платы  STM32F4VE и датчик DS18B20В моем примере будет обычный режим (не USART). Ручной 1-Wire®.  Один занятый порт на плате - это удобно. 

Итак начнем  . .. для этого сначала добавим необходимые файлы в наш проект. Это файлы ds18b20.cds18b20.h, serial.c, serial.h.

Для этого 

1675

 Нажимаем добавить 

и в открывшемся окне вводим названия первого файла ds18b20.c - обратите внимание на то куда создаете - в моем случае D:\Keil_pj\407\Main

1677

 После того как все установили и выбрали - нажимаем Add.

Создается файл и сразу открывается 

1678

Заполняем это файл ниже приведенным содержимым:

Начало файла:

***************************************************************************************************

#include "ds18b20.h"
#include "main.h"

uint8_t ds18b20_Reset(void)
{

  uint16_t status;
  GPIO_ResetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "0"
  delay_us(485);// Задерживаемся на 500 микросекунд
  GPIO_SetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "1"
  delay_us(65);// Задерживаемся на 65 микросекунд
  status = GPIOB->IDR & GPIO_IDR_IDR_1;//Проверяем ответила ли DS18b20 на шине
  delay_us(485);// Задерживаемся на 485 микросекунд
  return (status ? 1 : 0);//Возвращаем результат

}

uint8_t ds18b20_ReadBit(void)

{
  uint8_t bit = 0;
  GPIO_ResetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "0"
  delay_us(2);// Задерживаемся на 2 микросекунды
    GPIO_SetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "1"
  delay_us(13);// Задерживаемся на 13 микросекунды
    bit = (GPIOB->IDR & GPIO_IDR_IDR_1 ? 1 : 0);//Проверяем ответила ли DS18b20 на шине
  delay_us(45);// Задерживаемся на 45 микросекунд
    return bit;
}

uint8_t ds18b20_ReadByte(void)

{
  uint8_t data = 0;
  for (uint8_t i = 0; i <= 7; i++)
  data += ds18b20_ReadBit() << i;
  return data;
}

void ds18b20_WriteBit(uint8_t bit)

{

  GPIO_ResetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "0"
  delay_us(bit ? 3 : 65);   ///65
  GPIO_SetBits(GPIOB, GPIO_Pin_1); // Устанавливаем на ножке PB1 - "1"
  delay_us(bit ? 65 : 3);   ///65
 
}

void ds18b20_WriteByte(uint8_t dt)

{
  for (uint8_t i = 0; i < 8; i++)
  {
    ds18b20_WriteBit(dt >> i & 1);
    delay_us(5);
  }

}

uint8_t ds18b20_init(uint8_t mode)

{
  if(ds18b20_Reset()) return 1;
  if(mode==SKIP_ROM)
  {
   ds18b20_WriteByte(0xCC);
   ds18b20_WriteByte(0x4E);
   ds18b20_WriteByte(0x64);
   ds18b20_WriteByte(0x9E);
   ds18b20_WriteByte(RESOLUTION_12BIT); 
    }
  return 0;
}

void ds18b20_MeasureTemperCmd(uint8_t mode, uint8_t DevNum)

{
  ds18b20_Reset();
  if(mode==SKIP_ROM)
  {
    //SKIP ROM
    ds18b20_WriteByte(0xCC);
  }
  //CONVERT T
  ds18b20_WriteByte(0x44);
}

void ds18b20_ReadStratcpad(uint8_t mode, uint8_t *Data, uint8_t DevNum)

{
  uint8_t i;
  ds18b20_Reset();
  if(mode==SKIP_ROM)
  {
    //SKIP ROM
    ds18b20_WriteByte(0xCC);
  }
  ds18b20_WriteByte(0xBE);
  for(i=0;i<8;i++)
  {
    Data[i] = ds18b20_ReadByte();
  }
}


uint8_t ds18b20_GetSign(uint16_t dt)
{
  //Проверяем 11 бит
  if (dt&(1<<11)) return 1;
  else return 0;
}

float ds18b20_Convert(uint16_t dt)
{
  float t;
  t = (float) ((dt&0x07FF)>>4); 
  t += (float)(dt&0x000F) / 16.0f;
  return t;
}

//************************************************************************************************

Конец файла .

Не забываем что в конце созданного файла нужно оставить пустую строку!!! Иначе будет выдано предупреждение компилятором.

1679

На ошибки пока внимание не обращаем.

Далее создаем еще три файла ds18b20.h, serial.c, serial.h - не забывая куда создаем - в моем случае D:\Keil_pj\407\Main

ds18b20.h

1680

1681

Заполняем содержимым

Начало файла ds18b20.h

************************************************************************************************

#ifndef DS18B20_H_
#define DS18B20_H_


#include "stm32f4xx.h"
#include <string.h>
#include <stdlib.h>
#include <stdint.h>

#define SKIP_ROM 0
#define NO_SKIP_ROM 1
#define RESOLUTION_9BIT 0x1F
#define RESOLUTION_10BIT 0x3F
#define RESOLUTION_11BIT 0x5F
#define RESOLUTION_12BIT 0x7F

uint8_t ds18b20_init(uint8_t mode);
void ds18b20_MeasureTemperCmd(uint8_t mode, uint8_t DevNum);
void ds18b20_ReadStratcpad(uint8_t mode, uint8_t *Data, uint8_t DevNum);
uint8_t ds18b20_GetSign(uint16_t dt);
float ds18b20_Convert(uint16_t dt);

#endif /* DS18B20_H_ */

***************************************************************************************

Конец файла ds18b20.h

 

1682

serial.c

1683

1684

Заполняем содержимым

Начало файла serial.c

************************************************************************************************

#include "serial.h"

void uart_send_char (USART_TypeDef * USARTx, char dat)
{  
    while (!(USARTx->SR & USART_SR_TXE)) {}
      USART_SendData(USARTx,dat);
}

void uart_print_string(USART_TypeDef * USARTx, char * string, char newline)
{
    while (*string != 0x00){ uart_send_char(USARTx, *string++);}
    if (newline!=0){uart_send_char(USARTx, 13);}
}

void uart_print_value(USART_TypeDef * USARTx, long val)
{
    char buffer[10] = {0};
    char * head = buffer;
    char cnt=0;
    if (val!=0)
    {
        while( val )
        {
            *head++ = (val % 10)["0123456789"];
            val /= 10;
            cnt++;
        }
        while (cnt!=0){ cnt--; uart_send_char(USARTx, (buffer[cnt])); }
    }
    else
    {
        uart_send_char(USARTx, ('0'));
    }
}

void uart_print_hex_value(USART_TypeDef * USARTx, long val)
{
    char buffer[10] = {0};
    char * head = buffer;
    char cnt=0;
    uart_send_char(USARTx, ('0'));
    uart_send_char(USARTx, ('x'));
    if (val<=9)    uart_send_char(USARTx, ('0'));
    if (val!=0)
    {
        while( val )
        {
            *head++ = (val & 0x0F)["0123456789ABCDEF"];
            val=val>>4;
            cnt++;
        }
        while (cnt!=0){ cnt--; uart_send_char(USARTx, (buffer[cnt])); }
    }
    else
    {
        uart_send_char(USARTx, ('0'));
    }
    uart_send_char(USARTx, (' '));
}
 

***************************************************************************************

Конец файла serial.c

1685

serial.h

1691

1692

Заполняем содержимым

Начало файла serial.h

************************************************************************************************

//#include "stm32f10x_usart.h"
#include "stm32f4xx.h"  
void uart_send_char (USART_TypeDef * USARTx, char dat);
void uart_print_string(USART_TypeDef * USARTx, char * string, char newline);
void uart_print_value(USART_TypeDef * USARTx, long val);
void uart_print_hex_value(USART_TypeDef * USARTx, long val);

***************************************************************************************

Конец файла serial.h

Все необходимые файлы создали.  

Далее открываем файл main.h

 

1686

И дополняем его строчками 

#include "ds18b20.h"
#include "serial.h"

В итоге

1687

Далее ...

Открываем файл main.c и дополняем его строчками

#include <stdio.h>
#include <ds18b20.h>

1688

Переменными

char str3[10];
char str1[60];
unsigned char str2[60];
uint8_t dt[8];
uint16_t raw_temper;
float temper;
char c;
uint8_t status;

1689

Строчкой поиска датчика

status = ds18b20_init(SKIP_ROM);

1690

Далее чтобы ничего не потерять - сохраняемся 

1694

Далее 

Проверяем нет ошибок (пока еще ни чего не выводим)

1695

Если все нормально то увидим отсутствие ошибок ..

1696

Попробуем вывести температуру в USART для этого убираем тестовые проверки нажатия кнопок 

и добавляем в main.с строчки 

Эти  четыре строчки ниже добавил для того, чтобы видеть что программа крутиться нормально их можно не добавлять   

     ---------------------------------------------------------------------------------------

      GPIO_ResetBits(GPIOA, GPIO_Pin_7); //Подаем «0» на PA 
      delay_ms(50);            
      GPIO_SetBits(GPIOA, GPIO_Pin_7); //Подаем «0» на PA
      delay_ms(50);
      ---------------------------------------------------------------------------------------

     ds18b20_MeasureTemperCmd(SKIP_ROM, 0); // запускаем датчик на преобразование
     delay_ms(800);                                                                       // ожидаем
     ds18b20_ReadStratcpad(SKIP_ROM, dt, 0);                  // читаем температуру
     raw_temper = ((uint16_t)dt[1]<<8)|dt[0];
      if(ds18b20_GetSign(raw_temper)) c='-';                        // определяем знак 
      else c='+';
      temper = ds18b20_Convert(raw_temper);            
      sprintf(str1,"Температура воздуха - %c%.2f градусов \r\n",c, temper);  // преобразуем для вывода строки в терминал
      uart_print_string(USART2, str1,0); // выводим в терминал
      delay_ms(50);   // на всякий случай

1697

Далее

1694_0

И 

1695_0

В итого должны получить

1698

 

Прошиваем микроконтроллер

 

1699

 

1670

Светодиод D3 на плате должен загораться и гаснуть.\

Если к плате и PC был подключен преобразователь USB - USART (как я писал выше)  то и на нем (в моем случае   CP210X) должен заморгать светодиод.

Но светодиодов мало, конечно нужно увидеть температуру ... Необходима программа которая нам примет данные с преобразователя и покажет температуру. Я выбрал (и уже давно) программу Puttу взять ее можно на сайте разработчика ссылка.

Заходим на сайт 

16100

Нам нужно

16101

Нажимаем ссылку и выходим в окно для скачивания

16102

Скачиваем для своей системы и после установки запускаем

16103

 Выбираем Serial - COM №  (в моем случае как на картинке выше)

У вас после подключения USB - USART сом порт должен появиться в диспетчере устройств 

16105

Скорость порта у нас определяется в файле проекта port_ini.c  в том месте где мы конфигурируем USART 

вот эта строка 

// Конфигурируем настройки USART2 
      USART_InitStructure.USART_BaudRate = 115200; //Скорость обмена 115200 бод

Нажимаем в PuTTy - Соединиться и откроется окно связи 

16109

Если не пишет по русски - пробуем исправить  - для этого нажимаем в окне Putty нажимаем иконку > правой клавишей мышки и должно открыться меню

16107

Настройки - Кодировка -выбираем 

16108

Нажимаем применить

16106_0

Ура! Мы справились! 

P.S.

Если нужен проект пишем на stm32@stm32res.ru

 

Яндекс.Метрика