TRƯỜNG ĐẠI HỌC GIAO THÔNG VẬN TẢI TP.

HỒ CHÍ MINH
KHOA ĐIỆN – ĐIỆN TỬ VIỄN THÔNG

BÁO CÁO BÀI TẬP CUỐI KÌ

HỌC PHẦN: KỸ THUẬT VI XỬ LÝ
Giảng viên hướng dẫn: HOÀNG ĐỨC QUÝ
ĐỀ TÀI: PHOTODIODE BẬT TẮT ĐÈN TỰ ĐỘNG
Danh sách thành viên nhóm :

STT Họ và tên MSSV

1 Phan Phú Điền 21H1040037
2 Trương Gia Bảo 20H1040062
3 Lê Văn Hoàng Anh 20H1040001
4 Nguyễn Nhật Minh 21H1050054

Thành phố Hồ Chí Minh, năm 2023

I. Giới thiệu:
1. Kit STM32F407VET6 Cortex-M4:
Kit sử dụng vi điều khiển STM32F407 là loại được sử dụng ở rất nhiều
trường đại học hiện nay trong giảng dạy vi điều khiển ARM, kit có thiết kế ra
chân đầy đủ với các ngoại vi cơ bản: USB, MicroSD, Flash, Pin RTC...và
cổng nạp chuẩn Jtag tích hợp.
Thông số kỹ thuật:
 Vi điều khiển chính: STM32F407VET6 ARM Cortex-M4
 Nguồn sử dụng: 5VDC từ cổng Mini USB hoặc chân GPIO.
 Thiết kế ra chân GPIO đầy đủ.
 Tích hợp cổng USB.
 Tích hợp khe thẻ nhớ MicroSD.
 Tích hợp bộ nhớ Flash.
 Tích hợp khe pin RTC.
 Tích hợp cổng nạp chuẩn Jtag.
 Tích hợp khe cắm mạch RF NRF24L01+.
 Kích thước: 85 x 73mm.

2
2. Mạch nạp ST link V2:
Mạch hỗ trợ nạp đầy đủ các STM32 thông qua giao diện SWIM và STM8
thông qua giao diện JTAG/SWD và gỡ lỗi giao diện đơn giản,kết nối với PC
thông qua USB 2.0 tốc độ cao.
Phần mềm hỗ trợ:
 Trực tiếp hỗ trợ ST chính thức IDE (phần mềm môi trường phát triển
tích hợp) ST Visual Develop (STVD) và phần mềm ghi ST Visual
Program (STVP).
 Hỗ trợ STM32 như ATOLLIC, IAR, Keil, TASKING.
Thông số kỹ thuật:
 Điện áp cung cấp : 5VDC bằng cổng
USB
 Chức năng lập trình: Có thể ghi và ghi
FLASH ROM, EEPROM, AFR
 Hiệu suất mô phỏng: sử dụng giao diện
USB2.0 để gỡ lỗi
 Hiệu suất lập trình: sử dụng giao diện
USB2.0 để tải xuống SWIM / JTAG /
SWD.
3. Mạch chuyển USB UART PL2303 :
Cáp chuyển USB UART PL2303 được sử dụng để chuyển giao tiếp từ
USB sang UART và ngược lại thông qua cổng COM ảo trên máy tính, cáp
sử dụng IC giá rẻ PL2303 nên có chi phí thấp, đầu ra UART chuẩn Header
cái Female dễ dàng kết nối và sử dụng.

3
Thông số kỹ thuật:
 Điện áp hoạt động : 5VDC ( cổng USB)
 Ngõ ra dạng UART gồm 2 chân TX, RX.
 Với 3 led trên board: led báo nguồn, led RX, led TX.
 Kích thước:45x16mm
 Hỗ trợ một số các hệ điều hành cũ Win XP, Win7,Linux,…

4. LCD xanh dương 1602 kết hợp module PCF 8574 giao tiếp I2C
sang LCD:
Lcd xanh dương 1602 hiển thị 16 kí tự và 2 dòng
, màn hình được thiết
kế tốt độ bền cao được ứng dụng rất phổ biến.
Thông số kỹ thuật:
 Điện áp hoạt động : 5VDC
 Kích thước : 80x36x12.5mm
 Chữ trắng , nền xanh dương
 Khoảng cách giữa các chân là 0.1inch dễ
dàng kết nối Breadboard
5.Cảm biến ánh sáng photodiode:

4
Cảm biến ánh sáng Photodiod Light Sensor sử dụng Photodiode thay vì quang trở
để cảm biến ánh sáng nên cho độ chính xác và độ ổn định cao, cảm biến có
Opamp tích hợp cho cả hai ngõ ra tín hiệu là Digital và Analog rất dễ sử dụng,
thích hợp cho các ứng dụng nhận biết sáng tối, cảm biến cường độ sáng,...

