// STM32 Nucleo-L031K6 HAL Blink + printf() example
// Simulation: https://wokwi.com/projects/367244067477216257
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stm32l0xx_hal.h>
// ST Nucleo Green user LED (PB3)
#define LED_PORT GPIOB
#define LED_PIN GPIO_PIN_3
#define A3_PIN_DS GPIO_PIN_4
#define A4_PIN_STCP GPIO_PIN_5
#define A5_PIN_SHCP GPIO_PIN_6
#define D6_PIN_S3 GPIO_PIN_1
#define D5_PIN_S2 GPIO_PIN_6
#define D4_PIN_S1 GPIO_PIN_7
#define D3_PIN_S0 GPIO_PIN_0
//Дисплей
#define D9_PIN_RS GPIO_PIN_8 // PORT A
#define D10_PIN_E GPIO_PIN_11 // PORT A
#define D11_PIN_D4 GPIO_PIN_5 // PORT B
#define D12_PIN_D5 GPIO_PIN_4 // PORT B
#define A2_PIN_D6 GPIO_PIN_3 // PORT A
#define A1_PIN_D7 GPIO_PIN_1 // PORT A
uint8_t alphabet[33][8] = {
{0x04, 0x0A, 0x11, 0x11, 0x1F, 0x11, 0x11, 0x00}, // А (cmap[0])
{0x1F, 0x10, 0x10, 0x1E, 0x11, 0x11, 0x1E, 0x00}, // Б (cmap[1])
{0x1E, 0x11, 0x11, 0x1E, 0x11, 0x11, 0x1E, 0x00}, // В (cmap[2])
{0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00}, // Г (cmap[3])
{0x0E, 0x0A, 0x0A, 0x0A, 0x0A, 0x1F, 0x11, 0x00}, // Д (cmap[4])
{0x1F, 0x10, 0x10, 0x1E, 0x10, 0x10, 0x1F, 0x00}, // Е (cmap[5])
{0x15, 0x15, 0x15, 0x0E, 0x15, 0x15, 0x15, 0x00}, // Ж (cmap[6])
{0x0E, 0x11, 0x01, 0x06, 0x01, 0x11, 0x0E, 0x00}, // З (cmap[7])
{0x11, 0x11, 0x11, 0x13, 0x15, 0x19, 0x11, 0x00}, // И (cmap[8])
{0x0E, 0x00, 0x11, 0x13, 0x15, 0x19, 0x11, 0x00}, // Й (cmap[9])
{0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11, 0x00}, // К (cmap[10])
{0x07, 0x09, 0x09, 0x09, 0x09, 0x09, 0x11, 0x00}, // Л (cmap[11])
{0x11, 0x11, 0x1B, 0x15, 0x15, 0x11, 0x11, 0x00}, // М (cmap[12])
{0x11, 0x11, 0x11, 0x1F, 0x11, 0x11, 0x11, 0x00}, // Н (cmap[13])
{0x0E, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0E, 0x00}, // О (cmap[14])
{0x1F, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x00}, // П (cmap[15])
{0x1E, 0x11, 0x11, 0x11, 0x1E, 0x10, 0x10, 0x00}, // Р (cmap[16])
{0x0E, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0E, 0x00}, // С (cmap[17])
{0x1F, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00}, // Т (cmap[18])
{0x11, 0x11, 0x11, 0x0F, 0x01, 0x11, 0x0E, 0x00}, // У (cmap[19])
{0x0E, 0x15, 0x15, 0x15, 0x0E, 0x04, 0x04, 0x00}, // Ф (cmap[20])
{0x11, 0x0A, 0x04, 0x04, 0x0A, 0x0A, 0x11, 0x00}, // Х (cmap[21])
{0x12, 0x12, 0x12, 0x12, 0x12, 0x1F, 0x01, 0x00}, // Ц (cmap[22])
{0x11, 0x11, 0x11, 0x0F, 0x01, 0x01, 0x01, 0x00}, // Ч (cmap[23])
{0x11, 0x15, 0x15, 0x15, 0x15, 0x15, 0x1F, 0x00}, // Ш (cmap[24])
{0x11, 0x15, 0x15, 0x15, 0x15, 0x1F, 0x01, 0x00}, // Щ (cmap[25])
{0x18, 0x08, 0x08, 0x0E, 0x09, 0x09, 0x0E, 0x00}, // Ъ (cmap[26])
{0x11, 0x11, 0x19, 0x15, 0x15, 0x15, 0x19, 0x00}, // Ы (cmap[27])
{0x10, 0x10, 0x1E, 0x11, 0x11, 0x11, 0x1E, 0x00}, // Ь (cmap[28])
{0x1E, 0x01, 0x01, 0x0F, 0x01, 0x01, 0x1E, 0x00}, // Э (cmap[29])
{0x17, 0x15, 0x15, 0x1D, 0x15, 0x15, 0x17, 0x00}, // Ю (cmap[30])
{0x0F, 0x11, 0x11, 0x0F, 0x05, 0x09, 0x11, 0x00}, // Я (cmap[31])
{0x0A, 0x00, 0x1F, 0x10, 0x1E, 0x10, 0x1F, 0x00} // Ё (cmap[64])
};
volatile uint8_t cursor_position = 0;
volatile uint8_t cursor_line = 0;
uint8_t used_chars[8] = {0}; // Массив для отслеживания занятых слотов CGRAM
volatile uint8_t char_count = 0; // Количество занятых слотов
#define VCP_TX_Pin GPIO_PIN_2
#define VCP_RX_Pin GPIO_PIN_15
ADC_HandleTypeDef hadc1;
UART_HandleTypeDef huart2;
void SystemClock_Config(void);
static void MX_ADC1_Init(void);
static void MX_USART2_UART_Init(void);
static void ShiftOut8(uint8_t);
static void ShiftOut16(uint16_t);
static int Read_Multiplexor16_Channel(uint8_t channel);
void LCD_Init(void);
void LCD_SendCommand(uint8_t cmd);
void LCD_SendData(uint8_t data);
void LCD_SendString(char *str);
void LCD_SetCursor(uint8_t row, uint8_t col);
void LCD_PulseEnable(void);
void LCD_Send4Bits(uint8_t data);
void LCD_CreateChar(uint8_t location, uint8_t charmap[]);
void LCD_SendRussianString(const char *str);
void delay_us(uint32_t us) {
// Простая реализация задержки (настройте под ваш таймер или HAL)
HAL_Delay(us / 1000 + 1); // Примерная конверсия в миллисекунды
}
void osSystickHandler(void)
{
// 1 Hz blinking:
if ((HAL_GetTick() % 500) == 0)
{
HAL_GPIO_TogglePin(LED_PORT, LED_PIN);
}
}
void initGPIO()
{
GPIO_InitTypeDef GPIO_InitStruct = { 0 };
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = LED_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOA, A3_PIN_DS | A4_PIN_STCP | A5_PIN_SHCP, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = A3_PIN_DS | A4_PIN_STCP | A5_PIN_SHCP;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOB, D6_PIN_S3 | D5_PIN_S2 | D4_PIN_S1 | D3_PIN_S0, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = D6_PIN_S3 | D5_PIN_S2 | D4_PIN_S1 | D3_PIN_S0;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
// ДЛЯ ДИСПЛЕЯ
HAL_GPIO_WritePin(GPIOA, D9_PIN_RS | D10_PIN_E | A2_PIN_D6 | A1_PIN_D7, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = D9_PIN_RS | D10_PIN_E | A2_PIN_D6 | A1_PIN_D7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOB, D11_PIN_D4 | D12_PIN_D5, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = D11_PIN_D4 | D12_PIN_D5;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}
int main(void)
{
HAL_Init();
SystemClock_Config();
initGPIO();
MX_ADC1_Init();
MX_USART2_UART_Init();
printf("Hello, %s!\n", "DeD");
HAL_GPIO_TogglePin(LED_PORT, LED_PIN);
// Инициализация LCD
LCD_Init();
// Вывод текста
// LCD_SendString("ФЫВ, STM32!");
// LCD_SetCursor(1, 0); // Перейти на вторую строку cursor_position
// LCD_SendString("Wokwi Simulator");
// HAL_Delay(1000);
// LCD_SendCommand(0x01); // Очистить дисплей
// HAL_Delay(1000);
LCD_SendRussianString("Готов к работе");
cursor_line = 1;
cursor_position = 0;
LCD_SetCursor(1, 0); // Перейти на вторую строку
LCD_SendRussianString("ПЬЕШЬ САМОГОН");
// LCD_SendRussianString("ТЫ АЛКАШ");
ShiftOut16(0b0000000011111111);
HAL_Delay(1000);
ShiftOut16(0b1111111100000000);
HAL_Delay(1000);
ShiftOut16(0b0000000011011011);
HAL_Delay(1000);
ShiftOut16(0b1101101100000000);
HAL_Delay(1000);
uint16_t counter = 0;
while (1) {
ShiftOut16(counter++);
// for(int i = 0; i < 16; i++) {
// int res = Read_Multiplexor16_Channel(i);
// printf("Result_%d: %d", i, res);
// printf("\n");
// }
// printf("\n");
HAL_Delay(1000);
}
return 0;
}
// //Дисплей
// #define D9_PIN_RS GPIO_PIN_8 // PORT A
// #define D10_PIN_E GPIO_PIN_11 // PORT A
// #define D11_PIN_D4 GPIO_PIN_5 // PORT B
// #define D12_PIN_D5 GPIO_PIN_4 // PORT B
// #define A2_PIN_D6 GPIO_PIN_3 // PORT A
// #define A1_PIN_D7 GPIO_PIN_1 // PORT A
void LCD_Init(void) {
HAL_Delay(50); // Ждем старта LCD
HAL_GPIO_WritePin(GPIOA, D9_PIN_RS, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, D10_PIN_E, GPIO_PIN_RESET);
// Инициализация в 4-битном режиме
LCD_Send4Bits(0x03);
HAL_Delay(5);
LCD_Send4Bits(0x03);
HAL_Delay(1);
LCD_Send4Bits(0x03);
HAL_Delay(1);
LCD_Send4Bits(0x02); // Переход в 4-битный режим
HAL_Delay(1);
LCD_SendCommand(0x28); // 4 бит, 2 строки, 5x8
HAL_Delay(1);
LCD_SendCommand(0x08); // Выключить дисплей
HAL_Delay(1);
LCD_SendCommand(0x01); // Очистить дисплей
HAL_Delay(1);
LCD_SendCommand(0x06); // Режим ввода
HAL_Delay(1);
LCD_SendCommand(0x0C); // Включить дисплей
HAL_Delay(1);
}
// // Инициализация LCD в 4-битном режиме
// void LCD_Init(void) {
// HAL_Delay(50); // Ждем питания LCD
// LCD_SendCommand(0x30); // Инициализация
// HAL_Delay(5);
// LCD_SendCommand(0x30);
// delay_us(100);
// LCD_SendCommand(0x30);
// delay_us(100);
// LCD_SendCommand(0x20); // Установка 4-битного режима
// delay_us(100);
// LCD_SendCommand(0x28); // 4-битный режим, 2 строки, шрифт 5x8
// delay_us(100);
// LCD_SendCommand(0x08); // Выключить дисплей
// delay_us(100);
// LCD_SendCommand(0x01); // Очистить дисплей
// HAL_Delay(2);
// LCD_SendCommand(0x06); // Режим ввода: сдвиг вправо
// delay_us(100);
// LCD_SendCommand(0x0C); // Включить дисплей, курсор выкл
// delay_us(100);
// }
// #define D9_PIN_RS GPIO_PIN_8 // PORT A
// #define D10_PIN_E GPIO_PIN_11 // PORT A
// #define D11_PIN_D4 GPIO_PIN_5 // PORT B
// #define D12_PIN_D5 GPIO_PIN_4 // PORT B
// #define A2_PIN_D6 GPIO_PIN_3 // PORT A
// #define A1_PIN_D7 GPIO_PIN_1 // PORT A
// Отправка команды на LCD
void LCD_SendCommand(uint8_t cmd) {
HAL_GPIO_WritePin(GPIOA, D9_PIN_RS, GPIO_PIN_RESET); // RS = 0 для команд
LCD_Send4Bits(cmd >> 4); // Старшие 4 бита
LCD_Send4Bits(cmd & 0x0F); // Младшие 4 бита
}
// Отправка данных на LCD
void LCD_SendData(uint8_t data) {
HAL_GPIO_WritePin(GPIOA, D9_PIN_RS, GPIO_PIN_SET); // RS = 1 для данных
LCD_Send4Bits(data >> 4); // Старшие 4 бита
LCD_Send4Bits(data & 0x0F); // Младшие 4 бита
}
// Отправка 4 бит на LCD
void LCD_Send4Bits(uint8_t data) {
HAL_GPIO_WritePin(GPIOB, D11_PIN_D4, (data & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, D12_PIN_D5, (data & 0x02) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, A2_PIN_D6, (data & 0x04) ? GPIO_PIN_SET : GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, A1_PIN_D7, (data & 0x08) ? GPIO_PIN_SET : GPIO_PIN_RESET);
LCD_PulseEnable();
}
// Генерация импульса Enable
void LCD_PulseEnable(void) {
HAL_GPIO_WritePin(GPIOA, D10_PIN_E, GPIO_PIN_SET);
delay_us(10); // Увеличьте до 10 мкс
HAL_GPIO_WritePin(GPIOA, D10_PIN_E, GPIO_PIN_RESET);
delay_us(100); // Увеличьте до 100 мкс
}
// Отправка строки на LCD
void LCD_SendString(char *str) {
while (*str) {
LCD_SendData((uint8_t)(*str++));
}
}
// Установка позиции курсора (row: 0 или 1, col: 0-15)
void LCD_SetCursor(uint8_t row, uint8_t col) {
uint8_t address = (row == 0) ? 0x00 : 0x40;
address += col;
LCD_SendCommand(0x80 | address);
}
void LCD_CreateChar(uint8_t location, uint8_t charmap[]) {
LCD_SetCursor(cursor_line, cursor_position);
location &= 0x07; // Ограничиваем до 0-7
LCD_SendCommand(0x40 | (location << 3)); // Установить адрес в CGRAM
delay_us(100); // Дать время на установку адреса
for (uint8_t i = 0; i < 8; i++) {
LCD_SendData(charmap[i]); // Записать байт символа
delay_us(100); // Дать время на запись каждого байта
}
// LCD_SetCursor(cursor_line, cursor_position);
// delay_us(100);
LCD_SendCommand(0x80); // Вернуть указатель в DDRAM (начало первой строки)
delay_us(100);
LCD_SetCursor(cursor_line, cursor_position);
delay_us(100);
}
// Функция для вывода русского текста
void LCD_SendRussianString(const char *str) {
while (*str) {
// Проверяем, является ли символ русской буквой (кодировка UTF-8)
if ((unsigned char)*str == 0xD0 || (unsigned char)*str == 0xD1) {
uint8_t second_byte = (unsigned char)*(str + 1);
uint8_t letter_idx = 0;
uint8_t ascii_char = 0; // Для хранения ASCII-символа, если есть замена
if (*str == 0xD0 && second_byte >= 0x90 && second_byte <= 0xBF) {
letter_idx = second_byte - 0x90; // А-Я
} else if (*str == 0xD1 && second_byte >= 0x80 && second_byte <= 0x8F) {
letter_idx = second_byte - 0x80 + 16; // Продолжение Я
} else if (*str == 0xD1 && second_byte == 0x91) {
letter_idx = 32; // Ё
}
// Проверяем, можно ли заменить русскую букву на английскую
switch (letter_idx) {
case 0: // А
ascii_char = 'A'; break;
case 1: // Б
ascii_char = '6'; break;
case 2: // В
ascii_char = 'B'; break;
case 5: // Е
ascii_char = 'E'; break;
case 7: // З
ascii_char = '3'; break;
case 9: // Й
letter_idx = 8; break; // Замена на И
case 10: // М
ascii_char = 'K'; break;
case 12: // М
ascii_char = 'M'; break;
case 13: // Н
ascii_char = 'H'; break;
case 14: // О
ascii_char = 'O'; break;
case 16: // Р
ascii_char = 'P'; break;
case 17: // С
ascii_char = 'C'; break;
case 18: // Т
ascii_char = 'T'; break;
case 19: // У
ascii_char = 'y'; break;
case 21: // Х
ascii_char = 'X'; break;
case 28: // Ь
ascii_char = 'b'; break;
case 32: // Ё
ascii_char = 'E'; break;
default:
ascii_char = 0; // Нет замены
}
// Если есть ASCII-замена, выводим её напрямую
if (ascii_char) {
printf("Replacing with ASCII: %c\n", ascii_char);
LCD_SendData(ascii_char);
cursor_position++;
} else {
// Проверяем, есть ли эта буква в CGRAM
int8_t char_slot = -1;
for (uint8_t i = 0; i < char_count; i++) {
if (used_chars[i] == letter_idx) {
char_slot = i;
break;
}
}
// Если буквы нет и есть свободный слот, добавляем её
if (char_slot == -1 && char_count < 8) {
printf("create char\n");
char_slot = char_count;
LCD_CreateChar(char_slot, alphabet[letter_idx]);
used_chars[char_count++] = letter_idx;
}
// Выводим символ, если он есть
if (char_slot != -1) {
printf("print char_slot\n");
LCD_SendData(char_slot);
HAL_Delay(1);
cursor_position++;
} else {
printf("No free slots for letter_idx: %d\n", letter_idx);
}
printf("Letter idx: %d, slot: %d\n\n", letter_idx, char_slot);
}
str += 2; // Пропускаем два байта UTF-8
} else {
// Обычные ASCII символы выводим напрямую
LCD_SendData(*str);
str++;
cursor_position++;
}
}
}
void ShiftOut16(uint16_t data) {
// printf("ShiftOut16: %d\n", data);
// Отправляем 16 бит, начиная со старшего (MSB)
for (uint8_t i = 0; i < 16; i++) {
// Устанавливаем бит данных (DS) на PB4
if (data & (1 << (15 - i))) {
HAL_GPIO_WritePin(GPIOA, A3_PIN_DS, GPIO_PIN_SET);
} else {
HAL_GPIO_WritePin(GPIOA, A3_PIN_DS, GPIO_PIN_RESET);
}
// Импульс на SHCP (PB6) для сдвига данных
HAL_GPIO_WritePin(GPIOA, A5_PIN_SHCP, GPIO_PIN_SET);
HAL_Delay(1); // Задержка для стабильности (можно убрать при оптимизации)
HAL_GPIO_WritePin(GPIOA, A5_PIN_SHCP, GPIO_PIN_RESET);
}
// Импульс на STCP (PB5) для вывода данных на выходы
HAL_GPIO_WritePin(GPIOA, A4_PIN_STCP, GPIO_PIN_SET);
HAL_Delay(1); // Задержка для стабильности
HAL_GPIO_WritePin(GPIOA, A4_PIN_STCP, GPIO_PIN_RESET);
}
void ShiftOut8(uint8_t data) {
// printf("ShiftOut: %d\n", data);
// Отправляем биты по одному, начиная со старшего (MSB)
for (uint8_t i = 0; i < 8; i++) {
// Устанавливаем бит данных (DS)
if (data & (1 << (7 - i))) {
HAL_GPIO_WritePin(GPIOA, A3_PIN_DS, GPIO_PIN_SET);
} else {
HAL_GPIO_WritePin(GPIOA, A3_PIN_DS, GPIO_PIN_RESET);
}
// Импульс на SH_CP (сдвиг данных)
HAL_GPIO_WritePin(GPIOA, A5_PIN_SHCP, GPIO_PIN_SET);
HAL_Delay(1); // Небольшая задержка для стабильности (можно убрать при оптимизации)
HAL_GPIO_WritePin(GPIOA, A5_PIN_SHCP, GPIO_PIN_RESET);
}
// Импульс на ST_CP (перенос данных на выходы)
HAL_GPIO_WritePin(GPIOA, A4_PIN_STCP, GPIO_PIN_SET);
HAL_Delay(1); // Небольшая задержка для стабильности
HAL_GPIO_WritePin(GPIOA, A4_PIN_STCP, GPIO_PIN_RESET);
}
/**
* @brief Считывание канала с 16-и каналиного мультиплексора
* @param channel: Канал
* @retval Int >=0 значение с канала, -1 неверный канал, -2 ошибка чтения, -3 неизвестная ошибка
*/
int Read_Multiplexor16_Channel(uint8_t channel) {
// Проверяем, что канал в допустимом диапазоне (0–15)
if (channel > 15) {
return -1; // Ошибка: неверный канал
}
// printf("channel: %d\n", channel);
// printf("channel & 0x01: %d channel & 0x08: %d channel & 0x08: %d channel & 0x08: %d\n",
// (channel & 0x01), (channel & 0x02), (channel & 0x04), (channel & 0x08));
// Устанавливаем управляющие пины S0–S3
HAL_GPIO_WritePin(GPIOB, D3_PIN_S0, (channel & 0x01) ? GPIO_PIN_SET : GPIO_PIN_RESET); // S0
HAL_GPIO_WritePin(GPIOB, D4_PIN_S1, (channel & 0x02) ? GPIO_PIN_SET : GPIO_PIN_RESET); // S1
HAL_GPIO_WritePin(GPIOB, D5_PIN_S2, (channel & 0x04) ? GPIO_PIN_SET : GPIO_PIN_RESET); // S2
HAL_GPIO_WritePin(GPIOB, D6_PIN_S3, (channel & 0x08) ? GPIO_PIN_SET : GPIO_PIN_RESET); // S3
// Небольшая задержка для стабилизации мультиплексора
HAL_Delay(10);
// Запускаем преобразование ADC
HAL_ADC_Start(&hadc1);
if (HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK) {
uint16_t value = HAL_ADC_GetValue(&hadc1);
HAL_ADC_Stop(&hadc1);
return value;
} else {
HAL_ADC_Stop(&hadc1);
return -2; // Ошибка чтения
}
return -3;
}
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
/** Configure the main internal regulator output voltage
*/
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/** Initializes the RCC Oscillators according to the specified parameters
in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLLMUL_4;
RCC_OscInitStruct.PLL.PLLDIV = RCC_PLLDIV_2;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
| RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
{
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART2;
PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_PCLK1;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief ADC1 Initialization Function
* @param None
* @retval None
*/
static void MX_ADC1_Init(void) {
/* USER CODE BEGIN ADC1_Init 0 */
/* USER CODE END ADC1_Init 0 */
ADC_ChannelConfTypeDef sConfig = {0};
/* USER CODE BEGIN ADC1_Init 1 */
/* USER CODE END ADC1_Init 1 */
/** Common config
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; // Делитель частоты
hadc1.Init.Resolution = ADC_RESOLUTION_12B; // Разрешение 12 бит
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; // Выравнивание вправо
hadc1.Init.ScanConvMode = DISABLE; // Отключить режим сканирования
hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; // Флаг окончания для одиночного преобразования
hadc1.Init.LowPowerAutoWait = DISABLE; // Отключить автозадержку
hadc1.Init.ContinuousConvMode = DISABLE; // Одиночное преобразование
hadc1.Init.DiscontinuousConvMode = DISABLE; // Отключить прерывистый режим
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; // Программный запуск
hadc1.Init.DMAContinuousRequests = DISABLE; // Отключить непрерывные запросы DMA
hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; // Сохранять данные при переполнении
if (HAL_ADC_Init(&hadc1) != HAL_OK) {
Error_Handler();
}
/** Configure Regular Channel
*/
sConfig.Channel = ADC_CHANNEL_0; // Канал 0 для PA_0
sConfig.Rank = ADC_RANK_CHANNEL_NUMBER; // Ранг канала
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN ADC1_Init 2 */
/* USER CODE END ADC1_Init 2 */
}
/**
@brief USART2 Initialization Function
@param None
@retval None
*/
static void MX_USART2_UART_Init(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE();
/**USART2 GPIO Configuration
PA2 ------> USART2_TX
PA15 ------> USART2_RX
*/
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = VCP_TX_Pin | VCP_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_USART2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
huart2.Instance = USART2;
huart2.Init.BaudRate = 115200;
huart2.Init.WordLength = UART_WORDLENGTH_8B;
huart2.Init.StopBits = UART_STOPBITS_1;
huart2.Init.Parity = UART_PARITY_NONE;
huart2.Init.Mode = UART_MODE_TX_RX;
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
if (HAL_UART_Init(&huart2) != HAL_OK)
{
Error_Handler();
}
__HAL_RCC_USART2_CLK_ENABLE();
}
void Error_Handler(void)
{
/* User can add his own implementation to report the HAL error return state */
}
// The following makes printf() write to USART2:
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
int _write(int file, uint8_t *ptr, int len)
{
switch (file)
{
case STDOUT_FILENO:
HAL_UART_Transmit(&huart2, ptr, len, HAL_MAX_DELAY);
break;
case STDERR_FILENO:
HAL_UART_Transmit(&huart2, ptr, len, HAL_MAX_DELAY);
break;
default:
return -1;
}
return len;
}
Loading
st-nucleo-l031k6
st-nucleo-l031k6
Loading
cd74hc4067
cd74hc4067