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

STM32F4VE DS18B20 5510 Keil

Опубликовано stm32 - пн, 01/13/2020 - 11:29

STM32F4VE DS18B20 5510  в этой статье мы подключим к плате STM32F4VE  - LCD 5510. В предыдущей статье STM32F4VE DS18B20 USART мы выводили температуру с датчика в USART - воспользуемся этим проектом и выведем данные и в USART и на LCD 5510.

И так приступим к подключение LCD 5510 к плате STM32F4VE. 

Разъем подключения LCD 5510

1653_0

Для подключения будем использовать порт PB.  Можно выбрать тот порт который не занят, но надо учитывать особенность схемы платы. 

Подключим по порядку :

LCD 5510     ->   STM32F4VE    

8-  LED         ->   PB9

7- SCLK       ->   PB7

6- DIN         ->    PB6

5-D\C          ->    PB5

4-RST         ->    PB0

3-SCE        ->    PB13                 

2-GND       ->   GND

1-3.3V       ->    3V3

После того как подключили LCD 5510 к плате STM32F4VE приступим к дополнению ранее написанной программы.

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

Открываем Keil с проектом 

q1

Добавим библиотеки для работы с  LCD 5510  : 

Файлы :

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

port5110.h

ascii.c, ascii.h 

font.h

5110.c5110.h

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

Начнем с port5110.h

q2

Не забываем указывать папку куда сохраняем созданные файлы!!!

q3

q4

Наполняем содержимым port5110.h

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

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

//LCD 5510 ->   STM32F4VE    
//8-LED    ->     PB9
//7-SCLK   ->    PB7
//6-DIN    ->     PB6
//5-D\C    ->     PB5
//4-RST    ->     PB0
//3-SCE    ->     PB13                 
//2-GND    ->   GND
//1-3.3V   ->    3V3

#define LED_PIN                 GPIO_Pin_9
#define SCLK_PIN               GPIO_Pin_7
#define DIN_PIN                  GPIO_Pin_6
#define DC_PIN                   GPIO_Pin_5
#define REST_PIN              GPIO_Pin_0
#define SCE_PIN                 GPIO_Pin_13

#define GPIO_CLK             RCC_AHB1Periph_GPIOB
#define GPIO_NAME         GPIOB

 

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

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

Сохраняем.

q5

Далее делаем тоже самое и добавляем в проект  файлы ...

 ascii.c, ascii.h, font.h, 5110.c5110.h

 

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

ascii.c

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

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

#include "ascii.h"

char digitToAscii[16] = { 0x30, 0X31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0X38,
        0x39, 0x61, 0X62, 0x63, 0x64, 0x65, 0x66 };

void getDecimalFromShort(char* values, unsigned short value, uint8_t size) {
    char digit[5];
    uint16_t factors[5] = { 10000, 1000, 100, 10, 1 };
    uint8_t i;
    uint8_t zero = 1;

    for (i = 0; i < 5; i++) {
        digit[i] = value / factors[i];
        value = value - digit[i] * factors[i];

        if (zero == 1 && digit[i] == 0 && i < 4) {
            digit[i] = 32;
        } else {
            zero = 0;
            digit[i] += 48;
        }
    }
    memcpy(values, digit + (5 - size), size);
}

void getHexFromLong(char* values, unsigned long value, uint8_t nbDigits) {
    unsigned char digits[8];
    uint8_t i;
    uint8_t zero = 1;

    for (i = 0; i < 8; i++) {
        digits[i] = value >> ((7 - i) * 4);
        value = value - (digits[i] << ((7 - i) * 4));

        if (zero == 1 && digits[i] == 0) {
            digits[i] = 32;
        } else {
            zero = 0;
            digits[i] = digitToAscii[digits[i]];
        }
    }
    memcpy(values, digits + (8 - nbDigits), nbDigits);
}
 

 

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

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

ascii.h

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

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

#ifndef __ASCII_H
#define __ASCII_H

//******************************************************
//             Includes
//******************************************************
#include "stm32f4xx.h"

#include "string.h"
//******************************************************

void getDecimalFromShort(char* buffer, unsigned short value, uint8_t nbDigits);
void getHexFromLong(char* values, unsigned long value, uint8_t nbDigits);