Thông số kỹ thuật:
 Nguồn: 3.3 5VDC
 Sử dụng photodiode cho độ chính xác cao.
 Xuất tín hiệu Digital tinh chình bằng biến trở trên mạch hoặc Analog rất dễ sử
dụng.
 Kích thước: 30 x 16mm
A0 Ngõ ra tín hiệu Analog
DO Ngõ ra tín hiệu Digital
VCC Nguồn 3.3~5VDC

5
GND Mass

II. Cách thức hoạt động

Photodiode là một loại cảm biến ánh sáng được sử dụng để phát hiện hoặc đo lường
mức độ ánh sáng. Trong ứng dụng điều khiển đèn tự động trong STM32F4,
photodiode có thể được sử dụng để phát hiện mức độ sáng trong môi trường xung
quanh và kích hoạt chức năng bật/tắt đèn tự động.
Cách thức hoạt động thông thường là khi mức độ ánh sáng đạt đến một ngưỡng
được định trước, photodiode sẽ tạo ra một dòng điện tương ứng. Điện áp hoặc dòng
điện này có thể được đo bằng cách sử dụng các chân ADC (Analog-to-Digital
Converter) trên vi điều khiển STM32F4.
1. Photodiode: Một photodiode được đặt ở vị trí nơi cần theo dõi mức ánh sáng.
Khi mức ánh sáng chịu sự thay đổi, photodiode sẽ phát hiện và tạo ra một tín hiệu
điện tương ứng.
2. Điều khiển ADC: Tín hiệu từ photodiode được đưa vào một kênh ADC (Analog-
to-Digital Converter) trên vi điều khiển STM32F4. ADC sẽ chuyển đổi tín hiệu
analog thành một giá trị số để xử lý.
3. Xử lý và quyết định: Giá trị số từ ADC được xử lý bởi vi điều khiển STM32F4
để đưa ra quyết định về việc bật hoặc tắt đèn. Các ngưỡng ánh sáng được thiết lập
sẽ xác định mức ánh sáng cần thiết để bật hoặc tắt đèn.
4. Điều khiển đèn: Sau khi quyết định được đưa ra, vi điều khiển STM32F4 sẽ điều
khiển bật hoặc tắt đèn thông qua các chân GPIO (General Purpose Input/Output)
được kết nối với hệ thống đèn.
Khi mức độ ánh sáng thấp (ví dụ: trong điều kiện tối), photodiode sẽ tạo ra một
dòng điện thấp hoặc không có dòng điện. Điều này có thể được sử dụng để kích

6
hoạt chức năng bật đèn tự động trong thiết bị STM32F4. Khi mức độ ánh sáng tăng
lên (ví dụ: trong điều kiện sáng), photodiode sẽ tạo ra một dòng điện cao hơn, và có
thể được sử dụng để kích hoạt chức năng tắt đèn tự động.
Bằng cách sử dụng các chân GPIO (General Purpose Input/Output) trên STM32F4,
có thể kết nối photodiode và lập trình vi điều khiển để theo dõi giá trị đo được từ
photodiode và thực hiện các hành động bật/tắt đèn dựa trên mức độ ánh sáng đo
được.
Qua đó, vi điều khiển STM32F4 có thể được sử dụng để tạo ra một hệ thống điều
khiển đèn tự động dựa trên mức độ ánh sáng được đo bằng photodiode.
Tóm lại khi ánh sáng chiếu vào photondiode lấp đầy vùng nghèo làm tăng tính dẫn
điện và ngược lại. Sự biến thiên đó được ghi nhận bởi chức năng ADC và khi ràng
buộc bởi điều kiện if ,chương trình điều khiển đèn led sáng hoặc tắt.
III. Sơ đồ Mạch:
Sơ đồ khối:

Khối nguồn

3,3v

7
Khối cảm
Khối vi xử lý
Sơ đồ chức năng:
Vcc -> 3.3v

3.3V GND

Do -> Gnd
Gnd
SDA->PB7
Ao->Pa0
Vcc -> 3.3v

RXD->PA9
SCL->PD6

TXD->PA10

8
Lưu đồ giải thuật:

9
IV. Thiết kế hệ thống
Để thiết kế một hệ thống sử dụng photodiode để bật/tắt đèn tự động trong
STM32F4,cần thực hiện các bước:
Bước 1: Chuẩn bị thiết bị và linh kiện
- STM32F4 Discovery Kit hoặc một bo mạch STM32F4 tương tự.
- Mạch nạp ST link V2:
- Mạch chuyển USB UART PL2303
- LCD xanh dương 1602 kết hợp module PCF 8574 giao tiếp I2C sang LCD:
- Cảm biến ánh sáng Photodiode
Bước 2: Kết nối phần cứng
- Kết nối chân dương của photodiode với chân ANALOG INPUT của STM32F4.
- Kết nối chân âm của photodiode với một nguồn điện âm nếu cần thiết.
- Kết nối đèn LED với một chân GPIO OUTPUT của STM32F4.