#endif
 

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

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

font.h

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

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

unsigned char font6_8[][6] =
{
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // sp
    { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 },    // !
    { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 },        // #
    { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 },      // $
    { 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 },    // %
    { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 },    // &
    { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 },  // '
    { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
    { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
    { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
    { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
    { 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 },   // ,
    { 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 },   // -
    { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
    { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
    { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
    { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
    { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
    { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
    { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
    { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C },   // A
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
    { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
    { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
    { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
    { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
    { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
    { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C },   // g
    { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
    { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
    { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 },   // j
    { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
    { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
    { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 },   // p
    { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC },   // q
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
    { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
    { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
    { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
    { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
    { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C },   // y
    { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
    { 0x00,0x00, 0x06, 0x09, 0x09, 0x06  },   // horiz lines
    { 0x00, 0x77, 0x08, 0x7f, 0x08, 0x77 },   // Ж
};

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

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

5110.h

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

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

#ifndef __5110_H
#define __5110_H
#include "port5110.h"

#include "stm32f4xx.h"

#define    LCD_COMMAND    0
#define LCD_DATA 1

void LCD5110_init(void);

void LCD5110_Write_Char(unsigned char c);

void LCD5110_Write_Char_inv(unsigned char c);

void LCD5110_Clear(void);

void LCD5110_Set_XY(unsigned char X, unsigned char Y);

void LCD5110_Set_Pos(unsigned char X, unsigned char Y);

void LCD5110_Write_String(char *s);

void LCD5110_Write_Dec(uint16_t buffer, uint8_t size);

//void LCD5110_Write_Dec32(uint32_t buffer, uint8_t size);
void LCD5110_Write_Dec32(unsigned long b, uint8_t size);
void LCD5110_Led(unsigned char c);

void LCD5110_Write_Byte(unsigned char val);

#endif
 

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

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

5110.с

Начало файла 5110.с

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

#include "main.h"
#include "5110.h"
#include "font.h"
#include "stm32f4xx_conf.h"
#include "ascii.h"
#include "port5110.h"

//Define the LCD Operation function
void LCD5110_LCD_Write_Byte(unsigned char dat, unsigned char LCD5110_MOde);

//Define the hardware operation function
void LCD5110_GPIO_Config(void);
void LCD5110_SCK(unsigned char temp);
void LCD5110_DIN(unsigned char temp);
void LCD5110_CS(unsigned char temp);
void LCD5110_RST(unsigned char temp);
void LCD5110_DC(unsigned char temp);

//Data

/**
 * Initialize LCD module
 *
 * Input parameters : none
 * Return value        : none
 */
void LCD5110_init() {

    //Configure pins
    LCD5110_GPIO_Config();

    // Set pin initial state
    LCD5110_Led(0); //Turn back light off
    LCD5110_RST(0); //Set LCD reset = 0;
    LCD5110_DC(1); //Mode = command;
    LCD5110_DIN(1); //Set In at high level;
    LCD5110_SCK(1); //Set CLK high;
    LCD5110_CS(1); //Unselect chip;

    //Keep reset pin low for 10 ms
    delay_ms(10);
    //Release Reset Pin
    LCD5110_RST(1); //LCD_RST = 1;

    //Configure LCD module
    LCD5110_LCD_Write_Byte(0x21, LCD_COMMAND); //Extended instruction set selected
    LCD5110_LCD_Write_Byte(0xB7, LCD_COMMAND); //Set LCD voltage (defined by experimentation...)
    LCD5110_LCD_Write_Byte(0x14, LCD_COMMAND); //Set Bias for 1/48
    LCD5110_LCD_Write_Byte(0x06, LCD_COMMAND); //Set temperature control (TC2)
    LCD5110_LCD_Write_Byte(0x20, LCD_COMMAND); //Revert to standard instruction set
    LCD5110_Clear(); //Clear display (still off)
    LCD5110_LCD_Write_Byte(0x0c, LCD_COMMAND); //Set display on in "normal" mode (not inversed)

}
/**
 * Write byte to the module.
 *
 * @param dat      data to write
 * @param mode  0 if command, 1 if data
 *
 * @retval        None
 */
void LCD5110_LCD_Write_Byte(unsigned char dat, unsigned char mode) {
    unsigned char i;
    LCD5110_CS(0); //SPI_CS = 0;

    if (0 == mode)
        LCD5110_DC(0); //LCD_DC = 0;
    else
        LCD5110_DC(1); //LCD_DC = 1;

    for (i = 0; i < 8; i++) {
        LCD5110_DIN(dat & 0x80); //SPI_MO = dat & 0x80;
        dat = dat << 1;
        LCD5110_SCK(0); //SPI_SCK = 0;
        LCD5110_SCK(1); //SPI_SCK = 1;
    }

    LCD5110_CS(1); //SPI_CS = 1;

}

/**
 * Write character to LCD at current position
 *
 * @param c: char to write
 * @retval None
 */
void LCD5110_Write_Char(unsigned char c) {
    unsigned char line;
    unsigned char ch = 0;

    c = c - 32;

    for (line = 0; line < 6; line++) {
        ch = font6_8[c][line];
        LCD5110_LCD_Write_Byte(ch, LCD_DATA);

    }
}

/**
 * Write character to LCD in inverse video at current location
 *
 * @param c: char to write
 * @retval None
 */
void LCD5110_Write_Char_inv(unsigned char c) {
    unsigned char line;
    unsigned char ch = 0;

    c = c - 32;

    for (line = 0; line < 6; line++) {
        ch = ~font6_8[c][line];
        LCD5110_LCD_Write_Byte(ch, LCD_DATA);

    }
}

/**
 * Write string to LCD at current position. String must be null terminated.
 *
 * @param s: string pointer
 * @retval None
 */
void LCD5110_Write_String(char *s) {
    unsigned char ch;
    while (*s != '\0') {
        ch = *s;
        LCD5110_Write_Char(ch);
        s++;
    }
}

void LCD5110_Rectangle(uint8_t X, uint8_t Y, uint8_t width, uint8_t height) {

}

/**
 * Clear display. Write 0 in all memory location.
 *
 * @param None
 * @retval None
 */
void LCD5110_Clear() {
    unsigned char i, j;
    for (i = 0; i < 6; i++)
        for (j = 0; j < 84; j++)
            LCD5110_LCD_Write_Byte(0, LCD_DATA);
}

/**
 * Set memory current location for characters (set coordinates).
 * Applies only for Fonts with a 6 pixels width.
 *
 * @param X: Column (range from 0 to 13)
 * @param Y: Row (range from 0 to 5)
 * @retval None
 *
 */
void LCD5110_Set_XY(unsigned char X, unsigned char Y) {
    unsigned char x;
    x = 6 * X;

    LCD5110_LCD_Write_Byte(0x40 | Y, LCD_COMMAND);
    LCD5110_LCD_Write_Byte(0x80 | x, LCD_COMMAND);
}

void LCD5110_Set_Pos(unsigned char X, unsigned char Y) {
    LCD5110_LCD_Write_Byte(0x40 | Y, LCD_COMMAND);
    LCD5110_LCD_Write_Byte(0x80 | X, LCD_COMMAND);
}

/**
 * Write integer to LCD
 *
 * @param b: integer to write
 * @retval None
 */
void LCD5110_Write_Dec(uint16_t value, uint8_t size) {

    char digit[5];
    uint8_t i;
    getDecimalFromShort(digit, value, 5);

    for (i = 5 - size; i < 5; i++) {
        LCD5110_Write_Char(digit[i]);
    }
}

/**
 * Write long to LCD
 *
 * @param b: Long to write
 * @retval None
 */
void LCD5110_Write_Dec32(unsigned long b, uint8_t size) {

    unsigned char digit[9];
    int i;
    uint8_t zero = 1;

    digit[0] = b / 100000000;
    b = b - digit[0] * 100000000;
    digit[1] = b / 10000000;
    b = b - digit[1] * 10000000;
    digit[2] = b / 1000000;
    b = b - digit[2] * 1000000;
    digit[3] = b / 100000;
    b = b - digit[3] * 100000;
    digit[4] = b / 10000;
    b = b - digit[4] * 10000;
    digit[5] = b / 1000;
    b = b - digit[5] * 1000;
    digit[6] = b / 100;
    b = b - digit[6] * 100;
    digit[7] = b / 10;
    digit[8] = b - digit[7] * 10;

    for (i = 9 - size; i < 9; i++) {
        if ((zero == 1) && (digit[i] == 0)) {
            digit[i] = 32;
        } else {
            zero = 0;
            digit[i] += 48;
        }
        LCD5110_Write_Char(digit[i]);
    }
}
void LCD5110_Write_Byte(u8 val) {
    LCD5110_LCD_Write_Byte(val, LCD_DATA);
}

/**
 * Set pin configuration. 
 *

 * @param None
 * @retval None
 */
void LCD5110_GPIO_Config() {
    GPIO_InitTypeDef GPIO_Def;

    //Declare pins to configure
    GPIO_Def.GPIO_Pin = REST_PIN | SCE_PIN | DC_PIN | DIN_PIN | SCLK_PIN
            | LED_PIN;
    GPIO_Def.GPIO_Speed = GPIO_Speed_100MHz;
    GPIO_Def.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_Def.GPIO_OType = GPIO_OType_PP;
    GPIO_Def.GPIO_PuPd = GPIO_PuPd_NOPULL;

    //Start clock to the selected port
    RCC_AHB1PeriphClockCmd(GPIO_CLK, ENABLE);

    //Init Port
    GPIO_Init(GPIO_NAME, &GPIO_Def);

}

/**
 * Manage CS pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_CS(unsigned char state) {
    if (state == 0)
        GPIO_ResetBits(GPIO_NAME, SCE_PIN);
    else
        GPIO_SetBits(GPIO_NAME, SCE_PIN);
}

/**
 * Manage Reset pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_RST(unsigned char state) {
    if (state == 0)
        GPIO_ResetBits(GPIO_NAME, REST_PIN);
    else
        GPIO_SetBits(GPIO_NAME, REST_PIN);
}

/**
 * Manage DC pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_DC(unsigned char state) {
    if (state == 0)
        GPIO_ResetBits(GPIO_NAME, DC_PIN);
    else
        GPIO_SetBits(GPIO_NAME, DC_PIN);
}

/**
 * Manage DIN pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_DIN(unsigned char state) {
    if (state == 0)
        GPIO_ResetBits(GPIO_NAME, DIN_PIN);
    else
        GPIO_SetBits(GPIO_NAME, DIN_PIN);
}

/**
 * Manage CLK pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_SCK(unsigned char state) {
    if (state == 0)
        GPIO_ResetBits(GPIO_NAME, SCLK_PIN);
    else
        GPIO_SetBits(GPIO_NAME, SCLK_PIN);
}

/**
 * Manage LED pin
 *
 * @param state: pin state (0 or 1)
 * @retval None
 */
void LCD5110_Led(unsigned char state) {
    if (state == 0)
        GPIO_SetBits(GPIO_NAME, LED_PIN);
    else
        GPIO_ResetBits(GPIO_NAME, LED_PIN);
}
 

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

Конец файла 5110.с

После дополнения файлов - изменяем файл main.c

Который будет иметь вид

main.c

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

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

#include "main.h"
#include <stdio.h>
#include <ds18b20.h>
#include <5110.h>
//*******************************************************
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;


int main(void)
{    
  SysTick_Config(SystemCoreClock / 1000);
    
    //  Настраиваем порты
        GPIO_init();
    //  Настраиваем кнопки установленные на плате    
        button_ini();
    //
    // Настраиваем связь 
    USART2_Configuration();
    //
      status = ds18b20_init(SKIP_ROM);
    //
    LCD5110_init();
    //
    
      while (1)
     {      
    
         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);
        //

         LCD5110_Set_XY(2,0);
         LCD5110_Write_String("Temperatura");
         sprintf(str3,"%c%.2f",c, temper);
         LCD5110_Set_XY(4,2); 
         LCD5110_Write_String(str3);
         LCD5110_Set_XY(2,4);    
          LCD5110_Write_String("stm32res.ru"); 

                   
         }    
    
}
************************************************************************************

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

В результате 

q6

Сохраняем все

1694_1

Rebuild all target files

1695_1

Получаем окно 

q7

На LCD 5510

q10

Ура!!

Все получилось!!!

 

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