1
Bước 3: Cấu hình GPIO và ADC
- Cấu hình chân GPIO OUTPUT để điều khiển đèn LED.
- Cấu hình chân GPIO ANALOG INPUT và ADC để đọc giá trị ánh sáng từ
photodiode.

Bước 4: Lập trình

- Sử dụng thư viện HAL (Hardware Abstraction Layer) của STM32F4 để lập
trình.
- Thiết lập chức năng GPIO OUTPUT để điều khiển đèn LED.
- Thiết lập chức năng GPIO ANALOG INPUT và ADC để đọc giá trị ánh sáng từ
photodiode.
- Đọc giá trị ADC từ chân ANALOG INPUT.
- Dựa trên giá trị đọc được, quyết định khi nào bật/tắt đèn LED.

1
- Sử dụng hàm GPIO_WritePin để điều khiển chân GPIO OUTPUT để bật/tắt đèn
LED.

Phụ lục

1
Code
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/

/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "string.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/

/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/

/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/

/* USER CODE BEGIN PM */

/* USER CODE END PM */

1
/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;

I2C_HandleTypeDef hi2c1;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

uint16_t lightcount;
char msg[15] ;
int i;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_ADC1_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* MCU Configuration--------------------------------------------------------*/

/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();

/* USER CODE BEGIN Init */

1
 /* USER CODE END Init */

/* Configure the system clock */

SystemClock_Config();

/* USER CODE BEGIN SysInit */

/* USER CODE END SysInit */

/* Initialize all configured peripherals */

MX_GPIO_Init();
MX_ADC1_Init();
MX_I2C1_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
#include <i2c-lcd.h>
lcd_init();
lcd_put_cur(0,0);
lcd_send_string("7 sands");

/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
HAL_ADC_Start(&hadc1);
HAL_ADC_PollForConversion(&hadc1, 20);
lightcount=HAL_ADC_GetValue(&hadc1);
sprintf(msg,"light: %u",lightcount);
HAL_UART_Transmit(&huart1, (uint8_t*)msg , sizeof(msg), 100);
///for a count of time uart transmit a pack of information. Adjust this mean
update period being slower or faster. In reality to avoid a conflic when sunset make
the led toggle set the number 100 to thousand or bilion of milisecond///
if (HAL_ADC_GetValue(&hadc1)>2000){HAL_GPIO_WritePin(GPIOE, 7, SET);}
//for (int i=0;i<15;i++){msg[i]=lightcount;}
lcd_put_cur(1,0);
lcd_send_string(msg);
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}

1
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

/** Configure the main internal regulator output voltage

*/
__HAL_RCC_PWR_CLK_ENABLE();
__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_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLM = 4;
RCC_OscInitStruct.PLL.PLLN = 168;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
RCC_OscInitStruct.PLL.PLLQ = 4;
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_DIV4;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)

{
Error_Handler();
}
}

1
/**
* @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 */

/** Configure the global features of the ADC (Clock, Resolution, Data Alignment and
number of conversion)
*/
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV8;
hadc1.Init.Resolution = ADC_RESOLUTION_12B;
hadc1.Init.ScanConvMode = DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.DMAContinuousRequests = DISABLE;
hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
if (HAL_ADC_Init(&hadc1) != HAL_OK)
{
Error_Handler();
}

/** Configure for the selected ADC regular channel its corresponding rank in the
sequencer and its sample time.
*/
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;

1
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN ADC1_Init 2 */

/* USER CODE END ADC1_Init 2 */

/**
* @brief I2C1 Initialization Function
* @param None
* @retval None
*/
static void MX_I2C1_Init(void)
{

/* USER CODE BEGIN I2C1_Init 0 */

/* USER CODE END I2C1_Init 0 */

/* USER CODE BEGIN I2C1_Init 1 */

/* USER CODE END I2C1_Init 1 */

hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN I2C1_Init 2 */

/* USER CODE END I2C1_Init 2 */

/**

1
 * @brief USART1 Initialization Function
* @param None
* @retval None
*/
static void MX_USART1_UART_Init(void)
{

/* USER CODE BEGIN USART1_Init 0 */

/* USER CODE END USART1_Init 0 */

/* USER CODE BEGIN USART1_Init 1 */

/* USER CODE END USART1_Init 1 */

huart1.Instance = USART1;
huart1.Init.BaudRate = 115200;
huart1.Init.WordLength = UART_WORDLENGTH_8B;
huart1.Init.StopBits = UART_STOPBITS_1;
huart1.Init.Parity = UART_PARITY_NONE;
huart1.Init.Mode = UART_MODE_TX_RX;
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART1_Init 2 */

/* USER CODE END USART1_Init 2 */

/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

/* GPIO Ports Clock Enable */

__HAL_RCC_GPIOH_CLK_ENABLE();

1
 __HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();

/*Configure GPIO pin Output Level */

HAL_GPIO_WritePin(GPIOE, GPIO_PIN_7, GPIO_PIN_RESET);

/*Configure GPIO pin : PE7 */

GPIO_InitStruct.Pin = GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */

/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/

2
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/** Put this in the src folder **/

#include "i2c-lcd.h"
extern I2C_HandleTypeDef hi2c1; // change your handler here accordingly

#define ADDR_FOR_READ_LCD 0x4F // change this according to ur setup

#define ADDR_FOR_WRITE_LCD 0x4E//0x4E
void lcd_send_cmd (char cmd)
{
char data_u, data_l;
uint8_t data_t[4];
data_u = (cmd&0xf0);
data_l = ((cmd<<4)&0xf0);
data_t[0] = data_u|0x0C;
data_t[1] = data_u|0x08;
data_t[2] = data_l|0x0C;
data_t[3] = data_l|0x08;
HAL_I2C_Master_Transmit (&hi2c1, ADDR_FOR_READ_LCD,(uint8_t *) data_t, 4, 100);
}

void lcd_send_data (char data)

{
char data_u, data_l;
uint8_t data_t[4];
data_u = (data&0xf0);
data_l = ((data<<4)&0xf0);
data_t[0] = data_u|0x0D;
data_t[1] = data_u|0x09;
data_t[2] = data_l|0x0D;
data_t[3] = data_l|0x09;
HAL_I2C_Master_Transmit (&hi2c1, ADDR_FOR_READ_LCD,(uint8_t *) data_t, 4, 100);
}

2
void lcd_clear (void)
{
lcd_send_cmd (0x80);
for (int i=0; i<70; i++)
{
lcd_send_data (' ');
}
}

void lcd_put_cur(int row, int col)

{
switch (row)
{
case 0:
col |= 0x80;
break;
case 1:
col |= 0xC0;
break;
}

lcd_send_cmd (col);
}

void lcd_init (void)

{
// 4 bit initialization
HAL_Delay(16); //16>4.1>100us
lcd_send_cmd (0x30);
HAL_Delay(4.2);
lcd_send_cmd (0x30);
HAL_Delay(1.1/10);
lcd_send_cmd (0x30);
lcd_send_cmd (0x20);

// display initialization
lcd_send_cmd (0x28);
HAL_Delay(1);
lcd_send_cmd (0x08);
HAL_Delay(1);
lcd_send_cmd (0x01);
HAL_Delay(1);
HAL_Delay(1);
lcd_send_cmd (0x06);

2
 HAL_Delay(1);
lcd_send_cmd (0x0C);
}

void lcd_send_string (char *str)

{
while (*str) lcd_send_data (*str++);
}

//void lcd_de_stack_variable ()

/*
* i2c_lcd.h
*
* Created on: Dec 22, 2023
* Author: Dell Vostro 3400
*/
#include "stm32f4xx_hal.h"

void lcd_init (void); // initialize lcd

void lcd_send_cmd (char cmd); // send command to the lcd

void lcd_send_data (char data); // send data to the lcd

void lcd_send_string (char *str); // send string to the lcd

void lcd_put_cur(int row, int col); // put cursor at the entered position row (0 or
1), col (0-15);

void lcd_clear (void);

Header file
V. Kết luận
Kết luận là trong vi điều khiển STM32F4, photodiode được sử dụng để
phát hiện mức ánh sáng và điều khiển việc bật tắt đèn tự động. Tín hiệu từ
photodiode được chuyển đổi thành tín hiệu điện và sau đó được xử lý bởi

2
 vi điều khiển. Vi điều khiển sẽ đưa ra quyết định về việc bật hoặc tắt đèn
dựa trên giá trị ánh sáng được đo.
Link video:
https://www.youtube.com/shorts/UofZEEg2Ssw
Họ và tên Phân công công việc Đánh giá
Làm powerpoint thuyết
Lê Văn Hoàng Anh trình, báo cáo, tham gia Hoàn thành
làm sản phẩm
Thuyết trình ,tham gia
Trương Gia Bảo Hoàn thành
làm sản phẩm

Nguyễn Nhật Minh Tham gia làm sản phẩm Hoàn thành

Tham gia làm sản phẩm

Phan Phú Điền Hoàn thành
chính