파워 유튜버

[PCB#10] 아두이노(arduino) 보드를 직접 DIY할수 있는 PCB, PCBA 주문해보기 이어서 해보기!(녹칸다 easyeda시리즈)

덕력킹 — Wed, 22 Apr 2026 21:01:29 +0900

[PCB#10] 아두이노(arduino) 보드를 직접 DIY할수 있는 PCB, PCBA 주문해보기 이어서 해보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d7fbab4ea2_1_120#slide=id.g3d7fbab4ea2_1_120

아두이노 우노 SMT버전 만들어보기!

00:00:00 전반적인 개요
00:07:16 프로젝트 생성 및 부품선정하기!

01:04:11 PCB편집하기!
02:00:23 실크스크린넣기!02:10:22 실습보드 가상 주문해보기!

02:20:03 실습보드 작동시키는 방법!

[PCB#9] 아두이노(arduino) 보드를 직접 DIY할수 있는 PCB, PCBA 주문해보기!(녹칸다 easyeda시리즈)

덕력킹 — Mon, 20 Apr 2026 23:07:10 +0900

https://youtube.com/live/7NV0KUawu6g

[PCB#9] 아두이노(arduino) 보드를 직접 DIY할수 있는 PCB, PCBA 주문해보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d591aa4ff5_1_0#slide=id.g3d591aa4ff5_1_0

아두이노 보드를 직접 만들어보기!

00:00:00 전반적인 개요
00:10:26 아두이노 우노 최소보드 만들기!

01:52:17 DIY아두이노 보드 구동시키기!

[PCB#8] JLCPCB에서 PCB를 납땜까지 싹 해주는 PCBA주문하는 방법 알아보기!(녹칸다 easyeda시리즈)

덕력킹 — Wed, 8 Apr 2026 15:20:35 +0900

https://youtube.com/live/DbeCEYEmf5g

[PCB#8] JLCPCB에서 PCB를 납땜까지 싹 해주는 PCBA주문하는 방법 알아보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d4bd6fa2c8_1_184#slide=id.g3d4bd6fa2c8_1_184

PCBA주문 해보기!

00:00:00 전반적인 개요
00:01:44 PCBA주문을 위한 사전 준비작업
00:14:24 PCBA주문 시나리오1
00:57:21 시나리오1번에서 수동으로 업로드 하는 경우!
01:07:37 이코노믹 주문과 스탠다드 주문의 차이!
01:18:04 다른사람이 만든 PCB를 PCBA주문해보기!(시나리오2)
01:47:01 JLCPCB쪽 주문화면에서 실시간으로 부품을 교체하기!(시나리오3)
02:00:33 JLCPCB엔지니어의 피드백

[PCB#7] 본격 PCB를 JLCPCB에 주문하는 방법과 절차를 알아보기!(녹칸다 easyeda시리즈)

덕력킹 — Mon, 6 Apr 2026 22:54:43 +0900

https://youtube.com/live/PA7uLXogXkE

[PCB#7] 본격 PCB를 JLCPCB에 주문하는 방법과 절차를 알아보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d49c472ec1_1_0#slide=id.g3d49c472ec1_1_0

PCB생산하기!

00:00:00 전반적인 개요
00:04:31 녹칸다가 생각하는 PCB주문의 유형
00:09:11 PCB와 PCBA주문의 방식
00:19:23 PCB주문하기 간딴 방법 실습!
00:59:18 주문이 완료된 상태에서 벌어지는일들
01:06:30 PCB를 거버파일로 주문하는 방식의 실습
01:11:36 패널화에 대해서 알아보기!
01:26:59 V-CUT에 대해서 알아보기!
01:53:46 마우스바이트에 대해서 알아보기!

[PCB#6] PCB를 멋지게 꾸미기 위한 확장스크립트(Label Maker, Smooth Tracks, QRCode)에 대해 알아보기!(녹칸다 easyeda시리즈)

덕력킹 — Wed, 1 Apr 2026 15:58:43 +0900

https://youtube.com/live/wGWx_PczMaA

[PCB#6] PCB를 멋지게 꾸미기 위한 확장스크립트(Label Maker, Smooth Tracks, QRCode)에 대해 알아보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d363c4382e_1_219#slide=id.g3d363c4382e_1_219

PCB꾸며보기!

00:00:00 전반적인 개요
00:03:57 Label Maker 설치 및 사용

00:18:10 smooth track 설치 및 사용

00:31:10 QRcode 설치 및 사용

00:38:00 응용예제1 온습도센서 측정보드!

01:19:46 응용예제2 부저보드!

02:02:10 응용예제3 릴레이 제어 회로!

[PCB#5] 녹칸다가 주로 사용하는 커넥터(connector)에 대해서 알아보기!(녹칸다 easyeda시리즈)

덕력킹 — Mon, 30 Mar 2026 23:01:50 +0900

https://youtube.com/live/q0Gt68rqRp8

[PCB#5] 녹칸다가 주로 사용하는 커넥터(connector)에 대해서 알아보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d339095204_1_160#slide=id.g3d339095204_1_160

녹칸다가 주로 사용하는 커넥터에 대해서 알아보기!

00:00:00 전반적인 개요
00:07:28 피치가5.0mm인 터미널블록(KF301)

00:24:36 U자케이블을 PCB에 연결하는 터미널블록

00:47:11 JST XH2.54커넥터

01:12:27 MOLEX 5267 커넥터

01:24:22 랜선 커넥터(RJ45)

01:44:38 박스헤더커넥터

02:04:18 USB A커넥터

02:16:34 USB C커넥터

02:19:46 MSL-1C2P 스위치

02:30:19 로커 스위치

[PCB#4] 심볼과 풋프린트를 직접 만들어서 사용해보기!(녹칸다 easyeda시리즈)

덕력킹 — Wed, 25 Mar 2026 15:30:15 +0900

https://youtube.com/live/7f7iAekQ17Q

[PCB#4] 심볼과 풋프린트를 직접 만들어서 사용해보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d1c0149169_1_210#slide=id.g3d1c0149169_1_210

없으면 만들어서 쓰는 것!

00:00:00 전반적인 개요

00:07:28 ADM101E라는 부품의 심볼과 풋프린트 만들어보기!

00:39:39 10핀 헤더 그려보기!

00:57:16 D55캐패시터 그려보기!

01:08:47 crystal그려보기!

01:19:37 나머지 부품도 다 지정해서 전자캐드기능사를 easyeda버전으로 해보기!

(그냥 오토라우팅 해버리기)

[PCB#3] 여러가지 상황별로 접근하는 방법과 해결하는 방법을 알아보기!(녹칸다 easyeda시리즈)

덕력킹 — Mon, 23 Mar 2026 22:58:43 +0900

https://youtube.com/live/CMeNtMX9sm0

[PCB#3] 여러가지 상황별로 접근하는 방법과 해결하는 방법을 알아보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d19a36360e_1_0#slide=id.g3d19a36360e_1_0

상황을 설정하고 해결하는 방법을 알아봅시다!

00:00:00 전반적인 개요
00:03:15 클리어런스란 무엇인가요?

00:14:15 부품의 풋프린트를 꼭 앞면에만 배치할 수 있나요?

00:21:36 풋프린트가 변경되었을때 어떤 절차가 필요한가요?

00:29:55 배선이 완료된 상태에서 네트라벨이 변경되었을때 어떤 절차가 필요한가요?

00:39:20 배선을 하다보니 copper pour에 고립된 영역이 생겼어요!

00:51:03 내가 지정한 영역에 copper pour를 안하고 싶을때 어떻게 하나요?

01:06:58 보드 내부에 다각형 구멍을 내려면 어떻게 해야하나요?

01:25:16 네트별로 배선두께나 기타 설정을 프리셋으로 만들수 없나요?

01:36:49 정확한 위치에 부품을 놓으려면 어떻게 해야하나요?

02:00:30 배선에 코팅을 벗기려면 어떻게 해야하나요?

02:17:22 조금더 멋지게 생긴 마운팅홀을 적용하려면 어떻게 해야하나요?

02:22:44 지금 PCB에서 테두리를 둥글게 하려면 어떻게 해야하나요?

[PCB#2] 아두이노 나노(arduino nano)를 꽂아서 쓸수 있는 PCB보드 4종 디자인 해보기!(녹칸다 easyeda시리즈)

덕력킹 — Wed, 18 Mar 2026 19:00:31 +0900

https://youtube.com/live/FCLd38JWAwM

[PCB#2] 아두이노 나노(arduino nano)를 꽂아서 쓸수 있는 PCB보드 4종 디자인 해보기!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3d7759b24b5_1_266#slide=id.g3d7759b24b5_1_266

연습을 조금 해봅시다!

1.아두이노 나노보드를 이용한 신호등 제어(LED3, 버튼3)

2.아두이노 나노보드를 이용한 서보모터 제어(with 가변저항)

3.아두이노 나노보드를 이용한 스탭모터 제어(버튼3)

4.아두이노 나노보드를 이용한 모터드라이버 제어(버튼3, 가변저항)

[PCB#1] EasyEDA를 이용해서 취미용으로 PCB를 만드는 방법에 대해서 알아보자!(녹칸다 easyeda시리즈)

덕력킹 — Mon, 16 Mar 2026 23:06:47 +0900

https://youtube.com/live/I4hqlzPq2Cs

[PCB#1] EasyEDA를 이용해서 취미용으로 PCB를 만드는 방법에 대해서 알아보자!(녹칸다 easyeda시리즈)

심심한녹칸다의 easyeda로 PCB만들기 시리즈이다!

시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1UbMD0OMAamiVlwZupaN-_ZXcfirt9dmHdXeu39SRca0/edit?slide=id.g3c5a9ea53db_0_6#slide=id.g3c5a9ea53db_0_6

PCB만들기를 시작해봅시다!

00:00:00 전반적인 목표 및 목적 설명
00:30:00 튜토리얼 예제 만들어보기!
00:46:00 튜토리얼 예제 만들어보기!
00:50:00 심볼, 전원 심볼, 네트, 네트라벨, 풋프린트, 참조라벨 용어 설명
01:27:00 TH부품과 SMD부품에 대해서 알아보기!
01:34:00 패드(pad)와 비아(via)에 대해서 알아보기!
01:50:00 레이어란 무엇인가?
02:04:00 아두이노 나노를 이용한 간단한 PCB 만들기!

(튜토리얼 예제의 PCB)

(아두이노 나노를 연결해서 쓸수있는 PCB)

[STM32#40] TOUCHGFX와 CAN통신으로 PC와 통신하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Fri, 13 Mar 2026 19:17:06 +0900

https://youtube.com/live/mpJLqsrDBf8

[STM32#40] TOUCHGFX와 CAN통신으로 PC와 통신하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3c579db4ff3_1_219#slide=id.g3c579db4ff3_1_219

캔통신 해보기!

(소스코드는 수정해야할 파일이 너무 많아서 위쪽 구글 슬라이드를 참고해주세용)

1.f746보드에 touchgfx로 버튼을 4개 생성하고 1번 버튼을 누르면 stm32가 전송하는 캔메시지에 1이라는 값이 포함되도록하고, 2번버튼을 누르면 2가 포함되도록 해서 PC쪽에서 데이터를 확인했을때 어떤 버튼이 눌려졌는지를 알수있도록 하시오!(STM32에서 터치해서 PC쪽으로 전송)

2.(예제1과 동시에 동작함)PC쪽 캔통신 프로그램에서 캔메시지를 전송하면 전송된 캔메시지를 touchgfx로 만든 UI에 출력되도록 하시오! 캔메시지는 8개의 byte로 구성되도록하고 8개의 byte값을 8개의 textarea를 이용해서 출력하시오!(PC에서 STM32쪽으로 전송)

[STM32#39] TOUCHGFX와 RS485통신으로 modbus rtu 4채널릴레이와 온습도센서를 연동시켜보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 9 Mar 2026 23:06:40 +0900

https://youtube.com/live/OakFHTboOmw

[STM32#39] TOUCHGFX와 RS485통신으로 modbus rtu 4채널릴레이와 온습도센서를 연동시켜보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3cde51f01c7_2_0#slide=id.g3cde51f01c7_2_0

RS485통신과 modbus rtu!

(소스코드는 수정해야할 파일이 너무 많아서 위에있는 구글 슬라이드를 참고해주세용)

1.RS485모듈을 F746보드의 uart7에 연결하고 touchgfx로 버튼 8개를 작화해서 버튼을 터치했을때 4채널릴레이의 0~3번 채널까지의 릴레이를 on/off하는 기능을 구현하시오!(4채널릴레이의 ID는 1로 지정되어있음)

2.이번에는 modbus rtu로 동작하는 온습도센서를 연결해서 측정한 온도와 습도값을 touchgfx를 이용해서 화면에 출력하고, 센서와 통신에 성공했는지 아닌지 여부를 알수있도록 하시오!(온습도센서의 ID는 1로 지정되어있음)

[STM32#38] STM32F746g-DISCO보드의 센서값을 TOUCHGFX를 이용해서 LCD에 출력하는 방법 계속 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 4 Mar 2026 21:18:41 +0900

https://youtube.com/live/ECkkotogUdM

[STM32#38] STM32F746g-DISCO보드의 센서값을 TOUCHGFX를 이용해서 LCD에 출력하는 방법 계속 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g386cae80b9f_3_353#slide=id.g386cae80b9f_3_353

하드웨어와 상호작용!

(소스코드는 수정해야할 파일이 너무 많아서 상단에 있는 구글 슬라이드에 내용을 참고하세용)

1.D2(PG6)와 D4(PG7)에 연결된 버튼이 있고 D2버튼을 누르면 기름이 주유된다! 그리고 D3버튼을 누르면 주유량이 초기화된다! 이때 D2버튼을 계속 누르고 있으면 주유가 되고, 안누르면 멈추도록 하시오!
-D2버튼을 누르면 주유속도가 몇이냐?(200ml/s)
-LCD화면에 출력할 정보가 무엇인가? 현재 주유량+금액(1650원/L)

2.A0(PA0),A1(PF10),A2(PF9),A3(PF8)에 연결된 아날로그 4종세트의 값을 LCD화면에 보기좋게 textarea로 출력하시오![ADC설정참고자료] [NTC서미스터참고자료]
-A0(가변저항), A1(가변저항), A2(CDS), A3(NTC서미스터)

3.D7(PI3)에 연결된 온습도센서(DHT-11)에서 측정한 온도와 습도값을 LCD화면에 보기 좋게 textarea로 출력하시오!

4.예제3에서 만든 온습도측정기의 화면을 미려하게 꾸며보시오!

[STM32#37] STM32F746g-DISCO보드의 센서값을 TOUCHGFX를 이용해서 LCD에 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 2 Mar 2026 23:04:16 +0900

https://youtube.com/live/JiKzsrZzkvs

[STM32#37] STM32F746g-DISCO보드의 센서값을 TOUCHGFX를 이용해서 LCD에 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3cbf92cef5c_2_1#slide=id.g3cbf92cef5c_2_1

하드웨어와 상호작용!

(37편은 수정해야할 파일이 너무 방대해서 구글 슬라이드에 있는 코드를 참고해주세용)

1.녹칸다가 버튼이 D2,D4,D5로 3개 있고 순서대로 STM32핀번호로 보면 PG6,PG7,PI0이렇게 될때 D2버튼을 누르면 값이 1씩 업카운트되고, D4버튼을 누르면 다운카운트되고, D5버튼을 누르면 0으로 초기화 되도록하고 튜토리얼 예제에서 출력되는 숫자값을 카운터값으로 대체하시오!

2.가변저항이 A0과 A1에 연결되어있고 GPIO로 보면 순서대로 PA0, PF10에 연결되어있을때 측정한 값을 100밀리초 간격으로 touchgfx화면에 textarea를 2개 이용해서 출력하시오!(전송값을 uint16_t로 전송함)

3.예제2번에 추가해서 측정한 2개의 아날로그값으로 A0은 막대형태의 프로그레스바의 값을 0~4095의 범위로 조정하고 A1의 값은 원호형태의 프로그레스바의 값을 조정가능 하도록 하시오!

4.예제2번에서 gauge위젯 2개를 touchgfx로 작화하고 A0과 A1의 값을 0~4095로 변경하면 게이지의 바늘이 움직이도록 하시오!

[STM32#35] LCD가 내장된 STM32F746g-DISCO보드로 TOUCHGFX를 시작하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 23 Feb 2026 23:11:58 +0900

https://youtube.com/live/BoOS2gsGBY0

[STM32#35] LCD가 내장된 STM32F746g-DISCO보드로 TOUCHGFX를 시작하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3c8649eefc9_1_37#slide=id.g3c8649eefc9_1_37

이제부터 touchgfx를 해보는 것입니다~!

1.Touchgfx를 이용해서 button 2개와 textarea 1개를 생성하고 버튼1을 누르면 NOCKANDA라고 textarea에 출력하고 버튼2를 누르면 SUBSCRIBE라고 출력하시오!

2.위젯중에 토글버튼을 하나 추가하고 토글버튼의 상태가 바뀔때 ON상태면 circleProgress1의 값이 50이 되고 OFF상태면 0이되도록 하시오!

//Screen1View.hpp
#ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
class Screen1View : public Screen1ViewBase
{
public:
   Screen1View();
   virtual ~Screen1View() {}
   virtual void setupScreen();
   virtual void tearDownScreen();
   virtual void test1(); //나 test1 오버라이딩 할꺼야!
protected:
};
#endif // SCREEN1VIEW_HPP

//Screen1View.cpp
#include <gui/screen1_screen/Screen1View.hpp>
Screen1View::Screen1View()
{
}
void Screen1View::setupScreen()
{
   Screen1ViewBase::setupScreen();
}
void Screen1View::tearDownScreen()
{
   Screen1ViewBase::tearDownScreen();
}
void Screen1View::test1(){
	if(!toggleButton1.getState()){
		//토글버튼이 ON이면 circleProgress1에 50출력
		circleProgress1.setValue(50);
	}else{
		//토글버튼이 OFF이면 circleProgress1에 0출력
		circleProgress1.setValue(0);
	}
}

3.위젯중에 슬라이더를 추가하고 0~100사이의 값으로 바뀌는 슬라이드의 현재값을 textarea1에 출력하시오!

//Screen1View.hpp
#ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
class Screen1View : public Screen1ViewBase
{
public:
   Screen1View();
   virtual ~Screen1View() {}
   virtual void setupScreen();
   virtual void tearDownScreen();
   //textarea에 값을 출력하기 위한 중간변수
   touchgfx::Unicode::UnicodeChar testTextAreaBuffer[10];
   //슬라이더 값이 바뀌면 호출되는 함수
   virtual void test1(int value);
protected:
};
#endif // SCREEN1VIEW_HPP

//Screen1View.cpp
#include <gui/screen1_screen/Screen1View.hpp>
Screen1View::Screen1View()
{
}
void Screen1View::setupScreen()
{
   Screen1ViewBase::setupScreen();
   //textArea1에 추가한 와일드카드에 출력할 버퍼
   textArea1.setWildcard(testTextAreaBuffer);
   //처음 부팅될때 초기값 입력
   Unicode::snprintf(testTextAreaBuffer, 10,"%d", 0);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
}
void Screen1View::tearDownScreen()
{
   Screen1ViewBase::tearDownScreen();
}
void Screen1View::test1(int value){
	//현재슬라이더값인 value를 textarea1에 출력한다!
	//현재 슬라이더값을 버퍼에 대입한다!
	Unicode::snprintf(testTextAreaBuffer, 10,"%d", value);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
}

4.슬라이더값을 0~100사이로 바꿀수 있도록 하고, 박스프로그레스의 범위를 0~100사이로 지정해서 슬라이더값이 바뀔때마다 박스프로그레스를 업데이트하시오!

//Screen1View.hpp
#ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
class Screen1View : public Screen1ViewBase
{
public:
   Screen1View();
   virtual ~Screen1View() {}
   virtual void setupScreen();
   virtual void tearDownScreen();
   //textarea에 값을 출력하기 위한 중간변수
   touchgfx::Unicode::UnicodeChar testTextAreaBuffer[10];
   //슬라이더 값이 바뀌면 호출되는 함수
   virtual void test1(int value);
protected:
};
#endif // SCREEN1VIEW_HPP

//Screen1View.cpp
#include <gui/screen1_screen/Screen1View.hpp>
Screen1View::Screen1View()
{
}
void Screen1View::setupScreen()
{
   Screen1ViewBase::setupScreen();
   //textArea1에 추가한 와일드카드에 출력할 버퍼
   textArea1.setWildcard(testTextAreaBuffer);
   //처음 부팅될때 초기값 입력
   Unicode::snprintf(testTextAreaBuffer, 10,"%d", 0);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
}
void Screen1View::tearDownScreen()
{
   Screen1ViewBase::tearDownScreen();
}
void Screen1View::test1(int value){
	//현재슬라이더값인 value를 textarea1에 출력한다!
	//현재 슬라이더값을 버퍼에 대입한다!
	Unicode::snprintf(testTextAreaBuffer, 10,"%d", value);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
               boxProgress1.setValue(value);//박스프로그레스바 값 업데이트
}

5.슬라이더값을 0~100사이로 바꿀때 gauge를 추가해서 0~100사이로 값이 바뀌도록 하시오!

//Screen1View.hpp
#ifndef SCREEN1VIEW_HPP
#define SCREEN1VIEW_HPP
#include <gui_generated/screen1_screen/Screen1ViewBase.hpp>
#include <gui/screen1_screen/Screen1Presenter.hpp>
class Screen1View : public Screen1ViewBase
{
public:
   Screen1View();
   virtual ~Screen1View() {}
   virtual void setupScreen();
   virtual void tearDownScreen();
   //textarea에 값을 출력하기 위한 중간변수
   touchgfx::Unicode::UnicodeChar testTextAreaBuffer[10];
   //슬라이더 값이 바뀌면 호출되는 함수
   virtual void test1(int value);
protected:
};
#endif // SCREEN1VIEW_HPP

//Screen1View.cpp
#include <gui/screen1_screen/Screen1View.hpp>
Screen1View::Screen1View()
{
}
void Screen1View::setupScreen()
{
   Screen1ViewBase::setupScreen();
   //textArea1에 추가한 와일드카드에 출력할 버퍼
   textArea1.setWildcard(testTextAreaBuffer);
   //처음 부팅될때 초기값 입력
   Unicode::snprintf(testTextAreaBuffer, 10,"%d", 0);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
}
void Screen1View::tearDownScreen()
{
   Screen1ViewBase::tearDownScreen();
}
void Screen1View::test1(int value){
	//현재슬라이더값인 value를 textarea1에 출력한다!
	//현재 슬라이더값을 버퍼에 대입한다!
	Unicode::snprintf(testTextAreaBuffer, 10,"%d", value);
	textArea1.invalidate(); //UI업데이트
	textArea1.resizeToCurrentText(); //UI업데이트
	textArea1.invalidate(); //UI업데이트
               gauge1.setValue(value);//게이지 값 업데이트
}

녹칸다의 STM32f746g-DISCO 테스트보드를 만들기위한 거버파일 파일

덕력킹 — Tue, 17 Feb 2026 20:28:00 +0900

stm32f746g-disco보드는 LCD가 있는 STM32보드인데, GPIO가 뒷면에 있어서 연결하기가 불편했습니다!

그래서 보드 뒷면에서 연장선을 이용해서 밖으로 GPIO를 빼면 좋을것 같아서 녹칸다는 PCB를 만들기로 했습니다!

board1은 stm32f746g-disco보드 뒷면에 부착되어서 IDC 플랫케이블로 외부로 GPIO를 연결하기 위한 목적으로 사용!

board1은 board2 혹은 board3과 선택적으로 연결해서 사용하는 구조입니당!

f746_board1.zip

0.75MB

board1이 stm32에 부착된 모습!

board2는 board1과 플랫케이블로 연결되고 단순하게 GPIO를 사용하기 편하게 핀헤더로 빼놓은 형태!

f746_board2.zip

1.64MB

board1과 board2가 결합된 모습!

board3는 board1과 연장선으로 연결되고 테스트에 사용할 다양한것들이 이미 부착되어있는 형태임!

f746_board3.zip

2.56MB

board3이 납땜이 다된 모습!

[STM32#34] 블루필보드로 로봇하드웨어개발기사 공개문제에 있는 i2c가 아닌 1602lcd를 작동시키는 방법을 데이터시트로 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 11 Feb 2026 16:49:33 +0900

https://youtube.com/live/X9i3F1bRd_M

[STM32#34] 블루필보드로 로봇하드웨어개발기사 공개문제에 있는 i2c가 아닌 1602lcd를 작동시키는 방법을 데이터시트로 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bd7e320f89_10_229#slide=id.g3bd7e320f89_10_229

로봇하드웨어개발기사에 있는 일부 내용을 STM32보드로 한번 접근해보는 것입니다!

1.블루필보드에 1602LCD를 회로도에 맞게 연결한다음 데이터시트를 해석해서 첫번째 줄에는 “NOCKANDA”라고 출력하고 두번째 줄에는 “SUBSCRIBE!”라고 출력해보도록 한다!

/* USER CODE BEGIN 0 */
void lcd_write4(uint8_t n)
{
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, (n >> 0) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, (n >> 1) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, (n >> 2) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (n >> 3) & 1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_SET);
  HAL_Delay(1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_RESET);
  HAL_Delay(1);
}
void lcd_write8(uint8_t data, uint8_t rs)
{
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, rs);
  lcd_write4(data >> 4);   // 상위 4비트
  lcd_write4(data & 0x0F); // 하위 4비트
}
void lcd_cmd(uint8_t cmd)
{
  lcd_write8(cmd, 0);
}
void lcd_data(uint8_t data)
{
  lcd_write8(data, 1);
}
void lcd_puts(char *s)
{
  while(*s)
  	lcd_data(*s++);
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //STM32가 부팅된 후 15ms이상 기다려줘야한다!
 HAL_Delay(15);
 //그다음 0b0011을 전송한다
 lcd_write4(0b0011);
 HAL_Delay(5); //4.1ms이상 대기
 lcd_write4(0b0011);
 HAL_Delay(1); //100us(0.1ms)이상 대기
 lcd_write4(0b0011);
 //HAL_Delay(1);
 lcd_write4(0b0010);
 lcd_cmd(0b00101000);  // 4bit, 2line
 lcd_cmd(0b00001000);  // Display OFF
 lcd_cmd(0b00000001);  // Clear
 //HAL_Delay(5);
 lcd_cmd(0b00000110);  // Entry mode
 lcd_cmd(0b00001100);  // Display ON
 lcd_cmd(0x80);
 lcd_puts("NOCKANDA");
 lcd_cmd(0xC0);
 lcd_puts("SUBSCRIBE!");
 /* USER CODE END 2 */

2.첫번째줄에 왼쪽부터 2번째칸에서 시작해서 NOCKANDA라고 출력하고 두번째줄의 3번째 칸부터 시작해서 SUBSCRIBE!를 출력하시오!

/* USER CODE BEGIN 0 */
void lcd_write4(uint8_t n)
{
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, (n >> 0) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, (n >> 1) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, (n >> 2) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (n >> 3) & 1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_SET);
  HAL_Delay(1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_RESET);
  HAL_Delay(1);
}
void lcd_write8(uint8_t data, uint8_t rs)
{
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, rs);
  lcd_write4(data >> 4);   // 상위 4비트
  lcd_write4(data & 0x0F); // 하위 4비트
}
void lcd_cmd(uint8_t cmd)
{
  lcd_write8(cmd, 0);
}
void lcd_data(uint8_t data)
{
  lcd_write8(data, 1);
}
void lcd_puts(char *s)
{
  while(*s)
  	lcd_data(*s++);
}


void set_cursor(uint8_t x, uint8_t y){
	uint8_t cursor = 0b10000000;
	if(y != 0){
		cursor = cursor | 0b01000000;
	}
	cursor = cursor + x;
	lcd_cmd(cursor);
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //STM32가 부팅된 후 15ms이상 기다려줘야한다!
 HAL_Delay(15);
 //그다음 0b0011을 전송한다
 lcd_write4(0b0011);
 HAL_Delay(5); //4.1ms이상 대기
 lcd_write4(0b0011);
 HAL_Delay(1); //100us(0.1ms)이상 대기
 lcd_write4(0b0011);
 //HAL_Delay(1);
 lcd_write4(0b0010);
 lcd_cmd(0b00101000);  // 4bit, 2line
 lcd_cmd(0b00001000);  // Display OFF
 lcd_cmd(0b00000001);  // Clear
 //HAL_Delay(5);
 lcd_cmd(0b00000110);  // Entry mode
 lcd_cmd(0b00001100);  // Display ON
 set_cursor(2,0);
 lcd_puts("NOCKANDA");
 set_cursor(3,1);
 lcd_puts("SUBSCRIBE!");
 /* USER CODE END 2 */

3.로봇하드웨어개발기사에서 공개되어있는 부분만 STM32보드로 간단하게 구현해보시오!(조이스틱x축PA0, y축PA1, 서보모터PB11)

/* USER CODE BEGIN 0 */
void lcd_write4(uint8_t n)
{
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, (n >> 0) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, (n >> 1) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, (n >> 2) & 1);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (n >> 3) & 1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_SET);
  HAL_Delay(1);
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_15, GPIO_PIN_RESET);
  HAL_Delay(1);
}
void lcd_write8(uint8_t data, uint8_t rs)
{
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, rs);
  lcd_write4(data >> 4);   // 상위 4비트
  lcd_write4(data & 0x0F); // 하위 4비트
}
void lcd_cmd(uint8_t cmd)
{
  lcd_write8(cmd, 0);
}
void lcd_data(uint8_t data)
{
  lcd_write8(data, 1);
}
void lcd_puts(char *s)
{
  while(*s)
  	lcd_data(*s++);
}


void set_cursor(uint8_t x, uint8_t y){
	uint8_t cursor = 0b10000000;
	if(y != 0){
		cursor = cursor | 0b01000000;
	}
	cursor = cursor + x;
	lcd_cmd(cursor);
}
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
uint16_t map(uint16_t analog){
	return 180*analog/4095.0;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 //STM32가 부팅된 후 15ms이상 기다려줘야한다!
 HAL_Delay(15);
 //그다음 0b0011을 전송한다
 lcd_write4(0b0011);
 HAL_Delay(5); //4.1ms이상 대기
 lcd_write4(0b0011);
 HAL_Delay(1); //100us(0.1ms)이상 대기
 lcd_write4(0b0011);
 //HAL_Delay(1);
 lcd_write4(0b0010);
 lcd_cmd(0b00101000);  // 4bit, 2line
 lcd_cmd(0b00001000);  // Display OFF
 lcd_cmd(0b00000001);  // Clear
 //HAL_Delay(5);
 lcd_cmd(0b00000110);  // Entry mode
 lcd_cmd(0b00001100);  // Display ON
 set_cursor(0,0);
 lcd_puts("ROBOT ARM       ");
 set_cursor(0,1);
 lcd_puts("NUMBER:001      ");
 HAL_Delay(5000);
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint8_t line1[20];
 uint8_t line2[20];
 /* USER CODE END 2 */

while (1)
 {
	  //M1:AAAA  M2:BBBB
	  //M3:CCCC
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  sprintf(line1,"M1:%4d  M2:%4d",adc_value0,adc_value1);
	  sprintf(line2,"M3:%13d",HAL_GetTick());
	  set_cursor(0,0);
	  lcd_puts(line1);
	  set_cursor(0,1);
	  lcd_puts(line2);
	  //서보모터제어
	  set_servo(map(adc_value1));
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#33] 블루필보드로 3D프린터개발산업기사 실기 공개문제에 있는 메뉴트리 구현과 스탭모터(nema17 & a4988) 제어 구현해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Tue, 10 Feb 2026 00:07:53 +0900

https://youtube.com/live/g8DphoILqS0

[STM32#33] 블루필보드로 3D프린터개발산업기사 실기 공개문제에 있는 메뉴트리 구현과 스탭모터(nema17 & a4988) 제어 구현해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bd6ca3685c_3_55#slide=id.g3bd6ca3685c_3_55

3D프린터개발산업기사에 있는 일부 내용을 STM32보드로 한번 접근해보는 것입니다!
실제 시험은 아두이노 메가로 하니 실기 시험과 전혀 관련없습니당

1.PB5,PB6,PB7핀을 활용해서 로터리엔코더를 연결하고 선형적인 링크드 리스트를 구성해서 로터리 엔코더를 돌렸을때 항목이 바뀌는 결과를 PC의 putty 화면에 하시오!

/* USER CODE BEGIN 2 */
 uint8_t buff[50];
 uint8_t old_A = 0;
 typedef struct Node {
    struct Node *parent;
    struct Node *child;
    int value;
 }Node;
 Node n1; //최상위
 Node n2;
 Node n3;
 Node n4; //최하위
 //n1의 자식은 n2이고 부모는 없다!
 n1.value = 1;
 n1.child = &n2;
 n1.parent = NULL;
 //n2의 자식은 n3이고 부모는 n1이다!
 n2.value = 2;
 n2.child = &n3;
 n2.parent = &n1;
 //n3의 자식은 n4이고 부모는 n2이다!
 n3.value = 3;
 n3.child = &n4;
 n3.parent = &n2;
 //n4의 자식은 없고 부모는 n3이다!
 n4.value = 4;
 n4.child = NULL;
 n4.parent = &n3;
 //초기 관심노드는 n1이다!
 Node *CWD = &n1;
 int num = 0;
 /* USER CODE END 2 */

while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(rot_sw_GPIO_Port,rot_sw_Pin);
	  if(sw == 0){
		  //현재 CWD가 참조하는 원본의 num값이 몇이냐?
		  sprintf(buff,"num = %d\n",CWD->value);
		  CDC_Transmit_FS(buff, strlen(buff));
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(rot_clk_GPIO_Port,rot_clk_Pin);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(rot_dt_GPIO_Port,rot_dt_Pin);
		  if(now_B){
			 //반시계
			  //최하위 -> 최상위 방향으로 이동
			  //만약 부모노드가 없다면 이동하지 않는다!
			  if(CWD->parent){
				  CWD = CWD->parent;
			  }else{
				  CDC_Transmit_FS("THIS NODE IS ROOT!\n", 19);
			  }
			  sprintf(buff,"num = %d\n",CWD->value);
			  CDC_Transmit_FS(buff, strlen(buff));

		  }else{
			 //시계
			  //최상위 -> 최하위 방향이동
			  //만약 자식노드가 없다면 이동하지 않는다!
			  if(CWD->child){
				  CWD = CWD->child;
			  }else{
				  CDC_Transmit_FS("THIS NODE IS LEAF!\n", 19);
			  }
			  sprintf(buff,"num = %d\n",CWD->value);
			  CDC_Transmit_FS(buff, strlen(buff));
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.공개시험 문제에 나오는 메뉴트리를 그대로 구성하되 결과를 PC 화면에서 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t buff[50];
 uint8_t old_A = 0;
 typedef struct Node {
    struct Node *parent;
    struct Node *child;
    struct Node *next;
    struct Node *prev;
    uint8_t Text[20];
    uint8_t is_return; //true면 리턴노드
 }Node;
 Node root;
 Node menu1;
 Node menu2;
 Node menu2_1;
 Node menu2_2;
 strcpy(menu1.Text, "EXIT            ");
 strcpy(menu2.Text, "MOTOR TEST      ");
 strcpy(menu2_1.Text, "ANGLE:+000.0    ");
 strcpy(menu2_2.Text, "RETURN          ");
 root.is_return = 0;
 menu1.is_return = 1;
 menu2.is_return = 0;
 menu2_1.is_return = 0;
 menu2_2.is_return = 1;
 root.parent = NULL;
 root.child = &menu1;
 root.next = NULL;
 root.prev = NULL;

 menu1.parent = &root;
 menu1.child = NULL;
 menu1.next = &menu2;
 menu1.prev = &menu2;
 menu2.parent = &root;
 menu2.child = &menu2_1;
 menu2.next = &menu1;
 menu2.prev = &menu1;
 menu2_1.parent = &menu2;
 menu2_1.child = NULL;
 menu2_1.next = &menu2_2;
 menu2_1.prev = NULL;
 menu2_2.parent = &menu2;
 menu2_2.child = NULL;
 menu2_2.next = NULL;
 menu2_2.prev = &menu2_1;
 Node *CWD = &root;
 //초기화면은 root의 화면이 출력된다!
 CDC_Transmit_FS("X:    Y:    A000\n3D PRINTER READY\n", 34);
 /* USER CODE END 2 */


while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(rot_sw_GPIO_Port,rot_sw_Pin);
	  if(sw == 0){
		  //현재노드가 root노드이면 root의 하위메뉴로 진입한다!
		  if(CWD == &root){
			  CWD = CWD->child;
			  //LCD에 나와야할 내용은 child와 그다음 삼촌이다!
			  //>CWD->Text;
			  // CWD->next->Text;
			  CDC_Transmit_FS(">", 1);
			  HAL_Delay(10);
			  CDC_Transmit_FS(CWD->Text, strlen(CWD->Text));
			  HAL_Delay(10);
			  CDC_Transmit_FS("\n ", 2);
			  HAL_Delay(10);
			  CDC_Transmit_FS(CWD->next->Text, strlen(CWD->next->Text));
			  HAL_Delay(10);
			  CDC_Transmit_FS("\n", 1);
		  }else{
			  //만약에 현재 노드가 리턴노드면 상위메뉴로 이동한다
			  if(CWD->is_return){
				  if(CWD->parent){
					  CWD = CWD->parent;
					  //상위메뉴로 올라갔는데, 그 메뉴가 root인 경우

					  if(CWD == &root){
						  //root 고유한 화면 출력
						  CDC_Transmit_FS("X:    Y:    A000\n3D PRINTER READY\n", 34);
					  }else{
						  CDC_Transmit_FS(">", 1);
						  HAL_Delay(10);
						  CDC_Transmit_FS(CWD->Text, strlen(CWD->Text));
						  HAL_Delay(10);
						  CDC_Transmit_FS("\n ", 2);
						  HAL_Delay(10);
						  CDC_Transmit_FS(CWD->next->Text, strlen(CWD->next->Text));
						  HAL_Delay(10);
						  CDC_Transmit_FS("\n", 1);
					  }
				  }
			  }else{
				  //루트도 아니고 리턴노드도 아니라면 하위메뉴로 진입한다!
				  if(CWD->child){
					  CWD = CWD->child;
					  CDC_Transmit_FS(">", 1);
					  HAL_Delay(10);
					  CDC_Transmit_FS(CWD->Text, strlen(CWD->Text));
					  HAL_Delay(10);
					  CDC_Transmit_FS("\n ", 2);
					  HAL_Delay(10);

					  CDC_Transmit_FS(CWD->next->Text, strlen(CWD->next->Text));
					  HAL_Delay(10);
					  CDC_Transmit_FS("\n", 1);
				  }else{
					  //리프노드인 경우
				  }
			  }
		  }
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(rot_clk_GPIO_Port,rot_clk_Pin);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(rot_dt_GPIO_Port,rot_dt_Pin);
		  if(now_B){
			 //반시계
			  if(CWD != &root && CWD->prev){
				 CWD = CWD->prev;
				 //*CWD->text
				 // CWD->next->text
				 CDC_Transmit_FS(">", 1);
				  HAL_Delay(10);
				  CDC_Transmit_FS(CWD->Text, strlen(CWD->Text));
				  HAL_Delay(10);
				  CDC_Transmit_FS("\n ", 2);
				  HAL_Delay(10);
				  CDC_Transmit_FS(CWD->next->Text, strlen(CWD->next->Text));

				  HAL_Delay(10);
				  CDC_Transmit_FS("\n", 1);
			 }
		  }else{
			 //시계
			 //만약 next로 갈게 있다면 next로 이동한다!
			 if(CWD != &root && CWD->next){
				 CWD = CWD->next;
				 // CWD->prev->text
				 //*CWD->text
				 CDC_Transmit_FS(" ", 1);
				  HAL_Delay(10);
				  CDC_Transmit_FS(CWD->prev->Text, strlen(CWD->prev->Text));
				  HAL_Delay(10);
				  CDC_Transmit_FS("\n>", 2);
				  HAL_Delay(10);
				  CDC_Transmit_FS(CWD->Text, strlen(CWD->Text));
				  HAL_Delay(10);
				  CDC_Transmit_FS("\n", 1);
			 }
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.예제 2의 결과를 1602LCD 화면에 출력하시오!

#define delay_ms HAL_Delay
#define SYS_CLOCK    72
#define SYSTICK_LOAD 72000-1
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08
// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
 uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(data & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
 uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(cmd & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
 uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_INIT(void) {
 delay_ms(100);
 LCD_CMD_4bit(0x03); delay_ms(5);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x02); delay_us(100);
 LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
 LCD_CMD(0x08);  // display off, cursor off, blink off
 LCD_CMD(0x01);  // clear display
 delay_ms(3);
 LCD_CMD(0x06);  // cursor movint direction
 LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
 if      (y == 0) LCD_CMD(0x80 + x);
 else if (y == 1) LCD_CMD(0xC0 + x);
 else if (y == 2) LCD_CMD(0x94 + x);
 else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
 LCD_CMD(0x01);
 delay_ms(2);
}
void LCD_PUTS(char *str) {
 while (*str) LCD_DATA(*str++);
}
/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 uint8_t buff[50];
 uint8_t old_A = 0;
 typedef struct Node {
    struct Node *parent;
    struct Node *child;
    struct Node *next;
    struct Node *prev;
    uint8_t Text[20];
    uint8_t is_return; //true면 리턴노드
 }Node;
 Node root;
 Node menu1;
 Node menu2;
 Node menu2_1;
 Node menu2_2;
 strcpy(menu1.Text, "EXIT            ");
 strcpy(menu2.Text, "MOTOR TEST      ");
 strcpy(menu2_1.Text, "ANGLE:+000.0    ");
 strcpy(menu2_2.Text, "RETURN          ");
 root.is_return = 0;
 menu1.is_return = 1;
 menu2.is_return = 0;
 menu2_1.is_return = 0;
 menu2_2.is_return = 1;
 root.parent = NULL;
 root.child = &menu1;
 root.next = NULL;
 root.prev = NULL;

 menu1.parent = &root;
 menu1.child = NULL;
 menu1.next = &menu2;
 menu1.prev = &menu2;
 menu2.parent = &root;
 menu2.child = &menu2_1;
 menu2.next = &menu1;
 menu2.prev = &menu1;
 menu2_1.parent = &menu2;
 menu2_1.child = NULL;
 menu2_1.next = &menu2_2;
 menu2_1.prev = NULL;
 menu2_2.parent = &menu2;
 menu2_2.child = NULL;
 menu2_2.next = NULL;
 menu2_2.prev = &menu2_1;
 Node *CWD = &root;
 //초기화면은 root의 화면이 출력된다!
 LCD_XY(0, 0) ; LCD_PUTS("X:    Y:    A000");
 LCD_XY(0, 1) ; LCD_PUTS("3D PRINTER READY");
 /* USER CODE END 2 */


while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(rot_sw_GPIO_Port,rot_sw_Pin);
	  if(sw == 0){
		  //현재노드가 root노드이면 root의 하위메뉴로 진입한다!
		  if(CWD == &root){
			  CWD = CWD->child;
			  //LCD에 나와야할 내용은 child와 그다음 삼촌이다!
			  //>CWD->Text;
			  // CWD->next->Text;
			  LCD_XY(0, 0) ; LCD_PUTS(">");
			  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
			  LCD_XY(0, 1) ; LCD_PUTS(" ");
			  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
		  }else{
			  //만약에 현재 노드가 리턴노드면 상위메뉴로 이동한다
			  if(CWD->is_return){
				  if(CWD->parent){
					  CWD = CWD->parent;
					  //상위메뉴로 올라갔는데, 그 메뉴가 root인 경우
					  if(CWD == &root){
						  //root 고유한 화면 출력
						  LCD_XY(0, 0) ; LCD_PUTS("X:    Y:    A000");
						  LCD_XY(0, 1) ; LCD_PUTS("3D PRINTER READY");
					  }else{
						  LCD_XY(0, 0) ; LCD_PUTS(">");
						  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
						  LCD_XY(0, 1) ; LCD_PUTS(" ");
						  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
					  }
				  }
			  }else{
				  //루트도 아니고 리턴노드도 아니라면 하위메뉴로 진입한다!
				  if(CWD->child){
					  CWD = CWD->child;
					  LCD_XY(0, 0) ; LCD_PUTS(">");
					  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
					  LCD_XY(0, 1) ; LCD_PUTS(" ");
					  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
				  }else{
					  //리프노드인 경우
				  }
			  }
		  }
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(rot_clk_GPIO_Port,rot_clk_Pin);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(rot_dt_GPIO_Port,rot_dt_Pin);
		  if(now_B){
			 //반시계
			  if(CWD != &root && CWD->prev){
				 CWD = CWD->prev;
				 LCD_XY(0, 0) ; LCD_PUTS(">");
				 LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
				 LCD_XY(0, 1) ; LCD_PUTS(" ");
				 LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
			 }

		  }else{
			 //시계
			 //만약 next로 갈게 있다면 next로 이동한다!
			 if(CWD != &root && CWD->next){
				 CWD = CWD->next;
				 LCD_XY(0, 0) ; LCD_PUTS(" ");
				 LCD_XY(1, 0) ; LCD_PUTS(CWD->prev->Text);
				 LCD_XY(0, 1) ; LCD_PUTS(">");
				 LCD_XY(1, 1) ; LCD_PUTS(CWD->Text);
			 }
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.PB3핀에 A4988의 STEP핀을 연결하고 PB4에 DIR핀을 연결해서 NEMA17스탭모터를 테스트 하는 코드를 먼저 만드시오! 로터리엔코더 스위치를 누르면 시계방향으로 계속회전하고 한번더 누르면 멈추도록 하시오! 에서 그냥 최종 결과를 바로 반영하시오!

#define delay_ms HAL_Delay
#define SYS_CLOCK    72
#define SYSTICK_LOAD 72000-1
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08
// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
 uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(data & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
 uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(cmd & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
 uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_INIT(void) {
 delay_ms(100);
 LCD_CMD_4bit(0x03); delay_ms(5);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x02); delay_us(100);
 LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
 LCD_CMD(0x08);  // display off, cursor off, blink off
 LCD_CMD(0x01);  // clear display
 delay_ms(3);
 LCD_CMD(0x06);  // cursor movint direction
 LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
 if      (y == 0) LCD_CMD(0x80 + x);
 else if (y == 1) LCD_CMD(0xC0 + x);
 else if (y == 2) LCD_CMD(0x94 + x);
 else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
 LCD_CMD(0x01);
 delay_ms(2);
}
void LCD_PUTS(char *str) {
 while (*str) LCD_DATA(*str++);
}
/* USER CODE BEGIN 0 */
volatile int32_t set_deg = 0;
int32_t now_deg = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(set_deg*2 > now_deg){
		//시계방향으로 회전해서 목표지점에 도달한다!
		HAL_GPIO_WritePin(DIR_GPIO_Port, DIR_Pin, 0); //정회전
		HAL_GPIO_TogglePin(STEP_GPIO_Port, STEP_Pin);
		now_deg++;
	}else if(set_deg*2 < now_deg){
		//반시계방향으로 회전해서 목표지점에 도달한다!
		HAL_GPIO_WritePin(DIR_GPIO_Port, DIR_Pin, 1); //역회전
		HAL_GPIO_TogglePin(STEP_GPIO_Port, STEP_Pin);
		now_deg--;
	}
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim3);
 HAL_GPIO_WritePin(DIR_GPIO_Port, DIR_Pin, 0); //회전방향
 LCD_INIT(); //1회호출(메인루프 시작전)
 uint8_t buff[50];
 uint8_t old_A = 0;
 typedef struct Node {
    struct Node *parent;
    struct Node *child;
    struct Node *next;
    struct Node *prev;
    uint8_t Text[20];
    uint8_t is_return; //true면 리턴노드
 }Node;
 Node root;
 Node menu1;
 Node menu2;
 Node menu2_1;
 Node menu2_2;
 strcpy(menu1.Text, "EXIT            ");
 strcpy(menu2.Text, "MOTOR TEST      ");
 strcpy(menu2_1.Text, "ANGLE:+000.0    ");
 strcpy(menu2_2.Text, "RETURN          ");
 root.is_return = 0;
 menu1.is_return = 1;
 menu2.is_return = 0;
 menu2_1.is_return = 0;
 menu2_2.is_return = 1;
 root.parent = NULL;
 root.child = &menu1;
 root.next = NULL;
 root.prev = NULL;
 menu1.parent = &root;
 menu1.child = NULL;
 menu1.next = &menu2;
 menu1.prev = &menu2;
 menu2.parent = &root;
 menu2.child = &menu2_1;
 menu2.next = &menu1;
 menu2.prev = &menu1;
 menu2_1.parent = &menu2;
 menu2_1.child = NULL;
 menu2_1.next = &menu2_2;
 menu2_1.prev = NULL;
 menu2_2.parent = &menu2;
 menu2_2.child = NULL;
 menu2_2.next = NULL;
 menu2_2.prev = &menu2_1;
 Node *CWD = &root;
 //초기화면은 root의 화면이 출력된다!
 LCD_XY(0, 0) ; LCD_PUTS("X:    Y:    A000");
 LCD_XY(0, 1) ; LCD_PUTS("3D PRINTER READY");
 float target_deg = 0;
 int32_t tar_deg = 0;
 /* USER CODE END 2 */
while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(rot_sw_GPIO_Port,rot_sw_Pin);
	  if(sw == 0){
		  //현재노드가 root노드이면 root의 하위메뉴로 진입한다!
		  if(CWD == &root){
			  CWD = CWD->child;
			  //LCD에 나와야할 내용은 child와 그다음 삼촌이다!
			  //>CWD->Text;
			  // CWD->next->Text;
			  LCD_XY(0, 0) ; LCD_PUTS(">");
			  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
			  LCD_XY(0, 1) ; LCD_PUTS(" ");
			  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
		  }else{
			  //만약에 현재 노드가 리턴노드면 상위메뉴로 이동한다
			  if(CWD->is_return){
				  if(CWD->parent){
					  CWD = CWD->parent;
					  //상위메뉴로 올라갔는데, 그 메뉴가 root인 경우
					  if(CWD == &root){
						  //root 고유한 화면 출력
						  LCD_XY(0, 0) ; LCD_PUTS("X:    Y:    A000");
						  LCD_XY(0, 1) ; LCD_PUTS("3D PRINTER READY");

					  }else{
						  LCD_XY(0, 0) ; LCD_PUTS(">");
						  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
						  LCD_XY(0, 1) ; LCD_PUTS(" ");
						  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
					  }
				  }
			  }else{
				  //루트도 아니고 리턴노드도 아니라면 하위메뉴로 진입한다!
				  if(CWD->child){
					  CWD = CWD->child;
					  LCD_XY(0, 0) ; LCD_PUTS(">");
					  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
					  LCD_XY(0, 1) ; LCD_PUTS(" ");
					  LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
				  }else{
					  //리프노드인 경우
					  if(CWD == &menu2_1){
						  //한번 누르면 설정 한번더 누르면 확인
						  HAL_Delay(200);
						  while(1){
							  uint8_t now_A = HAL_GPIO_ReadPin(rot_clk_GPIO_Port,rot_clk_Pin);
							  if(old_A == 0 && now_A == 1){
								  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
								  uint8_t now_B = HAL_GPIO_ReadPin(rot_dt_GPIO_Port,rot_dt_Pin);

								  if(now_B){
									 //반시계
									  target_deg -= 1.8;
									  tar_deg--;
									  LCD_XY(0, 0) ; LCD_PUTS(">");
									  sprintf(CWD->Text,"ANGLE:%.1f       ",target_deg);
									  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
								  }else{
									 //시계
									  target_deg += 1.8;
									  tar_deg++;
									  LCD_XY(0, 0) ; LCD_PUTS(">");
									  sprintf(CWD->Text,"ANGLE:%.1f       ",target_deg);
									  LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
								  }
							  }
							  old_A = now_A;
							  HAL_Delay(1);
							  //버튼을 한번 누르면 무한루프
							  //한번더 누르면 종료
							  if(HAL_GPIO_ReadPin(rot_sw_GPIO_Port,rot_sw_Pin) == 0){
								  //녹칸다가 설정한 값으로 스탭모터를 회전시키기!
								  set_deg = tar_deg;
								  HAL_Delay(200);
								  break;
							  }
						  }
					  }

				  }
			  }
		  }
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(rot_clk_GPIO_Port,rot_clk_Pin);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(rot_dt_GPIO_Port,rot_dt_Pin);
		  if(now_B){
			 //반시계
			  if(CWD != &root && CWD->prev){
				 CWD = CWD->prev;
				 LCD_XY(0, 0) ; LCD_PUTS(">");
				 LCD_XY(1, 0) ; LCD_PUTS(CWD->Text);
				 LCD_XY(0, 1) ; LCD_PUTS(" ");
				 LCD_XY(1, 1) ; LCD_PUTS(CWD->next->Text);
			 }
		  }else{
			 //시계
			 //만약 next로 갈게 있다면 next로 이동한다!
			 if(CWD != &root && CWD->next){
				 CWD = CWD->next;
				 LCD_XY(0, 0) ; LCD_PUTS(" ");
				 LCD_XY(1, 0) ; LCD_PUTS(CWD->prev->Text);
				 LCD_XY(0, 1) ; LCD_PUTS(">");
				 LCD_XY(1, 1) ; LCD_PUTS(CWD->Text);

			 }
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#32] 블루필보드로 전자산업기사, 임베디드기능사 국가자격증 실기시험 공개문제에 있는 일부 문제를 해결해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 4 Feb 2026 18:40:00 +0900

https://youtube.com/live/Pl1SAaUqfII

[STM32#32] 블루필보드로 전자산업기사, 임베디드기능사 국가자격증 실기시험 공개문제에 있는 일부 문제를 해결해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bcab2a4904_2_225#slide=id.g3bcab2a4904_2_225

그냥 막 하면 재미 없으니 국가 자격증 시험에 있는 문제를 STM32로 접근해봅시당!

1.STM32의 PB9에 주파수발생기를 연결하고 PB8에 LED를 연결해서 주파수 발생기에서 엣지를 검출할때 마다 PB8의 LED가 토글되도록 하시오!

/* USER CODE BEGIN 0 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_9)
  {
      HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_8);
  }
}
/* USER CODE END 0 */

2.주파수 발생기에서 나오는 신호를 검출해서 1씩 증가하는 카운터를 구성한다음 단위시간으로 나눠서 USB CDC로 출력하시오!

/* USER CODE BEGIN 0 */
volatile uint16_t cnt = 0;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_9)
  {
	   //10ms초마다 1씩 증가
	   cnt++;
  }
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t buff[100];
 /* USER CODE END 2 */
while (1)
 {
	  //1초 간격으로 cnt값을 USB CDC로 출력하고 cnt를 0으로 초기화한다!
	  sprintf(buff,"now_cnt = %d\n",cnt);
	  CDC_Transmit_FS(buff, strlen(buff));
	  cnt = 0;
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.예제2에서 측정한 주파수값을 1602LCD(PB6,PB7)에 형식에 맞게 출력하시오!

#define delay_ms HAL_Delay
#define SYS_CLOCK    72
#define SYSTICK_LOAD 72000-1
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08
// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
 uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(data & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
 uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(cmd & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
 uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_INIT(void) {
 delay_ms(100);
 LCD_CMD_4bit(0x03); delay_ms(5);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x02); delay_us(100);
 LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
 LCD_CMD(0x08);  // display off, cursor off, blink off
 LCD_CMD(0x01);  // clear display
 delay_ms(3);
 LCD_CMD(0x06);  // cursor movint direction
 LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
 if      (y == 0) LCD_CMD(0x80 + x);
 else if (y == 1) LCD_CMD(0xC0 + x);
 else if (y == 2) LCD_CMD(0x94 + x);
 else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
 LCD_CMD(0x01);
 delay_ms(2);
}
void LCD_PUTS(char *str) {
 while (*str) LCD_DATA(*str++);
}
/* USER CODE BEGIN 0 */
volatile uint16_t cnt = 0;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_9)
  {
	   //10ms초마다 1씩 증가
	   cnt++;
  }
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t line1[20];
 uint8_t line2[20];
 LCD_INIT(); //1회호출(메인루프 시작전)
 LCD_XY(0, 0) ; LCD_PUTS("[Pulse Mode]    "); //첫번째줄
 /* USER CODE END 2 */
while (1)
 {
	  //1초간격으로 1602LCD에 출력한다!
	  sprintf(line2,"Freq: %3dHz     ",cnt);
	  LCD_XY(0, 1) ; LCD_PUTS(line2); //두번째줄
	  cnt = 0;
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.전자산업기사 공개문제 2번에서 주파수발생기로 시계만드는 부분을 블루필보드로 해결하시오!

//(LCD코드는 생략)
/* USER CODE BEGIN 0 */
volatile uint16_t h = 11; //시
volatile uint16_t m = 59; //분
volatile uint16_t s = 50; //초
volatile uint16_t ms = 0; //밀리초
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_9)
  {
	   //10ms초마다 1씩 증가
	   ms++;
	   if(ms >= 100){
		   ms = 0;
		   s++;
	   }
	   if(s >= 60){
		   s = 0;
		   m++;
	   }
	   if(m >= 60){
		   m = 0;
		   h++;
	   }
	   if(h >= 24){
		   h = 0;
	   }
  }
}

/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint8_t line1[20];
 uint8_t line2[20];
 LCD_INIT(); //1회호출(메인루프 시작전)
 LCD_XY(0, 0) ; LCD_PUTS("[ DigitalClock ]"); //첫번째줄
 /* USER CODE END 2 */

while (1)
 {
	  //1초간격으로 1602LCD에 출력한다!
	  sprintf(line2,"Freq: %3dHz     ",cnt);
	  LCD_XY(0, 1) ; LCD_PUTS(line2); //두번째줄
	  cnt = 0;
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
while (1)
 {
	  //1초간격으로 1602LCD에 출력한다!
	  sprintf(line2,"[%s]%02d:%02d:%02d:%02d ",(h>=12)?"PM":"AM",h,m,s,ms);
	  LCD_XY(0, 1) ; LCD_PUTS(line2); //두번째줄
	  HAL_Delay(10);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.임베디드기능사에서 나오는 문제를 P6~P9까지를 PB6~PB9까지 연결 P10을 PB4, P11을 PB5에 연결해서 FND에 숫자 두자리(15)를 출력하시오!

/* USER CODE BEGIN 0 */
void set_fnd(uint8_t num){
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, num&0b0001); //하위
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (num>>1)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, (num>>2)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, (num>>3)&0b0001); //상위
}
uint8_t fnd_num = 15;
uint8_t fnd_sw = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(fnd_sw == 0){
		//십의자리
		set_fnd(fnd_num/10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 1);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 0);
		fnd_sw = 1;
	}else if(fnd_sw == 1){
		//일의자리
		set_fnd(fnd_num%10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 0);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 1);
		fnd_sw = 0;
	}
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim3);
/* USER CODE END 2 */

6.예제5에서 PB12,PB13에 버튼을 1개씩 추가하고 PB12버튼을 누르면 FND에 1씩 업카운트되고 PB13을 누르면 다운카운트되는데 표시되는 숫자의 범위가 00~99까지 되도록 하시오!

/* USER CODE BEGIN 0 */
void set_fnd(uint8_t num){
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, num&0b0001); //하위
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (num>>1)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, (num>>2)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, (num>>3)&0b0001); //상위
}
uint8_t fnd_num = 15;
uint8_t fnd_sw = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(fnd_sw == 0){
		//십의자리
		set_fnd(fnd_num/10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 1);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 0);
		fnd_sw = 1;
	}else if(fnd_sw == 1){
		//일의자리
		set_fnd(fnd_num%10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 0);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 1);
		fnd_sw = 0;
	}
}
/* USER CODE END 0 */



/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim3);
 for(int i = 0;i<2;i++){
	  fnd_control = 1;
	  fnd_num = 88;
	  HAL_Delay(1000);
	  fnd_control = 0;
	  HAL_Delay(1000);
 }
 fnd_control = 1;
 fnd_num = 0;
 /* USER CODE END 2 */

while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == 0){
		  if(fnd_num != 99){
			  fnd_num++;
		  }
		  HAL_Delay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == 0){
		  if(fnd_num != 0){
			  fnd_num--;
		  }
		  HAL_Delay(200);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.예제6에서 PB12를 누르면 0에서 99까지 0.5초간격으로 업카운트되고 PB13을 누르면 99에서 0까지 1씩 다운카운트되는 원래 임베디드기능사에 있는 문제를 구현하시오!

/* USER CODE BEGIN 0 */
void set_fnd(uint8_t num){
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, num&0b0001); //하위
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, (num>>1)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, (num>>2)&0b0001);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, (num>>3)&0b0001); //상위
}
uint8_t fnd_num = 15;
uint8_t fnd_sw = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(fnd_sw == 0){
		//십의자리
		set_fnd(fnd_num/10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 1);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 0);
		fnd_sw = 1;
	}else if(fnd_sw == 1){
		//일의자리
		set_fnd(fnd_num%10);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 0);
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 1);
		fnd_sw = 0;
	}
}
/* USER CODE END 0 */



/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim3);
 for(int i = 0;i<2;i++){
	  fnd_control = 1;
	  fnd_num = 88;
	  HAL_Delay(1000);
	  fnd_control = 0;
	  HAL_Delay(1000);
 }
 fnd_control = 1;
 fnd_num = 0;
 uint32_t t = 0;
 //task_num이 0이면 아무것도 안함, 1이면 task1, 2면 task2
 uint8_t task_num = 0;
 /* USER CODE END 2 */
while (1)
 {
	  if(task_num == 1){
		  if(HAL_GetTick() - t >= 500){
			  t = HAL_GetTick();
			  //0부터 상승
			  if(fnd_num == 99){
				  fnd_num = 0;
			  }else{
				  fnd_num++;
			  }
		  }

	  }else if(task_num == 2){
		  if(HAL_GetTick() - t >= 500){
			  t = HAL_GetTick();
			  //99부터 하강
			  if(fnd_num == 0){
				  fnd_num = 99;
			  }else{
				  fnd_num--;
			  }
		  }
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == 0){
		  //task1 작동
		  task_num = 1;
		  fnd_num = 0;
		  HAL_Delay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == 0){
		  //task2 작동
		  task_num = 2;
		  fnd_num = 99;
		  HAL_Delay(200);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#31] F103C8T6 blue pill board(블루필보드)를 cubeIDE와 ST-LINK를 이용해서 업로드하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 2 Feb 2026 23:00:06 +0900

https://youtube.com/live/SpbPhleFvAc

[STM32#31] F103C8T6 blue pill board(블루필보드)를 cubeIDE와 ST-LINK를 이용해서 업로드하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bc8a5e1652_2_99#slide=id.g3bc8a5e1652_2_99

이번편은 뉴클레오 보드가 아니라 블루필 보드를 알아보도록 하겠습니다!

1.블루필보드에 내장되어있는 PC13번핀을 1초 간격으로 토글하시오!

while (1)
 {
	  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.블루필보드가 1초간격으로 “NOCKANDA!!\n”라는 문자열을 USB CDC를 이용해서 시리얼 출력한뒤 PC에서 putty로 확인하시오!

/* USER CODE BEGIN 2 */
 char msg[] = "NOCKANDA!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  CDC_Transmit_FS(msg, strlen(msg));
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.PB8, PB9핀에 LED를 1개씩 연결하고 1초 간격으로 서로 번갈아가면서 LED가 점멸되도록 하시오!

while (1)
 {
	  //PB8 ON PB9 OFF
	  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, 1);
	  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, 0);
	  HAL_Delay(1000);
	  //PB8 OFF PB9 ON
	  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, 0);
	  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, 1);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.PB6,PB7에 버튼(택트스위치)을 1개씩 연결하고 버튼을 누르면 PB6은 PB8 LED가 토글되고, PB7은 PB9 LED가 토글되도록 하시오!(버튼의 연결은 풀업방식)

while (1)
 {
	  //PB6을 누르면 PB8이 토글된다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_8);
		  HAL_Delay(200); //너무 빠르게 눌려지는 것 방지!
	  }
	  //PB7을 누르면 PB9가 토글된다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == 0){
		  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9);
		  HAL_Delay(200); //너무 빠르게 눌려지는 것 방지!
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.PB6 버튼을 누르면 PC시리얼화면에 “NOCKANDA!!\n”라고 출력되고 PB7을 누르면 “SUBSCRIBE!!\n”라고 출력되도록 하시오!

/* USER CODE BEGIN 2 */
 uint8_t msg1[] = "NOCKANDA!!\n";
 uint8_t msg2[] = "SUBSCRIBE!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB6을 누르면 PB8이 토글된다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  CDC_Transmit_FS(msg1, strlen(msg1));
		  HAL_Delay(200); //너무 빠르게 눌려지는 것 방지!
	  }
	  //PB7을 누르면 PB9가 토글된다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == 0){
		  CDC_Transmit_FS(msg2, strlen(msg2));
		  HAL_Delay(200); //너무 빠르게 눌려지는 것 방지!
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.PA0에 가변저항을 연결해서 가변저항값을 PC의 시리얼 화면에 100밀리초 간격으로 출력하시오!

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  sprintf(buff,"A0 = %d\n",adc_value0);
		  CDC_Transmit_FS(buff, strlen(buff));
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PA0에 연결된 가변저항을 돌리면 서보모터(PB5)의 각도가 0~180도 사이로 바뀌도록 하시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM3->CCR2 = (uint32_t)(600+(2400-600)*degree/180.0);
}
//0~4095범위의 값을 0~180사이로 변환!
uint16_t map(uint16_t analog){
	return 180*analog/4095.0;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_2); //PB5
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //0~4095를 0~180도 범위로 조정해야한다!
		  set_servo(map(adc_value0));
	  }
	  HAL_Delay(10);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.I2C통신으로 작동되는 1602LCD를 블루필보드에 연결해서 첫번째 줄에는 타이머카운터값을 출력하고 두번째 줄에는 PA0에 연결된 가변저항값을 출력하시오!

#define delay_ms HAL_Delay
#define SYS_CLOCK    72
#define SYSTICK_LOAD 72000-1
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08
// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
 uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(data & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
 uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(cmd & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
 uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_INIT(void) {
 delay_ms(100);
 LCD_CMD_4bit(0x03); delay_ms(5);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x02); delay_us(100);
 LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
 LCD_CMD(0x08);  // display off, cursor off, blink off
 LCD_CMD(0x01);  // clear display
 delay_ms(3);
 LCD_CMD(0x06);  // cursor movint direction
 LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
 if      (y == 0) LCD_CMD(0x80 + x);
 else if (y == 1) LCD_CMD(0xC0 + x);
 else if (y == 2) LCD_CMD(0x94 + x);
 else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
 LCD_CMD(0x01);
 delay_ms(2);
}
void LCD_PUTS(char *str) {
 while (*str) LCD_DATA(*str++);
}
/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 uint8_t line1[20];
 uint8_t line2[20];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1);
		  sprintf(line1,"CNT = %10d",HAL_GetTick());
		  sprintf(line2,"PA0 = %10d",adc_value0);
		  LCD_XY(0, 0) ; LCD_PUTS(line1);
		  LCD_XY(0, 1) ; LCD_PUTS(line2);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#30] CAN통신으로 각종 센서값을 전송하고 자동차에서 사용하는 OBD2 프로토콜을 간단하게 모방해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 28 Jan 2026 16:07:22 +0900

https://youtube.com/live/zxJ_ntNADKc

[STM32#30] CAN통신으로 각종 센서값을 전송하고 자동차에서 사용하는 OBD2 프로토콜을 간단하게 모방해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3be1268f534_1_233#slide=id.g3be1268f534_1_233

이번편까지 해서 CAN통신은 마무리!

1.녹칸다의 STM32쉴드에 PA0에 붙어있는 가변저항값을 측정해서 CAN통신으로 PC로 전송하기!

/* USER CODE BEGIN 0 */
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 Can_Set();
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */

while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //CAN데이터로 송신!
		  TxMessage.DLC = 1; //데이터길이
		  TxMessage.ExtId = 0;
		  TxMessage.IDE = CAN_ID_STD;
		  TxMessage.RTR = CAN_RTR_DATA;
		  TxMessage.StdId = 0x600;
		  TxMessage.TransmitGlobalTime = DISABLE;
		  //0~4095범위의 ADC값을 0~255범위로 축소
		  TxData[0] = (uint8_t)(adc_value0/4095.0*255);
		  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.예제1에서 0~4095의 숫자를 각 자리로 나눠서 4byte로 전송하기!

/* USER CODE BEGIN 0 */
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 Can_Set();
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */

while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //CAN데이터로 송신!
		  TxMessage.DLC = 4; //데이터길이
		  TxMessage.ExtId = 0;
		  TxMessage.IDE = CAN_ID_STD;
		  TxMessage.RTR = CAN_RTR_DATA;
		  TxMessage.StdId = 0x600;
		  TxMessage.TransmitGlobalTime = DISABLE;
		  TxData[0] = adc_value0/1000; //천의자리
		  TxData[1] = (adc_value0/100)%10; //백의자리
		  TxData[2] = (adc_value0/10)%10; //십의자리
		  TxData[3] = adc_value0%10; //일의자리
		  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.온습도센서(DHT-11)의 측정값을 CAN통신으로 PC로 전송하기!

/* USER CODE BEGIN 0 *//* USER CODE BEGIN 2 */
 Can_Set();
 char str[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  sprintf(str, "T:%.1f'C H:%.1f%c\n", temp,humi,'%');
		  HAL_UART_Transmit(&huart2,str,strlen(str),100);
		  TxMessage.DLC = 4; //데이터길이
		  TxMessage.ExtId = 0;
		  TxMessage.IDE = CAN_ID_STD;
		  TxMessage.RTR = CAN_RTR_DATA;
		  TxMessage.StdId = 0x600;
		  TxMessage.TransmitGlobalTime = DISABLE;
		  TxData[0] = (uint8_t)temp; //온도의 정수부
		  TxData[1] = ((uint8_t)(temp*10))%10; //온도의 실수부
		  TxData[2] = (uint8_t)humi; //습도의 정부수
		  TxData[3] = ((uint8_t)(humi*10))%10; //습도의 실수부
		  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  }
	  HAL_Delay(2000);
 }


#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
return millis_cnt;
}
uint32_t micros() {
return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
if (us > 1) {
  uint32_t count = us * 7 - 6;
  while (count--);
} else {
  uint32_t count = 2;
  while (count--);
}
}

union {
 uint32_t data;
 struct {
   uint8_t temp_d;
   uint8_t temp_i;
   uint8_t rh_d;
   uint8_t rh_i;
 };
} DHT;
uint8_t DHT_read () {
 uint8_t i, check_sum;
 uint32_t start;
 check_sum = 0;
 DHT.data = 0;
 GPIOC->CRL = (GPIOC->CRL&0xFFFFFF0F)|(7<<(1*4));  // Output Open-drain (Master send LOW signal)
 delay_ms(18);
 GPIOC->CRL= (GPIOC->CRL&0xFFFFFF0F)|(4<<(1*4));  // Floating input (Master send HIGH signal & data receive)
 start = micros();
 while (GPIOC->IDR&(1<<1)) {
   if (micros()-start > 50) return 1;  // 20~40us
 }
 start = micros();
 while (!(GPIOC->IDR&(1<<1))) {
   if (micros()-start > 120) return 2;  // 80us
 }
 start = micros();
 while (GPIOC->IDR&(1<<1)) {
   if (micros()-start > 120) return 3;  // 80us
 }
 for (i = 0; i < 32; i++) {
   while (!(GPIOC->IDR&(1<<1))); // 50us
   start = micros();
   while (GPIOC->IDR&(1<<1));
   if (micros()-start > 50) DHT.data |= (0x80000000 >> i); // "0"=26~28us, "1"=70us
 }
 for (i = 0; i < 8; i++) {
   while (!(GPIOC->IDR&(1<<1))); // 50us
   start = micros();
   while (GPIOC->IDR&(1<<1));
   if (micros()-start > 50) check_sum |= (0x80 >> i);
 }
 if ((DHT.rh_i + DHT.rh_d + DHT.temp_i + DHT.temp_d) == check_sum) return 0;
 else return 4;
}

CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 Can_Set();
 char str[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  sprintf(str, "T:%.1f'C H:%.1f%c\n", temp,humi,'%');
		  HAL_UART_Transmit(&huart2,str,strlen(str),100);
		  TxMessage.DLC = 4; //데이터길이
		  TxMessage.ExtId = 0;
		  TxMessage.IDE = CAN_ID_STD;
		  TxMessage.RTR = CAN_RTR_DATA;
		  TxMessage.StdId = 0x600;
		  TxMessage.TransmitGlobalTime = DISABLE;
		  TxData[0] = (uint8_t)temp; //온도의 정수부
		  TxData[1] = ((uint8_t)(temp*10))%10; //온도의 실수부
		  TxData[2] = (uint8_t)humi; //습도의 정부수
		  TxData[3] = ((uint8_t)(humi*10))%10; //습도의 실수부
		  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  }
	  HAL_Delay(2000);
 }

4.PC프로그램에 0x7DF와 데이터 8byte를 stm32로 전송하면 STM32는 0x7E0이라는 ID와 PC가 보낸 데이터를 그대로 ECHO하도록 하시오!

/* USER CODE BEGIN 0 */
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}


void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.StdId == 0x7DF){
		TxMessage.DLC = 8; //데이터길이
		TxMessage.ExtId = 0;
		TxMessage.IDE = CAN_ID_STD;
		TxMessage.RTR = CAN_RTR_DATA;
		TxMessage.StdId = 0x7E0;
		TxMessage.TransmitGlobalTime = DISABLE;
		for(int i = 0;i<8;i++){
			TxData[i] = RxData[i];
		}
		HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	}
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 Can_Set();
 /* USER CODE END 2 */

5.PC프로그램이 현재 자동차의 속도를 물어보는 PID를 전송하면 STM32는 속도를 255(0xFF)로 고정해서 응답하도록 하시오!

/* USER CODE BEGIN 0 */
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}


void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.StdId == 0x7DF){
		TxMessage.DLC = 8; //데이터길이
		TxMessage.ExtId = 0;
		TxMessage.IDE = CAN_ID_STD;
		TxMessage.RTR = CAN_RTR_DATA;
		TxMessage.StdId = 0x7E0;
		TxMessage.TransmitGlobalTime = DISABLE;
		uint8_t length = RxData[0];
		uint8_t service_id = RxData[1];
		uint8_t p_id = RxData[2];
		//Vehicle speed
		if(service_id == 0x01 && p_id == 0x0D){
			TxData[0] = 3;
			TxData[1] = service_id;
			TxData[2] = p_id;
			TxData[3] = 255;
			TxData[4] = 0;
			TxData[5] = 0;
			TxData[6] = 0;
			TxData[7] = 0;
			HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
		}
		
	}
}

/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 Can_Set();
 /* USER CODE END 2 */

6.예제5에서 가변저항을 돌리면 속도가 0~255사이로 변화하도록 하시오!

/* USER CODE BEGIN 0 */
//이 변수가 인터럽트를 포함한 여기저기서 사용할 경우 이 키워드를 붙혀야한다!
volatile uint16_t adc_value0 = 0;
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.StdId == 0x7DF){
		TxMessage.DLC = 8; //데이터길이
		TxMessage.ExtId = 0;
		TxMessage.IDE = CAN_ID_STD;
		TxMessage.RTR = CAN_RTR_DATA;
		TxMessage.StdId = 0x7E0;
		TxMessage.TransmitGlobalTime = DISABLE;
		uint8_t length = RxData[0];
		uint8_t service_id = RxData[1];
		uint8_t p_id = RxData[2];
		//Vehicle speed
		if(service_id == 0x01 && p_id == 0x0D){
			TxData[0] = 3;
			TxData[1] = service_id;
			TxData[2] = p_id;
			TxData[3] = (uint8_t)(adc_value0/4095.0*255);
			TxData[4] = 0;
			TxData[5] = 0;
			TxData[6] = 0;
			TxData[7] = 0;
			HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
		}
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 Can_Set();
 HAL_ADC_Start(&hadc1);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PC프로그램에서 자동차의 엔진RPM을 물어보는 PID를 전송하면 가변저항을 돌려서 엔진 RPM이 최소값에서 최대값 사이로 변화도록 하시오!

/* USER CODE BEGIN 0 */
//이 변수가 인터럽트를 포함한 여기저기서 사용할 경우 이 키워드를 붙혀야한다!
volatile uint16_t adc_value0 = 0;
char tx_buff[50];
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.StdId == 0x7DF){
		TxMessage.DLC = 8; //데이터길이
		TxMessage.ExtId = 0;
		TxMessage.IDE = CAN_ID_STD;
		TxMessage.RTR = CAN_RTR_DATA;
		TxMessage.StdId = 0x7E0;
		TxMessage.TransmitGlobalTime = DISABLE;
		uint8_t length = RxData[0];
		uint8_t service_id = RxData[1];
		uint8_t p_id = RxData[2];
		//Engine speed
		if(service_id == 0x01 && p_id == 0x0C){
			TxData[0] = 4;
			TxData[1] = service_id;
			TxData[2] = p_id;
			uint16_t rpm = (uint16_t)(adc_value0/4095.0*16383.75);
			TxData[3] = (rpm*4)/256; //A
			TxData[4] = (rpm*4)%256; //B
			TxData[5] = 0;
			TxData[6] = 0;
			TxData[7] = 0;
			HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
			sprintf(tx_buff,"RPM=%d, A=%02X, B=%02X, C_RPM=%d\n",rpm,TxData[3],TxData[4],(TxData[3]*256+TxData[4])/4);
			HAL_UART_Transmit(&huart2,tx_buff,strlen(tx_buff),100);
		}
	}
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 Can_Set();
 HAL_ADC_Start(&hadc1);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.동일한 방식으로 자동차의 냉각수 온도를 조회하시오!

/* USER CODE BEGIN 0 */
//이 변수가 인터럽트를 포함한 여기저기서 사용할 경우 이 키워드를 붙혀야한다!
volatile uint16_t adc_value0 = 0;
char tx_buff[50];
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//main에서 1회 호출
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.StdId == 0x7DF){
		TxMessage.DLC = 8; //데이터길이
		TxMessage.ExtId = 0;
		TxMessage.IDE = CAN_ID_STD;
		TxMessage.RTR = CAN_RTR_DATA;
		TxMessage.StdId = 0x7E0;
		TxMessage.TransmitGlobalTime = DISABLE;
		uint8_t length = RxData[0];
		uint8_t service_id = RxData[1];
		uint8_t p_id = RxData[2];
		//Engine coolant temperature
		if(service_id == 0x01 && p_id == 0x05){
			TxData[0] = 4;
			TxData[1] = service_id;
			TxData[2] = p_id;
			int16_t temp = (uint16_t)(adc_value0/4095.0*255) -40;
			TxData[3] = temp + 40;
			TxData[4] = 0;
			TxData[5] = 0;
			TxData[6] = 0;
			TxData[7] = 0;
			HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
			sprintf(tx_buff,"temp=%d, A=%02X, c_temp=%d\n",temp,TxData[3],TxData[3]-40);
			HAL_UART_Transmit(&huart2,tx_buff,strlen(tx_buff),100);
		}
	}
}

/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 Can_Set();
 HAL_ADC_Start(&hadc1);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#29] CAN통신 모듈인 SN65HVD230을 연결해서 설정하는 방법을 알아보고 ecan-u01s을 이용해서 패킷을 확인해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 26 Jan 2026 23:02:19 +0900

https://youtube.com/live/Y64tBhImAvo

[STM32#29] CAN통신 모듈인 SN65HVD230을 연결해서 설정하는 방법을 알아보고 ecan-u01s을 이용해서 패킷을 확인해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bb3c8bdfec_1_0#slide=id.g3bb3c8bdfec_1_0

이번편은 stm32보드로 간단하게 can통신을 해보도록 함!

1.STM32가 1초간격으로 CAN통신 메시지를 PC로 전송할때, PC에 CAN통신을 모니터링하는 전용 프로그램으로 그 결과를 확인하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */


while (1)
 {
	  //STM32가 1초간격으로 메시지를 전송한다!
	  //송신
	  TxMessage.DLC = 8; //데이터길이
	  TxMessage.ExtId = 0;
	  TxMessage.IDE = CAN_ID_STD;
	  TxMessage.RTR = CAN_RTR_DATA;
	  TxMessage.StdId = 0x123; //0x000 ~ 0x7FF
	  TxMessage.TransmitGlobalTime = DISABLE;
	  TxData[0] = 1;
	  TxData[1] = 2;
	  TxData[2] = 3;
	  TxData[3] = 4;
	  TxData[5] = 5;
	  TxData[6] = 6;
	  TxData[7] = 7;
	  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.이번에는 PC쪽 프로그램에서 8개의 길이를 가지는 데이터를 송신했을때 STM32의 usart2를 이용해서 putty에 log를 출력하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);

	if(RxMessage.RTR == CAN_RTR_DATA && RxMessage.IDE == CAN_ID_STD){
		sprintf(tx_buff,"CAN ID = %X, Length = %d, ",RxMessage.StdId,RxMessage.DLC);
		HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		for(int i = 0;i<RxMessage.DLC;i++){
			sprintf(tx_buff,"%d, ",RxData[i]);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}
		HAL_UART_Transmit(&huart2, "\n", 1, 100);
	}
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */
while (1)
 {
	  //STM32가 1초간격으로 메시지를 전송한다!
	  //송신
	  TxMessage.DLC = 8; //데이터길이
	  TxMessage.ExtId = 0;
	  TxMessage.IDE = CAN_ID_STD;
	  TxMessage.RTR = CAN_RTR_DATA;
	  TxMessage.StdId = 0x123; //0x000 ~ 0x7FF
	  TxMessage.TransmitGlobalTime = DISABLE;
	  TxData[0] = 1;
	  TxData[1] = 2;
	  TxData[2] = 3;
	  TxData[3] = 4;
	  TxData[5] = 5;
	  TxData[6] = 6;
	  TxData[7] = 7;
	  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.녹칸다의 STM32쉴드에보면 LED가 8개 붙어있는데, PC에서 8byte의 CAN메시지를 송신해서 각 바이트가 0이면 LED가 OFF이고 1이면 LED가 ON되도록하시오!(일괄제어)

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.RTR == CAN_RTR_DATA && RxMessage.IDE == CAN_ID_STD){
		//LED 8개가 제어됨!
		if(RxData[0]){
		  //0이 아닌 모든경우(ON)
		  HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, 1);
		}else{
		  //0을 수신(OFF)
		  HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, 0);
		}
		if(RxData[1]){
		  HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, 0);
		}
		if(RxData[2]){
		  HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, 0);
		}
		if(RxData[3]){
		  HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_Pin, 0);
		}

		if(RxData[4]){
		  HAL_GPIO_WritePin(LED5_GPIO_Port, LED5_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED5_GPIO_Port, LED5_Pin, 0);
		}
		if(RxData[5]){
		  HAL_GPIO_WritePin(LED6_GPIO_Port, LED6_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED6_GPIO_Port, LED6_Pin, 0);
		}
		if(RxData[6]){
		  HAL_GPIO_WritePin(LED7_GPIO_Port, LED7_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED7_GPIO_Port, LED7_Pin, 0);
		}
		if(RxData[7]){
		  HAL_GPIO_WritePin(LED8_GPIO_Port, LED8_Pin, 1);
		}else{
		  HAL_GPIO_WritePin(LED8_GPIO_Port, LED8_Pin, 0);
		}
	}
}

/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */

4.예제3번과 유사하지만 CAN데이터를 2개만 보내서, 첫번째 바이트가 LED번호, 두번째 바이트가 0이면 OFF, 1이면 ON인 스타일로 접근하시오!(번호 8이면 전체를 ON/OFF)

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.RTR == CAN_RTR_DATA && RxMessage.IDE == CAN_ID_STD){
		//LED 8개가 제어됨!
		if(RxMessage.DLC == 2){
			//RxData[0] LED 번호
			//RxData[1] LED 작동명령
			if(RxData[0] == 0){
			  HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, RxData[1]);
			}else if(RxData[0] == 1){
			  HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, RxData[1]);
			}else if(RxData[0] == 2){
			  HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, RxData[1]);
			}else if(RxData[0] == 3){
			  HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_Pin, RxData[1]);
			}else if(RxData[0] == 4){
			  HAL_GPIO_WritePin(LED5_GPIO_Port, LED5_Pin, RxData[1]);
			}else if(RxData[0] == 5){
			  HAL_GPIO_WritePin(LED6_GPIO_Port, LED6_Pin, RxData[1]);
			}else if(RxData[0] == 6){
			  HAL_GPIO_WritePin(LED7_GPIO_Port, LED7_Pin, RxData[1]);
			}else if(RxData[0] == 7){
			  HAL_GPIO_WritePin(LED8_GPIO_Port, LED8_Pin, RxData[1]);


			}else if(RxData[0] == 8){
			  //전체 일괄제어
			  HAL_GPIO_WritePin(LED1_GPIO_Port, LED1_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED2_GPIO_Port, LED2_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED3_GPIO_Port, LED3_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED4_GPIO_Port, LED4_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED5_GPIO_Port, LED5_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED6_GPIO_Port, LED6_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED7_GPIO_Port, LED7_Pin, RxData[1]);
			  HAL_GPIO_WritePin(LED8_GPIO_Port, LED8_Pin, RxData[1]);
			}
		}
	}
}

/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */

5.녹칸다의 STM32쉴드에 PB11에 서보모터(SG90)을 연결하고 CAN통신 메시지를 1바이트 범위로 0~180의 값을 전송해서 서보모터의 각도를 제어하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void set_servo(uint8_t degree){
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}

//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
	if(RxMessage.RTR == CAN_RTR_DATA && RxMessage.IDE == CAN_ID_STD){
		//LED 8개가 제어됨!
		if(RxMessage.DLC == 1){
			//RxData[0] 서보모터의각도 0~180
			if(RxData[0] > 180) RxData[0] = 180;
			set_servo(RxData[0]);
		}
	}
}
/* USER CODE END 0 */

//캔통신 시작~
 Can_Set();
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 /* USER CODE END 2 */

6.이번에는 STM32에 붙어있는 버튼 8개가 있는데, 8바이트의 정보로 각버튼이 눌려지면 1, 안눌려지면 0의 값을 CAN메시지로 송신하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */
while (1)
 {
	  //0.1초간격으로 8byte array에 버튼의 눌려짐 상태를 넣어서 송신한다!
	  TxMessage.DLC = 8; //데이터길이
	  TxMessage.ExtId = 0;
	  TxMessage.IDE = CAN_ID_STD;
	  TxMessage.RTR = CAN_RTR_DATA;
	  TxMessage.StdId = 0x123; //0x000 ~ 0x7FF
	  TxMessage.TransmitGlobalTime = DISABLE;
	  TxData[0] = !HAL_GPIO_ReadPin(BTN1_GPIO_Port, BTN1_Pin);
	  TxData[1] = !HAL_GPIO_ReadPin(BTN2_GPIO_Port, BTN2_Pin);
	  TxData[2] = !HAL_GPIO_ReadPin(BTN3_GPIO_Port, BTN3_Pin);
	  TxData[3] = !HAL_GPIO_ReadPin(BTN4_GPIO_Port, BTN4_Pin);
	  TxData[4] = !HAL_GPIO_ReadPin(BTN5_GPIO_Port, BTN5_Pin);
	  TxData[5] = !HAL_GPIO_ReadPin(BTN6_GPIO_Port, BTN6_Pin);
	  TxData[6] = !HAL_GPIO_ReadPin(BTN7_GPIO_Port, BTN7_Pin);
	  TxData[7] = !HAL_GPIO_ReadPin(BTN8_GPIO_Port, BTN8_Pin);
	  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.버튼1~버튼8까지있을때 버튼1을 최하위bit로 생각하고 8bit로 계산해서 can메시지를 1바이트 전송하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 GPIO_TypeDef * myport[] = {BTN1_GPIO_Port,BTN2_GPIO_Port,BTN3_GPIO_Port,BTN4_GPIO_Port,BTN5_GPIO_Port,BTN6_GPIO_Port,BTN7_GPIO_Port,BTN8_GPIO_Port};
 uint16_t mypin[] = {BTN1_Pin,BTN2_Pin,BTN3_Pin,BTN4_Pin,BTN5_Pin,BTN6_Pin,BTN7_Pin,BTN8_Pin};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //0.1초간격으로 1byte 버튼의 눌려짐 상태를 bit연산으로 송신한다!
	  TxMessage.DLC = 1; //데이터길이
	  TxMessage.ExtId = 0;
	  TxMessage.IDE = CAN_ID_STD;
	  TxMessage.RTR = CAN_RTR_DATA;
	  TxMessage.StdId = 0x123; //0x000 ~ 0x7FF
	  TxMessage.TransmitGlobalTime = DISABLE;
	  TxData[0] = 0;
	  for(int i = 0;i<8;i++){
		  TxData[0] |= (!HAL_GPIO_ReadPin(myport[i], mypin[i]) << i);
	  }
	  HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.버튼1을 누르면 0~255범위에서 숫자가 1씩 업카운트된다! 버튼2를 누르면 1씩 다운카운트된다! 그리고 버튼3을 누르면 0으로 초기화된다! 이 카운터값을 버튼이 눌려지는 타이밍에 can통신으로 1바이트 전송하시오!

/* USER CODE BEGIN 0 */
//CAN통신할때 필요한 변수와 구조체
CAN_FilterTypeDef sFilterConfig;
CAN_TxHeaderTypeDef TxMessage;
CAN_RxHeaderTypeDef RxMessage;
uint8_t               TxData[8];
uint8_t               RxData[8];
uint32_t              TxMailbox;
//로그출력용 변수
uint8_t tx_buff[50];
void Can_Set(){
	sFilterConfig.FilterBank= 0;
	sFilterConfig.FilterMode= CAN_FILTERMODE_IDMASK;
	sFilterConfig.FilterScale= CAN_FILTERSCALE_32BIT;
	sFilterConfig.FilterIdHigh= 0x0000;
	sFilterConfig.FilterIdLow= 0x0000;
	sFilterConfig.FilterMaskIdHigh= 0x0000;
	sFilterConfig.FilterMaskIdLow= 0x0000;
	sFilterConfig.FilterFIFOAssignment= CAN_RX_FIFO0;
	sFilterConfig.FilterActivation= ENABLE;
	sFilterConfig.SlaveStartFilterBank = 14;
	HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
	HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
	HAL_CAN_Start(&hcan);
}
//CAN수신부
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)
{
	HAL_CAN_GetRxMessage(hcan1, CAN_RX_FIFO0, &RxMessage, RxData);
}

int cnt = 0;
void send_can_msg(){
	TxMessage.DLC = 1; //데이터길이
   TxMessage.ExtId = 0;
   TxMessage.IDE = CAN_ID_STD;
   TxMessage.RTR = CAN_RTR_DATA;
   TxMessage.StdId = 0x123; //0x000 ~ 0x7FF
   TxMessage.TransmitGlobalTime = DISABLE;
   TxData[0] = cnt;
   HAL_CAN_AddTxMessage(&hcan, &TxMessage, TxData, &TxMailbox);
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //캔통신 시작~
 Can_Set();
 /* USER CODE END 2 */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(BTN1_GPIO_Port, BTN1_Pin) == 0){
		  cnt++;
		  if(cnt > 255) cnt = 255;
		  send_can_msg();
		  HAL_Delay(200);
	  }
	  if(HAL_GPIO_ReadPin(BTN2_GPIO_Port, BTN2_Pin) == 0){
		  cnt--;
		  if(cnt < 0) cnt = 0;
		  send_can_msg();
		  HAL_Delay(200);
	  }
	  if(HAL_GPIO_ReadPin(BTN3_GPIO_Port, BTN3_Pin) == 0){
		  cnt = 0;
		  send_can_msg();
		  HAL_Delay(200);
	  }
 }

[STM32#28] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(4)!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 21 Jan 2026 19:18:08 +0900

https://youtube.com/live/YIJnO-q8EEM

[STM32#28] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(4)!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3bace9f0d28_4_189#slide=id.g3bace9f0d28_4_189

read input register부터 이어서 해보기!

1.녹칸다의 STM32시리즈 27-4번예제에서 가변저항, CDS, NTC서미스터의 값을 레지스터에 기록하고 C#윈폼 화면에 modbus rtu로 읽어와서 출력하시오! [참고]
-가변저항(12bit), CDS(12bit), ntc서미스터(온도/소수점이있겠지?)

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
  uint16_t crc = 0xFFFF;
  for(uint8_t i = 0; i < len; i++)
  {
      crc ^= data[i];   // LSB부터 XOR
      for(uint8_t j = 0; j < 8; j++)
      {
          if(crc & 0x0001)
          {
              crc >>= 1;
              crc ^= 0xA001;   // Modbus polynomial
          }
          else
          {
              crc >>= 1;
          }
      }
  }
  return crc;
}
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[50];
 uint8_t res[50];
 //modbus rtu에서 읽기전용 레지스터
 uint16_t r_reg[6] = {0};
 uint32_t t = 0;
 float logR2, R2, T, Tc, Tf;
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 /* USER CODE END 2 */

while (1)
 {
	  //100밀리초 간격으로 adc값을 읽어서 레지스터(uint16_t로 된 배열)에 대입한다
	  if(HAL_GetTick() - t >= 100){
		  t = HAL_GetTick();
		  //PA0 ADC1 RANK1
		  HAL_ADC_Start(&hadc1);
		  HAL_ADC_PollForConversion(&hadc1, 100);
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //가변저항
		  //PA1 ADC1 RANK2
		  HAL_ADC_Start(&hadc1);
		  HAL_ADC_PollForConversion(&hadc1, 100);
		  adc_value1 = HAL_ADC_GetValue(&hadc1); //CDS
		  //PA4 ADC1 RANK3
		  HAL_ADC_Start(&hadc1);
		  HAL_ADC_PollForConversion(&hadc1, 100);
		  adc_value2 = HAL_ADC_GetValue(&hadc1); //NTC서미스터
		  //온도계산
		  R2 = R1 * (4095.0 / adc_value2 - 1.0);
		  logR2 = log(R2);
		  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
		  Tc = T - 273.15; //온도값
		  //modbus레지스터에 대입
		  r_reg[0] = adc_value0;
		  r_reg[1] = adc_value1;
		  r_reg[2] = (uint16_t)(Tc*100);
	  }
	  //read input register에 대응하는 부분
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		//응답예시데이터
		uint8_t id = req[0];
		//내 id에게 req가 왔을때만 res를 전송한다!
		if(id == slave_id){
			uint8_t fc = req[1];
			if(fc == 0x04){
				//read input register
				uint16_t start_addr = (req[2] << 8) | req[3];
				uint16_t count = (req[4] << 8) | req[5];
				uint16_t crc16 = (req[7] << 8) | req[6];
				//STM32가 CRC16을 계산함!
				uint16_t my_crc16 = cal_crc(req,6);
				if(crc16 == my_crc16){
					sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
					HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					//마스터가 요구한 워드에 갯수만큼 응답한다!
					//0~2번까지는 자리가 고정이다!
					res[0] = id;
					res[1] = fc;
					res[2] = count * 2; //count는 무조건 1인상태!
					//count == 2
					//반복문
					for(int i = 0;i < count * 2;i++){
					 //i의 값을 2로 나눠서 나머지가 없으면 짝수다!
						  if(i%2 == 0){
							  //짝수
							  res[3+i] = r_reg[start_addr+(i/2)] >> 8; //상위8bit
						  }else{
							  //홀수
							  res[3+i] = r_reg[start_addr+(i/2)] & 0xFF; //하위8bit
						  }
					  }
						//count가 2이라면~ [0,1,2,3,4,5,6] [7,8]
					  //CRC16의 위치는 3+count*2, 4+count*2
					  //CRC16이전의 데이터로 체크섬을 계산한다!
					  uint16_t res_crc16 = cal_crc(res,3+count*2);
					  res[3+count*2] = (res_crc16 & 0xFF);
					  res[4+count*2] = (res_crc16 >> 8);
					  //3+count*2에다가 체크섬 갯수 2개를 더한개 최종보낼 데이터의 길이
					  HAL_UART_Transmit(&huart1, res, 5+count*2, 100);
					  HAL_UART_Transmit(&huart2, "RES DATA = ", 11, 100);
					  for(int i = 0;i<5+count*2;i++){
						  sprintf(tx_buff,"%02X, ",res[i]);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  }
					  HAL_UART_Transmit(&huart2, "\n", 1, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
	  /*
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            //타이머인터럽트가 0.1초마다 뭐하면되는냐?
            //0번지부터 2개를 읽는다!
            ushort[] data = msm.ReadInputRegisters(1, 0, 3);
            textBox4.Text = data[0].ToString(); //가변저항
            textBox2.Text = data[1].ToString(); //CDS
            textBox3.Text = (data[2]/100.0f).ToString(); //온도
        }

2.이번에는 프로토콜 자료를 참고해서 write multiple coil명령으로 STM32쉴드에 붙어있는 8개의 LED를 동시에 제어하도록 하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
  uint16_t crc = 0xFFFF;
  for(uint8_t i = 0; i < len; i++)
  {
      crc ^= data[i];   // LSB부터 XOR
      for(uint8_t j = 0; j < 8; j++)
      {
          if(crc & 0x0001)
          {
              crc >>= 1;
              crc ^= 0xA001;   // Modbus polynomial
          }
          else
          {
              crc >>= 1;
          }
      }
  }
  return crc;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t recv; //1개씩 읽는 변수
 uint8_t pos = 0;
 uint8_t req[50];
 uint8_t res[50];
 //modbus rtu의 write coil
 uint8_t mycoil[8] = {0};
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */

while (1)
 {
	  for(int i = 0;i<8;i++){
		  HAL_GPIO_WritePin(mygroup[i], mypin[i], mycoil[i]);
	  }
	  //write multiple coil은 길이가 확정되어있지 않다!
	  if(HAL_UART_Receive(&huart1, &recv, 1, 500) == HAL_OK){
		  pos = 0;
		  req[pos++] = recv;
		  while(HAL_UART_Receive(&huart1, &recv, 1, 100) == HAL_OK){
			  req[pos++] = recv;
		  }
		  uint8_t id = req[0];
		  uint8_t fc = req[1];
		  uint16_t addr = (req[2] << 8) | req[3];
		  uint16_t qty = (req[4] << 8) | req[5];
		  uint8_t cnt = req[6];
		  //CRC16의 위치
		  //req 7+cnt개
		  uint16_t crc1 = cal_crc(req,7+cnt);
		  uint16_t crc2 = (req[7+cnt+1] << 8) |  req[7+cnt];
		  if(crc1 == crc2){
			  //데이터 해석
			  for(int i = 0;i < qty;i++){
				  uint8_t state = (req[7+(i/8)] >> (i%8)) & 0x01;
				  mycoil[i] = state;
				  sprintf(tx_buff,"%d = %d\n",i,state);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			  }
			  //응답
			  res[0] = req[0];
			  res[1] = req[1];
			  res[2] = req[2];
			  res[3] = req[3];
			  res[4] = req[4];
			  res[5] = req[5];
			  uint16_t crc3 = cal_crc(res,6);
			  res[6] = crc3 & 0x00FF; //crc3의 하위 8bit
			  res[7] = crc3 >> 8; //crc3의 상위 8bit
			  HAL_UART_Transmit(&huart1, res, 8, 100);
		  }
		  /*
		  //흐름이 끊어짐(지금 STM32가 읽은 데이터 갯수는 pos byte)
		  for(int i = 0;i<pos;i++){
			  sprintf(tx_buff,"%02X, ",req[i]);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		  }
		  */
	  }
	  /*
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            //타이머인터럽트가 0.1초마다 뭐하면되는냐?
            //0번지부터 2개를 읽는다!
            ushort[] data = msm.ReadInputRegisters(1, 0, 3);
            textBox4.Text = data[0].ToString(); //가변저항
            textBox2.Text = data[1].ToString(); //CDS
            textBox3.Text = (data[2]/100.0f).ToString(); //온도
        }

3.이번에는 write multiple register명령을 stm32에 전송해서 putty에 stm32가 수신한 값을 출력하도록 하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
  uint16_t crc = 0xFFFF;
  for(uint8_t i = 0; i < len; i++)
  {
      crc ^= data[i];   // LSB부터 XOR
      for(uint8_t j = 0; j < 8; j++)
      {
          if(crc & 0x0001)
          {
              crc >>= 1;
              crc ^= 0xA001;   // Modbus polynomial
          }
          else
          {
              crc >>= 1;
          }
      }
  }
  return crc;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t recv; //1개씩 읽는 변수
 uint8_t pos = 0;
 uint8_t req[50];
 uint8_t res[50];
 //modbus rtu의 write register
 uint16_t w_reg[10];
 /* USER CODE END 2 */

while (1)
 {
	  //write multiple coil은 길이가 확정되어있지 않다!
	  if(HAL_UART_Receive(&huart1, &recv, 1, 500) == HAL_OK){
		  pos = 0;
		  req[pos++] = recv;
		  while(HAL_UART_Receive(&huart1, &recv, 1, 100) == HAL_OK){
			  req[pos++] = recv;
		  }
		  uint8_t id = req[0];
		  uint8_t fc = req[1];
		  uint16_t addr = (req[2] << 8) | req[3];
		  uint16_t qty = (req[4] << 8) | req[5];
		  uint8_t cnt = req[6];
		  for(int i =0;i<cnt;i++){
			  if(i%2 == 0){
				  w_reg[i/2] =  (req[7+i]<<8);
			  }else{
				  w_reg[i/2] = w_reg[i/2] | req[7+i];
			  }
		  }
		  //출력테스트
		  for(int i = 0;i<qty;i++){
			  sprintf(tx_buff,"%d = %d\n",i,w_reg[i]);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		  }

		  //응답
		  res[0] = req[0];
		  res[1] = req[1];
		  res[2] = req[2];
		  res[3] = req[3];
		  res[4] = req[4];
		  res[5] = req[5];
		  uint16_t crc3 = cal_crc(res,6);
		  res[6] = crc3 & 0x00FF; //crc3의 하위 8bit
		  res[7] = crc3 >> 8; //crc3의 상위 8bit
		  HAL_UART_Transmit(&huart1, res, 8, 100);
	  }
	  /*
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


      private void button2_Click(object sender, EventArgs e)
        {
            ushort[] data = new ushort[6];
            data[0] = (ushort)numericUpDown1.Value;
            data[1] = (ushort)numericUpDown2.Value;
            data[2] = (ushort)numericUpDown3.Value;
            data[3] = (ushort)numericUpDown4.Value;
            data[4] = (ushort)numericUpDown5.Value;
            data[5] = (ushort)numericUpDown6.Value;
            try
            {
                msm.WriteMultipleRegisters(1, 0, data);
            }
            catch
            {

            }
            
        }

[STM32#27] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(3)!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 19 Jan 2026 23:05:46 +0900

https://youtube.com/live/5ZRg9t2ga8o

[STM32#27] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(3)!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b7a28c0ef6_1_0#slide=id.g3b7a28c0ef6_1_0

read holding register부터 이어서 해보기!

1.녹칸다의 STM32 26편-6번예제에서 C#으로 만든 modbus rtu마스터가 1개의 word를 read holding register하도록 해놓았는데, 2개이상도 가능하도록 수정하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint8_t res[50];
 uint16_t w_reg[6] = {0}; //6word 정도의 레지스터가 있다고 가정함
 /* USER CODE END 2 */





while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  if(fc == 0x06){
				  uint16_t reg_addr = (req[2] << 8) | req[3];
				  uint16_t reg_data = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,reg_addr,reg_data,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  w_reg[reg_addr] = reg_data;
					  //레지스터가 6개 있으니까 6개의 값을 출력한다!
					  sprintf(tx_buff,"w_reg=%d, %d, %d, %d, %d, %d\n",w_reg[0],w_reg[1],w_reg[2],w_reg[3],w_reg[4],w_reg[5]);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //응답은 req를 그대로 응답하면 된다!
					  HAL_UART_Transmit(&huart1, req, 8, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }

			  }else if(fc == 0x03){
				  //read holding register
				  uint16_t start_addr = (req[2] << 8) | req[3];
				  uint16_t count = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //마스터가 요구한 워드에 갯수만큼 응답한다!
					  //0~2번까지는 자리가 고정이다!
					  res[0] = id;
					  res[1] = fc;
					  res[2] = count * 2; //count는 무조건 1인상태!
					  //count == 2
					  //반복문
					  for(int i = 0;i < count * 2;i++){
						  //i의 값을 2로 나눠서 나머지가 없으면 짝수다!
						  if(i%2 == 0){
							  //짝수
							  res[3+i] = w_reg[start_addr+(i/2)] >> 8; //상위8bit
						  }else{
							  //홀수
							  res[3+i] = w_reg[start_addr+(i/2)] & 0xFF; //하위8bit
						  }
					  }

					  //count가 2이라면~ [0,1,2,3,4,5,6] [7,8]
					  //CRC16의 위치는 3+count*2, 4+count*2
					  //CRC16이전의 데이터로 체크섬을 계산한다!
					  uint16_t res_crc16 = cal_crc(res,3+count*2);
					  res[3+count*2] = (res_crc16 & 0xFF);
					  res[4+count*2] = (res_crc16 >> 8);
					  //3+count*2에다가 체크섬 갯수 2개를 더한개 최종보낼 데이터의 길이
					  HAL_UART_Transmit(&huart1, res, 5+count*2, 100);
					  HAL_UART_Transmit(&huart2, "RES DATA = ", 11, 100);
					  for(int i = 0;i<5+count*2;i++){
						  sprintf(tx_buff,"%02X, ",res[i]);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  }
					  HAL_UART_Transmit(&huart2, "\n", 1, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox2.Text);
            ushort value = ushort.Parse(textBox3.Text);
            msm.WriteSingleRegister(1, addr, value);
        }


        private void button3_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox4.Text);
            ushort cnt = ushort.Parse(textBox5.Text);
            ushort[] data = msm.ReadHoldingRegisters(1, addr, cnt);

            richTextBox1.Text += "응답데이터=\n";
            for(int i = 0; i < data.Length; i++)
            {
                richTextBox1.Text += data[i] + "\n";
            }
        }

2.(지금부터 새로운예제로 구현하기) read holding register를 참고해서 read input register를 구현한다음 stm32의 내부 메모리값을 읽어오시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint8_t res[50];
 //
 uint16_t r_reg[6] = {111,222,333,444,555,666}; //dummy data

 /* USER CODE END 2 */





while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	 	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	 	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
	 		  //응답예시데이터
	 		  uint8_t id = req[0];
	 		  //내 id에게 req가 왔을때만 res를 전송한다!
	 		  if(id == slave_id){
	 			  uint8_t fc = req[1];
	 			  if(fc == 0x04){
					  //read input register
					  uint16_t start_addr = (req[2] << 8) | req[3];
					  uint16_t count = (req[4] << 8) | req[5];
					  uint16_t crc16 = (req[7] << 8) | req[6];
					  //STM32가 CRC16을 계산함!
					  uint16_t my_crc16 = cal_crc(req,6);
					  if(crc16 == my_crc16){
						  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
						  //마스터가 요구한 워드에 갯수만큼 응답한다!
						  //0~2번까지는 자리가 고정이다!
						  res[0] = id;
						  res[1] = fc;
						  res[2] = count * 2; //count는 무조건 1인상태!
						  //count == 2
						  //반복문
						  for(int i = 0;i < count * 2;i++){
							  //i의 값을 2로 나눠서 나머지가 없으면 짝수다!
							  if(i%2 == 0){
								  //짝수
								  res[3+i] = r_reg[start_addr+(i/2)] >> 8; //상위8bit
							  }else{
								  //홀수
								  res[3+i] = r_reg[start_addr+(i/2)] & 0xFF; //하위8bit
							  }
						  }
						  //count가 2이라면~ [0,1,2,3,4,5,6] [7,8]
						  //CRC16의 위치는 3+count*2, 4+count*2
						  //CRC16이전의 데이터로 체크섬을 계산한다!
						  uint16_t res_crc16 = cal_crc(res,3+count*2);
						  res[3+count*2] = (res_crc16 & 0xFF);
						  res[4+count*2] = (res_crc16 >> 8);
						  //3+count*2에다가 체크섬 갯수 2개를 더한개 최종보낼 데이터의 길이
						  HAL_UART_Transmit(&huart1, res, 5+count*2, 100);
						  HAL_UART_Transmit(&huart2, "RES DATA = ", 11, 100);
						  for(int i = 0;i<5+count*2;i++){
							  sprintf(tx_buff,"%02X, ",res[i]);
							  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
						  }
						  HAL_UART_Transmit(&huart2, "\n", 1, 100);
					  }else{
						  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
					  }
				  }
			  }
		  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device;

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox2.Text);
            ushort cnt = ushort.Parse(textBox3.Text);

            ushort[] data = msm.ReadInputRegisters(1, addr, cnt);

            richTextBox1.Text = "수신데이터=\n";
            for(int i = 0; i < data.Length; i++)
            {
                richTextBox1.Text += data[i] + "\n";
            }
        }

3.예제2에서 만든 수신구문은 마스터가 보낸 request를 8개가 다 올때까지 기다리는 형식이라서 blocking이 너무 심하게 걸린다! RTOS를 적용하고 PB1에 연결된 버튼을 누르면 1씩 다운카운트되고, PA8에 연결된 버튼을 누르면 1씩 업카운트될때, 그 카운터값이 읽기전용 레지스터 0번지에 지정되었다고 할때 마스터에서 그 값을 읽을 수 있도록 하시오!
-task1 : 마스터에서 modbus rtu명령이 오면 응답한다
-task2 : 버튼을 누르면 업/다운 카운트한다

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
  uint16_t crc = 0xFFFF;
  for(uint8_t i = 0; i < len; i++)
  {
      crc ^= data[i];   // LSB부터 XOR
      for(uint8_t j = 0; j < 8; j++)
      {
          if(crc & 0x0001)
          {
              crc >>= 1;
              crc ^= 0xA001;   // Modbus polynomial
          }
          else
          {
              crc >>= 1;
          }
      }
  }
  return crc;
}
//task1과 task2가 동시에 참조하는 메모리
 volatile uint16_t r_reg[6] = {0};
/* USER CODE END 0 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[50];
 uint8_t res[50];
 /* Infinite loop */
 for(;;)
 {
		  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
			  //응답예시데이터
			  uint8_t id = req[0];
			  //내 id에게 req가 왔을때만 res를 전송한다!
			  if(id == slave_id){
				  uint8_t fc = req[1];
				  if(fc == 0x04){
					  //read input register
					  uint16_t start_addr = (req[2] << 8) | req[3];
					  uint16_t count = (req[4] << 8) | req[5];
					  uint16_t crc16 = (req[7] << 8) | req[6];
					  //STM32가 CRC16을 계산함!
					  uint16_t my_crc16 = cal_crc(req,6);
					  if(crc16 == my_crc16){
						  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
						  //마스터가 요구한 워드에 갯수만큼 응답한다!
						  //0~2번까지는 자리가 고정이다!
						  res[0] = id;
						  res[1] = fc;
						  res[2] = count * 2; //count는 무조건 1인상태!

						  //count == 2
						  //반복문
						  for(int i = 0;i < count * 2;i++){
							  //i의 값을 2로 나눠서 나머지가 없으면 짝수다!
							  if(i%2 == 0){
								  //짝수
								  res[3+i] = r_reg[start_addr+(i/2)] >> 8; //상위8bit
							  }else{
								  //홀수
								  res[3+i] = r_reg[start_addr+(i/2)] & 0xFF; //하위8bit
							  }
						  }
						//count가 2이라면~ [0,1,2,3,4,5,6] [7,8]
					  //CRC16의 위치는 3+count*2, 4+count*2
					  //CRC16이전의 데이터로 체크섬을 계산한다!
					  uint16_t res_crc16 = cal_crc(res,3+count*2);
					  res[3+count*2] = (res_crc16 & 0xFF);
					  res[4+count*2] = (res_crc16 >> 8);
					  //3+count*2에다가 체크섬 갯수 2개를 더한개 최종보낼 데이터의 길이
					  HAL_UART_Transmit(&huart1, res, 5+count*2, 100);
					  HAL_UART_Transmit(&huart2, "RES DATA = ", 11, 100);
					  for(int i = 0;i<5+count*2;i++){
						  sprintf(tx_buff,"%02X, ",res[i]);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  }
					  HAL_UART_Transmit(&huart2, "\n", 1, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
   osDelay(1);
 }
 /* USER CODE END 5 */
}
void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  r_reg[0]--;
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  r_reg[0]++;
		  osDelay(200);
	  }
   osDelay(1); //반드시 있어야함
 }
 /* USER CODE END StartTask02 */
}

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            //타이머인터럽트가 0.1초마다 뭐하면되는냐?
            ushort[] data = msm.ReadInputRegisters(1, 0, 1);
            textBox4.Text = ((short)data[0]).ToString();
        }

4.녹칸다의 STM32쉴드에 붙어있는 가변저항의 값을 읽기전용 레지스터 1번지에 저장을해서 마스터 화면에 출력하시오!
   -task1 : 마스터에서 modbus rtu명령이 오면 응답한다
   -task2 : 버튼을 누르면 업/다운 카운트한다
   -task3 : ADC값 측정하기~

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
  uint16_t crc = 0xFFFF;
  for(uint8_t i = 0; i < len; i++)
  {
      crc ^= data[i];   // LSB부터 XOR
      for(uint8_t j = 0; j < 8; j++)
      {
          if(crc & 0x0001)
          {
              crc >>= 1;
              crc ^= 0xA001;   // Modbus polynomial
          }
          else
          {
              crc >>= 1;
          }
      }
  }
  return crc;
}
//task1과 task2가 동시에 참조하는 메모리
 volatile uint16_t r_reg[6] = {0};
/* USER CODE END 0 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[50];
 uint8_t res[50];
 /* Infinite loop */
 for(;;)
 {
		  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
			  //응답예시데이터
			  uint8_t id = req[0];
			  //내 id에게 req가 왔을때만 res를 전송한다!
			  if(id == slave_id){
				  uint8_t fc = req[1];
				  if(fc == 0x04){
					  //read input register
					  uint16_t start_addr = (req[2] << 8) | req[3];
					  uint16_t count = (req[4] << 8) | req[5];
					  uint16_t crc16 = (req[7] << 8) | req[6];
					  //STM32가 CRC16을 계산함!
					  uint16_t my_crc16 = cal_crc(req,6);
					  if(crc16 == my_crc16){
						  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
						  //마스터가 요구한 워드에 갯수만큼 응답한다!
						  //0~2번까지는 자리가 고정이다!
						  res[0] = id;
						  res[1] = fc;
						  res[2] = count * 2; //count는 무조건 1인상태!

						  //count == 2
						  //반복문
						  for(int i = 0;i < count * 2;i++){
							  //i의 값을 2로 나눠서 나머지가 없으면 짝수다!
							  if(i%2 == 0){
								  //짝수
								  res[3+i] = r_reg[start_addr+(i/2)] >> 8; //상위8bit
							  }else{
								  //홀수
								  res[3+i] = r_reg[start_addr+(i/2)] & 0xFF; //하위8bit
							  }
						  }
						//count가 2이라면~ [0,1,2,3,4,5,6] [7,8]
					  //CRC16의 위치는 3+count*2, 4+count*2
					  //CRC16이전의 데이터로 체크섬을 계산한다!
					  uint16_t res_crc16 = cal_crc(res,3+count*2);
					  res[3+count*2] = (res_crc16 & 0xFF);
					  res[4+count*2] = (res_crc16 >> 8);
					  //3+count*2에다가 체크섬 갯수 2개를 더한개 최종보낼 데이터의 길이
					  HAL_UART_Transmit(&huart1, res, 5+count*2, 100);
					  HAL_UART_Transmit(&huart2, "RES DATA = ", 11, 100);
					  for(int i = 0;i<5+count*2;i++){
						  sprintf(tx_buff,"%02X, ",res[i]);
						  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  }
					  HAL_UART_Transmit(&huart2, "\n", 1, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
   osDelay(1);
 }
 /* USER CODE END 5 */
}
void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  r_reg[0]--;
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  r_reg[0]++;
		  osDelay(200);
	  }
   osDelay(1); //반드시 있어야함
 }
 /* USER CODE END StartTask02 */
}
void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
  HAL_ADC_Start(&hadc1); //딱 한번만 호출
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  r_reg[1] = HAL_ADC_GetValue(&hadc1); //0~4095
	  }
	  osDelay(100);
 }
 /* USER CODE END StartTask03 */
}

ModbusSerialMaster msm;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 9600;
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                msm = ModbusSerialMaster.CreateRtu(serialPort1);

                MessageBox.Show("접속완료");
            }
            else
            {
                MessageBox.Show("접속실패");
            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            //타이머인터럽트가 0.1초마다 뭐하면되는냐?
            //0번지부터 2개를 읽는다!
            ushort[] data = msm.ReadInputRegisters(1, 0, 2);
            textBox4.Text = ((short)data[0]).ToString();
            textBox2.Text = ((short)data[1]).ToString();
        }

[STM32#26] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(2)!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 7 Jan 2026 16:26:36 +0900

https://youtube.com/live/0GP7utrIFTw

[STM32#26] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(2)!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b2751bc412_11_154#slide=id.g3b2751bc412_11_154

마스터인 C#윈폼에서는 nmodbus4 라이브러리를 적용해보도록 하자!

1.예제25편-2에서 만든 예제를 마스터쪽에 nmodbus4라이브러리를 적용해서 stm32가 정상적으로 작동되는지 보이시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //녹칸다의 STM32쉴드의 8개의 LED를 배열로 뭉쳐놓은것!
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 /* USER CODE END 2 */

while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  uint16_t coil_addr = (req[2] << 8) | req[3];
			  uint16_t coil_data = (req[4] << 8) | req[5];
			  uint16_t crc16 = (req[7] << 8) | req[6];
			  //STM32가 CRC16을 계산함!
			  uint16_t my_crc16 = cal_crc(req,6);
			  if(crc16 == my_crc16){
				  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,coil_addr,coil_data,crc16);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  //write single coil명령어 수행
				  if(coil_data == 0xFF00){
					  //ON
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 1);
				  }else{
					  //OFF
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 0);
				  }
				  //응답전송! 그런데 FC=0x05는 req와 res가 같다!
				  HAL_UART_Transmit(&huart1, req, 8, 100);
			  }else{
				  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
			  }
		  }
	  }
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //coil 0번을 ON한다!
            msm.WriteSingleCoil(1, 0, true);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 0, false);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, true);
        }
        private void button5_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, false);
        }

        private void button6_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, true);
        }

        private void button7_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, false);
        }

        private void button8_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, true);
        }

        private void button9_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, false);
        }

        

        private void button10_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, true);
        }

        private void button11_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, false);
        }
        private void button12_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, true);
        }

        private void button13_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, false);
        }

        private void button14_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, true);
        }

        private void button15_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, false);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, true);
        }
        private void button17_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, false);
        }

2.예제1에 더해서 마스터쪽에서 readcoil을 실행했을때 STM32의 8개의 LED의 작동상태를 읽어와서 화면에 출력할수있도록 하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //녹칸다의 STM32쉴드의 8개의 LED를 배열로 뭉쳐놓은것!
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint8_t res[6]; //read coils 전용
 uint8_t write_coil[1];
 /* USER CODE END 2 */


while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  if(fc == 0x01){
				  //read coils
				  uint16_t start_addr = (req[2] << 8) | req[3];
				  uint16_t count = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  //read coil 응답데이터 만들기
					  //write_coil[0]여기에 순서에 맞게 bit 상태를 넣으면 됨!
					  write_coil[0] = 0;
					  for(int i = 0; i < count; i++)
					  {
					      if(mygroup[i]->ODR & mypin[i])
					          write_coil[0] |= (1 << i);
					  }
					  sprintf(tx_buff,"id=%02X, fc=%02X, start_addr=%04X, cnt=%04X, crc=%04X, data=%d\n",id,fc,start_addr,count,crc16,write_coil[0]);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  res[0] = id;
					  res[1] = fc;
					  res[2] = 1; //응답데이터는 1byte이다!
					  res[3] = write_coil[0];
					  uint16_t res_crc = cal_crc(res,4);

					  res[4] = res_crc & 0xFF; //res_crc의 하위8bit
					  res[5] = res_crc >> 8; //res_crc의 상위8bit
					  HAL_UART_Transmit(&huart1, res, 6, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }else if(fc == 0x05){
				  //write single coil
				  uint16_t coil_addr = (req[2] << 8) | req[3];
				  uint16_t coil_data = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,coil_addr,coil_data,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //write single coil명령어 수행
					  if(coil_data == 0xFF00){
						  //ON
						  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 1);
					  }else{
						  //OFF
						  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 0);
					  }
					  //응답전송! 그런데 FC=0x05는 req와 res가 같다!
					  HAL_UART_Transmit(&huart1, req, 8, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //coil 0번을 ON한다!
            msm.WriteSingleCoil(1, 0, true);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 0, false);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, true);
        }
        private void button5_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, false);
        }

        private void button6_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, true);
        }

        private void button7_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, false);
        }

        private void button8_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, true);
        }

        private void button9_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, false);
        }
        private void button10_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, true);
        }

        private void button11_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, false);
        }
        private void button12_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, true);
        }
        private void button13_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, false);
        }

        private void button14_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, true);
        }

        private void button15_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, false);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, true);
        }
        private void button17_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, false);
        }
        private void button18_Click(object sender, EventArgs e)
        {
            //라이브러리가 stm32에게 0번지부터 8개의 쓰기코일값을 요구한다!
            bool[] data = msm.ReadCoils(1, 0, 8);

            string text = "";
            for(int i = 0; i < 8; i++)
            {
                text += data[i].ToString() + ", ";
            }
            richTextBox1.Text += text + "\n";
        }

3.예제2번에서 마스터쪽에 STM32쪽 LED가 켜져있으면 ON버튼의 배경색을 녹색으로 하고, OFF상태면 OFF버튼의 배경색을 빨간색으로 하시오! 여기서 C#의 timer를 하나 추가해서 100밀리초 간격으로 read coils 명령을 수행하도록하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //녹칸다의 STM32쉴드의 8개의 LED를 배열로 뭉쳐놓은것!
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint8_t res[6]; //read coils 전용
 uint8_t write_coil[1];
 /* USER CODE END 2 */


while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  if(fc == 0x01){
				  //read coils
				  uint16_t start_addr = (req[2] << 8) | req[3];
				  uint16_t count = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  //read coil 응답데이터 만들기
					  //write_coil[0]여기에 순서에 맞게 bit 상태를 넣으면 됨!
					  write_coil[0] = 0;
					  for(int i = 0; i < count; i++)
					  {
					      if(mygroup[i]->ODR & mypin[i])
					          write_coil[0] |= (1 << i);
					  }
					  sprintf(tx_buff,"id=%02X, fc=%02X, start_addr=%04X, cnt=%04X, crc=%04X, data=%d\n",id,fc,start_addr,count,crc16,write_coil[0]);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  res[0] = id;
					  res[1] = fc;
					  res[2] = 1; //응답데이터는 1byte이다!
					  res[3] = write_coil[0];
					  uint16_t res_crc = cal_crc(res,4);

					  res[4] = res_crc & 0xFF; //res_crc의 하위8bit
					  res[5] = res_crc >> 8; //res_crc의 상위8bit
					  HAL_UART_Transmit(&huart1, res, 6, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }else if(fc == 0x05){
				  //write single coil
				  uint16_t coil_addr = (req[2] << 8) | req[3];
				  uint16_t coil_data = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,coil_addr,coil_data,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //write single coil명령어 수행
					  if(coil_data == 0xFF00){
						  //ON
						  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 1);
					  }else{
						  //OFF
						  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 0);
					  }
					  //응답전송! 그런데 FC=0x05는 req와 res가 같다!
					  HAL_UART_Transmit(&huart1, req, 8, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //coil 0번을 ON한다!
            msm.WriteSingleCoil(1, 0, true);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 0, false);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, true);
        }
        private void button5_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 1, false);
        }

        private void button6_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, true);
        }

        private void button7_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 2, false);
        }

        private void button8_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, true);
        }

        private void button9_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 3, false);
        }
        private void button10_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, true);
        }

        private void button11_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 4, false);
        }
        private void button12_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, true);
        }
        private void button13_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 5, false);
        }

        private void button14_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, true);
        }

        private void button15_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 6, false);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, true);
        }
        private void button17_Click(object sender, EventArgs e)
        {
            msm.WriteSingleCoil(1, 7, false);
        }
        private void button18_Click(object sender, EventArgs e)
        {
            timer1.Start();
        }


        private void timer1_Tick(object sender, EventArgs e)
        {
            //0.1초마다 이부분이 실행되는데 뭐할래?
            //라이브러리가 stm32에게 0번지부터 8개의 쓰기코일값을 요구한다!
            bool[] data = msm.ReadCoils(1, 0, 8);

            if (data[0])
            {
                button2.BackColor = Color.Green;
                button3.BackColor = SystemColors.Control;
            }
            else
            {
                button2.BackColor = SystemColors.Control;
                button3.BackColor = Color.Red;
            }
            if (data[1])
            {
                button4.BackColor = Color.Green;
                button5.BackColor = SystemColors.Control;
            }
            else
            {
                button4.BackColor = SystemColors.Control;
                button5.BackColor = Color.Red;
            }
            if (data[2])
            {
                button6.BackColor = Color.Green;
                button7.BackColor = SystemColors.Control;
            }
            else
            {
                button6.BackColor = SystemColors.Control;
                button7.BackColor = Color.Red;
            }

            if (data[3])
            {
                button8.BackColor = Color.Green;
                button9.BackColor = SystemColors.Control;
            }
            else
            {
                button8.BackColor = SystemColors.Control;
                button9.BackColor = Color.Red;
            }
            if (data[4])
            {
                button10.BackColor = Color.Green;
                button11.BackColor = SystemColors.Control;
            }
            else
            {
                button10.BackColor = SystemColors.Control;
                button11.BackColor = Color.Red;
            }
            if (data[5])
            {
                button12.BackColor = Color.Green;
                button13.BackColor = SystemColors.Control;
            }
            else
            {
                button12.BackColor = SystemColors.Control;
                button13.BackColor = Color.Red;
            }

            if (data[6])
            {
                button14.BackColor = Color.Green;
                button15.BackColor = SystemColors.Control;
            }
            else
            {
                button14.BackColor = SystemColors.Control;
                button15.BackColor = Color.Red;
            }
            if (data[7])
            {
                button16.BackColor = Color.Green;
                button17.BackColor = SystemColors.Control;
            }
            else
            {
                button16.BackColor = SystemColors.Control;
                button17.BackColor = Color.Red;
            }
        }

4.이번예제는 지금까지 했던 coil내용을 다 제거하고 write single register에 대해서 예제를 만들어보도록 한다! 마스터쪽에서 설정한 값을 stm32가 받아서 putty에 단순 출력하는 예시를 보이시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint16_t w_reg[6] = {0}; //6word 정도의 레지스터가 있다고 가정함
 /* USER CODE END 2 */



while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  //fc가 0x06이 올 예정!
			  uint16_t reg_addr = (req[2] << 8) | req[3];
			  uint16_t reg_data = (req[4] << 8) | req[5];
			  uint16_t crc16 = (req[7] << 8) | req[6];
			  //STM32가 CRC16을 계산함!
			  uint16_t my_crc16 = cal_crc(req,6);
			  if(crc16 == my_crc16){
				  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,reg_addr,reg_data,crc16);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  w_reg[reg_addr] = reg_data;
				  //레지스터가 6개 있으니까 6개의 값을 출력한다!
				  sprintf(tx_buff,"w_reg=%d, %d, %d, %d, %d, %d\n",w_reg[0],w_reg[1],w_reg[2],w_reg[3],w_reg[4],w_reg[5]);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  //응답은 req를 그대로 응답하면 된다!
				  HAL_UART_Transmit(&huart1, req, 8, 100);
			  }else{
				  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox2.Text);
            ushort value = ushort.Parse(textBox3.Text);
            msm.WriteSingleRegister(1, addr, value);
        }

5.마스터쪽에서 STM32의 쓰기레지스터 0번지에 값을 쓰면 녹칸다의 STM32쉴드에 붙어있는 FND모듈에 그 값이 출력되도록 하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
//여기 추가해야하는 코드는 FND모듈에추가해야하는 코드 그대로 복붙하기!
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint16_t w_reg[6] = {0}; //6word 정도의 레지스터가 있다고 가정함
 tm1637Init();
 tm1637SetBrightness(4);
 tm1637DisplayDecimalTrim(0, 0);
 /* USER CODE END 2 */




while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  //fc가 0x06이 올 예정!
			  uint16_t reg_addr = (req[2] << 8) | req[3];
			  uint16_t reg_data = (req[4] << 8) | req[5];
			  uint16_t crc16 = (req[7] << 8) | req[6];
			  //STM32가 CRC16을 계산함!
			  uint16_t my_crc16 = cal_crc(req,6);
			  if(crc16 == my_crc16){
				  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,reg_addr,reg_data,crc16);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  w_reg[reg_addr] = reg_data;
				  if(reg_addr == 0)
					  tm1637DisplayDecimalTrim(w_reg[0], 0);
				  //레지스터가 6개 있으니까 6개의 값을 출력한다!
				  sprintf(tx_buff,"w_reg=%d, %d, %d, %d, %d, %d\n",w_reg[0],w_reg[1],w_reg[2],w_reg[3],w_reg[4],w_reg[5]);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  //응답은 req를 그대로 응답하면 된다!
				  HAL_UART_Transmit(&huart1, req, 8, 100);
			  }else{
				  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox2.Text);
            ushort value = ushort.Parse(textBox3.Text);
            msm.WriteSingleRegister(1, addr, value);
        }

6.이번에는 예제4에 더해서 쓰기 레지스터에서 값을 읽는 명령인 read holding register를 구현해서 C#화면에 출력하도록 한다! (마스터는 1워드의 데이터만 요구할수있는 제약조건을 주고 다음주 예제부터 다시 이어서 구현하도록 함 시간관계상)

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 uint8_t res[17];
 uint16_t w_reg[6] = {0}; //6word 정도의 레지스터가 있다고 가정함
 /* USER CODE END 2 */





while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 500) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  if(fc == 0x06){
				  uint16_t reg_addr = (req[2] << 8) | req[3];
				  uint16_t reg_data = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,reg_addr,reg_data,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  w_reg[reg_addr] = reg_data;
					  //레지스터가 6개 있으니까 6개의 값을 출력한다!
					  sprintf(tx_buff,"w_reg=%d, %d, %d, %d, %d, %d\n",w_reg[0],w_reg[1],w_reg[2],w_reg[3],w_reg[4],w_reg[5]);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //응답은 req를 그대로 응답하면 된다!
					  HAL_UART_Transmit(&huart1, req, 8, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }

			  }else if(fc == 0x03){
				  //read holding register
				  uint16_t start_addr = (req[2] << 8) | req[3];
				  uint16_t count = (req[4] << 8) | req[5];
				  uint16_t crc16 = (req[7] << 8) | req[6];
				  //STM32가 CRC16을 계산함!
				  uint16_t my_crc16 = cal_crc(req,6);
				  if(crc16 == my_crc16){
					  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,start_addr,count,crc16);
					  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
					  //마스터가 요구한 워드에 갯수만큼 응답한다!
					  res[0] = id;
					  res[1] = fc;
					  res[2] = count * 2;
					  res[3] = (w_reg[start_addr] >> 8);
					  res[4] = (w_reg[start_addr] & 0xFF);
					  uint16_t res_crc16 = cal_crc(res,5);
					  res[5] = (res_crc16 & 0xFF);
					  res[6] = (res_crc16 >> 8);
					  HAL_UART_Transmit(&huart1, res, 7, 100);
				  }else{
					  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
				  }
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Modbus.Device; //네임스페이스를 추가!

//nmodbus4 객체선언(modbus rtu전용)
        ModbusSerialMaster msm;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //접속이 완료된 serialport 객체를 라이브러리에게 넘긴다!
                msm = ModbusSerialMaster.CreateRtu(serialPort1);
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox2.Text);
            ushort value = ushort.Parse(textBox3.Text);
            msm.WriteSingleRegister(1, addr, value);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            ushort addr = ushort.Parse(textBox4.Text);
            ushort[] data = msm.ReadHoldingRegisters(1, addr, 1);

            richTextBox1.Text += "응답데이터=" + data[0].ToString() + "\n";
        }

[STM32#25] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(1)!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 5 Jan 2026 23:16:30 +0900

https://youtube.com/live/xWxbcANp3ac

[STM32#25] stm32를 modbus rtu 슬레이브(slave)로 C# winform을 마스터(master)로 설정해서 제어하는 방법(1)!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b25d818391_8_0#slide=id.g3b25d818391_8_0

이제 stm32가 마스터가 아니라 슬레이브가 되는 것입니다~~!

1.C#윈폼에서 버튼을 2개 생성하고 ON버튼을 누르면 STM32의 PB3의 LED가 켜지고, OFF버튼을 누르면 꺼지도록 하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //녹칸다의 STM32쉴드의 8개의 LED를 배열로 뭉쳐놓은것!
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 /* USER CODE END 2 */

while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 100) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  uint16_t coil_addr = (req[2] << 8) | req[3];
			  uint16_t coil_data = (req[4] << 8) | req[5];
			  uint16_t crc16 = (req[7] << 8) | req[6];
			  //STM32가 CRC16을 계산함!
			  uint16_t my_crc16 = cal_crc(req,6);
			  if(crc16 == my_crc16){
				  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,coil_addr,coil_data,crc16);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  //write single coil명령어 수행
				  if(coil_data == 0xFF00){
					  //ON
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 1);
				  }else{
					  //OFF
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 0);
				  }
				  //응답전송! 그런데 FC=0x05는 req와 res가 같다!
				  HAL_UART_Transmit(&huart1, req, 8, 100);
			  }else{
				  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
			  }
		  }
	  }
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                byte[] req = { 0x01, 0x05, 0x00, 0x00, 0xFF, 0x00, 0x8C, 0x3A };
                serialPort1.Write(req, 0, 8);
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                byte[] req = { 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0xCD, 0xCA };
                serialPort1.Write(req, 0, 8);
            }
        }

private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //슬레이브로부터 8개의 데이터가 응답으로 올 예정이다!
            byte[] res = new byte[8];
            int pos = 0;
            for (int i = 0; i < 8; i++)
            {
                res[pos++] = (byte)serialPort1.ReadByte();
            }
            
            richTextBox1.Text += "[응답] ";
            for(int i = 0; i < 8; i++)
            {
                richTextBox1.Text += res[i].ToString("X") + ", ";
            }
            richTextBox1.Text += "\n";
        }

2.예제1번에서 PB3번 LED만 제어했던것을 녹칸다의 STM32쉴드에 붙어있는 8개의 LED를 제어할 수 있는 기능으로 확장하시오!

/* USER CODE BEGIN 0 */
uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //녹칸다의 STM32쉴드의 8개의 LED를 배열로 뭉쳐놓은것!
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 uint8_t slave_id = 0x01;
 uint8_t tx_buff[100];
 uint8_t req[8];
 /* USER CODE END 2 */

while (1)
 {
	  //usart1은 RS485통신, usart2는 PC와 통신
	  //usart1으로 수신해서 usart2로 결과를 송신한다!
	  if(HAL_UART_Receive(&huart1, req, 8, 100) == HAL_OK){
		  //응답예시데이터
		  uint8_t id = req[0];
		  //내 id에게 req가 왔을때만 res를 전송한다!
		  if(id == slave_id){
			  uint8_t fc = req[1];
			  uint16_t coil_addr = (req[2] << 8) | req[3];
			  uint16_t coil_data = (req[4] << 8) | req[5];
			  uint16_t crc16 = (req[7] << 8) | req[6];
			  //STM32가 CRC16을 계산함!
			  uint16_t my_crc16 = cal_crc(req,6);
			  if(crc16 == my_crc16){
				  sprintf(tx_buff,"id=%02X, fc=%02X, addr=%04X, data=%04X, crc=%04X\n",id,fc,coil_addr,coil_data,crc16);
				  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
				  //write single coil명령어 수행
				  if(coil_data == 0xFF00){
					  //ON
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 1);
				  }else{
					  //OFF
					  HAL_GPIO_WritePin(mygroup[coil_addr], mypin[coil_addr], 0);
				  }
				  //응답전송! 그런데 FC=0x05는 req와 res가 같다!
				  HAL_UART_Transmit(&huart1, req, 8, 100);
			  }else{
				  HAL_UART_Transmit(&huart2, "CRC16 ERROR!\n", 13, 100);
			  }
		  }
	  }
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.BaudRate = 9600;
            serialPort1.PortName = textBox1.Text;

            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                MessageBox.Show("연결완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(0, true);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(0, false);
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //슬레이브로부터 8개의 데이터가 응답으로 올 예정이다!
            byte[] res = new byte[8];
            int pos = 0;
            for (int i = 0; i < 8; i++)
            {
                res[pos++] = (byte)serialPort1.ReadByte();
            }
            

            richTextBox1.Text += "[응답] ";
            for(int i = 0; i < 8; i++)
            {
                richTextBox1.Text += res[i].ToString("X") + ", ";
            }
            richTextBox1.Text += "\n";
        }
        UInt16 cal_crc(byte[] data, int len)
        {
            UInt16 crc = 0xFFFF;
            for (int pos = 0; pos < len; pos++)
            {
                crc ^= data[pos];

                for (int i = 0; i < 8; i++)
                {
                    if ((crc & 0x0001) != 0)
                    {
                        crc >>= 1;
                        crc ^= 0xA001;
                    }
                    else
                    {
                        crc >>= 1;
                    }
                }
            }
            return crc;
        }
        void write_single_coil(UInt16 coil_num, bool state)
        {
            byte[] req = { 0x01, 0x05, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00 };
            if (state == false)
            {
                req[4] = 0x00;
            }

            req[2] = (byte)(coil_num >> 8);
            req[3] = (byte)(coil_num & 0xFF);
            UInt16 crc = cal_crc(req, 6);
            req[6] = (byte)(crc & 0xFF);
            req[7] = (byte)(crc >> 8);
            serialPort1.Write(req, 0, 8);
        }
        private void button4_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(1, true);
        }

        private void button5_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(1, false);
        }

        private void button6_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(2, true);
        }

        private void button7_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(2, false);
        }

        private void button8_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(3, true);
        }

        private void button9_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(3, false);
        }

         private void button10_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(4, true);
        }

        private void button11_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(4, false);
        }

        private void button12_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(5, true);
        }

        private void button13_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(5, false);
        }

        private void button14_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(6, true);
        }
        private void button15_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(6, false);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(7, true);
        }
        private void button17_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen) write_single_coil(7, false);
        }

[STM32#24] RS485 to TTL모듈을 이용해서 modbus rtu로 4채널릴레이(relay)와 온습도센서(XY-MD02) 제어해보기 계속!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 31 Dec 2025 17:01:16 +0900

https://youtube.com/live/AaawBcSBXX0

[STM32#24] RS485 to TTL모듈을 이용해서 modbus rtu로 4채널릴레이(relay)와 온습도센서(XY-MD02) 제어해보기 계속!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b3e89c7231_3_141#slide=id.g3b3e89c7231_3_141

4채널릴레이는 어느정도 했고 이번에는 온습도센서를 처리해보도록 하겠습니다!

1.녹칸다가 23편에서 만든 예제2번을 그대로 적용한다음, modbus 4채널릴레이의 매뉴얼에 보면 릴레이의 on/off상태를 읽어오는 명령이 있는데, 이 명령을 이용해서 슬레이브쪽 릴레이의 작동상태를 마스터에서 알수있도록 하시오!(usart2출력)

/* USER CODE BEGIN 0 */
uint8_t nockanda_req[][8] = {
		{0x01,0x05,0x00,0x00,0xFF,0x00,0x8C,0x3A},
		{0x01,0x05,0x00,0x00,0x00,0x00,0xCD,0xCA},
		{0x01,0x05,0x00,0x01,0xFF,0x00,0xDD,0xFA},
		{0x01,0x05,0x00,0x01,0x00,0x00,0x9C,0x0A},
		{0x01,0x05,0x00,0x02,0xFF,0x00,0x2D,0xFA},
		{0x01,0x05,0x00,0x02,0x00,0x00,0x6C,0x0A},
		{0x01,0x05,0x00,0x03,0xFF,0x00,0x7C,0x3A},
		{0x01,0x05,0x00,0x03,0x00,0x00,0x3D,0xCA}
};
uint8_t res[8];
uint8_t tx_buff[100];
//btn_num은 0부터 7까지 눌려진 버튼의 번호이다!
void control_relay(int btn_num){
  HAL_UART_Transmit(&huart1, nockanda_req[btn_num], sizeof(nockanda_req[btn_num]), 100);
  if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
  }
  HAL_Delay(200);
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint32_t nockanda_t = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초 간격으로 4채널릴레이에게 릴레이 상태를 물어본다!
	  if(HAL_GetTick() - nockanda_t >= 100){
		  nockanda_t = HAL_GetTick();
		  uint8_t req[] = {0x01,0x01,0x00,0x00,0x00,0x08,0x3D,0xCC};
		  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
		  //릴레이로부터 응답을 수신함!
		  //HAL_Delay(100);
		  if(HAL_UART_Receive(&huart1, res, 6, 100) == HAL_OK){
			//res[3]에 coil의 상태가 들어있다!
			uint8_t coils[4];
			for(int i = 0;i<4;i++){
				coils[i] = (res[3] >> i) & 0b00000001;
				sprintf(tx_buff,"COIL%d = %s,",i,coils[i] ? "ON" : "OFF");
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}
		   HAL_UART_Transmit(&huart2, "\n", 1, 100);
		  }
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0) control_relay(0);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0) control_relay(2);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0) control_relay(4);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0) control_relay(6);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0) control_relay(1);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0) control_relay(3);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0) control_relay(5);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == 0) control_relay(7);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.예제1번에서 녹칸다가 버튼을 무지하게 빠르게 누르게되면 read coils쪽 코드가 HAL_Delay에 의해서 멈추게 된다! 이 부분을 freeRTOS를 이용해서 간단하게 극복해보시오!
task1:녹칸다가 8개의 버튼중에 어떤 버튼을 눌렀는지를 대기열에 넣음!
task2:100밀리초 간격으로 read coils명령을 대기열에 넣음!
task3:대기열에 있는 내용을 수행해서 반영함

/* USER CODE BEGIN 0 */
uint8_t nockanda_req[][8] = {
		{0x01,0x05,0x00,0x00,0xFF,0x00,0x8C,0x3A},
		{0x01,0x05,0x00,0x00,0x00,0x00,0xCD,0xCA},
		{0x01,0x05,0x00,0x01,0xFF,0x00,0xDD,0xFA},
		{0x01,0x05,0x00,0x01,0x00,0x00,0x9C,0x0A},
		{0x01,0x05,0x00,0x02,0xFF,0x00,0x2D,0xFA},
		{0x01,0x05,0x00,0x02,0x00,0x00,0x6C,0x0A},
		{0x01,0x05,0x00,0x03,0xFF,0x00,0x7C,0x3A},
		{0x01,0x05,0x00,0x03,0x00,0x00,0x3D,0xCA}
};
uint8_t res[8];
uint8_t tx_buff[100];
//btn_num은 0부터 7까지 눌려진 버튼의 번호이다!
void control_relay(int btn_num){
  HAL_UART_Transmit(&huart1, nockanda_req[btn_num], sizeof(nockanda_req[btn_num]), 100);
  if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
  }
}
typedef struct {
   uint8_t fc; //fc가 0x05면 write single coil, 0x01이면 read coils
   uint8_t btn_num;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
	//8개의 버튼중에 어떤 버튼이 눌려졌는지를 대기열에 넣는다!
	Msg_t msg;
	msg.fc  = 0x05;
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  //큐에다가 버튼 0번이 눌려졌다고 넣어준다
		  msg.btn_num = 0;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  msg.btn_num = 2;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  msg.btn_num = 4;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  msg.btn_num = 6;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0) {
		  msg.btn_num = 1;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }

	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  msg.btn_num = 3;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0){
		  msg.btn_num = 5;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == 0){
		  msg.btn_num = 7;
		  osMessageQueuePut(dataQueue, &msg, 0, 0);
		  osDelay(200);
	  }
	  osDelay(1); //이녀석 필수!
 }
 /* USER CODE END 5 */
/* USER CODE END Header_StartTask02 */
void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
	//100밀리초 간격으로 read coils에 대한 명령을 대기열에 넣는다!
	Msg_t msg;
	msg.fc = 0x01;
 /* Infinite loop */
 for(;;)
 {
	  osMessageQueuePut(dataQueue, &msg, 0, 0);
     osDelay(100);
 }

/* USER CODE END Header_StartTask03 */
void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
	//대기열에 뭔가 기다리는게 있으면 순서대로 뺴서 처리한다!
	Msg_t msg;
 /* Infinite loop */
 for(;;)
 {
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever);
	  if(msg.fc == 0x01){
		  uint8_t req[] = {0x01,0x01,0x00,0x00,0x00,0x08,0x3D,0xCC};
		  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
		  //릴레이로부터 응답을 수신함!
		  //HAL_Delay(100);
		  if(HAL_UART_Receive(&huart1, res, 6, 100) == HAL_OK){
			//res[3]에 coil의 상태가 들어있다!
			uint8_t coils[4];
			for(int i = 0;i<4;i++){
				coils[i] = (res[3] >> i) & 0b00000001;
				sprintf(tx_buff,"COIL%d = %s,",i,coils[i] ? "ON" : "OFF");
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}
		   HAL_UART_Transmit(&huart2, "\n", 1, 100);
		  }
	  }else if(msg.fc == 0x05){
		  //task1으로부터 온 메시지
		  control_relay(msg.btn_num);
	  }
 }
 /* USER CODE END StartTask03 */
}

3.modbus rtu 온습도센서를 연결해서 온도를 측정해서 putty화면에 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t res[8];
 uint8_t tx_buff[100];
 /* USER CODE END 2 */


while (1)
 {
	  uint8_t req[] = {0x01,0x04,0x00,0x01,0x00,0x01,0x60,0x0A};
	  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
	  if(HAL_UART_Receive(&huart1, res, 7, 100) == HAL_OK){
	 		//USART2로 출력!
	 		HAL_UART_Transmit(&huart2, "res = ", 6, 100);
	 		for(int i = 0;i<7;i++){
	 		  sprintf(tx_buff,"%02X, ",res[i]);
	 		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	 	  }
	 	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	 	  //온도계산 res[3] res[4]
	 	  int16_t temp = (res[3] << 8) | res[4];
	 	  sprintf(tx_buff,"temp = %.1f\n",temp/10.0);
	 	 HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	   }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.modbus rtu 온습도센서를 연결해서 습도를 측정해서 putty화면에 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t res[8];
 uint8_t tx_buff[100];
 /* USER CODE END 2 */


while (1)
 {
	  uint8_t req[] = {0x01,0x04,0x00,0x02,0x00,0x01,0x90,0x0A};
	  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
	  if(HAL_UART_Receive(&huart1, res, 7, 100) == HAL_OK){
	 		//USART2로 출력!
	 		HAL_UART_Transmit(&huart2, "res = ", 6, 100);
	 		for(int i = 0;i<7;i++){
	 		  sprintf(tx_buff,"%02X, ",res[i]);
	 		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	 	  }
	 	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	 	  //습도계산 res[3] res[4]
	 	  uint16_t humi = (res[3] << 8) | res[4];
	 	  sprintf(tx_buff,"humi = %.1f\n",humi/10.0);
	 	 HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	   }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.온도와 습도를 동시에 측정해서 putty화면에 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t res[8];
 uint8_t tx_buff[100];
 /* USER CODE END 2 */

while (1)
 {
	  uint8_t req[] = {0x01,0x04,0x00,0x01,0x00,0x02,0x20,0x0B};
	  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
	  if(HAL_UART_Receive(&huart1, res, 9, 100) == HAL_OK){
	 		//USART2로 출력!
	 		HAL_UART_Transmit(&huart2, "res = ", 6, 100);
	 		for(int i = 0;i<9;i++){
	 		  sprintf(tx_buff,"%02X, ",res[i]);
	 		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	 	  }
	 	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	 	  //온도 res[3] + res[4]
	 	  //습도 res[5] + res[6]
	 	  int16_t temp = (res[3] << 8) | res[4];
	 	  uint16_t humi = (res[5] << 8) | res[6];
	 	  sprintf(tx_buff,"temp = %.1f, humi = %.1f\n",temp/10.0,humi/10.0);
	 	 HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	   }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.측정한 온도와 습도를 1602LCD에 출력하시오!

//BEGIN0에 i2c 1602LCD관련코드 링크타고가서 추가하기!

/* USER CODE BEGIN 2 */
 uint8_t res[9];
 uint8_t tx_buff[100];
 uint8_t line1[20];
 uint8_t line2[20];
 LCD_INIT(); //1회호출(메인루프 시작전)
 /* USER CODE END 2 */

while (1)
 {
	  uint8_t req[] = {0x01,0x04,0x00,0x01,0x00,0x02,0x20,0x0B};
	  HAL_UART_Transmit(&huart1, req, sizeof(req), 100);
	  if(HAL_UART_Receive(&huart1, res, 9, 100) == HAL_OK){
	 		//USART2로 출력!
	 		HAL_UART_Transmit(&huart2, "res = ", 6, 100);
	 		for(int i = 0;i<9;i++){
	 		  sprintf(tx_buff,"%02X, ",res[i]);
	 		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	 	  }
	 	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	 	  //온도 res[3] + res[4]
	 	  //습도 res[5] + res[6]
	 	  int16_t temp = (res[3] << 8) | res[4];
	 	  uint16_t humi = (res[5] << 8) | res[6];
	 	  sprintf(tx_buff,"temp = %.1f, humi = %.1f\n",temp/10.0,humi/10.0);
	 	  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	 	  //1602LCD에 출력하기
	 	  LCD_CLEAR();
	 	  sprintf(line1,"TEMP = %.1f'C",temp/10.0);
	 	  sprintf(line2,"HUMI = %.1f%c",humi/10.0,'%');
	 	  LCD_XY(0, 0) ; LCD_PUTS(line1);
	 	  LCD_XY(0, 1) ; LCD_PUTS(line2);
	   }
	  HAL_Delay(1000);
 }

[STM32#23] RS485 to TTL모듈을 이용해서 modbus rtu로 4채널릴레이(relay)와 온습도센서(XY-MD02) 제어하는 방법!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 29 Dec 2025 23:21:44 +0900

https://youtube.com/live/oMZoDk0ourA

[STM32#23] RS485 to TTL모듈을 이용해서 modbus rtu로 4채널릴레이(relay)와 온습도센서(XY-MD02) 제어하는 방법!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3ab12818c94_4_1#slide=id.g3ab12818c94_4_1

산업용 통신인 modbus rtu를 해보도록 하겠습니다!

(연결)

1.STM32가 RS485릴레이의 채널0을 1초간격으로 on/off하도록 하시오!

/* USER CODE BEGIN 2 */
 uint8_t on_req[] = {0x01,0x05,0x00,0x00,0xFF,0x00,0x8C,0x3A};
 uint8_t off_req[] = {0x01,0x05,0x00,0x00,0x00,0x00,0xCD,0xCA};
 uint8_t res[8];
 uint8_t tx_buff[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //채널0 ON명령어 전송!(01 05 00 00 FF 00 8C 3A)
	  HAL_UART_Transmit(&huart1, on_req, sizeof(on_req), 100);
	  HAL_UART_Transmit(&huart2, "on_req sent!\n", 13, 100);
	  //릴레이로부터 응답을 수신함!
	  //HAL_Delay(100);
	  if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
		  //USART2로 출력!
		  HAL_UART_Transmit(&huart2, "res = ", 6, 100);
		  for(int i = 0;i<8;i++){
			  sprintf(tx_buff,"%02X, ",res[i]);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		  }
		  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	  }
	  HAL_Delay(1000);

	  //채널0 OFF명령어 전송!(01 05 00 00 00 00 CD CA)
	  HAL_UART_Transmit(&huart1, off_req, sizeof(off_req), 100);
	  HAL_UART_Transmit(&huart2, "off_req sent!\n", 14, 100);
	  //HAL_Delay(100);
	  //릴레이로부터 응답을 수신함!
	  if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
		  //USART2로 출력!
		  HAL_UART_Transmit(&huart2, "res = ", 6, 100);
		  for(int i = 0;i<8;i++){
			  sprintf(tx_buff,"%02X, ",res[i]);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		  }
		  HAL_UART_Transmit(&huart2, "\n", 1, 100);
	  }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.녹칸다의 STM32쉴드에 붙어있는 버튼 8개를 이용해서 4채널 릴레이를 모두 on/off할수있는 기능을 구현하시오!

/* USER CODE BEGIN 0 */
uint8_t nockanda_req[][8] = {
		{0x01,0x05,0x00,0x00,0xFF,0x00,0x8C,0x3A},
		{0x01,0x05,0x00,0x00,0x00,0x00,0xCD,0xCA},
		{0x01,0x05,0x00,0x01,0xFF,0x00,0xDD,0xFA},
		{0x01,0x05,0x00,0x01,0x00,0x00,0x9C,0x0A},
		{0x01,0x05,0x00,0x02,0xFF,0x00,0x2D,0xFA},
		{0x01,0x05,0x00,0x02,0x00,0x00,0x6C,0x0A},
		{0x01,0x05,0x00,0x03,0xFF,0x00,0x7C,0x3A},
		{0x01,0x05,0x00,0x03,0x00,0x00,0x3D,0xCA}
};
uint8_t res[8];
uint8_t tx_buff[100];
//btn_num은 0부터 7까지 눌려진 버튼의 번호이다!
void control_relay(int btn_num){
	//채널0 ON명령어 전송!(01 05 00 00 FF 00 8C 3A)
   HAL_UART_Transmit(&huart1, nockanda_req[btn_num], sizeof(nockanda_req[btn_num]), 100);
   HAL_UART_Transmit(&huart2, "on_req sent!\n", 13, 100);
   //릴레이로부터 응답을 수신함!
   //HAL_Delay(100);
   if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
	    //USART2로 출력!
	    HAL_UART_Transmit(&huart2, "res = ", 6, 100);
	    for(int i = 0;i<8;i++){
	  	  sprintf(tx_buff,"%02X, ",res[i]);
		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	  }
	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
   }
   HAL_Delay(200);
}
/* USER CODE END 0 */

while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0) control_relay(0);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0) control_relay(2);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0) control_relay(4);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0) control_relay(6);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0) control_relay(1);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0) control_relay(3);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0) control_relay(5);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == 0) control_relay(7);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.예제2에서 릴레이를 제어하는 8개의 커맨드가 있는데, 각 커맨드의 CRC16을 계산하는 함수를 이용해서 CRC16만 계산해서 출력하시오!

/* USER CODE BEGIN 0 */
uint8_t nockanda_req[][8] = {
		{0x01,0x05,0x00,0x00,0xFF,0x00,0x8C,0x3A}, //0
		{0x01,0x05,0x00,0x00,0x00,0x00,0xCD,0xCA}, //1
		{0x01,0x05,0x00,0x01,0xFF,0x00,0xDD,0xFA}, //2
		{0x01,0x05,0x00,0x01,0x00,0x00,0x9C,0x0A}, //3
		{0x01,0x05,0x00,0x02,0xFF,0x00,0x2D,0xFA}, //4
		{0x01,0x05,0x00,0x02,0x00,0x00,0x6C,0x0A}, //5
		{0x01,0x05,0x00,0x03,0xFF,0x00,0x7C,0x3A}, //6
		{0x01,0x05,0x00,0x03,0x00,0x00,0x3D,0xCA} //7
};
uint8_t res[8];
uint8_t tx_buff[100];
//함수의 프로토타입 선언
void control_relay(int btn_num);
uint16_t cal_crc(uint8_t *data, uint8_t len);
//btn_num은 0부터 7까지 눌려진 버튼의 번호이다!
void control_relay(int btn_num){
	uint16_t crc16 = cal_crc(nockanda_req[btn_num],6);
	sprintf(tx_buff,"btn_num= %d, crc16= %04x\n",btn_num,crc16);
	HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
   HAL_Delay(200);
}


uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0) control_relay(0);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0) control_relay(2);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0) control_relay(4);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0) control_relay(6);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0) control_relay(1);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0) control_relay(3);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0) control_relay(5);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == 0) control_relay(7);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.modbus rtu명령어에서 CRC16자리를 비워두고 직접 계산해서 대입한다음 명령을 전송하시오!

/* USER CODE BEGIN 0 */
uint8_t nockanda_req[][8] = {
		{0x01,0x05,0x00,0x00,0xFF,0x00,0x00,0x00}, //0
		{0x01,0x05,0x00,0x00,0x00,0x00,0x00,0x00}, //1
		{0x01,0x05,0x00,0x01,0xFF,0x00,0x00,0x00}, //2
		{0x01,0x05,0x00,0x01,0x00,0x00,0x00,0x00}, //3
		{0x01,0x05,0x00,0x02,0xFF,0x00,0x00,0x00}, //4
		{0x01,0x05,0x00,0x02,0x00,0x00,0x00,0x00}, //5
		{0x01,0x05,0x00,0x03,0xFF,0x00,0x00,0x00}, //6
		{0x01,0x05,0x00,0x03,0x00,0x00,0x00,0x00} //7
};
uint8_t res[8];
uint8_t tx_buff[100];
//함수의 프로토타입 선언
void control_relay(int btn_num);
uint16_t cal_crc(uint8_t *data, uint8_t len);
//btn_num은 0부터 7까지 눌려진 버튼의 번호이다!
void control_relay(int btn_num){
	uint16_t crc16 = cal_crc(nockanda_req[btn_num],6);
	nockanda_req[btn_num][6] = crc16 & 0x00FF; //CRC_L
	nockanda_req[btn_num][7] = crc16 >> 8; //CRC_H
	HAL_UART_Transmit(&huart1, nockanda_req[btn_num], sizeof(nockanda_req[btn_num]), 100);
  HAL_UART_Transmit(&huart2, "on_req sent!\n", 13, 100);
  //릴레이로부터 응답을 수신함!
  //HAL_Delay(100);
  if(HAL_UART_Receive(&huart1, res, 8, 100) == HAL_OK){
		//USART2로 출력!
		HAL_UART_Transmit(&huart2, "res = ", 6, 100);
		for(int i = 0;i<8;i++){
		  sprintf(tx_buff,"%02X, ",res[i]);
		  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
	  }
	  HAL_UART_Transmit(&huart2, "\n", 1, 100);
  }
   HAL_Delay(200);
}

uint16_t cal_crc(uint8_t *data, uint8_t len)
{
   uint16_t crc = 0xFFFF;
   for(uint8_t i = 0; i < len; i++)
   {
       crc ^= data[i];   // LSB부터 XOR
       for(uint8_t j = 0; j < 8; j++)
       {
           if(crc & 0x0001)
           {
               crc >>= 1;
               crc ^= 0xA001;   // Modbus polynomial
           }
           else
           {
               crc >>= 1;
           }
       }
   }
   return crc;
}
while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0) control_relay(0);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0) control_relay(2);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0) control_relay(4);
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0) control_relay(6);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0) control_relay(1);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0) control_relay(3);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0) control_relay(5);
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12) == 0) control_relay(7);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#22] freeRTOS를 적용해서 녹칸다의 STM32쉴드에 붙어있는 여러가지 부분에 응용해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 24 Dec 2025 15:42:12 +0900

https://youtube.com/live/snS0bWdWQZw

[STM32#22] freeRTOS를 적용해서 녹칸다의 STM32쉴드에 붙어있는 여러가지 부분에 응용해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b2ee18b41b_9_216#slide=id.g3b2ee18b41b_9_216

아주 약간만 응용하고 넘어가버리기!

1.로터리엔코더와 부저를 조합해서 아래와 같이 2개의 task를 rtos로 작동시키시오!
task1:로터리엔코더를 돌리면 LED8개가 시계방향 혹은 반시계방향으로 회전한다!
task2:버튼5개를 이용해서 도레미파솔까지 부저로 재생한다!

/* USER CODE BEGIN 4 */
GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void set_led(int num){
	//LED의 상태 업데이트 현재 켜져야하는 LED는 CNT번째꺼
	  for(int i = 0;i<8;i++){
		  if(i == num){
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
		  }else{
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
		  }
	  }
}
static void Tone(uint32_t Frequency)
{
  TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
  TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도
/* USER CODE END 4 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 uint8_t old_A = 0;
 int cnt = 0;
 //시작하자마자 일단 12시방향의 LED는 1개 켜고 출발한다!
 HAL_GPIO_WritePin(mygroup[0],mypin[0],GPIO_PIN_SET);
 /* Infinite loop */
 for(;;)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "SW\n", 3, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  cnt--;
			  if(cnt < 0) cnt = 7;
			  set_led(cnt);
		  }else{
			 //시계
			  cnt++;
			  if(cnt > 7) cnt = 0;
			  set_led(cnt);
		  }
	  }
	  old_A = now_A;
     osDelay(1); //1밀리초 지연~
 }
 /* USER CODE END 5 */
}

void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_C6);
	  }else if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_D6);
	  }else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_E6);
	  }else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_6) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_F6);
	  }else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_5) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_G6);
	  }else{
		  //소리를 끈다
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  }
 }
 /* USER CODE END StartTask02 */
}

2.로터리엔코더+TM1637와 가변저항을 조합해서 아래와 같이 2개의 task를 rtos로 작동시키시오!
task1:로터리엔코더를 시계방향으로 돌리면 1씩 증가하고 반시계방향으로 돌리면 1씩 감소하는 카운터값이 있는데, 그 값을 FND모듈인 TM1637에 출력하시오!
task2:PA0에 연결된 가변저항값을 ADC로 읽어들여서 USART2로 시리얼 출력하시오!

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int16_t value;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */


void DWT_Delay_Init(void)
{
   CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
   DWT->CYCCNT = 0;
   DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}
void delay_us(uint32_t us)
{
   uint32_t cycles = (SystemCoreClock / 1000000) * us;
   uint32_t start = DWT->CYCCNT;
   while ((DWT->CYCCNT - start) < cycles);
}
// TM1637 7세그먼트 숫자 코드 매핑
const char segmentMap[] = {
  0x3f, 0x06, 0x5b, 0x4f,
  0x66, 0x6d, 0x7d, 0x07,
  0x7f, 0x6f, 0x77, 0x7c,
  0x39, 0x5e, 0x79, 0x71,
  0x00
};
// GPIOB 클럭 활성화 매크로
#define PORTB_CLK_ENABLE() (RCC->APB2ENR |= RCC_APB2ENR_IOPBEN)
// PB8, PB9 핀 사용 (GPIOB)
// PB8 = CLK, PB9 = DIO
// CLK와 DIO 핀 제어 함수
static inline void _tm1637ClkHigh(void) { GPIOB->BSRR = (1 << 8); } // CLK HIGH
static inline void _tm1637ClkLow(void)  { GPIOB->BRR = (1 << 8); }  // CLK LOW
static inline void _tm1637DioHigh(void) { GPIOB->BSRR = (1 << 9); } // DIO HIGH
static inline void _tm1637DioLow(void)  { GPIOB->BRR = (1 << 9); }  // DIO LOW
// 마이크로초 단위 딜레이
void _tm1637DelayUsec(unsigned int i)
{
	delay_us(i); // 사용자 정의 delay_us 함수 사용
}

// TM1637 초기화 함수 (GPIO 출력 설정)
void tm1637Init(void)
{
  PORTB_CLK_ENABLE(); // GPIOB 클럭 활성화
  // GPIOB CRH 초기화 (PB8, PB9 출력 2MHz Push-Pull)
  GPIOB->CRH &= ~((0xF << 0) | (0xF << 4)); // 해당 비트 클리어
  GPIOB->CRH |= (0x2 << 0); // PB8: MODE=10(출력 2MHz), CNF=00(Push-Pull)
  GPIOB->CRH |= (0x2 << 4); // PB9: MODE=10(출력 2MHz), CNF=00(Push-Pull)
  tm1637SetBrightness(8); // 밝기 최대
}
// TM1637 시작 신호
void _tm1637Start(void)
{
  _tm1637ClkHigh();
  _tm1637DioHigh();
  _tm1637DelayUsec(20);
  _tm1637DioLow(); // START 조건: DIO LOW
}
// TM1637 종료 신호
void _tm1637Stop(void)
{
  _tm1637ClkLow();
  _tm1637DelayUsec(20);
  _tm1637DioLow();
  _tm1637DelayUsec(20);
  _tm1637ClkHigh();
  _tm1637DelayUsec(20);
  _tm1637DioHigh(); // STOP 조건: DIO HIGH
}

// TM1637 ACK 무시 (결과 확인용)
void _tm1637ReadResult(void)
{
  _tm1637ClkLow();
  _tm1637DelayUsec(50);
  // DIO 상태 확인, ACK 처리 (여기서는 실제 확인 없이 무시)
  _tm1637ClkHigh();
  _tm1637DelayUsec(20);
  _tm1637ClkLow();
}
// TM1637 1바이트 전송
void _tm1637WriteByte(unsigned char b)
{
  for (int i = 0; i < 8; ++i) {
      _tm1637ClkLow();
      if (b & 0x01) {
          _tm1637DioHigh();
      } else {
          _tm1637DioLow();
      }
      _tm1637DelayUsec(30);
      b >>= 1; // 다음 비트로 이동
      _tm1637ClkHigh();
      _tm1637DelayUsec(30);
  }
}
// 밝기 설정 (0~8, 0 = 꺼짐)
void tm1637SetBrightness(char brightness)
{
  _tm1637Start();
  _tm1637WriteByte(0x87 + brightness); // 밝기 명령어
  _tm1637ReadResult();
  _tm1637Stop();
}

// 4자리 10진수 표시 (displaySeparator=1이면 3번째 자리 점 켬)
void tm1637DisplayDecimal(int v, int displaySeparator)
{
  unsigned char digitArr[4];
  int isNegative = 0;
  if (v < 0) {
      isNegative = 1;
      v = -v;
  }
  // 숫자를 segmentMap으로 변환
  for (int i = 0; i < 4; ++i) {
      digitArr[i] = segmentMap[v % 10];
      if (i == 2 && displaySeparator) {
          digitArr[i] |= 1 << 7; // 점(DP) 켬
      }
      v /= 10;
  }
  // 음수 표시
  if (isNegative) {
      digitArr[3] = 0x40; // '-' 표시
  }
  // TM1637에 데이터 전송
  _tm1637Start();
  _tm1637WriteByte(0x40); // 자동 주소 증가 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xc0); // 시작 주소 0
  _tm1637ReadResult();
  for (int i = 0; i < 4; ++i) {
      _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
      _tm1637ReadResult();
  }
  _tm1637Stop();
}

// 4자리 10진수 표시 (앞자리 0 제거, displaySeparator=1이면 점 켬)
void tm1637DisplayDecimalTrim(int v, int displaySeparator)
{
  unsigned char digitArr[4];
  int isNegative = 0;
  if (v < 0) {
      isNegative = 1;
      v = -v;
  }
  // 숫자를 segmentMap으로 변환
  for (int i = 0; i < 4; ++i) {
      digitArr[i] = segmentMap[v % 10];
      if (i == 2 && displaySeparator) {
          digitArr[i] |= 1 << 7; // 점(DP) 켬
      }
      v /= 10;
  }
  // 앞자리 0 제거 (공백 처리)
  int leadingZero = 1;
  for (int i = 3; i >= 0; --i) {
      if (digitArr[i] != segmentMap[0] || i == 0) {
          leadingZero = 0;
      }
      if (leadingZero && digitArr[i] == segmentMap[0]) {
          digitArr[i] = 0x00; // 공백
      }
  }
  // 음수 표시
  if (isNegative) {
      digitArr[3] = 0x40; // '-'
  }

  // TM1637에 데이터 전송
  _tm1637Start();
  _tm1637WriteByte(0x40); // 자동 주소 증가 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xC0); // 시작 주소 0
  _tm1637ReadResult();
  for (int i = 0; i < 4; ++i) {
      _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
      _tm1637ReadResult();
  }
  _tm1637Stop();
}
void tm1637SetRawSegment(uint8_t position, uint8_t segData)
{
  // 주소 범위 보호
  if (position > 3) return;
  _tm1637Start();
  _tm1637WriteByte(0x40);      // 데이터 입력 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xC0 + position);   // 자리 선택
  _tm1637ReadResult();
  _tm1637WriteByte(segData);           // 세그먼트 데이터 전송
  _tm1637ReadResult();
  _tm1637Stop();
}
/* USER CODE END 4 */

3.예제2에서 task1의 기능을 다음과 같이 수정하시오!(앗 usart2에 출력하는걸로 충돌발생)
task1:로터리엔코더를 시계방향으로 돌리면 1씩 증가하고 반시계방향으로 돌리면 1씩 감소하는 카운터값이 있는데, 그 값을 task3에 메시지큐로 전송한다!
task2:PA0에 연결된 가변저항값을 ADC로 읽어들여서 task3에 메시지큐로 전송한다!
task3:task1과 task2에서 받은 메시지를 usart2로 출력한다!

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int16_t value;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */


void DWT_Delay_Init(void)
{
   CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
   DWT->CYCCNT = 0;
   DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}
void delay_us(uint32_t us)
{
   uint32_t cycles = (SystemCoreClock / 1000000) * us;
   uint32_t start = DWT->CYCCNT;
   while ((DWT->CYCCNT - start) < cycles);
}
// TM1637 7세그먼트 숫자 코드 매핑
const char segmentMap[] = {
  0x3f, 0x06, 0x5b, 0x4f,
  0x66, 0x6d, 0x7d, 0x07,
  0x7f, 0x6f, 0x77, 0x7c,
  0x39, 0x5e, 0x79, 0x71,
  0x00
};
// GPIOB 클럭 활성화 매크로
#define PORTB_CLK_ENABLE() (RCC->APB2ENR |= RCC_APB2ENR_IOPBEN)
// PB8, PB9 핀 사용 (GPIOB)
// PB8 = CLK, PB9 = DIO
// CLK와 DIO 핀 제어 함수
static inline void _tm1637ClkHigh(void) { GPIOB->BSRR = (1 << 8); } // CLK HIGH
static inline void _tm1637ClkLow(void)  { GPIOB->BRR = (1 << 8); }  // CLK LOW
static inline void _tm1637DioHigh(void) { GPIOB->BSRR = (1 << 9); } // DIO HIGH
static inline void _tm1637DioLow(void)  { GPIOB->BRR = (1 << 9); }  // DIO LOW
// 마이크로초 단위 딜레이
void _tm1637DelayUsec(unsigned int i)
{
	delay_us(i); // 사용자 정의 delay_us 함수 사용
}

// TM1637 초기화 함수 (GPIO 출력 설정)
void tm1637Init(void)
{
  PORTB_CLK_ENABLE(); // GPIOB 클럭 활성화
  // GPIOB CRH 초기화 (PB8, PB9 출력 2MHz Push-Pull)
  GPIOB->CRH &= ~((0xF << 0) | (0xF << 4)); // 해당 비트 클리어
  GPIOB->CRH |= (0x2 << 0); // PB8: MODE=10(출력 2MHz), CNF=00(Push-Pull)
  GPIOB->CRH |= (0x2 << 4); // PB9: MODE=10(출력 2MHz), CNF=00(Push-Pull)
  tm1637SetBrightness(8); // 밝기 최대
}
// TM1637 시작 신호
void _tm1637Start(void)
{
  _tm1637ClkHigh();
  _tm1637DioHigh();
  _tm1637DelayUsec(20);
  _tm1637DioLow(); // START 조건: DIO LOW
}
// TM1637 종료 신호
void _tm1637Stop(void)
{
  _tm1637ClkLow();
  _tm1637DelayUsec(20);
  _tm1637DioLow();
  _tm1637DelayUsec(20);
  _tm1637ClkHigh();
  _tm1637DelayUsec(20);
  _tm1637DioHigh(); // STOP 조건: DIO HIGH
}

// TM1637 ACK 무시 (결과 확인용)
void _tm1637ReadResult(void)
{
  _tm1637ClkLow();
  _tm1637DelayUsec(50);
  // DIO 상태 확인, ACK 처리 (여기서는 실제 확인 없이 무시)
  _tm1637ClkHigh();
  _tm1637DelayUsec(20);
  _tm1637ClkLow();
}
// TM1637 1바이트 전송
void _tm1637WriteByte(unsigned char b)
{
  for (int i = 0; i < 8; ++i) {
      _tm1637ClkLow();
      if (b & 0x01) {
          _tm1637DioHigh();
      } else {
          _tm1637DioLow();
      }
      _tm1637DelayUsec(30);
      b >>= 1; // 다음 비트로 이동
      _tm1637ClkHigh();
      _tm1637DelayUsec(30);
  }
}
// 밝기 설정 (0~8, 0 = 꺼짐)
void tm1637SetBrightness(char brightness)
{
  _tm1637Start();
  _tm1637WriteByte(0x87 + brightness); // 밝기 명령어
  _tm1637ReadResult();
  _tm1637Stop();
}

// 4자리 10진수 표시 (displaySeparator=1이면 3번째 자리 점 켬)
void tm1637DisplayDecimal(int v, int displaySeparator)
{
  unsigned char digitArr[4];
  int isNegative = 0;
  if (v < 0) {
      isNegative = 1;
      v = -v;
  }
  // 숫자를 segmentMap으로 변환
  for (int i = 0; i < 4; ++i) {
      digitArr[i] = segmentMap[v % 10];
      if (i == 2 && displaySeparator) {
          digitArr[i] |= 1 << 7; // 점(DP) 켬
      }
      v /= 10;
  }
  // 음수 표시
  if (isNegative) {
      digitArr[3] = 0x40; // '-' 표시
  }
  // TM1637에 데이터 전송
  _tm1637Start();
  _tm1637WriteByte(0x40); // 자동 주소 증가 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xc0); // 시작 주소 0
  _tm1637ReadResult();
  for (int i = 0; i < 4; ++i) {
      _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
      _tm1637ReadResult();
  }
  _tm1637Stop();
}

// 4자리 10진수 표시 (앞자리 0 제거, displaySeparator=1이면 점 켬)
void tm1637DisplayDecimalTrim(int v, int displaySeparator)
{
  unsigned char digitArr[4];
  int isNegative = 0;
  if (v < 0) {
      isNegative = 1;
      v = -v;
  }
  // 숫자를 segmentMap으로 변환
  for (int i = 0; i < 4; ++i) {
      digitArr[i] = segmentMap[v % 10];
      if (i == 2 && displaySeparator) {
          digitArr[i] |= 1 << 7; // 점(DP) 켬
      }
      v /= 10;
  }
  // 앞자리 0 제거 (공백 처리)
  int leadingZero = 1;
  for (int i = 3; i >= 0; --i) {
      if (digitArr[i] != segmentMap[0] || i == 0) {
          leadingZero = 0;
      }
      if (leadingZero && digitArr[i] == segmentMap[0]) {
          digitArr[i] = 0x00; // 공백
      }
  }
  // 음수 표시
  if (isNegative) {
      digitArr[3] = 0x40; // '-'
  }

  // TM1637에 데이터 전송
  _tm1637Start();
  _tm1637WriteByte(0x40); // 자동 주소 증가 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xC0); // 시작 주소 0
  _tm1637ReadResult();
  for (int i = 0; i < 4; ++i) {
      _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
      _tm1637ReadResult();
  }
  _tm1637Stop();
}
void tm1637SetRawSegment(uint8_t position, uint8_t segData)
{
  // 주소 범위 보호
  if (position > 3) return;
  _tm1637Start();
  _tm1637WriteByte(0x40);      // 데이터 입력 모드
  _tm1637ReadResult();
  _tm1637Stop();
  _tm1637Start();
  _tm1637WriteByte(0xC0 + position);   // 자리 선택
  _tm1637ReadResult();
  _tm1637WriteByte(segData);           // 세그먼트 데이터 전송
  _tm1637ReadResult();
  _tm1637Stop();
}
/* USER CODE END 4 */




void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 DWT_Delay_Init();
 tm1637Init();
 int cnt = 0;
 //초기값 출력하기~
 tm1637DisplayDecimalTrim(cnt,0);
 uint8_t old_rot_A = 0;
 Msg_t msg;
 msg.id = 1;
 /* Infinite loop */
 for(;;)
 {
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  cnt = 0;
		  tm1637DisplayDecimalTrim(cnt,0);
		  //cnt값을 메시지큐에 넣는다!
		  msg.value = cnt;
		  osMessageQueuePut(dataQueue, &msg, 0, 0); //송신
	  }
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  cnt--;
		  }else{
			  //CW
			  cnt++;
		  }
		  tm1637DisplayDecimalTrim(cnt,0);
		  msg.value = cnt;
		  osMessageQueuePut(dataQueue, &msg, 0, 0); //송신
	  }
	  old_rot_A = now_rot_A;
	  osDelay(1);
 }
 /* USER CODE END 5 */
}

void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 Msg_t msg;
 msg.id  = 2;
 /* Infinite loop */
 for(;;)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  msg.value = adc_value0;
		  osMessageQueuePut(dataQueue, &msg, 0, 0); //송신
	  }
	  osDelay(100);
 }
 /* USER CODE END StartTask02 */
}
void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
 Msg_t msg;
 char buff[50];
 /* Infinite loop */
 for(;;)
 {
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever);
	  sprintf(buff,"id = %d, value= %d\n",msg.id,msg.value);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
 }
 /* USER CODE END StartTask03 */
}

4.온습도센서와 가변저항과 1602LCD의 조합으로 아래와 같이 3개의 task를 구성하시오!
task1:0.1초간격으로 1씩 증가하는 카운터값을 task3에 메시지큐로 전송한다!
task2:PA0에 연결된 가변저항값을 ADC로 읽어들여서 task3에 메시지큐로 전송한다!
task3:task1과 task2에서 받은 메시지를 1602LCD에 출력하는데, task1의 값은 첫번째 line에 출력하고 가변저항값은 두번째 line에 출력하시오!

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int16_t value;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */
/* USER CODE BEGIN 4 */
void DWT_Delay_Init(void)
{
   CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
   DWT->CYCCNT = 0;
   DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
}
void delay_us(uint32_t us)
{
   uint32_t cycles = (SystemCoreClock / 1000000) * us;
   uint32_t start = DWT->CYCCNT;
   while ((DWT->CYCCNT - start) < cycles);
}
#define delay_ms osDelay
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08

// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
temp=(data & 0xF0)|RS1_EN0|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
delay_us(4);
temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
temp=(cmd & 0xF0)|RS0_EN0|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
delay_us(4);
temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
delay_us(50);
}

void LCD_INIT(void) {
delay_ms(100);
LCD_CMD_4bit(0x03); delay_ms(5);
LCD_CMD_4bit(0x03); delay_us(100);
LCD_CMD_4bit(0x03); delay_us(100);
LCD_CMD_4bit(0x02); delay_us(100);
LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
LCD_CMD(0x08);  // display off, cursor off, blink off
LCD_CMD(0x01);  // clear display
delay_ms(3);
LCD_CMD(0x06);  // cursor movint direction
LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
if      (y == 0) LCD_CMD(0x80 + x);
else if (y == 1) LCD_CMD(0xC0 + x);
else if (y == 2) LCD_CMD(0x94 + x);
else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
LCD_CMD(0x01);
delay_ms(2);
}
void LCD_PUTS(char *str) {
while (*str) LCD_DATA(*str++);
}
/* USER CODE END 4 */




void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
	uint16_t cnt = 0;
	Msg_t msg;
	msg.id  = 1;
 /* Infinite loop */
 for(;;)
 {
	  cnt++;
	  msg.value = cnt;
	  osMessageQueuePut(dataQueue, &msg, 0, 0); //송신
	  osDelay(1000);
 }
}
void StartTask02(void *argument)
{
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 Msg_t msg;
 msg.id  = 2;
 /* Infinite loop */
 for(;;)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  msg.value = adc_value0;
		  osMessageQueuePut(dataQueue, &msg, 0, 0); //송신
	  }
	  osDelay(100);
 }
}

void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
 Msg_t msg;
 char buff[50];
 DWT_Delay_Init(); //한번 호출하기~
 LCD_INIT(); //1회호출(메인루프 시작전)
 /* Infinite loop */
 for(;;)
 {
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever);
	  if(msg.id == 1){
		  sprintf(buff,"cnt = %10d",msg.value);
		  LCD_XY(0, 0) ; LCD_PUTS(buff);
	  }else if(msg.id == 2){
		  sprintf(buff,"PA0 value=%6d",msg.value);
		  LCD_XY(0, 1) ; LCD_PUTS(buff);
	  }
 }
 /* USER CODE END StartTask03 */
}

[STM32#21] freeRTOS를 적용하는 방법과 메시지큐(osMessageQueueId_t)를 이용해서 데이터를 주고받는 방법 간단하게 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 22 Dec 2025 23:08:17 +0900

https://youtube.com/live/vSkSt9_30jQ

[STM32#21] freeRTOS를 적용하는 방법과 메시지큐(osMessageQueueId_t)를 이용해서 데이터를 주고받는 방법 간단하게 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b24791482c_1_0#slide=id.g3b24791482c_1_0

STM32에서 freeRTOS를 사용하는 방법을 아주 간단히만 알아보겠습니다!

1.main 루프에서 HAL_getTick을 이용해서 2개의 task를 구현하는 방법에 대해서 보이시오!
-task1 : PB3을 1000밀리초 간격으로 깜빡인다!
-task2 : PB13을 1500밀리초 간격으로 깜빡인다!

/* USER CODE BEGIN 2 */
 uint32_t t1 = 0;
 uint32_t t2 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //-task1 : PB3을 1000밀리초 간격으로 깜빡인다!
	  if(HAL_GetTick() - t1 >= 1000){
		  t1 = HAL_GetTick();
		  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
	  }
	  //-task2 : PB13을 1500밀리초 간격으로 깜빡인다!
	  if(HAL_GetTick() - t2 >= 1500){
		  t2 = HAL_GetTick();
		  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_13);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.task1을 TIM1에 task2를 TIM2에 적용해서 LED를 깜빡이시오!

/* USER CODE BEGIN 0 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //TIM2일수도있고 TIM3일수도있고~
	if (htim->Instance == TIM2)
	{
		// TASK1
		HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
	}
	else if (htim->Instance == TIM3)
	{
		// TASK2
		HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_13);
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 HAL_TIM_Base_Start_IT(&htim3);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //메인루트에서는 할일 없음!
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.cubeide에서 tim1을 클락소스로 지정하고 rtos로 task2개를 생성해서 작동시키는 예시를 보이시오!

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 for(;;)
 {
	  //task1
	  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
	  osDelay(1000);
 }
 /* USER CODE END 5 */
}

void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 for(;;)
 {
	  //task2
	  HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_13);
	  osDelay(1500);
 }
 /* USER CODE END StartTask02 */
}

4.아래와 같이 task를 구성해서 예제를 구현하시오!
-task1 : 1000밀리초 간격으로 task1의 내부변수값을 usart2에 출력한다!
-task2 : 1000밀리초 간격으로 task2의 내부변수값을 usart2에 출력한다!

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 int num = 1234;
 char buff[20];
 for(;;)
 {
	  //task1
	  sprintf(buff,"TASK1=%d\n",num);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
	  osDelay(1000);
 }
 /* USER CODE END 5 */
}
void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 int num = 5678;
 char buff[20];
 for(;;)
 {
	  //task2
	  sprintf(buff,"TASK2=%d\n",num);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
	  osDelay(1000);
 }
 /* USER CODE END StartTask02 */
}

5.예제 4에서 아래와 같이 task를 구성하고 메시지큐를 활용해서 충돌이 나는것을 방지하시오!
-task1 : 1000밀리초 간격으로 내부에 있는 변수값을 메시지큐에 넣는다!(생산자)
-task2 : 1000밀리초 간격으로 내부에 있는 변수값을 메시지큐에 넣는다!(생산자)
-task3 : 메시지큐에 있는 내용을 usart2에 출력한다!(소비자)

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int value;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 int num = 1234;
 Msg_t msg;
 msg.id  = 1;
 for(;;)
 {
	  //task1(공급자)
	  msg.value = num;
	  osMessageQueuePut(dataQueue, &msg, 0, 0); //non-blocking
	  osDelay(1000);
 }

void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 int num = 5678;
 Msg_t msg;
 msg.id  = 2;
 for(;;)
 {
	  //task2(공급자)
	  msg.value = num;
	  osMessageQueuePut(dataQueue, &msg, 0, 0); //non-blocking
	  osDelay(1000);
 }
void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
 /* Infinite loop */
 Msg_t msg;
 char buff[30];
 for(;;)
 {
	  //소비자
	  //dataQueue에 공급자가 넣은 데이터가 없으면 무한대기
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever); //blocking
	  sprintf(buff,"id=%d, value=%d\n",msg.id,msg.value);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
 }
 /* USER CODE END StartTask03 */
}

6.예제5에서 공급자가 소비자보다 큐에 데이터를 넣는 속도가 더 빠르면 큐가 용량초과가 발생할 수 있다! 간단하게 예외처리하는 기법에 대해서 예제로 만드시오!

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int value;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 int num = 1234;
 Msg_t msg;
 msg.id  = 1;
 for(;;)
 {
	  //task1(공급자)
	  msg.value = num;
	  if(osMessageQueuePut(dataQueue, &msg, 0, 0) == osOK){
		  //큐에 빈공간이 있어서 성공적으로 넣었다!
	  }else{
		  //큐에 빈공간이 없어서 실패했다!
	  }

	  osDelay(1000);
 }

void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 int num = 5678;
 Msg_t msg;
 msg.id  = 2;
 for(;;)
 {
	  //task2(공급자)
	  msg.value = num;
	  if(osMessageQueuePut(dataQueue, &msg, 0, 0) == osOK){
		  //큐에 빈공간이 있어서 성공적으로 넣었다!
	  }else{
		  //큐에 빈공간이 없어서 실패했다!
	  }

	  osDelay(1000);
 }
void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
 /* Infinite loop */
 Msg_t msg;
 char buff[30];
 for(;;)
 {
	  //소비자
	  //dataQueue에 공급자가 넣은 데이터가 없으면 무한대기
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever); //blocking
	  sprintf(buff,"id=%d, value=%d\n",msg.id,msg.value);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
 }
 /* USER CODE END StartTask03 */
}

7.아래와 같이 task를 구현해서 usart2로 출력하시오!
-task1 : 1000밀리초 간격으로 num1의 값은 1씩 증가하고 num2의 값은 1씩 감소시켜서 큐에 넣는다!
-task2 : 1000밀리초 간격으로 num1의 값은 1씩 증가하고 num2의 값은 1씩 감소시켜서 큐에 넣는다!
-task3 : 메시지큐에 있는 내용을 usart2에 출력한다!(소비자)

/* USER CODE BEGIN 0 */
//주고받는 데이터 (사용자 정의)
typedef struct {
   uint16_t id;
   int value1;
   int value2;
} Msg_t;
//메시지 큐(전역)
osMessageQueueId_t dataQueue;
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 //메시지큐(메인)
 dataQueue = osMessageQueueNew(
                   8,              // queue length
                   sizeof(Msg_t),  // item size
                   NULL);
 /* USER CODE END 2 */

void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 Msg_t msg = {1,0,0};
 for(;;)
 {
	  //task1(공급자)
	  msg.value1++;
	  msg.value2--;
	  if(osMessageQueuePut(dataQueue, &msg, 0, 0) == osOK){
		  //큐에 빈공간이 있어서 성공적으로 넣었다!
	  }else{
		  //큐에 빈공간이 없어서 실패했다!
	  }
	  osDelay(1000);
 }
 /* USER CODE END 5 */
}
void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 Msg_t msg = {2,0,0};
 for(;;)
 {
	  //task2(공급자)
	  msg.value1++;
	  msg.value2--;
	  if(osMessageQueuePut(dataQueue, &msg, 0, 0) == osOK){
		  //큐에 빈공간이 있어서 성공적으로 넣었다!
	  }else{
		  //큐에 빈공간이 없어서 실패했다!
	  }
	  osDelay(1000);
 }
 /* USER CODE END StartTask02 */
}

void StartTask03(void *argument)
{
 /* USER CODE BEGIN StartTask03 */
 /* Infinite loop */
 Msg_t msg;
 char buff[30];
 for(;;)
 {
	  //소비자
	  //dataQueue에 공급자가 넣은 데이터가 없으면 무한대기
	  osMessageQueueGet(dataQueue, &msg, NULL, osWaitForever); //blocking
	  sprintf(buff,"id=%d, value1=%d, value2=%d\n",msg.id,msg.value1,msg.value2);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
 }
 /* USER CODE END StartTask03 */
}

8.아래와 같이 task를 구현하시오!
-task1 : 100밀리초 간격으로 LED 8개가 링모양으로 순차적으로 켜진다!
-task2 : 1초 간격으로 1씩 증가하는 카운터값을 usart2로 전송하시오!

/* USER CODE BEGIN 0 */
GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
/* USER CODE END 0 */
void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 int led_num = 0;
 for(;;)
 {
	  //task1
	  //100밀리초 간격으로 LED를 빙글빙글돌린다
	  for(int i = 0;i<8;i++){
		  //led_num와 i가 같은 녀석만 켜고 나머지는 끈다!
		  if(led_num == i){
			  HAL_GPIO_WritePin(mygpio[i], mypin[i], 1);
		  }else{
			  HAL_GPIO_WritePin(mygpio[i], mypin[i], 0);
		  }
	  }
	  led_num++;
	  if(led_num == 8) led_num = 0;
	  osDelay(100);
 }


void StartTask02(void *argument)
{
 /* USER CODE BEGIN StartTask02 */
 /* Infinite loop */
 int num = 0;
 char buff[30];
 for(;;)
 {
	  sprintf(buff,"num = %d\n",num);
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
	  num++;
	  osDelay(1000);
 }
 /* USER CODE END StartTask02 */
}

[STM32#20] usart1에 esp01을 연결해서 wifi에 연결하고 mqtt프로토콜을 이용해서 데이터를 전송하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 17 Dec 2025 16:55:21 +0900

https://youtube.com/live/vxvtke2AAUc

[STM32#20] usart1에 esp01을 연결해서 wifi에 연결하고 mqtt프로토콜을 이용해서 데이터를 전송하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3a6f1f77138_2_233#slide=id.g3a6f1f77138_2_233

STM32에서 sscanf와 ring buffer를 활용해봅시당!

1.STM32에서 ESP01에 AT커맨드를 전송할때 제대로 전송되었는지를 확인할 수 있는 코드를 작성하시요!(테스트용코드)

/* USER CODE BEGIN 0 */
char cmd1[] = "AT\r\n";
char cmd2[] = "ATE0\r\n";
char mode_set[] = "AT+CWMODE=1\r\n";
char ap_con[] = "AT+CWJAP=\"popcorn\",\"11213144\"\r\n";
char ap_discon[] = "AT+CWQAP\r\n";
char tcp_con[] = "AT+CIPSTART=\"TCP\",\"broker.emqx.io\",1883\r\n";
char data;
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	HAL_UART_Receive_IT(&huart1, &data, 1); //인터럽트 재시작~
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //usart1에서 수신한 ring buffer안에 내용을 usart2에 출력한다!
	if(head != tail){
		char data = ring_buffer[tail];
		HAL_UART_Transmit(&huart2, &data, 1, 100);
		tail++;
		if (tail == b_size) tail = 0;
	}
}

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart1, &data, 1); //수신인터럽트
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트
 char u2_data;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //usart2로 녹칸다가 문자 '1'을 전송하면 AT커맨드를 전송한다!
	  if(HAL_UART_Receive(&huart2, &u2_data, 1, 100) == HAL_OK){
		  if(u2_data == '1'){
			  //생존확인
			  HAL_UART_Transmit(&huart1, cmd1, strlen(cmd1), 100);
		  }else if(u2_data == '2'){
			  //echo off
			  HAL_UART_Transmit(&huart1, cmd2, strlen(cmd2), 100);
		  }else if(u2_data == '3'){
			  //스테이션 모드로 변경
			  HAL_UART_Transmit(&huart1, mode_set, strlen(mode_set), 100);
		  }else if(u2_data == '4'){
			  //인터넷공유기에 접쏙!
			  HAL_UART_Transmit(&huart1, ap_con, strlen(ap_con), 100);
		  }else if(u2_data == '5'){
			  //인터넷공유기 접속 해제!
			  HAL_UART_Transmit(&huart1, ap_discon, strlen(ap_discon), 100);
		  }else if(u2_data == '6'){
			  //브로커와 TCP 연결하기
			  //MQTT브로커와 TCP연결한다음, MQTT연결 명령어를 시간내 전송안하면
			  //서버가 자동으로 연결을 끊어버린다!
			  HAL_UART_Transmit(&huart1, tcp_con, strlen(tcp_con), 100);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.MQTT브로커랑 접속하고 녹칸다가 준비해놓은 기본 예제를 작동시켜보시오!

/* USER CODE BEGIN 0 */
char cmd1[] = "AT\r\n";
char cmd2[] = "ATE0\r\n";
char mode_set[] = "AT+CWMODE=1\r\n";
char ap_con[] = "AT+CWJAP=\"popcorn\",\"11213144\"\r\n";
char ap_discon[] = "AT+CWQAP\r\n";
char tcp_con[] = "AT+CIPSTART=\"TCP\",\"broker.emqx.io\",1883\r\n";
char data;
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	HAL_UART_Receive_IT(&huart1, &data, 1); //인터럽트 재시작~
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //usart1에서 수신한 ring buffer안에 내용을 usart2에 출력한다!
	if(head != tail){
		char data = ring_buffer[tail];
		HAL_UART_Transmit(&huart2, &data, 1, 100);
		tail++;
		if (tail == b_size) tail = 0;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart1, &data, 1); //수신인터럽트
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트
 char u2_data;
 uint8_t msg[256];
 //연결 해제
 HAL_UART_Transmit(&huart1,ap_discon,strlen(ap_discon),100);
 HAL_UART_Transmit(&huart2,"AP DIS CON\r\n",12,100);
 HAL_Delay(2000); //2초정도 기다리면 되겠지?
 //연결
 HAL_UART_Transmit(&huart1,ap_con,strlen(ap_con),100);
 HAL_UART_Transmit(&huart2,"AP CONNECTING\r\n",15,100);
 HAL_Delay(10000);
 //브로커 접속
 HAL_UART_Transmit(&huart1,tcp_con,strlen(tcp_con),100);
 HAL_UART_Transmit(&huart2,"BROKER CONNECTING\r\n",19,100);
 HAL_Delay(5000);
 //MQTT 연결
 uint8_t num1 = (HAL_GetTick()/1000) %10;
 uint8_t num2 = (HAL_GetTick()/100) %10;
 uint8_t num3 = (HAL_GetTick()/10) %10;
 uint8_t num4 = HAL_GetTick() %10;
 uint8_t MQTT_CONNECT[] = {0x10,0x14,0x00,0x04,'M','Q','T','T',0x04,0x02,0x00,0x3C,0x00,0x08,'N','O','C','K','0'+num1,'0'+num2,'0'+num3,'0'+num4};
 sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_CONNECT));
 HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
 HAL_Delay(1000);
 HAL_UART_Transmit(&huart1,MQTT_CONNECT,sizeof(MQTT_CONNECT),100);
 HAL_UART_Transmit(&huart2,"MQTT SET\r\n",10,100);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t MQTT_PUBLISH[] = {0x30,0x00,0x00,0x08,'N','O','C','K','A','N','D','A',0x00,0x00};
	  uint8_t MQTT_MSG[50];
	  sprintf(MQTT_MSG,"STM32 HAL_GetTick()=%d",HAL_GetTick());
	  MQTT_PUBLISH[13] = strlen(MQTT_MSG);
	  MQTT_PUBLISH[1] = (sizeof(MQTT_PUBLISH)-2) +strlen(MQTT_MSG);
	  sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_PUBLISH)+strlen(MQTT_MSG));
	  HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
	  HAL_Delay(500);
	  HAL_UART_Transmit(&huart1,MQTT_PUBLISH,sizeof(MQTT_PUBLISH),100);
	  HAL_UART_Transmit(&huart1,MQTT_MSG,strlen(MQTT_MSG),100);
	  HAL_UART_Transmit(&huart2,"publish\r\n",9,100);
	  HAL_Delay(500);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

//전역으로 클래스선언
        MqttClient client;
        string clientId;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //메인폼이 로드되어서 사용자 눈에 딱 보였다!
            //MQTT 브로커와 연결하는 부분
            string BrokerAddress = "broker.emqx.io";
            client = new MqttClient(BrokerAddress);

            // register a callback-function (we have to implement, see below) which is called by the library when a message was received
            client.MqttMsgPublishReceived += client_MqttMsgPublishReceived;

            // use a unique id as client id, each time we start the application
            clientId = Guid.NewGuid().ToString();
            client.Connect(clientId);

            richTextBox1.Text += "접속완료\n";


            //접속이 완료된 위치
            //Subscribe Topic 추가
            string[] mytopic = { "NOCKANDA" };
            byte[] qos = { 0 };
            client.Subscribe(mytopic, qos);

            richTextBox1.Text += "구독완료\n";
        }
        //MQTT이벤트 핸들러
        void client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
        {
            string ReceivedMessage = Encoding.UTF8.GetString(e.Message, 2, e.Message.Length - 2);
            //DO SOMETHING..!

            richTextBox1.Text += "[수신] " + ReceivedMessage + "\n";

        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            //사용자가 프로그램을 껐다!
            //MQTT 연결 종료
            client.Disconnect();
        }

3.녹칸다의 STM32쉴드에 PA0에 붙어있는 가변저항값을 12bit로 측정해서 MQTT로 C#윈폼에 전송한다음 화면에 출력하시오!

/* USER CODE BEGIN 0 */
char cmd1[] = "AT\r\n";
char cmd2[] = "ATE0\r\n";
char mode_set[] = "AT+CWMODE=1\r\n";
char ap_con[] = "AT+CWJAP=\"popcorn\",\"11213144\"\r\n";
char ap_discon[] = "AT+CWQAP\r\n";
char tcp_con[] = "AT+CIPSTART=\"TCP\",\"broker.emqx.io\",1883\r\n";
char data;
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	HAL_UART_Receive_IT(&huart1, &data, 1); //인터럽트 재시작~
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //usart1에서 수신한 ring buffer안에 내용을 usart2에 출력한다!
	if(head != tail){
		char data = ring_buffer[tail];
		HAL_UART_Transmit(&huart2, &data, 1, 100);
		tail++;
		if (tail == b_size) tail = 0;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart1, &data, 1); //수신인터럽트
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트
HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;

 char u2_data;
 uint8_t msg[256];
 //연결 해제
 HAL_UART_Transmit(&huart1,ap_discon,strlen(ap_discon),100);
 HAL_UART_Transmit(&huart2,"AP DIS CON\r\n",12,100);
 HAL_Delay(2000); //2초정도 기다리면 되겠지?
 //연결
 HAL_UART_Transmit(&huart1,ap_con,strlen(ap_con),100);
 HAL_UART_Transmit(&huart2,"AP CONNECTING\r\n",15,100);
 HAL_Delay(10000);
 //브로커 접속
 HAL_UART_Transmit(&huart1,tcp_con,strlen(tcp_con),100);
 HAL_UART_Transmit(&huart2,"BROKER CONNECTING\r\n",19,100);
 HAL_Delay(5000);
 //MQTT 연결
 uint8_t num1 = (HAL_GetTick()/1000) %10;
 uint8_t num2 = (HAL_GetTick()/100) %10;
 uint8_t num3 = (HAL_GetTick()/10) %10;
 uint8_t num4 = HAL_GetTick() %10;
 uint8_t MQTT_CONNECT[] = {0x10,0x14,0x00,0x04,'M','Q','T','T',0x04,0x02,0x00,0x3C,0x00,0x08,'N','O','C','K','0'+num1,'0'+num2,'0'+num3,'0'+num4};
 sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_CONNECT));
 HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
 HAL_Delay(1000);
 HAL_UART_Transmit(&huart1,MQTT_CONNECT,sizeof(MQTT_CONNECT),100);
 HAL_UART_Transmit(&huart2,"MQTT SET\r\n",10,100);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  }
	  uint8_t MQTT_PUBLISH[] = {0x30,0x00,0x00,0x08,'N','O','C','K','A','N','D','A',0x00,0x00};
	  uint8_t MQTT_MSG[50];
	  sprintf(MQTT_MSG,"%d,%d",msg_num,adc_value0);
	  msg_num++;
	  MQTT_PUBLISH[13] = strlen(MQTT_MSG);
	  MQTT_PUBLISH[1] = (sizeof(MQTT_PUBLISH)-2) +strlen(MQTT_MSG);
	  sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_PUBLISH)+strlen(MQTT_MSG));
	  HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
	  HAL_Delay(500);
	  HAL_UART_Transmit(&huart1,MQTT_PUBLISH,sizeof(MQTT_PUBLISH),100);
	  HAL_UART_Transmit(&huart1,MQTT_MSG,strlen(MQTT_MSG),100);
	  HAL_UART_Transmit(&huart2,"publish\r\n",9,100);
	  HAL_Delay(500);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

//전역으로 클래스선언
        MqttClient client;
        string clientId;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //메인폼이 로드되어서 사용자 눈에 딱 보였다!
            //MQTT 브로커와 연결하는 부분
            string BrokerAddress = "broker.emqx.io";
            client = new MqttClient(BrokerAddress);

            // register a callback-function (we have to implement, see below) which is called by the library when a message was received
            client.MqttMsgPublishReceived += client_MqttMsgPublishReceived;

            // use a unique id as client id, each time we start the application
            clientId = Guid.NewGuid().ToString();
            client.Connect(clientId);

            richTextBox1.Text += "접속완료\n";


            //접속이 완료된 위치
            //Subscribe Topic 추가
            string[] mytopic = { "NOCKANDA" };
            byte[] qos = { 0 };
            client.Subscribe(mytopic, qos);

            richTextBox1.Text += "구독완료\n";
        }
        //MQTT이벤트 핸들러
        void client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
        {
            string ReceivedMessage = Encoding.UTF8.GetString(e.Message, 2, e.Message.Length - 2);
            //DO SOMETHING..!

            richTextBox1.Text += "[수신] " + ReceivedMessage + "\n";

            string[] data = ReceivedMessage.Split(',');
            if(data.Length == 2)
            {
                textBox1.Text = data[0];
                textBox2.Text = data[1];
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            //사용자가 프로그램을 껐다!
            //MQTT 연결 종료
            client.Disconnect();
        }

4.STM32쉴드에 붙어있는 온습도센서인 DHT-11의 값을 측정해서 MQTT로 C#윈폼에 전송한다음 화면에 출력하시오!

/* USER CODE BEGIN 0 */
char cmd1[] = "AT\r\n";
char cmd2[] = "ATE0\r\n";
char mode_set[] = "AT+CWMODE=1\r\n";
char ap_con[] = "AT+CWJAP=\"popcorn\",\"11213144\"\r\n";
char ap_discon[] = "AT+CWQAP\r\n";
char tcp_con[] = "AT+CIPSTART=\"TCP\",\"broker.emqx.io\",1883\r\n";
char data;
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	HAL_UART_Receive_IT(&huart1, &data, 1); //인터럽트 재시작~
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //usart1에서 수신한 ring buffer안에 내용을 usart2에 출력한다!
	if(head != tail){
		char data = ring_buffer[tail];
		HAL_UART_Transmit(&huart2, &data, 1, 100);
		tail++;
		if (tail == b_size) tail = 0;
	}
}

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
return millis_cnt;
}
uint32_t micros() {
return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
if (us > 1) {
 uint32_t count = us * 7 - 6;
 while (count--);
} else {
 uint32_t count = 2;
 while (count--);
}
}
union {
uint32_t data;
struct {
  uint8_t temp_d;
  uint8_t temp_i;
  uint8_t rh_d;
  uint8_t rh_i;
};
} DHT;

uint8_t DHT_read () {
uint8_t i, check_sum;
uint32_t start;
check_sum = 0;
DHT.data = 0;
GPIOC->CRL = (GPIOC->CRL&0xFFFFFF0F)|(7<<(1*4));  // Output Open-drain (Master send LOW signal)
delay_ms(18);
GPIOC->CRL= (GPIOC->CRL&0xFFFFFF0F)|(4<<(1*4));  // Floating input (Master send HIGH signal & data receive)
start = micros();
while (GPIOC->IDR&(1<<1)) {
  if (micros()-start > 50) return 1;  // 20~40us
}
start = micros();
while (!(GPIOC->IDR&(1<<1))) {
  if (micros()-start > 120) return 2;  // 80us
}
start = micros();
while (GPIOC->IDR&(1<<1)) {
  if (micros()-start > 120) return 3;  // 80us
}
for (i = 0; i < 32; i++) {
  while (!(GPIOC->IDR&(1<<1))); // 50us
  start = micros();
  while (GPIOC->IDR&(1<<1));
  if (micros()-start > 50) DHT.data |= (0x80000000 >> i); // "0"=26~28us, "1"=70us
}
for (i = 0; i < 8; i++) {
  while (!(GPIOC->IDR&(1<<1))); // 50us
  start = micros();
  while (GPIOC->IDR&(1<<1));
  if (micros()-start > 50) check_sum |= (0x80 >> i);
}
if ((DHT.rh_i + DHT.rh_d + DHT.temp_i + DHT.temp_d) == check_sum) return 0;
else return 4;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart1, &data, 1); //수신인터럽트
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char u2_data;
 uint8_t msg[256];
 //연결 해제
 HAL_UART_Transmit(&huart1,ap_discon,strlen(ap_discon),100);
 HAL_UART_Transmit(&huart2,"AP DIS CON\r\n",12,100);
 HAL_Delay(2000); //2초정도 기다리면 되겠지?
 //연결
 HAL_UART_Transmit(&huart1,ap_con,strlen(ap_con),100);
 HAL_UART_Transmit(&huart2,"AP CONNECTING\r\n",15,100);
 HAL_Delay(10000);
 //브로커 접속
 HAL_UART_Transmit(&huart1,tcp_con,strlen(tcp_con),100);
 HAL_UART_Transmit(&huart2,"BROKER CONNECTING\r\n",19,100);
 HAL_Delay(5000);

 //MQTT 연결
 uint8_t num1 = (HAL_GetTick()/1000) %10;
 uint8_t num2 = (HAL_GetTick()/100) %10;
 uint8_t num3 = (HAL_GetTick()/10) %10;
 uint8_t num4 = HAL_GetTick() %10;
 uint8_t MQTT_CONNECT[] = {0x10,0x14,0x00,0x04,'M','Q','T','T',0x04,0x02,0x00,0x3C,0x00,0x08,'N','O','C','K','0'+num1,'0'+num2,'0'+num3,'0'+num4};
 sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_CONNECT));
 HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
 HAL_Delay(1000);
 HAL_UART_Transmit(&huart1,MQTT_CONNECT,sizeof(MQTT_CONNECT),100);
 HAL_UART_Transmit(&huart2,"MQTT SET\r\n",10,100);
 int msg_num = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;

		  uint8_t MQTT_PUBLISH[] = {0x30,0x00,0x00,0x08,'N','O','C','K','A','N','D','A',0x00,0x00};
		  uint8_t MQTT_MSG[50];
		  sprintf(MQTT_MSG,"%d,%.2f,%.2f",msg_num,temp,humi);
		  msg_num++;
		  MQTT_PUBLISH[13] = strlen(MQTT_MSG);
		  MQTT_PUBLISH[1] = (sizeof(MQTT_PUBLISH)-2) +strlen(MQTT_MSG);
		  sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_PUBLISH)+strlen(MQTT_MSG));
		  HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
		  HAL_Delay(500);
		  HAL_UART_Transmit(&huart1,MQTT_PUBLISH,sizeof(MQTT_PUBLISH),100);
		  HAL_UART_Transmit(&huart1,MQTT_MSG,strlen(MQTT_MSG),100);
		  HAL_UART_Transmit(&huart2,"publish\r\n",9,100);
	  } else {
		  //측정실패
	  }
	  HAL_Delay(1500);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

//전역으로 클래스선언
        MqttClient client;
        string clientId;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //메인폼이 로드되어서 사용자 눈에 딱 보였다!
            //MQTT 브로커와 연결하는 부분
            string BrokerAddress = "broker.emqx.io";
            client = new MqttClient(BrokerAddress);

            // register a callback-function (we have to implement, see below) which is called by the library when a message was received
            client.MqttMsgPublishReceived += client_MqttMsgPublishReceived;

            // use a unique id as client id, each time we start the application
            clientId = Guid.NewGuid().ToString();
            client.Connect(clientId);

            richTextBox1.Text += "접속완료\n";


            //접속이 완료된 위치
            //Subscribe Topic 추가
            string[] mytopic = { "NOCKANDA" };
            byte[] qos = { 0 };
            client.Subscribe(mytopic, qos);

            richTextBox1.Text += "구독완료\n";
        }
        //MQTT이벤트 핸들러
        void client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
        {
            string ReceivedMessage = Encoding.UTF8.GetString(e.Message, 2, e.Message.Length - 2);
            //DO SOMETHING..!

            richTextBox1.Text += "[수신] " + ReceivedMessage + "\n";
            string[] data = ReceivedMessage.Split(',');
            if(data.Length == 3)
            {
                textBox1.Text = data[0];
                textBox2.Text = data[1];
                textBox3.Text = data[2];
            }

        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            //사용자가 프로그램을 껐다!
            //MQTT 연결 종료
            client.Disconnect();
        }

5.예제4에서 수신받은 온도와 습도값을 좀더 그럴싸하게 보이도록 하고 마무리하시오!

/* USER CODE BEGIN 0 */
char cmd1[] = "AT\r\n";
char cmd2[] = "ATE0\r\n";
char mode_set[] = "AT+CWMODE=1\r\n";
char ap_con[] = "AT+CWJAP=\"popcorn\",\"11213144\"\r\n";
char ap_discon[] = "AT+CWQAP\r\n";
char tcp_con[] = "AT+CIPSTART=\"TCP\",\"broker.emqx.io\",1883\r\n";
char data;
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	HAL_UART_Receive_IT(&huart1, &data, 1); //인터럽트 재시작~
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //usart1에서 수신한 ring buffer안에 내용을 usart2에 출력한다!
	if(head != tail){
		char data = ring_buffer[tail];
		HAL_UART_Transmit(&huart2, &data, 1, 100);
		tail++;
		if (tail == b_size) tail = 0;
	}
}

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
return millis_cnt;
}
uint32_t micros() {
return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
if (us > 1) {
 uint32_t count = us * 7 - 6;
 while (count--);
} else {
 uint32_t count = 2;
 while (count--);
}
}
union {
uint32_t data;
struct {
  uint8_t temp_d;
  uint8_t temp_i;
  uint8_t rh_d;
  uint8_t rh_i;
};
} DHT;

uint8_t DHT_read () {
uint8_t i, check_sum;
uint32_t start;
check_sum = 0;
DHT.data = 0;
GPIOC->CRL = (GPIOC->CRL&0xFFFFFF0F)|(7<<(1*4));  // Output Open-drain (Master send LOW signal)
delay_ms(18);
GPIOC->CRL= (GPIOC->CRL&0xFFFFFF0F)|(4<<(1*4));  // Floating input (Master send HIGH signal & data receive)
start = micros();
while (GPIOC->IDR&(1<<1)) {
  if (micros()-start > 50) return 1;  // 20~40us
}
start = micros();
while (!(GPIOC->IDR&(1<<1))) {
  if (micros()-start > 120) return 2;  // 80us
}
start = micros();
while (GPIOC->IDR&(1<<1)) {
  if (micros()-start > 120) return 3;  // 80us
}
for (i = 0; i < 32; i++) {
  while (!(GPIOC->IDR&(1<<1))); // 50us
  start = micros();
  while (GPIOC->IDR&(1<<1));
  if (micros()-start > 50) DHT.data |= (0x80000000 >> i); // "0"=26~28us, "1"=70us
}
for (i = 0; i < 8; i++) {
  while (!(GPIOC->IDR&(1<<1))); // 50us
  start = micros();
  while (GPIOC->IDR&(1<<1));
  if (micros()-start > 50) check_sum |= (0x80 >> i);
}
if ((DHT.rh_i + DHT.rh_d + DHT.temp_i + DHT.temp_d) == check_sum) return 0;
else return 4;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart1, &data, 1); //수신인터럽트
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char u2_data;
 uint8_t msg[256];
 //연결 해제
 HAL_UART_Transmit(&huart1,ap_discon,strlen(ap_discon),100);
 HAL_UART_Transmit(&huart2,"AP DIS CON\r\n",12,100);
 HAL_Delay(2000); //2초정도 기다리면 되겠지?
 //연결
 HAL_UART_Transmit(&huart1,ap_con,strlen(ap_con),100);
 HAL_UART_Transmit(&huart2,"AP CONNECTING\r\n",15,100);
 HAL_Delay(10000);
 //브로커 접속
 HAL_UART_Transmit(&huart1,tcp_con,strlen(tcp_con),100);
 HAL_UART_Transmit(&huart2,"BROKER CONNECTING\r\n",19,100);
 HAL_Delay(5000);

 //MQTT 연결
 uint8_t num1 = (HAL_GetTick()/1000) %10;
 uint8_t num2 = (HAL_GetTick()/100) %10;
 uint8_t num3 = (HAL_GetTick()/10) %10;
 uint8_t num4 = HAL_GetTick() %10;
 uint8_t MQTT_CONNECT[] = {0x10,0x14,0x00,0x04,'M','Q','T','T',0x04,0x02,0x00,0x3C,0x00,0x08,'N','O','C','K','0'+num1,'0'+num2,'0'+num3,'0'+num4};
 sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_CONNECT));
 HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
 HAL_Delay(1000);
 HAL_UART_Transmit(&huart1,MQTT_CONNECT,sizeof(MQTT_CONNECT),100);
 HAL_UART_Transmit(&huart2,"MQTT SET\r\n",10,100);
 int msg_num = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;

		  uint8_t MQTT_PUBLISH[] = {0x30,0x00,0x00,0x08,'N','O','C','K','A','N','D','A',0x00,0x00};
		  uint8_t MQTT_MSG[50];
		  sprintf(MQTT_MSG,"%d,%.2f,%.2f",msg_num,temp,humi);
		  msg_num++;
		  MQTT_PUBLISH[13] = strlen(MQTT_MSG);
		  MQTT_PUBLISH[1] = (sizeof(MQTT_PUBLISH)-2) +strlen(MQTT_MSG);
		  sprintf(msg, "AT+CIPSEND=%d\r\n", sizeof(MQTT_PUBLISH)+strlen(MQTT_MSG));
		  HAL_UART_Transmit(&huart1,msg,strlen(msg),100);
		  HAL_Delay(500);
		  HAL_UART_Transmit(&huart1,MQTT_PUBLISH,sizeof(MQTT_PUBLISH),100);
		  HAL_UART_Transmit(&huart1,MQTT_MSG,strlen(MQTT_MSG),100);
		  HAL_UART_Transmit(&huart2,"publish\r\n",9,100);
	  } else {
		  //측정실패
	  }
	  HAL_Delay(1500);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

//전역으로 클래스선언
        MqttClient client;
        string clientId;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //메인폼이 로드되어서 사용자 눈에 딱 보였다!
            //MQTT 브로커와 연결하는 부분
            string BrokerAddress = "broker.emqx.io";
            client = new MqttClient(BrokerAddress);

            // register a callback-function (we have to implement, see below) which is called by the library when a message was received
            client.MqttMsgPublishReceived += client_MqttMsgPublishReceived;

            // use a unique id as client id, each time we start the application
            clientId = Guid.NewGuid().ToString();
            client.Connect(clientId);

            richTextBox1.Text += "접속완료\n";


            //접속이 완료된 위치
            //Subscribe Topic 추가
            string[] mytopic = { "NOCKANDA" };
            byte[] qos = { 0 };
            client.Subscribe(mytopic, qos);

            richTextBox1.Text += "구독완료\n";
        }
        //MQTT이벤트 핸들러
        void client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
        {
            string ReceivedMessage = Encoding.UTF8.GetString(e.Message, 2, e.Message.Length - 2);
            //DO SOMETHING..!

            string[] data = ReceivedMessage.Split(',');
            if(data.Length == 3)
            {
                textBox1.Text = data[0];
                textBox2.Text = data[1]; //온도
                textBox3.Text = data[2]; //습도
                float temp = float.Parse(data[1]);
                float humi = float.Parse(data[2]);
                aGauge1.Value = temp;
                aGauge2.Value = humi;
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            //사용자가 프로그램을 껐다!
            //MQTT 연결 종료
            client.Disconnect();
        }

[STM32#19] STM32에서 형식이 있는 데이터를 sscanf로 수신하는 방법과 ring buffer 활용방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 15 Dec 2025 23:19:47 +0900

https://youtube.com/live/sM4WSj0hdWk

[STM32#19] STM32에서 형식이 있는 데이터를 sscanf로 수신하는 방법과 ring buffer 활용방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3b065dcc8fb_1_0#slide=id.g3b065dcc8fb_1_0

STM32에서 sscanf와 ring buffer를 활용해봅시당!

1.C#에서 아래와 같은 데이터를 전송할때 STM32가 해석해서 응답을 보낼 수 있도록 sscanf로 기능 구현을 하시오!
(데이터) “num1=1234\n” 일때 STM32는 1234를 추출한다!
(응답) “num1 is 1234!!\n”

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int num1 = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 num1=1234
		if(sscanf(rx_buff,"num1=%d",&num1) == 1){
			//성공
			sprintf(tx_buff,"num1 is %d!!\n",num1);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error!\n", 7, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200; //usart2

            serialPort1.Open(); //개방!

            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("연결완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            string data = serialPort1.ReadLine();
            richTextBox1.Text += "[수신]=" + data + "\n";
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //포트가 열려있고, 입력창이 빈칸이 아닐때~
            if (serialPort1.IsOpen && textBox2.Text != "")
            {
                serialPort1.WriteLine(textBox2.Text);
            }
        }

2.이번에는 아래와같은 커맨드 형식일때 여러개의 명령어를 인식가능하도록 하시오!
(데이터1) “select value = 10”
(데이터2) “update value = 10”
(데이터3) “delete value = 10”
(응답) “cmd is select, value is 10”

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int num1 = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 “select value = 10”
		if(sscanf(rx_buff,"select value = %d",&num1) == 1){
			//성공
			sprintf(tx_buff,"cmd is select, value is %d\n",num1);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}else if(sscanf(rx_buff,"update value = %d",&num1) == 1){
			//성공
			sprintf(tx_buff,"cmd is update, value is %d\n",num1);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}else if(sscanf(rx_buff,"delete value = %d",&num1) == 1){
			//성공
			sprintf(tx_buff,"cmd is delete, value is %d\n",num1);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error!\n", 7, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

(C#코드는 예제1과 같음)

3.예제2에서 녹칸다가 제기한 원인을 해결하는 방법에서 약간 다른 방법을 제시해보시오!(여러개의 조건문을 1개로 압축하기)

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int num1 = 0;
char cmd[20];
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 “select value = 10”
		if(sscanf(rx_buff,"%s value = %d",cmd,&num1) == 2){
			//성공
			sprintf(tx_buff,"cmd is %s, value is %d\n",cmd,num1);
			HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error!\n", 7, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

(C#코드는 예제1과 같음)

4.녹칸다가 아래와 같은 명령어를 입력하면 STM32의 PB3 LED가 제어된다!
(LED OFF) “LED=0” (LED ON) “LED=1”

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int state = 0;
char cmd[20];
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 "LED=0"
		if(sscanf(rx_buff,"LED=%d",&state) == 1){
			//성공
			if(state == 0){
				HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, state);
				HAL_UART_Transmit(&huart2, "LED IS OFF!\n", 12, 100);
			}else if(state == 1){
				HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, state);
				HAL_UART_Transmit(&huart2, "LED IS ON!\n", 11, 100);
			}
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error!\n", 7, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

(C#코드는 예제1과 같음)

5.이번에는 예제4와 동일한 구성을 가지면서 STM32쉴드에 붙어있는 LED 8개를 개별적으로 제어할 수 있는 명령어 체계를 구성하시오!
“LED@=%” : LED번호는 @, ON/OFF여부는 % (예시) “LED2=1” : LED2번을 ON해라!

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int led_num = 0;
int state = 0;
char cmd[20];
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 "LED@=%"
		if(sscanf(rx_buff,"LED%d=%d",&led_num,&state) == 2){
			//성공
			if(led_num == 1){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, state);
					HAL_UART_Transmit(&huart2, "LED1 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, state);
					HAL_UART_Transmit(&huart2, "LED1 IS ON!\n", 12, 100);
				}
			}else if(led_num == 2){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, state);
					HAL_UART_Transmit(&huart2, "LED2 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, state);
					HAL_UART_Transmit(&huart2, "LED2 IS ON!\n", 12, 100);
				}

			}else if(led_num == 3){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, state);
					HAL_UART_Transmit(&huart2, "LED3 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, state);
					HAL_UART_Transmit(&huart2, "LED3 IS ON!\n", 12, 100);
				}
			}else if(led_num == 4){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, state);
					HAL_UART_Transmit(&huart2, "LED4 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, state);
					HAL_UART_Transmit(&huart2, "LED4 IS ON!\n", 12, 100);
				}
			}else if(led_num == 5){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, state);
					HAL_UART_Transmit(&huart2, "LED5 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, state);
					HAL_UART_Transmit(&huart2, "LED5 IS ON!\n", 12, 100);
				}
			}else if(led_num == 6){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, state);
					HAL_UART_Transmit(&huart2, "LED6 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, state);
					HAL_UART_Transmit(&huart2, "LED6 IS ON!\n", 12, 100);
				}

			}else if(led_num == 7){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, state);
					HAL_UART_Transmit(&huart2, "LED7 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, state);
					HAL_UART_Transmit(&huart2, "LED7 IS ON!\n", 12, 100);
				}
			}else if(led_num == 8){
				if(state == 0){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, state);
					HAL_UART_Transmit(&huart2, "LED8 IS OFF!\n", 13, 100);
				}else if(state == 1){
					HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, state);
					HAL_UART_Transmit(&huart2, "LED8 IS ON!\n", 12, 100);
				}
			}
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error!\n", 7, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

(C#코드는 예제1과 같음)

6.예제5번에서 코드를 좀 압축해보시오!

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int led_num = 0;
int state = 0;
char cmd[20];
GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 "LED@=%"
		if(sscanf(rx_buff,"LED%d=%d",&led_num,&state) == 2){
			//성공
			if(led_num >=0 && led_num<=8 && (state == 0 || state == 1)){
				HAL_GPIO_WritePin(mygpio[led_num-1], mypin[led_num-1], state);
				sprintf(tx_buff,"LED%d IS %s\n",led_num,state == 0 ? "OFF" : "ON");
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}else{
				HAL_UART_Transmit(&huart2, "error-2!\n", 9, 100);
			}
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error-1!\n", 9, 100);
		}
		rx_pos = 0;
	}
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}

(C#코드는 예제1과 같음)

7.예제6번에서 동작하는 방식을 JSON명령어를 인식하도록 하시오!
{"led_num":1,"state":0} : LED1 OFF
{"led_num":3,"state":1} : LED3 ON

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int led_num = 0;
int state = 0;
char cmd[20];
GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 "{"led_num":1,"state":0}"
		if(sscanf(rx_buff,"{\"led_num\":%d,\"state\":%d}",&led_num,&state) == 2){
			//성공
			if(led_num >=0 && led_num<=8 && (state == 0 || state == 1)){
				HAL_GPIO_WritePin(mygpio[led_num-1], mypin[led_num-1], state);
				sprintf(tx_buff,"LED%d IS %s\n",led_num,state == 0 ? "OFF" : "ON");
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}else{
				HAL_UART_Transmit(&huart2, "error-2!\n", 9, 100);
			}
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error-1!\n", 9, 100);
		}
		rx_pos = 0;
	}
	HAL_UART_Receive_IT(&huart2, &data, 1);//수신인터럽트 다시 시작
}

(C#코드는 예제1과 같음)

8.데이터 형식이 JSON이 되었으니, C#에서도 JSON데이터를 생성할 수 있게 되었다! C#에 JSON라이브러리를 추가해서 조금더 고급스러운 기능을 보이시오!

/* USER CODE BEGIN 0 */
char rx_buff[100];
char tx_buff[100];
int rx_pos = 0;
char data;
int led_num = 0;
int state = 0;
char cmd[20];
GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//데이터 처리(종료문자가 \n인 상황)
	rx_buff[rx_pos++] = data;
	if(data == '\n'){
		//STM32가 echo
		rx_buff[rx_pos] = '\0';
		//rx_buff에 있는 데이터 형식 "{"led_num":1,"state":0}"
		if(sscanf(rx_buff,"{\"led_num\":%d,\"state\":%d}",&led_num,&state) == 2){
			//성공
			if(led_num >=0 && led_num<=8 && (state == 0 || state == 1)){
				HAL_GPIO_WritePin(mygpio[led_num-1], mypin[led_num-1], state);
				sprintf(tx_buff,"LED%d IS %s\n",led_num,state == 0 ? "OFF" : "ON");
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}else{
				HAL_UART_Transmit(&huart2, "error-2!\n", 9, 100);
			}
		}else{
			//실패
			HAL_UART_Transmit(&huart2, "error-1!\n", 9, 100);
		}
		rx_pos = 0;
	}
	HAL_UART_Receive_IT(&huart2, &data, 1);//수신인터럽트 다시 시작
}

using Newtonsoft.Json;
////////////////////////////////////
//C#의 전역위치
        class Nockanda
        {
            public int led_num;
            public int state;
        }

        Nockanda data = new Nockanda();
/////////////////////////////////////
private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200; //usart2

            serialPort1.Open(); //개방!

            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("연결완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            string data = serialPort1.ReadLine();
            richTextBox1.Text += "[수신]=" + data + "\n";
        }
        void send_data(int led_num, int state)
        {
            if (serialPort1.IsOpen)
            {
                data.led_num = led_num;
                data.state = state;
                string output = JsonConvert.SerializeObject(data);
                serialPort1.WriteLine(output);
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            send_data(1, 1);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            send_data(1, 0);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            send_data(2, 1);
        }

        private void button5_Click(object sender, EventArgs e)
        {
            send_data(2, 0);
        }


        private void button6_Click(object sender, EventArgs e)
        {
            send_data(3, 1);
        }

        private void button7_Click(object sender, EventArgs e)
        {
            send_data(3, 0);
        }

        private void button8_Click(object sender, EventArgs e)
        {
            send_data(4, 1);
        }

        private void button9_Click(object sender, EventArgs e)
        {
            send_data(4, 0);
        }

        private void button10_Click(object sender, EventArgs e)
        {
            send_data(5, 1);
        }

        private void button11_Click(object sender, EventArgs e)
        {
            send_data(5, 0);
        }

        private void button12_Click(object sender, EventArgs e)
        {
            send_data(6, 1);
        }

        private void button13_Click(object sender, EventArgs e)
        {
            send_data(6, 0);
        }

        private void button14_Click(object sender, EventArgs e)
        {
            send_data(7, 1);
        }

        private void button15_Click(object sender, EventArgs e)
        {
            send_data(7, 0);
        }

        private void button16_Click(object sender, EventArgs e)
        {
            send_data(8, 1);
        }

        private void button17_Click(object sender, EventArgs e)
        {
            send_data(8, 0);
        }

9.STM32의 수신인터럽트에서 1개의 문자를 받으면 즉시 응답하도록 해서 putty에서 데이터를 전송하시오!

/* USER CODE BEGIN 0 */
#define b_size 256
uint8_t ring_buffer[b_size];
int head = 0;
int tail = 0;
char data;
char tx_buff[256];
int tx_pos = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//수신인터럽트로 받은 데이터를 ring_buffer에 대입한다
	//버퍼에 집어넣는 쪽
	ring_buffer[head++] = data;
	if(head == b_size) head = 0;
	//bad case
	//HAL_UART_Transmit(&huart2, &data, 1, 100);
	//수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &data, 1);
}


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &data, 1); //수신인터럽트 시작
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //버퍼에서 읽는 쪽
		if(head != tail){
			tx_buff[tx_pos++] = ring_buffer[tail];
			if(ring_buffer[tail] == '\n'){
				//녹칸다가 보낸 데이터의 끝지점이구나!
				tx_buff[tx_pos] = '\0';
				tx_pos = 0;
				HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			}
			tail++;
			if (tail == b_size) tail = 0;
		}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#18] HAL_UART_Receive_IT, HAL_UART_RxCpltCallback수신 인터럽트를 이용해서 각종 모터 제어해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 10 Dec 2025 16:42:33 +0900

https://youtube.com/live/NtAF5P2SCoM

[STM32#18] HAL_UART_Receive_IT, HAL_UART_RxCpltCallback수신 인터럽트를 이용해서 각종 모터 제어해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3ae770b99e6_1_256#slide=id.g3ae770b99e6_1_256

녹칸다의 STM32쉴드에 붙어있는 각종 모터를 제어해보는 것입니다!

수신인터럽트 ioc 설정

1.STM32의 usart2수신부분을 폴링방식에서 인터럽트 방식으로 변환한 기본 예제를 구현하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 char buff2[100];
 /* USER CODE END 2 */
/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //1초간격으로 stm32의 타이머카운터값을 전송한다!
	  sprintf(buff2,"now getTick = %d\n",HAL_GetTick());
	  HAL_UART_Transmit(&huart2, buff2, strlen(buff2), 100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }


/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\r'){
		buff[pos] = '\n';
		pos++;
		buff[pos] = '\0';
		//echo
		HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}
/* USER CODE END 4 */

2.C#윈폼에서 STM32와 시리얼통신으로 연결되고 버튼1을 누르면 0도, 버튼2를 누르면 90도, 버튼3을 누르면 180도로 서보모터의 각도가 회전되도록 하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4); //PWM시작~
 char buff2[100];
 /* USER CODE END 2 */

while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }



/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		//"0" ~ "180"
		int degree = atoi(buff);
		set_servo(degree);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("0");
            }
        }

private void button3_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("90");
            }
        }

        private void button4_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("180");
            }
        }

3.이번에는 컨트롤중에 numericupdown이라는 녀석을 이용해서 사용자가 입력한 숫자값을 버튼을 누르면 STM32에 전송해서 각도를 제어하시오!(STM32코드는 예제2와 동일함)

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4); //PWM시작~
 char buff2[100];
 /* USER CODE END 2 */

while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }



/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		//"0" ~ "180"
		int degree = atoi(buff);
		set_servo(degree);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            //전송버튼 클릭이벤트!
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine(numericUpDown1.Value.ToString());
            }
        }

4.이번에는 컨트롤중에 hcrollbar라는 녀석을 이용해서 컨트롤을 드래그해서 서보모터의 각도를 회전시키시오!(STM32코드는 예제2와 동일함)

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4); //PWM시작~
 char buff2[100];
 /* USER CODE END 2 */

while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }



/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		//"0" ~ "180"
		int degree = atoi(buff);
		set_servo(degree);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void hScrollBar1_Scroll(object sender, ScrollEventArgs e)
        {
            label2.Text = hScrollBar1.Value.ToString();
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine(hScrollBar1.Value.ToString());
            }
        }

5.예제4에서 STM32보드가 100밀리초 간격으로 현재 서보모터의 설정 각도를 전송하고 C#은 그 값을 화면에 출력하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
int degree = 0; //현재 서보모터의 각도값
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */



/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4); //PWM시작~
 char buff2[100];
 /* USER CODE END 2 */

/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //0.1초간격으로 degree값을 C#으로 전송한다!(종료문자 \n)
	  sprintf(buff2,"%d\n",degree);
	  HAL_UART_Transmit(&huart2, buff2, strlen(buff2), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		//"0" ~ "180"
		int degree = atoi(buff);
		set_servo(degree);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

       private void hScrollBar1_Scroll(object sender, ScrollEventArgs e)
        {
            label2.Text = hScrollBar1.Value.ToString();
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine(hScrollBar1.Value.ToString());
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            string data = serialPort1.ReadLine();
            textBox2.Text = data;
        }

6.이번에는 STM32의 부저를 활용하는데, C#에서 부저에 발생해야하는 주파수값을 직접적으로 전송하고 0을 전송하면 OFF하는걸로 하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
static void Tone(uint32_t Frequency)
{
  TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
  TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
/* USER CODE END 0 */




/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 char buff2[100];
 /* USER CODE END 2 */


/* USER CODE BEGIN WHILE */
 while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */

/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		//0이면 OFF이고 0이 아니면 재생한다
		int pitch = atoi(buff);
		if(pitch == 0){
			HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
		}else{
			HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
			Tone(pitch);
		}
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void button2_MouseDown(object sender, MouseEventArgs e)
        {
            //도6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1047");
        }

        private void button2_MouseUp(object sender, MouseEventArgs e)
        {
            //도6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button3_MouseDown(object sender, MouseEventArgs e)
        {
            //레6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1175");
        }
        private void button3_MouseUp(object sender, MouseEventArgs e)
        {
            //레6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button4_MouseDown(object sender, MouseEventArgs e)
        {
            //미6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1319");
        }

        private void button4_MouseUp(object sender, MouseEventArgs e)
        {
            //미6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button5_MouseDown(object sender, MouseEventArgs e)
        {
            //파6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1397");
        }

        private void button5_MouseUp(object sender, MouseEventArgs e)
        {
            //파6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }


        private void button6_MouseDown(object sender, MouseEventArgs e)
        {
            //솔6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1568");
        }

        private void button6_MouseUp(object sender, MouseEventArgs e)
        {
            //솔6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button7_MouseDown(object sender, MouseEventArgs e)
        {
            //라6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1760");
        }

        private void button7_MouseUp(object sender, MouseEventArgs e)
        {
            //라6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button8_MouseDown(object sender, MouseEventArgs e)
        {
            //시6
            if (serialPort1.IsOpen) serialPort1.WriteLine("1976");
        }


        private void button8_MouseUp(object sender, MouseEventArgs e)
        {
            //시6
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

        private void button9_MouseDown(object sender, MouseEventArgs e)
        {
            //도7
            if (serialPort1.IsOpen) serialPort1.WriteLine("2093");
        }

        private void button9_MouseUp(object sender, MouseEventArgs e)
        {
            //도7
            if (serialPort1.IsOpen) serialPort1.WriteLine("0");
        }

~~7.h스크롤바를 이용해서 0~2500정도의 범위에서 값을 STM32에 전송해서 해당되는 진동의 음을 재생하도록 하시오!~~

8.스탭모터(28byj-48)의 위치제어값을 C#윈폼에서 전송해서 C#에서 요구한 각도대로 회전하게 하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int now_pos = 0; //스탭모터가 알고있는 자기의 현재 위치
int target_pos = 0; //녹칸다가 설정한 목표위치
int seq_num = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  //타이머 인터럽트 콜백함수
	if(now_pos < target_pos){
		//시계방향으로 회전해야하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num++;
		if(seq_num >= 8) seq_num = 0;
		now_pos++; //시퀀스 1회당 현재위치 1 증가
	}else if(now_pos > target_pos){
		//반시계방향으로 회전해야 하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num--;
		if(seq_num < 0) seq_num = 7;
		now_pos--; //시퀀스 1회당 현재위치 1 감소
	}
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트 시작
 char buff2[100];
 /* USER CODE END 2 */
/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //now_pos
	  sprintf(buff2,"%d\n",now_pos);
	  HAL_UART_Transmit(&huart2, buff2, strlen(buff2), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		target_pos = atoi(buff);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}
/* USER CODE END 4 */

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void button2_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("0");
            }
        }

private void button3_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("1024");
            }
        }
private void button4_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine("-1024");
            }
        }

9.numericupdown을 이용해서 -4096*3 ~ +4096*3의 범위에서 스탭모터의 위치를 결정할 수 있고, 현재 위치값을 STM32가 100밀리초 간격으로 C#에게 전송해서 화면에 나올 수 있도록 하시오!

/* USER CODE BEGIN 0 */
char recv;
char buff[100]; //수신메모리
int pos = 0;
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int now_pos = 0; //스탭모터가 알고있는 자기의 현재 위치
int target_pos = 0; //녹칸다가 설정한 목표위치
int seq_num = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  //타이머 인터럽트 콜백함수
	if(now_pos < target_pos){
		//시계방향으로 회전해야하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num++;
		if(seq_num >= 8) seq_num = 0;
		now_pos++; //시퀀스 1회당 현재위치 1 증가
	}else if(now_pos > target_pos){
		//반시계방향으로 회전해야 하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num--;
		if(seq_num < 0) seq_num = 7;
		now_pos--; //시퀀스 1회당 현재위치 1 감소
	}
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 HAL_UART_Receive_IT(&huart2, &recv, 1); //수신인터럽트 시작
 HAL_TIM_Base_Start_IT(&htim2); //타이머인터럽트 시작
 char buff2[100];
 /* USER CODE END 2 */
/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //now_pos
	  sprintf(buff2,"%d\n",now_pos);
	  HAL_UART_Transmit(&huart2, buff2, strlen(buff2), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
/* USER CODE BEGIN 4 */
//usart2 수신인터럽트
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//recv에 1개 읽은 문자가 들어있는 상황이다!
	buff[pos] = recv;
	pos++;
	if(recv == '\n'){
		buff[pos] = '\0';
		//C#에서 보낸 데이터 한덩어리가 여기서 처리된다!
		target_pos = atoi(buff);
		pos = 0;
	}
   //수신인터럽트 다시 시작
	HAL_UART_Receive_IT(&huart2, &recv, 1);
}
/* USER CODE END 4 */

private void button1_Click(object sender, EventArgs e)
        {
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void button2_Click(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                serialPort1.WriteLine(numericUpDown1.Value.ToString());
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            string data = serialPort1.ReadLine();
            textBox2.Text = data;
        }

[STM32#17] STM32쉴드에 붙어있는 각종 센서값을 C# winform에게 전송하고 UI에 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 8 Dec 2025 23:11:57 +0900

https://youtube.com/live/1HmpkgreFAA

[STM32#17] STM32쉴드에 붙어있는 각종 센서값을 C# winform에게 전송하고 UI에 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3ae38c5a1b6_3_0#slide=id.g3ae38c5a1b6_3_0

녹칸다의 STM32쉴드에 붙어있는 센서값을 C#윈폼으로 전송해보도록 하겠습니다~!

1.바로직전 슬라이드를 참고해서, A0,A1,A4에 연결된 아날로그 3종세트의 값을 ADC1을 이용해서 동시에 측정하고, 그 값을 C#윈폼 화면에 richtextbox1에 출력하시오!(보내는 데이터는 CSV 형식으로 전송하시오)

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  sprintf(buff,"%d,%d,%.2f\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);

   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            richTextBox1.Text += data + "\n";
            //data안에 들어있는 값은 CSV형식이다!
            string[] analog_value = data.Split(',');
            //짤려진 조각의 갯수는 반드시 3개여야한다!
            if(analog_value.Length == 3)
            {
                textBox2.Text = analog_value[0];
                textBox3.Text = analog_value[1];
                textBox4.Text = analog_value[2];
            }
        }

2.예제1번에서 STM32가 보내는 데이터의 형식을 바이너리로 전송하시오!

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;
 struct{
	  uint16_t sen1; //2
	  uint16_t sen2; //2
	  float sen3; //4
 }dataset;

 /* USER CODE END 2 */

 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  dataset.sen1 = adc_value0;
	  dataset.sen2 = adc_value1;
	  dataset.sen3 = Tc;
	  //내가 변환하고자하는 변수의 주소를 (uint8_t*)으로 명시적 형변환을 하면
	  //어떤 변수가 uint8_t array로 변환되는 효과를 가져올 수 있다!
	  HAL_UART_Transmit(&huart2, (uint8_t*)(&dataset), sizeof(dataset), 100);
	  HAL_Delay(100);


   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            //C#에서 STM32가 보낸 데이터를 무조건 8개를 받아야한다!
            byte[] recv = new byte[8]; //uint8_t
            int cnt = 0;
            while (true)
            {
                recv[cnt] = (byte)serialPort1.ReadByte();
                cnt++;
                if (cnt == 8) break;
            }
            //rawdata 출력
            richTextBox1.Text += "수신 = ";
            string text = "";
            for(int i = 0; i < 8; i++)
            {
                text += recv[i] + ", ";
            }
            richTextBox1.Text += text + "\n";
            //데이터해석
            UInt16 sen1 = BitConverter.ToUInt16(recv, 0);
            UInt16 sen2 = BitConverter.ToUInt16(recv, 2);
            float sen3 = BitConverter.ToSingle(recv, 4);
            textBox2.Text = sen1.ToString();
            textBox3.Text = sen2.ToString();
            textBox4.Text = sen3.ToString();
        }

3.예제1번에서 STM32가 key-value형식을 가지는 json형식으로 데이터를 전송한다음 C#에서 json파서를 이용해서 데이터 해석을 한다음 출력하시오!

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;


 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  sprintf(buff,"{\"sen1\":%d,\"sen2\":%d,\"sen3\":%.2f}\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);



   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            richTextBox1.Text += data + "\n";
            //데이터를 해석하려면 json parser가 필요하다!
            try
            {
                JObject myjson = JObject.Parse(data);
                //key값이 sen1인 value값이 뭐냐?
                textBox2.Text = myjson["sen1"].ToString();
                textBox3.Text = myjson["sen2"].ToString();
                textBox4.Text = myjson["sen3"].ToString();
            }
            catch { }
            
        }

4.예제3에서 했던 결과에서 C#윈폼의 chart를 이용해서 꺾은선그래프를 그리시오!

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;


 /* USER CODE END 2 */

 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  sprintf(buff,"{\"sen1\":%d,\"sen2\":%d,\"sen3\":%.2f}\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);



   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            //데이터를 해석하려면 json parser가 필요하다!
            try
            {
                JObject myjson = JObject.Parse(data);
                //key값이 sen1인 value값이 뭐냐?
                textBox2.Text = myjson["sen1"].ToString();
                textBox3.Text = myjson["sen2"].ToString();
                textBox4.Text = myjson["sen3"].ToString();

                UInt16 sen1 = UInt16.Parse(myjson["sen1"].ToString());
                UInt16 sen2 = UInt16.Parse(myjson["sen2"].ToString());
                float sen3 = Single.Parse(myjson["sen3"].ToString());

                chart1.Series[0].Points.AddY(sen1);
                chart1.Series[1].Points.AddY(sen2);
                chart1.Series[2].Points.AddY(sen3);
            }
            catch { }
            
        }

5.예제4에서 그래프는 계속 데이터가 누적되는 방식이라서 결국 화면상에 보여지는 그래프가 너무 촘촘해진다! x축을 기준으로 50개의 데이터만 유지하고 큐와 동일하게 제일 처음 들어온 데이터는 51개가 되는 순간 빠지도록 하시오!

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;


 /* USER CODE END 2 */

 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  sprintf(buff,"{\"sen1\":%d,\"sen2\":%d,\"sen3\":%.2f}\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);



   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            //데이터를 해석하려면 json parser가 필요하다!
            try
            {
                JObject myjson = JObject.Parse(data);
                //key값이 sen1인 value값이 뭐냐?
                textBox2.Text = myjson["sen1"].ToString();
                textBox3.Text = myjson["sen2"].ToString();
                textBox4.Text = myjson["sen3"].ToString();

                UInt16 sen1 = UInt16.Parse(myjson["sen1"].ToString());
                UInt16 sen2 = UInt16.Parse(myjson["sen2"].ToString());
                float sen3 = Single.Parse(myjson["sen3"].ToString());

                //지금 데이터 갯수가 50개보다 많다면 1개 뺀다
                if(chart1.Series[0].Points.Count > 50)
                {
                    chart1.Series[0].Points.RemoveAt(0);
                    chart1.Series[0].Points.AddY(sen1);
                    chart1.Series[1].Points.AddY(sen2);
                    chart1.Series[2].Points.AddY(sen3);
                }
                else
                {
                    chart1.Series[0].Points.AddY(sen1);
                    chart1.Series[1].Points.AddY(sen2);
                    chart1.Series[2].Points.AddY(sen3);
                }
            }
            catch { }
        }

6.I2C통신으로 측정된 온습도센서인 AHT-10의 값을 C#윈폼 화면에 출력하시오!(기본 데이터 형식은 JSON형식으로 하도록 함)

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 /* USER CODE END 2 */

/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str,"{\"temp\":%.2f,\"humi\":%.2f}\n",AHT10_Temperature,AHT10_Humidity);
	  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            richTextBox1.Text += data + "\n";
            //데이터 해석
            try
            {
                JObject myjson = JObject.Parse(data);
                textBox2.Text = myjson["temp"].ToString();
                textBox3.Text = myjson["humi"].ToString();
            }
            catch { }
        }

7.예제6에서 측정된 온도와 습도값을 listview를 이용해서 table형식으로 출력하되 측정이 된 시간을 함께 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 /* USER CODE END 2 */

/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str,"{\"temp\":%.2f,\"humi\":%.2f}\n",AHT10_Temperature,AHT10_Humidity);
	  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

//전역변수자리
 int cnt = 1;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            //데이터 해석
            try
            {
                JObject myjson = JObject.Parse(data);
                textBox2.Text = myjson["temp"].ToString();
                textBox3.Text = myjson["humi"].ToString();

                //데이터 삽입
                ListViewItem lvi = new ListViewItem();
                lvi.Text = cnt.ToString();
                lvi.SubItems.Add(myjson["temp"].ToString());
                lvi.SubItems.Add(myjson["humi"].ToString());
                lvi.SubItems.Add(DateTime.Now.ToString());
                listView1.Items.Add(lvi);
                cnt++;
            }
            catch { }
        }

8.예제3에서 아날로그값 3종과 예제6에서 온습도값 2종을 모두 C#에 전송해서 listview에 현재 시간을 포함해서 출력하시오!(1초간격)

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 float logR2, R2, T, Tc, Tf;
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 /* USER CODE END 2 */


/* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;

	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str,"{\"sen1\":%d,\"sen2\":%d,\"sen3\":%.2f,\"temp\":%.2f,\"humi\":%.2f}\n",adc_value0,adc_value1,Tc,AHT10_Temperature,AHT10_Humidity);
	  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가

//전역변수자리
 int cnt = 1;

private void button1_Click(object sender, EventArgs e)
        {
            //접속버튼 클릭
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;
            serialPort1.Open();
            if (serialPort1.IsOpen)
            {
                //수신버퍼 클리어
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //STM32가 데이터를 전송했다!
            string data = serialPort1.ReadLine();
            //데이터 해석
            try
            {
                JObject myjson = JObject.Parse(data);
                textBox2.Text = myjson["temp"].ToString();
                textBox3.Text = myjson["humi"].ToString();
                textBox4.Text = myjson["sen1"].ToString();
                textBox5.Text = myjson["sen2"].ToString();
                textBox6.Text = myjson["sen3"].ToString();

                //데이터 삽입
                ListViewItem lvi = new ListViewItem();
                lvi.Text = cnt.ToString();
                lvi.SubItems.Add(myjson["temp"].ToString());
                lvi.SubItems.Add(myjson["humi"].ToString());
                lvi.SubItems.Add(myjson["sen1"].ToString());
                lvi.SubItems.Add(myjson["sen2"].ToString());
                lvi.SubItems.Add(myjson["sen3"].ToString());
                lvi.SubItems.Add(DateTime.Now.ToString());
                listView1.Items.Add(lvi);
                cnt++;
            }
            catch { }
        }

[STM32#16] C# winform을 이용해서 STM32f103rb nucleo보드와 usart2로 serial통신하는 방법 계속알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 3 Dec 2025 16:51:14 +0900

https://youtube.com/live/oTKsk64gdPY

[STM32#16] C# winform을 이용해서 STM32f103rb nucleo보드와 usart2로 serial통신하는 방법 계속알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39a36328931_2_238#slide=id.g39a36328931_2_238

이제 C#윈폼으로 응용을 해봅시다!

1.STM32에서 부호가없는 32bit정수 타입의 값 2개를 1초 간격으로 C#으로 전송한다! 이때 데이터 형식은 CSV 형식이다! C#에서 수신한 데이터를 분리해서 출력하시오!
-(결과예시) num1은 12345이고, num2는 56789이고, num1+num2는 ???입니다!

/* USER CODE BEGIN 2 */
 uint32_t num1 = 12345;
 uint32_t num2 = 67890;
 char buff[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //num1, num2를 csv형식으로 buff에 대입한다
	  sprintf(buff,"%d,%d\n",num1,num2);
	  //buff안에 있는 값을 널문자(\0)까지의 길이를 반환해서 전송한다
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //stm32는 반드시 문자열로 전송하고 종료문자 \n붙힌다!
            string data = serialPort1.ReadLine();
            //STM32가 보낸 데이터는 CSV형식이다!
            string[] csv_data = data.Split(',');
            //STM32가 보낸 데이터는 2개이기 때문에 배열의 갯수는 2여야한다!
            if(csv_data.Length == 2)
            {
                //csv_data[0] : num1
                //csv_data[1] : num2
                UInt32 num1 = UInt32.Parse(csv_data[0]);
                UInt32 num2 = UInt32.Parse(csv_data[1]);
                UInt32 sum = num1 + num2;

                //richTextBox1.Text += "num1=" + num1 + ", num2=" + num2 + ", sum=" + sum + "\n";
                richTextBox1.Text += $"num1={num1}, num2={num2}, sum={sum}\n";
            }
        }

2.예제1번과 동일한 구성인데, STM32가 JSON형식으로 데이터를 전송할때 C#윈폼에서 동일하게 parse해서 richtextbox1에 적절하게 출력하시오!

/* USER CODE BEGIN 2 */
 uint32_t num1 = 12345;
 uint32_t num2 = 67890;
 char buff[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //num1, num2를 csv형식으로 buff에 대입한다
	  sprintf(buff,"{\"num1\":%d, \"num2\":%d}\n",num1,num2);
	  //buff안에 있는 값을 널문자(\0)까지의 길이를 반환해서 전송한다
	  HAL_UART_Transmit(&huart2,buff,strlen(buff),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

using Newtonsoft.Json.Linq; //네임스페이스 추가~

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //stm32는 반드시 문자열로 전송하고 종료문자 \n붙힌다!
            string data = serialPort1.ReadLine();
            //data안에 JSON형식의 데이터가 있다!

            try
            {    
                JObject json_data = JObject.Parse(data);
                UInt32 num1 = UInt32.Parse(json_data["num1"].ToString());// : num1
                UInt32 num2 = UInt32.Parse(json_data["num2"].ToString());// : num2
                UInt32 sum = num1 + num2;

                richTextBox1.Text += $"원본={data}\n";
                richTextBox1.Text += $"num1={num1}, num2={num2}, sum={sum}\n";
            }
            catch
            {
                //만약 json데이터에 문제가 있다면 이쪽으로 떨어짐!
            }
        }

3.이번에는 STM32에서 2개의 숫자 데이터를 바이너리로 전송하는데, 공용체를 이용해서 전송해보시오!

/* USER CODE BEGIN 2 */
 union{
    uint32_t input[2]; //8byte
    uint8_t output[8]; //8byte
 }myunion;
 myunion.input[0] = 12345; //num1
 myunion.input[1] = 67890; //num2
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //공용체에 들어갈때는 32bit정수2개지만, 나올때는 8byte 배열이란다~
	  HAL_UART_Transmit(&huart2,myunion.output,sizeof(myunion.output),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //STM32쪽에서 8byte 배열에 날라온다!
            byte[] recv = new byte[8];
            int cnt = 0;
            while (true)
            {
                recv[cnt] = (byte)serialPort1.ReadByte();
                cnt++;
                if (cnt == 8) break;
            }

            //recv배열안에 0~3이 num1, 4~7까지 num2인상황
            UInt32 num1 = BitConverter.ToUInt32(recv, 0);
            UInt32 num2 = BitConverter.ToUInt32(recv, 4);
            UInt32 sum = num1 + num2;

            richTextBox1.Text += $"[수신] = ";
            for (int i = 0; i < 8; i++)
            {
                richTextBox1.Text += recv[i] + ", ";
            }
            richTextBox1.Text += "\n";
            richTextBox1.Text += $"num1={num1}, num2={num2}, sum={sum}\n";

        }

4.예제3과 동일한 구성인데, 이번에는 구조체를 활용해서 전송하시오!(녹칸다 생각에는 이방법이 제일 좋은 방법인듯)

/* USER CODE BEGIN 2 */
 struct{
	 uint32_t num1;
	 uint32_t num2;
 }mystruct;
 mystruct.num1 = 12345;
 mystruct.num2 = 67890;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  HAL_UART_Transmit(&huart2,(uint8_t*)&mystruct,sizeof(mystruct),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //STM32쪽에서 8byte 배열에 날라온다!
            byte[] recv = new byte[8];
            int cnt = 0;
            while (true)
            {
                recv[cnt] = (byte)serialPort1.ReadByte();
                cnt++;
                if (cnt == 8) break;
            }

            //recv배열안에 0~3이 num1, 4~7까지 num2인상황
            UInt32 num1 = BitConverter.ToUInt32(recv, 0);
            UInt32 num2 = BitConverter.ToUInt32(recv, 4);
            UInt32 sum = num1 + num2;

            richTextBox1.Text += $"[수신] = ";
            for (int i = 0; i < 8; i++)
            {
                richTextBox1.Text += recv[i] + ", ";
            }
            richTextBox1.Text += "\n";
            richTextBox1.Text += $"num1={num1}, num2={num2}, sum={sum}\n";

        }

5.녹칸다의 STM32쉴드에 붙어있는 로터리엔코더를 시계방향으로 돌리면 C#윈폼 화면에 값이 1씩 증가하도록하고 반시계방향으로 돌리면 1씩감소하고 스위치를 누르면 0으로 초기화 하도록 하시오!(변화되는 값은 C#의 변수값이다)

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "0", 1, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  HAL_UART_Transmit(&huart2, "-", 1, 100);
		  }else{
			 //시계
			  HAL_UART_Transmit(&huart2, "+", 1, 100);
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

//C#의 전역변수 위치
int cnt = 0;


private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }


private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //STM32에서 문자 1개가 수신된다!
            //'+' : 시계방향
            //'-' : 반시계방향
            //'0' : 초기화
            char c = (char)serialPort1.ReadChar();
            richTextBox1.Text += c + "\n";

            if(c == '0')
            {
                cnt = 0;
                textBox2.Text = cnt.ToString();
            }else if (c == '+')
            {
                cnt++;
                textBox2.Text = cnt.ToString();
            }
            else if (c == '-')
            {
                cnt--;
                textBox2.Text = cnt.ToString();
            }
        }

6.예제5에서 로터리엔코더를 돌려서 바뀌는 값은 STM32메모리에 기억되고, 변화되는 값을 C#으로 전송해서 화면에 출력하시오!(카운터값이 -10~+10사이면 흰색, +11부터는 빨간색, -11이하면 노란색으로 바꾸시오!)

/* USER CODE BEGIN 2 */
 int cnt = 0;
 uint8_t old_A = 0;
 char buff[50];
 char recv;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_UART_Receive(&huart2, &recv, 1, 1) == HAL_OK){
		  if(recv == '0'){
			  //C#에서 현재 CNT값을 1회 전송해달라는 명령!
			  sprintf(buff,"%d\n",cnt);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }
	  }
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  cnt = 0;
		  sprintf(buff,"%d\n",cnt);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  cnt--;
		  }else{
			 //시계
			  cnt++;
		  }
		  sprintf(buff,"%d\n",cnt);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                //C#에서 포트를 개방한 직후 STM32에게 CNT값을 물어본다!
                //STM32에게 문자 '0'을 전송하면 STM32는 응답한다!
                serialPort1.Write("0");
                MessageBox.Show("접속완료!");
            }
        }

private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            string data = serialPort1.ReadLine();
            textBox2.Text = data;

            int cnt = int.Parse(data);
            if(cnt > 10)
            {
                //빨간색
                textBox2.BackColor = Color.Red;
            }else if(cnt < -11)
            {
                //노란색
                textBox2.BackColor = Color.Yellow;
            }
            else
            {
                //흰색
                textBox2.BackColor = Color.White;
            }
        }

7.예제5에서 로터리엔코더의 스위치를 누르면 0으로 초기화한다라는 조건 대신에, C#윈폼의 listbox를 이용해서 값을 하나씩 추가하는 것을 보이시오!

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "0", 1, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  HAL_UART_Transmit(&huart2, "-", 1, 100);
		  }else{
			 //시계
			  HAL_UART_Transmit(&huart2, "+", 1, 100);
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

//C#의 전역변수 위치
int cnt = 0;


private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }



private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //STM32에서 문자 1개가 수신된다!
            //'+' : 시계방향
            //'-' : 반시계방향
            //'0' : 초기화
            char c = (char)serialPort1.ReadChar();
            richTextBox1.Text += c + "\n";

            if (c == '0')
            {
                //cnt = 0;
                //textBox2.Text = cnt.ToString();
                //listbox1에 현재 cnt값을 추가함!
                listBox1.Items.Add(cnt);
            }
            else if (c == '+')
            {
                cnt++;
                textBox2.Text = cnt.ToString();
            }
            else if (c == '-')
            {
                cnt--;
                textBox2.Text = cnt.ToString();
            }

        }

        private void button2_Click(object sender, EventArgs e)
        {
            //listbox1에 있는 내용을 다 지운다!
            listBox1.Items.Clear();
        }

8.예제5에서 누겟페키지관리로가서 agauge2를 다운받아서 로터리엔코더로 게이지값을 변화시키시오!

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "0", 1, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  HAL_UART_Transmit(&huart2, "-", 1, 100);
		  }else{
			 //시계
			  HAL_UART_Transmit(&huart2, "+", 1, 100);
		  }
	  }
	  old_A = now_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

//C#의 전역변수 위치
int cnt = 0;

private void button1_Click(object sender, EventArgs e)
        {
            //접속하기 버튼 클릭했다 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            //serialport1의 open메서드를 콜한다!
            serialPort1.Open();

            if (serialPort1.IsOpen)
            {
                //버퍼의 직전데이터가 밀려서 들어온다!
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }



private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32가 데이터를 보냈는데 뭐할래?
            //STM32에서 문자 1개가 수신된다!
            //'+' : 시계방향
            //'-' : 반시계방향
            //'0' : 초기화
            char c = (char)serialPort1.ReadChar();
            richTextBox1.Text += c + "\n";

            if (c == '0')
            {
                cnt = 0;
                textBox2.Text = cnt.ToString();
                aGauge1.Value = cnt;
            }
            else if (c == '+')
            {
                cnt+=5;
                if (cnt > 400) cnt = 400;
                textBox2.Text = cnt.ToString();
                aGauge1.Value = cnt;
            }
            else if (c == '-')
            {
                cnt-=5;
                if (cnt < -100) cnt = -100;
                textBox2.Text = cnt.ToString();
                aGauge1.Value = cnt;
            }

        }

[STM32#15] C# winform을 이용해서 STM32f103rb nucleo보드와 usart2로 시리얼(serial)통신하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 1 Dec 2025 23:17:23 +0900

https://youtube.com/live/Q39rzRj1ol8

[STM32#15] C# winform을 이용해서 STM32f103rb nucleo보드와 usart2로 serial통신하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3ab9129297f_1_25#slide=id.g3ab9129297f_1_25

이번편 부터 STM32의 친구 C#윈폼이 등장합니다!

1.STM32가 1초간격으로 “I’m stm32 board!!”라는 문자열을 PC로 전송할때, C#윈폼으로 만든 프로그램화면에 받은 문자열을 그대로 출력하시오!

/* USER CODE BEGIN 2 */
 char msg[] = "I'm STM32 BOARD!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //1초간격으로 지정된 문자열을 전송한다
	  HAL_UART_Transmit(&huart2,msg,strlen(msg),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32에서 데이터가 수신되었다! 뭐할래?
            //stm32가 보낸 문자열중 종료문자가 LF일때 까지를 읽겠다!
            string data = serialPort1.ReadLine();
            richTextBox1.Text += data + "\n";
        }

2.STM32에서 PB1에 연결된 버튼을 누르면 BTN1 CLICK!이라고 전송하고 PA8에 연결된 버튼을 누르면 BTN2 CLICK이라고 전송해서 C#윈폼으로 만든 GUI에 출력한다!

/* USER CODE BEGIN 2 */
 char msg1[] = "BTN1 CLICKED!\n";
 char msg2[] = "BTN2 CLICKED!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면~
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  HAL_UART_Transmit(&huart2,msg1,strlen(msg1),100);
		  HAL_Delay(300);
	  }
	  //PA8을 누르면~
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  HAL_UART_Transmit(&huart2,msg2,strlen(msg2),100);
		  HAL_Delay(300);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32에서 데이터가 수신되었다! 뭐할래?
            //stm32가 보낸 문자열중 종료문자가 LF일때 까지를 읽겠다!
            string data = serialPort1.ReadLine();
            richTextBox1.Text += data + "\n";
        }

3.예제2에서 PB1을 누르면 STM32내부에 있는 uint32_t num1 = 1234;의 값을 C#윈폼으로 바이너리로 전송하고, PA8을 누르면 int32_t num2 = -5678;의 값을 C#으로 전송해서 출력하시오!

/* USER CODE BEGIN 2 */
 uint32_t num1 = 1234;
 int32_t num2 = -5678;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면~
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  HAL_UART_Transmit(&huart2,(uint8_t*)&num1,sizeof(num1),100);
		  HAL_Delay(300);
	  }
	  //PA8을 누르면~
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  HAL_UART_Transmit(&huart2,(uint8_t*)&num2,sizeof(num2),100);
		  HAL_Delay(300);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

        private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            //stm32에서 데이터가 수신되었다! 뭐할래?
            //4byte로 구성된 숫자가 날라오는 상황이 되었다!
            byte[] buff = new byte[4];
            //STM32가 보낸 데이터를 buff에 0번부터 시작해서
            //4개를 가져와서 대입하겠다!
            serialPort1.Read(buff, 0, 4);

            //buff안에 들어있는 값을 0부터 4개를 uint32로 해석!
            UInt32 num1 = BitConverter.ToUInt32(buff, 0);
            Int32 num2 = BitConverter.ToInt32(buff, 0);

            richTextBox1.Text = num1 + ", " + num2;
        }

4.C#에서 ON버튼과 OFF버튼을 2개 생성하고, ON버튼을 누르면 PB3에 연결된 LED를 ON하고 OFF버튼은 OFF시키시오!(문자 ‘0’일때 OFF, 문자 ‘1’일때 ON)

/* USER CODE BEGIN 2 */
 char recv;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  //C#에서 보낸 데이터 1개를 성공적으로 수신함!
		  if(recv == '0'){
			  //LED OFF
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0);
		  }else if(recv == '1'){
			  //LED ON
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void button3_Click(object sender, EventArgs e)
        {
            //OFF버튼 문자 '0'전송
            if (serialPort1.IsOpen)
            {
                serialPort1.Write("0");
            }
            else
            {
                MessageBox.Show("접속을 해주세요!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //ON버튼 문자 '1'전송
            if (serialPort1.IsOpen)
            {
                serialPort1.Write("1");
            }
            else
            {
                MessageBox.Show("접속을 해주세요!");
            }
        }

5.C#에서 ON버튼과 OFF버튼을 2개 생성하고, ON버튼을 누르면 PB3에 연결된 LED를 ON하고 OFF버튼은 OFF시키시오!(숫자 0일때 OFF, 숫자 1일때 ON)

/* USER CODE BEGIN 2 */
 char recv;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  //C#에서 보낸 데이터 1개를 성공적으로 수신함!
		  //녹칸다가 recv에 0을 보내면 LED OFF신호고 바로 적용하고
		  //1을 보내면 ON신호로 바로 적용가능하나,
		  //만약 C#에서 0,1 이외에 다른걸 보내게되면 문제가 생길수있음!
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, recv);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

private void button3_Click(object sender, EventArgs e)
        {
            //OFF버튼 문자 '0'전송
            if (serialPort1.IsOpen)
            {
                //숫자 1개 전송하기!
                byte[] data = { 0 };
                serialPort1.Write(data, 0, 1);
            }
            else
            {
                MessageBox.Show("접속을 해주세요!");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //ON버튼 문자 '1'전송
            if (serialPort1.IsOpen)
            {
                //숫자 1개 전송하기!
                byte[] data = { 1 };
                serialPort1.Write(data, 0, 1);
            }
            else
            {
                MessageBox.Show("접속을 해주세요!");
            }
        }

6.PB3,PB13,PB5,PB14,PB4,PB15,PC4,PB7에 LED가 총 8개 연결되어있는데, C#윈폼에서 버튼을 이용해서 모든 LED를 제어할 수 있는 UI와 기능을 구현하시오!

-문자0,1(LED1), 문자2,3(LED2), 문자4,5(LED3), 문자6,7(LED4), 문자8,9(LED5), 문자A,B(LED6), 문자C,D(LED7), 문자E,F(LED8)

/* USER CODE BEGIN 2 */
 char recv;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  if(recv == '0'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0);
		  }else if(recv == '1'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1);
		  }else if(recv == '2'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0);
		  }else if(recv == '3'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 1);
		  }else if(recv == '4'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 0);
		  }else if(recv == '5'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 1);
		  }else if(recv == '6'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, 0);
		  }else if(recv == '7'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, 1);
		  }else if(recv == '8'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 0);
		  }else if(recv == '9'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, 1);
		  }else if(recv == 'A'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, 0);
		  }else if(recv == 'B'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, 1);
		  }else if(recv == 'C'){
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, 0);
		  }else if(recv == 'D'){
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, 1);
		  }else if(recv == 'E'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 0);
		  }else if(recv == 'F'){
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 1);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }

private void button3_Click(object sender, EventArgs e)
        {
            serialPort1.Write("0");
        }
        private void button2_Click(object sender, EventArgs e)
        {
            serialPort1.Write("1");
        }
        private void button5_Click(object sender, EventArgs e)
        {
            serialPort1.Write("2");
        }

        private void button4_Click(object sender, EventArgs e)
        {
            serialPort1.Write("3");
        }

        private void button7_Click(object sender, EventArgs e)
        {
            serialPort1.Write("4");
        }

        private void button6_Click(object sender, EventArgs e)
        {
            serialPort1.Write("5");
        }

        private void button9_Click(object sender, EventArgs e)
        {
            serialPort1.Write("6");
        }

        private void button8_Click(object sender, EventArgs e)
        {
            serialPort1.Write("7");
        }

        private void button16_Click(object sender, EventArgs e)
        {
            serialPort1.Write("8");
        }


        private void button17_Click(object sender, EventArgs e)
        {
            serialPort1.Write("9");
        }
        private void button14_Click(object sender, EventArgs e)
        {
            serialPort1.Write("A");
        }
        private void button15_Click(object sender, EventArgs e)
        {
            serialPort1.Write("B");
        }
        private void button12_Click(object sender, EventArgs e)
        {
            serialPort1.Write("C");
        }
        private void button13_Click(object sender, EventArgs e)
        {
            serialPort1.Write("D");
        }

        private void button10_Click(object sender, EventArgs e)
        {
            serialPort1.Write("E");
        }

        private void button11_Click(object sender, EventArgs e)
        {
            serialPort1.Write("F");
        }

7.예제6번을 조금더 고급스럽게, 효율적으로 바꿔보시오! 추가로 모든 LED를 ON하고나 OFF하는 기능을 추가하시오!

/* USER CODE BEGIN 2 */
 GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 char recv[2];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_UART_Receive(&huart2, recv, 2, 500) == HAL_OK){
		  //recv[0] : LED번호
		  int led_num = recv[0];
		  //recv[1] : 0이면 OFF, 1이면 ON
		  int state = recv[1];
		  if(led_num == 8){
			  //led_num이 8이면 모든 LED를 제어하는 것이다!
			  for(int i = 0;i<8;i++){
				  HAL_GPIO_WritePin(mygpio[i], mypin[i], state);
			  }
		  }else{
			  HAL_GPIO_WritePin(mygpio[led_num], mypin[led_num], state);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

private void button1_Click(object sender, EventArgs e)
        {
            //button1이 클릭된게 감지되었는데 너 뭐할래?
            serialPort1.PortName = textBox1.Text;
            serialPort1.BaudRate = 115200;

            serialPort1.Open(); //포트 개방!

            if (serialPort1.IsOpen)
            {
                //버퍼에 있는 데이터를 모조리 소멸시킨다
                serialPort1.ReadExisting();
                MessageBox.Show("접속완료!");
            }
        }
private void button3_Click(object sender, EventArgs e)
        {
            byte[] data = { 0, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button2_Click(object sender, EventArgs e)
        {
            byte[] data = { 0,1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button5_Click(object sender, EventArgs e)
        {
            byte[] data = { 1, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button4_Click(object sender, EventArgs e)
        {
            byte[] data = { 1, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button7_Click(object sender, EventArgs e)
        {
            byte[] data = { 2, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button6_Click(object sender, EventArgs e)
        {
            byte[] data = { 2, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button9_Click(object sender, EventArgs e)
        {
            byte[] data = { 3, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button8_Click(object sender, EventArgs e)
        {
            byte[] data = { 3, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button16_Click(object sender, EventArgs e)
        {
            byte[] data = { 4, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button17_Click(object sender, EventArgs e)
        {
            byte[] data = { 4, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button14_Click(object sender, EventArgs e)
        {
            byte[] data = { 5, 0 };
            serialPort1.Write(data, 0, 2);
        }

        private void button15_Click(object sender, EventArgs e)
        {
            byte[] data = { 5, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button12_Click(object sender, EventArgs e)
        {
            byte[] data = { 6, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button13_Click(object sender, EventArgs e)
        {
            byte[] data = { 6, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button10_Click(object sender, EventArgs e)
        {
            byte[] data = { 7, 0 };
            serialPort1.Write(data, 0, 2);
        }
        private void button11_Click(object sender, EventArgs e)
        {
            byte[] data = { 7, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button18_Click(object sender, EventArgs e)
        {
            byte[] data = { 8, 1 };
            serialPort1.Write(data, 0, 2);
        }
        private void button19_Click(object sender, EventArgs e)
        {
            byte[] data = { 8, 0 };
            serialPort1.Write(data, 0, 2);
        }

[STM32#14] DHT-11과 AHT-10(i2c) 온습도센서를 STM32f103rb nucleo에 연결해서 온도와 습도를 측정하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 26 Nov 2025 18:52:57 +0900

https://youtube.com/live/DxaNkZ3ZAoU

[STM32#14] DHT-11과 AHT-10(i2c) 온습도센서를 STM32f103rb nucleo에 연결해서 온도와 습도를 측정하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39a118d174f_1_193#slide=id.g39a118d174f_1_193

이번편은 온습도센서 2종세트 입니다~!

(DHT-11연결도)

(DHT-11 코드)

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
return millis_cnt;
}
uint32_t micros() {
return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
if (us > 1) {
  uint32_t count = us * 7 - 6;
  while (count--);
} else {
  uint32_t count = 2;
  while (count--);
}
}

union {
 uint32_t data;
 struct {
   uint8_t temp_d;
   uint8_t temp_i;
   uint8_t rh_d;
   uint8_t rh_i;
 };
} DHT;
uint8_t DHT_read () {
 uint8_t i, check_sum;
 uint32_t start;
 check_sum = 0;
 DHT.data = 0;
 GPIOC->CRL = (GPIOC->CRL&0xFFFFFF0F)|(7<<(1*4));  // Output Open-drain (Master send LOW signal)
 delay_ms(18);
 GPIOC->CRL= (GPIOC->CRL&0xFFFFFF0F)|(4<<(1*4));  // Floating input (Master send HIGH signal & data receive)
 start = micros();
 while (GPIOC->IDR&(1<<1)) {
   if (micros()-start > 50) return 1;  // 20~40us
 }
 start = micros();
 while (!(GPIOC->IDR&(1<<1))) {
   if (micros()-start > 120) return 2;  // 80us
 }
 start = micros();
 while (GPIOC->IDR&(1<<1)) {
   if (micros()-start > 120) return 3;  // 80us
 }
 for (i = 0; i < 32; i++) {
   while (!(GPIOC->IDR&(1<<1))); // 50us
   start = micros();
   while (GPIOC->IDR&(1<<1));
   if (micros()-start > 50) DHT.data |= (0x80000000 >> i); // "0"=26~28us, "1"=70us
 }
 for (i = 0; i < 8; i++) {
   while (!(GPIOC->IDR&(1<<1))); // 50us
   start = micros();
   while (GPIOC->IDR&(1<<1));
   if (micros()-start > 50) check_sum |= (0x80 >> i);
 }
 if ((DHT.rh_i + DHT.rh_d + DHT.temp_i + DHT.temp_d) == check_sum) return 0;
 else return 4;
}

(AHT-10 연결도)

(AHT-10 추가코드)

uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
uint8_t AHT10_RX_Data[6];
uint32_t AHT10_ADC_Raw;
float AHT10_Temperature;
float AHT10_Humidity;
char str[100];

//요청
HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
//수신대기
uint8_t recv[1];
while(1){
  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
  if(~recv[0] & 0x80){
      break;
  }
}
//데이터 수신
HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
//수신데이터 출력
AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;

/* Convert to Relative Humidity in % */
AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);

sprintf(str,"%f, %f\r\n",AHT10_Temperature,AHT10_Humidity);
HAL_UART_Transmit(&huart2,str,strlen(str),100);

(예제목차)

1.DHT-11의 기본예제를 이용해서 온도와 습도값을 usart2로 출력해서 putty에 터미널로 값을 확인하시오!

/* USER CODE BEGIN 2 */
 char str[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  sprintf(str, "T:%.1f'C H:%.1f%c\n", temp,humi,'%');
		  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  } else {
		  sprintf(str, "Error=%d\n", error_no);
		  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  }
	  HAL_Delay(2000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.측정한 온도와 습도값을 I2C통신을 하는 1602LCD에 출력하시오!(I2C설정을 IOC에서 할 것)

/* USER CODE BEGIN 2 */
 char str[100];
 LCD_INIT(); //1회호출(메인루프 시작전)
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  sprintf(str, "T:%.1f'C H:%.1f%c", temp,humi,'%');
		  LCD_CLEAR();//원래 있던거 삭제!
		  LCD_XY(0, 0) ; LCD_PUTS("NOCKANDA DHT11");
		  LCD_XY(0, 1) ; LCD_PUTS(str);
	  }
	  HAL_Delay(2000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.측정한 온도와 습도를 FND모듈인 TM1637에 출력하는데, 소수점이하는 버리고 숫자 2개씩 해서 왼쪽 2칸은 온도, 오른쪽 2칸은 습도로 출력하시오!

/* USER CODE BEGIN 2 */
 char str[100];
 tm1637Init();
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  float temp = 0;
		  float humi = 0;
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  int data = ((int)temp * 100) + (int)humi;
		  tm1637DisplayDecimalTrim(data,0);
	  }
	  HAL_Delay(2000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.STM32가 DHT11의 온습도값을 2초간격으로 측정한다! 그리고 FND모듈에 1초간격으로 한번은 온도, 한번은 습도를 출력한다! 이때 소수점값을 출력한다!

/* USER CODE BEGIN 2 */
 char str[100];
 tm1637Init();
 uint32_t t1 = 0; //온습도값 2초
 uint32_t t2 = 0; //FND출력 1초
 float temp = 0;
 float humi = 0;
 uint8_t sw = 0; //0이면 온도, 1이면 습도
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //2초간격으로 temp와 humi에 값을 입력만 한다!
	  if(HAL_GetTick() - t1 >= 2000){
		  t1 = HAL_GetTick();
		  uint8_t error_no = DHT_read();
		  if(error_no == 0){  // 정상일 때 처리
			  temp = DHT.temp_i;
			  if (DHT.temp_d & 0x80) {
				  temp = -1 - temp;
			  }
			  temp += (DHT.temp_d & 0x0f) * 0.1;
			  humi = DHT.rh_i + DHT.rh_d * 0.1;
		  }
	  }
	  //1초간격으로 온도와 습도를 번갈아가면서 출력한다!
	  if(HAL_GetTick() - t2 >= 1000){
		  t2 = HAL_GetTick();
		  if(sw == 0){
			  //온도
			  tm1637DisplayDecimalTrim((int)(temp*100),1);
			  tm1637SetRawSegment(3,0b00111001);
			  sw = 1;
		  }else if(sw == 1){
			  //습도
			  tm1637DisplayDecimalTrim((int)(humi*100),1);
			  tm1637SetRawSegment(3,0b01001001);
			  sw = 0;
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.이번에는 AHT-10온습도센서값을 usart2통신으로 터미널에 출력해서 확인하시오!

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str,"TEMP:%.2f'C, HUMI:%.2f%c\n",AHT10_Temperature,AHT10_Humidity,'%');
	  HAL_UART_Transmit(&huart2,str,strlen(str),100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.AHT-10에서 측정한 온도와 습도값을 1602LCD화면에 보기 좋게 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 LCD_INIT();
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str, "T:%.1f'C H:%.1f%c", AHT10_Temperature,AHT10_Humidity,'%');
	  LCD_CLEAR();//원래 있던거 삭제!
	  LCD_XY(0, 0) ; LCD_PUTS("NOCKANDA AHT-10!");
	  LCD_XY(0, 1) ; LCD_PUTS(str);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.녹칸다의 STM32쉴드에서 링모양으로 배치된 LED가 8개있는데, 12시방향을 시작으로 해서 온도 3도당 LED가 1개씩 켜지도록 하시오!

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 LCD_INIT();
 GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);
	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  sprintf(str, "T:%.1f'C H:%.1f%c", AHT10_Temperature,AHT10_Humidity,'%');
	  LCD_CLEAR();//원래 있던거 삭제!
	  LCD_XY(0, 0) ; LCD_PUTS("NOCKANDA AHT-10!");
	  LCD_XY(0, 1) ; LCD_PUTS(str);
	  int last_index =  (int)(AHT10_Temperature/3);
	  if(last_index > 7) last_index = 7;
	  for(int i =0;i<8;i++){
		  if(i <= last_index){
			  HAL_GPIO_WritePin(mygpio[i], mypin[i], 1);
		  }else{
			  HAL_GPIO_WritePin(mygpio[i], mypin[i], 0);
		  }
	  }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.DHT-11값과 AHT-10의값을 둘다 측정해서 1602LCD에 출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t AHT10_TmpHum_Cmd[3] = {0xAC, 0x33, 0x00};
 uint8_t AHT10_RX_Data[6];
 uint32_t AHT10_ADC_Raw;
 float AHT10_Temperature;
 float AHT10_Humidity;
 char str[100];
 LCD_INIT();
 float temp = 0;
 float humi = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //요청
	  HAL_I2C_Master_Transmit(&hi2c1, (0x38 << 1), AHT10_TmpHum_Cmd, 3, 10);
	  //수신대기
	  uint8_t recv[1];
	  while(1){
		  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), recv, 6, 10);
		  if(~recv[0] & 0x80){
			  break;
		  }
	  }
	  //데이터 수신
	  HAL_I2C_Master_Receive(&hi2c1, (0x38 << 1), AHT10_RX_Data, 6, 10);


	  //수신데이터 출력
	  AHT10_ADC_Raw = (((uint32_t)AHT10_RX_Data[3] & 15) << 16) | ((uint32_t)AHT10_RX_Data[4] << 8) | AHT10_RX_Data[5];
	  AHT10_Temperature = (float)(AHT10_ADC_Raw * 200.00 / 1048576.00) - 50.00;
	  /* Convert to Relative Humidity in % */
	  AHT10_ADC_Raw = ((uint32_t)AHT10_RX_Data[1] << 12) | ((uint32_t)AHT10_RX_Data[2] << 4) | (AHT10_RX_Data[3] >> 4);
	  AHT10_Humidity = (float)(AHT10_ADC_Raw*100.00/1048576.00);
	  uint8_t error_no = DHT_read();
	  if(error_no == 0){  // 정상일 때 처리
		  temp = DHT.temp_i;
		  if (DHT.temp_d & 0x80) {
			  temp = -1 - temp;
		  }
		  temp += (DHT.temp_d & 0x0f) * 0.1;
		  humi = DHT.rh_i + DHT.rh_d * 0.1;
	  }
	  LCD_CLEAR();//원래 있던거 삭제!
	  sprintf(str, "T:%.1f'C H:%.1f%c", temp,humi,'%');
	  LCD_XY(0, 0) ; LCD_PUTS(str);
	  sprintf(str, "T:%.1f'C H:%.1f%c", AHT10_Temperature,AHT10_Humidity,'%');
	  LCD_XY(0, 1) ; LCD_PUTS(str);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#13] FND모듈인 TM1637을 STM32f103rb nucleo에 연결해서 디스플레이에 다양한 센서값 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 24 Nov 2025 23:17:01 +0900

https://youtube.com/live/Iz-1TaHBU88

[STM32#13] FND모듈인 TM1637을 STM32f103rb nucleo에 연결해서 디스플레이에 다양한 센서값 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3a8e99eac0a_1_8#slide=id.g3a8e99eac0a_1_8

이번편은 FND모듈인 TM1637입니다~!

(필수추가코드)

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
// TM1637 7세그먼트 숫자 코드 매핑
const char segmentMap[] = {
   0x3f, 0x06, 0x5b, 0x4f,
   0x66, 0x6d, 0x7d, 0x07,
   0x7f, 0x6f, 0x77, 0x7c,
   0x39, 0x5e, 0x79, 0x71,
   0x00
};
// GPIOB 클럭 활성화 매크로
#define PORTB_CLK_ENABLE() (RCC->APB2ENR |= RCC_APB2ENR_IOPBEN)
// PB8, PB9 핀 사용 (GPIOB)
// PB8 = CLK, PB9 = DIO
// CLK와 DIO 핀 제어 함수
static inline void _tm1637ClkHigh(void) { GPIOB->BSRR = (1 << 8); } // CLK HIGH
static inline void _tm1637ClkLow(void)  { GPIOB->BRR = (1 << 8); }  // CLK LOW
static inline void _tm1637DioHigh(void) { GPIOB->BSRR = (1 << 9); } // DIO HIGH
static inline void _tm1637DioLow(void)  { GPIOB->BRR = (1 << 9); }  // DIO LOW
// 마이크로초 단위 딜레이
void _tm1637DelayUsec(unsigned int i)
{
	delay_us(i); // 사용자 정의 delay_us 함수 사용
}
// TM1637 초기화 함수 (GPIO 출력 설정)
void tm1637Init(void)
{
   PORTB_CLK_ENABLE(); // GPIOB 클럭 활성화
   // GPIOB CRH 초기화 (PB8, PB9 출력 2MHz Push-Pull)
   GPIOB->CRH &= ~((0xF << 0) | (0xF << 4)); // 해당 비트 클리어
   GPIOB->CRH |= (0x2 << 0); // PB8: MODE=10(출력 2MHz), CNF=00(Push-Pull)
   GPIOB->CRH |= (0x2 << 4); // PB9: MODE=10(출력 2MHz), CNF=00(Push-Pull)
   tm1637SetBrightness(8); // 밝기 최대
}

// TM1637 시작 신호
void _tm1637Start(void)
{
   _tm1637ClkHigh();
   _tm1637DioHigh();
   _tm1637DelayUsec(20);
   _tm1637DioLow(); // START 조건: DIO LOW
}
// TM1637 종료 신호
void _tm1637Stop(void)
{
   _tm1637ClkLow();
   _tm1637DelayUsec(20);
   _tm1637DioLow();
   _tm1637DelayUsec(20);
   _tm1637ClkHigh();
   _tm1637DelayUsec(20);
   _tm1637DioHigh(); // STOP 조건: DIO HIGH
}
// TM1637 ACK 무시 (결과 확인용)
void _tm1637ReadResult(void)
{
   _tm1637ClkLow();
   _tm1637DelayUsec(50);
   // DIO 상태 확인, ACK 처리 (여기서는 실제 확인 없이 무시)
   _tm1637ClkHigh();
   _tm1637DelayUsec(20);
   _tm1637ClkLow();
}

// TM1637 1바이트 전송
void _tm1637WriteByte(unsigned char b)
{
   for (int i = 0; i < 8; ++i) {
       _tm1637ClkLow();
       if (b & 0x01) {
           _tm1637DioHigh();
       } else {
           _tm1637DioLow();
       }
       _tm1637DelayUsec(30);
       b >>= 1; // 다음 비트로 이동
       _tm1637ClkHigh();
       _tm1637DelayUsec(30);
   }
}
// 밝기 설정 (0~8, 0 = 꺼짐)
void tm1637SetBrightness(char brightness)
{
   _tm1637Start();
   _tm1637WriteByte(0x87 + brightness); // 밝기 명령어
   _tm1637ReadResult();
   _tm1637Stop();
}

// 4자리 10진수 표시 (displaySeparator=1이면 3번째 자리 점 켬)
void tm1637DisplayDecimal(int v, int displaySeparator)
{
   unsigned char digitArr[4];
   int isNegative = 0;
   if (v < 0) {
       isNegative = 1;
       v = -v;
   }
   // 숫자를 segmentMap으로 변환
   for (int i = 0; i < 4; ++i) {
       digitArr[i] = segmentMap[v % 10];
       if (i == 2 && displaySeparator) {
           digitArr[i] |= 1 << 7; // 점(DP) 켬
       }
       v /= 10;
   }
   // 음수 표시
   if (isNegative) {
       digitArr[3] = 0x40; // '-' 표시
   }
   // TM1637에 데이터 전송
   _tm1637Start();
   _tm1637WriteByte(0x40); // 자동 주소 증가 모드
   _tm1637ReadResult();
   _tm1637Stop();
   _tm1637Start();
   _tm1637WriteByte(0xc0); // 시작 주소 0
   _tm1637ReadResult();
   for (int i = 0; i < 4; ++i) {
       _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
       _tm1637ReadResult();
   }
   _tm1637Stop();
}

// 4자리 10진수 표시 (앞자리 0 제거, displaySeparator=1이면 점 켬)
void tm1637DisplayDecimalTrim(int v, int displaySeparator)
{
   unsigned char digitArr[4];
   int isNegative = 0;
   if (v < 0) {
       isNegative = 1;
       v = -v;
   }
   // 숫자를 segmentMap으로 변환
   for (int i = 0; i < 4; ++i) {
       digitArr[i] = segmentMap[v % 10];
       if (i == 2 && displaySeparator) {
           digitArr[i] |= 1 << 7; // 점(DP) 켬
       }
       v /= 10;
   }
   // 앞자리 0 제거 (공백 처리)
   int leadingZero = 1;
   for (int i = 3; i >= 0; --i) {
       if (digitArr[i] != segmentMap[0] || i == 0) {
           leadingZero = 0;
       }
       if (leadingZero && digitArr[i] == segmentMap[0]) {
           digitArr[i] = 0x00; // 공백
       }
   }

   // 음수 표시
   if (isNegative) {
       digitArr[3] = 0x40; // '-'
   }
   // TM1637에 데이터 전송
   _tm1637Start();
   _tm1637WriteByte(0x40); // 자동 주소 증가 모드
   _tm1637ReadResult();
   _tm1637Stop();
   _tm1637Start();
   _tm1637WriteByte(0xC0); // 시작 주소 0
   _tm1637ReadResult();
   for (int i = 0; i < 4; ++i) {
       _tm1637WriteByte(digitArr[3 - i]); // 3->0 순서로 전송
       _tm1637ReadResult();
   }
   _tm1637Stop();
}
void tm1637SetRawSegment(uint8_t position, uint8_t segData)
{
   // 주소 범위 보호
   if (position > 3) return;
   _tm1637Start();
   _tm1637WriteByte(0x40);      // 데이터 입력 모드
   _tm1637ReadResult();
   _tm1637Stop();
   _tm1637Start();
   _tm1637WriteByte(0xC0 + position);   // 자리 선택
   _tm1637ReadResult();
   _tm1637WriteByte(segData);           // 세그먼트 데이터 전송
   _tm1637ReadResult();
   _tm1637Stop();
}

1.참고코드를 프로젝트에 반영하고 TM1637화면에 123이라고 출력하는데 2종류의 함수를 각각 사용해서 결과를 확인하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 //원하는 숫자 출력
 tm1637DisplayDecimal(123, 0);  //0123
 //tm1637DisplayDecimalTrim(123, 0);  //_123
 /* USER CODE END 2 */

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 //원하는 숫자 출력
 //tm1637DisplayDecimal(123, 0);  //0123
 tm1637DisplayDecimalTrim(123, 0);  //_123
 /* USER CODE END 2 */

2.TM1637에 0.1초 간격으로 1씩 업카운트를 하는데, tm1637DisplayDecimalTrim함수를 이용해서 출력하시오!(0~9999까지만 출력하시오)

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 int cnt = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  tm1637DisplayDecimalTrim(cnt, 0);
	  cnt++;
	  //cnt가 9999를 초과하면 다시 0으로 초기화한다!
	  if(cnt > 9999) cnt = 0;
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.예제2와 동일한데, 0부터 출발해서 음의 방향으로 1씩 다운카운트를하고 (-999 ~ 0)

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 int cnt = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  tm1637DisplayDecimalTrim(cnt, 0);
	  cnt--;
	  //cnt가 -999를 미만이 되면 0으로 초기화한다!
	  if(cnt < -999) cnt = 0;
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.tm1637SetRawSegment함수를 이용해서 왼쪽부터 1번 FND는 0b0001자리만 ON하고, 2번은 0b0010만 ON하고, 3번은 0b0100만 ON하고 4번은 0b1000만 ON하도록 하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 tm1637SetRawSegment(0,0b0001);
 tm1637SetRawSegment(1,0b0010);
 tm1637SetRawSegment(2,0b0100);
 tm1637SetRawSegment(3,0b1000);
 /* USER CODE END 2 */

5.이번에는 숫자패턴은 출력하지말고 4개의 FND의 소수점을 표시하는 dp만 모조리 다 출력하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 tm1637SetRawSegment(0,0b10000000);
 tm1637SetRawSegment(1,0b10000000);
 tm1637SetRawSegment(2,0b10000000);
 tm1637SetRawSegment(3,0b10000000);
 /* USER CODE END 2 */

6.TM1637에 붙은 FND4개의 테두리를 이용해서 시계방향으로 빙글빙글 돌아가는 듯한 효과를 연출하시오!

/* USER CODE BEGIN 2 */
 int nockanda_i = 0;
 uint8_t nockanda_array[][4] = {
	  {0b00000001, 0b00000000, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000001, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000001, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000001},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000010},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000100},
	  {0b00000000, 0b00000000, 0b00000000, 0b00001000},
	  {0b00000000, 0b00000000, 0b00001000, 0b00000000},
	  {0b00000000, 0b00001000, 0b00000000, 0b00000000},
	  {0b00001000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00010000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00100000, 0b00000000, 0b00000000, 0b00000000}
 };
 //TM1637 시작~
 tm1637Init();
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  for(int j = 0;j<4;j++){
		  tm1637SetRawSegment(j,nockanda_array[nockanda_i][j]);
	  }
	  nockanda_i++;
	  if(nockanda_i == 12) nockanda_i = 0;
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PB1버튼을 누르면 예제6이 시계방향으로 회전하고, PA8을 누르면 반시계방향으로 회전하도록 하시오!

/* USER CODE BEGIN 2 */
 int nockanda_i = 0;
 uint8_t nockanda_array[][4] = {
	  {0b00000001, 0b00000000, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000001, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000001, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000001},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000010},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000100},
	  {0b00000000, 0b00000000, 0b00000000, 0b00001000},
	  {0b00000000, 0b00000000, 0b00001000, 0b00000000},
	  {0b00000000, 0b00001000, 0b00000000, 0b00000000},
	  {0b00001000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00010000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00100000, 0b00000000, 0b00000000, 0b00000000}
 };
 int direct = 0; //0이면 시계 1이면 반시계
 //TM1637 시작~
 tm1637Init();
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  direct = 0;
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  direct = 1;
	  }
	  for(int j = 0;j<4;j++){
		  tm1637SetRawSegment(j,nockanda_array[nockanda_i][j]);
	  }
	  if(direct == 0){
		  nockanda_i++;
		  if(nockanda_i == 12) nockanda_i = 0;
	  }else if(direct == 1){
		  nockanda_i--;
		  if(nockanda_i == -1) nockanda_i = 11;
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.PB1버튼을 누르면 1씩 업카운트되고, PA8버튼을 누르면 1씩 다운카운트 되고, PB2를 누르면 0으로 초기화하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 int cnt = 0;
 //초기값 출력하기~
 tm1637DisplayDecimalTrim(cnt,0);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  cnt++;
		  tm1637DisplayDecimalTrim(cnt,0);
		  HAL_Delay(300);//채터링방지
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  cnt--;
		  tm1637DisplayDecimalTrim(cnt,0);
		  HAL_Delay(300);//채터링방지
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  cnt = 0;
		  tm1637DisplayDecimalTrim(cnt,0);
		  HAL_Delay(300);//채터링방지
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.PA11과 PA12에 연결된 로터리 엔코더를 시계방향으로 돌리면 1씩 업카운트, 반시계방향으로 돌리면 1씩 다운카운트, PC7이 로터리엔코더 스위치인데 누르면 0으로 초기화하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 int cnt = 0;
 //초기값 출력하기~
 tm1637DisplayDecimalTrim(cnt,0);
 uint8_t old_rot_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  cnt = 0;
		  tm1637DisplayDecimalTrim(cnt,0);
	  }
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  cnt--;
		  }else{
			  //CW
			  cnt++;
		  }
		  tm1637DisplayDecimalTrim(cnt,0);
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

10.PA0에 연결된 12BIT 가변저항값을 TM1637에 그대로 출력하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  tm1637DisplayDecimalTrim(adc_value0,0);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

11.예제10에서 측정한 가변저항값을 전압으로 환산해서 TM1637에 소수점을 포함해서 출력하시오!

/* USER CODE BEGIN 2 */
 //TM1637 시작~
 tm1637Init();
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  float voltage = 3.3*adc_value0/4095;
		  voltage = voltage * 100; //FND에 출력하기 위한 용도
		  tm1637DisplayDecimalTrim((int)voltage, 1);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

12.예제6번과 예제9번을 합쳐서 로터리엔코더를 돌리면 시계나 반시계방향으로 빙글빙글 돌아가는 효과를 연출하시오!

/* USER CODE BEGIN 2 */
 int nockanda_i = 0;
 uint8_t nockanda_array[][4] = {
	  {0b00000001, 0b00000000, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000001, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000001, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000001},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000010},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000100},
	  {0b00000000, 0b00000000, 0b00000000, 0b00001000},
	  {0b00000000, 0b00000000, 0b00001000, 0b00000000},
	  {0b00000000, 0b00001000, 0b00000000, 0b00000000},
	  {0b00001000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00010000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00100000, 0b00000000, 0b00000000, 0b00000000}
 };
 //초기패턴출력
 for(int j = 0;j<4;j++){
	  tm1637SetRawSegment(j,nockanda_array[0][j]);
 }
 //TM1637 시작~
 tm1637Init();
 uint8_t old_rot_A = 0;
/* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */

 while (1)
 {
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  //패턴이 반시계방향으로 1씩 움직인다
			  nockanda_i--;
			  if(nockanda_i == -1) nockanda_i = 11;
		  }else{
			  //CW
			  //패턴이 시계방향으로 1씩 움직인다
			  nockanda_i++;
			  if(nockanda_i == 12) nockanda_i = 0;
		  }
		  for(int j = 0;j<4;j++){
			  tm1637SetRawSegment(j,nockanda_array[nockanda_i][j]);
		  }
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(1);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

13.로터리엔코더를 돌려서 0~10의 범위로 값을 결정하고, 스위치를 누르면 녹칸다쿠쿠가 밥을 짓기 시작하는데, 지정된 시간에서 1초마다 1씩 다운카운트된다! 시간이 0이되면 TM1637에 빙글빙글 돌아가는 패턴이 나오도록하시오! 밥이 다되면 부저에서 도레미파솔라시도가 LED가 빙글빙글 돌아가는 타이밍에 맞춰서 출력되도록 하시오!

static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1;
   TIM3->CCR3 = (TIM3->ARR >> 1);
}
static void noTone()
{
   TIM3->CCR3 = 0;
}
#define NOTE_C6  1047
#define NOTE_D6  1175
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_G6  1568
#define NOTE_A6  1760
#define NOTE_B6  1976
#define NOTE_C7  2093
uint8_t melody_i = 0;
uint16_t melody[] = {NOTE_C6,NOTE_D6,NOTE_E6,NOTE_F6,NOTE_G6,NOTE_A6,NOTE_B6,NOTE_C7};

/* USER CODE BEGIN 2 */
 int nockanda_i = 0;
 uint8_t nockanda_array[][4] = {
	  {0b00000001, 0b00000000, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000001, 0b00000000, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000001, 0b00000000},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000001},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000010},
	  {0b00000000, 0b00000000, 0b00000000, 0b00000100},
	  {0b00000000, 0b00000000, 0b00000000, 0b00001000},
	  {0b00000000, 0b00000000, 0b00001000, 0b00000000},
	  {0b00000000, 0b00001000, 0b00000000, 0b00000000},
	  {0b00001000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00010000, 0b00000000, 0b00000000, 0b00000000},
	  {0b00100000, 0b00000000, 0b00000000, 0b00000000}
 };
 //초기패턴출력
 for(int j = 0;j<4;j++){
	  tm1637SetRawSegment(j,nockanda_array[0][j]);
 }
 //TM1637 시작~
 tm1637Init();
 uint8_t old_rot_A = 0;
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 uint8_t task_run = 0;
 uint8_t task_run2 = 0;
 uint32_t t = 0;

 int nockanda_cnt = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(task_run2){
		  if(HAL_GetTick() - t >= 100){
			  t = HAL_GetTick();
			  for(int j = 0;j<4;j++){
				  tm1637SetRawSegment(j,nockanda_array[nockanda_i][j]);
			  }
			  nockanda_i++;
			  if(nockanda_i == 12) nockanda_i = 0;
			  //부저 재생하기
			  Tone(melody[melody_i]);
			  melody_i++;
			  if(melody_i > 8) melody_i = 0;
		  }
	  }
	  if(task_run){
		  //task가 시작되면 1000밀리초 간격마다 걸리는 조건문
		  if(HAL_GetTick() - t >= 1000){
			  t = HAL_GetTick();
			  nockanda_cnt--;
			  tm1637DisplayDecimalTrim(nockanda_cnt,0);
			  if(nockanda_cnt == 0){
				  //탈출조건
				  task_run2 = 1;//LED빙글빙글 돌리는 작업
				  melody_i = 0;
				  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1); //부저ON
				  task_run = 0;
			  }
		  }
	  }

	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  //카운트가 0보다 크면서 task가 실행중이 아니라면~
		  if(nockanda_cnt > 0 && task_run == 0 && task_run2 == 0){
			  task_run = 1;
		  }
		  task_run2 = 0; //스위치 누르면 종료
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0); //부저종료
		  HAL_Delay(300);
	  }
	  if(task_run2 == 0){
		  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
		  if(now_rot_A == 1 && old_rot_A == 0){
			  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
			  if(now_rot_B){
				  //CCW
				  nockanda_cnt--;
				  if(nockanda_cnt < 0) nockanda_cnt = 0;
			  }else{
				  //CW
				  nockanda_cnt++;
				  if(nockanda_cnt > 10) nockanda_cnt = 10;
			  }
			  tm1637DisplayDecimalTrim(nockanda_cnt,0);
		  }
		  old_rot_A = now_rot_A;
		  HAL_Delay(1);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#12] I2C버전의 1602LCD를 STM32f103rb nucleo에 연결해서 디스플레이에 다양한 센서값 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 19 Nov 2025 19:34:17 +0900

https://youtube.com/live/64BtomW26XQ

[STM32#12] I2C버전의 1602LCD를 STM32f103rb nucleo에 연결해서 디스플레이에 다양한 센서값 출력하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g399b448d9bb_1_162#slide=id.g399b448d9bb_1_162

이번편은 1602LCD입니다~!

(i2c 설정)

(연결도)

(LCD사용을 위한 기본 추가 코드)

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}
#define ADDRESS   0x27<<1
#define RS1_EN1   0x05
#define RS1_EN0   0x01
#define RS0_EN1   0x04
#define RS0_EN0   0x00
#define BackLight 0x08
// RS-Q0 / RW-Q1 / EN-Q2 / BackLight-Q3 / D4-Q4 / D5-Q5 / D6-Q6 / D7-Q7
void LCD_DATA(uint8_t data) {
 uint8_t temp=(data & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(data & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((data << 4) & 0xF0)|RS1_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp = ((data << 4) & 0xF0)|RS1_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD(uint8_t cmd) {
 uint8_t temp=(cmd & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=(cmd & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(4);
 temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_CMD_4bit(uint8_t cmd) {
 uint8_t temp=((cmd << 4) & 0xF0)|RS0_EN1|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 temp=((cmd << 4) & 0xF0)|RS0_EN0|BackLight;
 while(HAL_I2C_Master_Transmit(&hi2c1, ADDRESS, &temp, 1, 1000)!=HAL_OK);
 delay_us(50);
}
void LCD_INIT(void) {
 delay_ms(100);
 LCD_CMD_4bit(0x03); delay_ms(5);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x03); delay_us(100);
 LCD_CMD_4bit(0x02); delay_us(100);
 LCD_CMD(0x28);  // 4 bits, 2 line, 5x8 font
 LCD_CMD(0x08);  // display off, cursor off, blink off
 LCD_CMD(0x01);  // clear display
 delay_ms(3);
 LCD_CMD(0x06);  // cursor movint direction
 LCD_CMD(0x0C);  // display on, cursor off, blink off
}
void LCD_XY(char x, char y) {
 if      (y == 0) LCD_CMD(0x80 + x);
 else if (y == 1) LCD_CMD(0xC0 + x);
 else if (y == 2) LCD_CMD(0x94 + x);
 else if (y == 3) LCD_CMD(0xD4 + x);
}
void LCD_CLEAR(void) {
 LCD_CMD(0x01);
 delay_ms(2);
}
void LCD_PUTS(char *str) {
 while (*str) LCD_DATA(*str++);
}

(LCD관련 함수)

LCD_INIT(); //I2C 1602LCD를 초기화한다!

LCD_XY(char x, char y); //LCD에서 입력커서의 위치를 결정한다!

LCD_XY(0, 0); //LCD의 좌측상단 모서리부터 문자를 순서대로 출력하겠다!

LCD_XY(0, 1); //LCD의 좌측하단 모서리부터 문자를 순서대로 출력하겠다!

LCD_CLEAR(); //LCD에 입력되어있는 모든 문자열을 지워버린다!

LCD_PUTS(char *str); //입력된 문자열을 커서의 시작위치부터 해서 순서대로 출력한다!(실제로 화면에 글자가 보인다)

1.STM32프로젝트를 생성하고 IOC에서 I2C통신을 활성화한다음 첫번째줄에는 “NOCKANDA”라고 출력하고 두번째 줄에는 “STM32 TEST!”라고 출력하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 //예제1번에 지정된 문자열을 커서위치를 잡으면서 출력한다!
 LCD_XY(0, 0); LCD_PUTS("NOCKANDA        ");
 LCD_XY(0, 1); LCD_PUTS("STM32 TEST!     ");
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //메인루프는 아무것도 할게 없음!
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.STM32에서 1초간격으로 1씩 증가하는 변수가 있다! 이 값을 첫번째 줄에 “CNT = ????”형식으로 출력하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 int cnt = 0;//카운터
 char buff[20]; //가변적인 문자열을 저장할 버퍼
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //cnt변수값을 %d자리에 넣어서 문자열을 생성한다음 buff에 입력한다!
	  sprintf(buff,"CNT = %05d",cnt);
	  //LCD에 buff에 들어있는값을 출력한다!
	  LCD_XY(0, 0); LCD_PUTS(buff);
	  cnt++;
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.PB1에 연결된버튼을 누르면 LCD의 첫번째줄에 BTN1 PRESSED!라고 출력되고, PA8에 연결된 버튼을 누르면 BTN2 PRESSED!라고 출력되도록 하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  LCD_XY(0, 0); LCD_PUTS("BTN1 PRESSED!   ");
		  HAL_Delay(300);
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  LCD_XY(0, 0); LCD_PUTS("BTN2 PRESSED!   ");
		  HAL_Delay(300);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.버튼8개를 모두 이용해서, LCD화면에 아래와 같은 형식으로 출력하시오!(버튼8개의 상태를 2진수로 출력해라!)
    00000000 : 모든 버튼이 안눌려지고있다!
    11110000 : 1~4까지는 눌려지고있고, 5~8까지는 안눌려지고있음!
    10101010 : 홀수번째 버튼만 눌려지고 있는 상태임!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 char buff[20];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초간격으로 버튼1~8까지의 상태를 변수에 저장해서 한번에 출력한다!
	  uint8_t btn1 = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
	  uint8_t btn2 = !HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8);
	  uint8_t btn3 = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
	  uint8_t btn4 = !HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6);
	  uint8_t btn5 = !HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5);
	  uint8_t btn6 = !HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7);
	  uint8_t btn7 = !HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  uint8_t btn8 = !HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
	  sprintf(buff,"%d%d%d%d%d%d%d%d",btn1,btn2,btn3,btn4,btn5,btn6,btn7,btn8);
	  LCD_XY(0, 0); LCD_PUTS(buff);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.쉴드에 붙어있는 로터리엔코더를 시계방향으로 돌리면 값이 1씩 증가하고, 반시계방향으로 돌리면 값이 1씩 감소하도록 해서 두번째 라인에 출력하고 첫번째줄에는 그냥 할게없으니 “NOCKANDA EX5”라고 출력하시오! 그리고 PC7에 연결된 스위치를 누르면 카운터값이 0으로 초기화되도록 하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 char buff[20];
 int cnt = 0;
 uint8_t old_rot_A = 0;
 LCD_XY(0, 0); LCD_PUTS("NOCKANDA! EX5!!!");
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA11에 A가 연결되었고 PA12에 B가 연결되었다!
	  //A의 상승엣지가 발생했을때 B의 상태가 HIGH면 CCW, LOW면 CW이다!
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  cnt--;
		  }else{
			  //CW
			  cnt++;
		  }
		  sprintf(buff,"CNT = %05d",cnt);
		  LCD_XY(0, 1); LCD_PUTS(buff);
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(10);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  cnt = 0;
		  sprintf(buff,"CNT = %05d",cnt);
		  LCD_XY(0, 1); LCD_PUTS(buff);
		  HAL_Delay(300);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.예제5와 동일하게 작동이 되는데, 증감되는 변수가 실수형이고 값을 0.5씩 증감되도록 하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 char buff[20];
 float cnt = 0;
 uint8_t old_rot_A = 0;
 LCD_XY(0, 0); LCD_PUTS("NOCKANDA! EX6!!!");
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA11에 A가 연결되었고 PA12에 B가 연결되었다!
	  //A의 상승엣지가 발생했을때 B의 상태가 HIGH면 CCW, LOW면 CW이다!
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  cnt -= 0.5;
		  }else{
			  //CW
			  cnt += 0.5;
		  }
		  //정수부3자리, 실수부1자리
		  //sprintf(buff,"CNT = %3.1f",cnt);
		  sprintf(buff,"CNT = %3d.%1d",(int)cnt,abs(((int)(cnt*10))%10));
		  LCD_XY(0, 1); LCD_PUTS(buff);
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(1);
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  cnt = 0;
		  sprintf(buff,"CNT = %3d.%1d",(int)cnt,abs(((int)(cnt*10))%10));
		  LCD_XY(0, 1); LCD_PUTS(buff);
		  HAL_Delay(300);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PA0에 연결된 가변저항값을 측정해서 0~4095 범위로 두번쨰 줄에 값을 출력하고 첫번째 줄에는 적당한 문구를 출력하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[20];
 LCD_XY(0, 0); LCD_PUTS("NOCKANDA! EX7!!!");
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초 간격으로 가변저항값을 측정해서 출력한다!
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  sprintf(buff,"ROTARY = %4d",adc_value0);
		  LCD_XY(0, 1); LCD_PUTS(buff);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.PA0에 연결된 가변저항과 PA1에 연결된 CDS값을 동시에 측정해서 1602LCD의 두번째줄에 전압으로 나란하게 출력하시오!

/* USER CODE BEGIN 2 */
 LCD_INIT(); //1회호출(메인루프 시작전)
 float a0 = 0;
 float a1 = 0;
 char buff[20];
 LCD_XY(0, 0); LCD_PUTS("NOCKANDA! EX7!!!");
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  a0 = 3.3*HAL_ADC_GetValue(&hadc1)/4095; //0.0~3.3
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
     a1 = 3.3*HAL_ADC_GetValue(&hadc1)/4095; //0.0~3.3
	  sprintf(buff,"PA0=%.1f,PA1=%.1f",a0,a1);
	  LCD_XY(0, 1); LCD_PUTS(buff);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#11] L293D 모터드라이버를 이용해서 DC모터를 정역제어하고 PWM출력으로 속도제어하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 17 Nov 2025 23:05:20 +0900

[STM32#11] L293D 모터드라이버를 이용해서 DC모터를 정역제어하고 PWM출력으로 속도제어하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3a44d9dbe16_1_0#slide=id.g3a44d9dbe16_1_0

이번편은 모터드라이버와 DC모터입니다~!

1.STM32에 연결된 L293D에 DC모터를 연결하고 속도는 항상 100으로 고정하고 PB1버튼을 누르면 모터가 역회전, PA8버튼을 누르면 브레이크, PB2버튼을 누르면 정회전 하도록 하시오!(EN1핀을 PWM제어하지 않음)

/* USER CODE BEGIN 2 */
 //속도는 항상 100이다!
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, 1);
 //기본 모터는 브레이크 상태
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 역회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  //IN1이 0이고 IN2가 1일때
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
	  }
	  //PA8을 누르면 정지
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  //둘다 0일떄
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
	  }
	  //PB2를 누르면 정회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  //IN1이 1이고 IN2가 0일때
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.이번에는 DC모터가 항상 정회전으로 설정되어있고 PB1을 누르면 속도가 0%가되고 PA8을 누르면 50%가되고, PB2를 누르면 100%가 되도록 하시오!(주파수490hz)

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
 //무조건 정회전
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 //시작하자 마자 속도는 0
 TIM2->CCR3 = 0; //0~255
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 속도는 0으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  TIM2->CCR3 = 0;
	  }
	  //PA8을 누르면 속도는 50으로 설정
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  TIM2->CCR3 = 128;
	  }
	  //PB2를 누르면 속도를 100으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  TIM2->CCR3 = 255;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.속도제어될때 사람귀에 들리는 가청주파수 밖의 범위로 주파수를 설정해서 듀티비로 속도제어하시오!(20khz)

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
 //무조건 정회전
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 //시작하자 마자 속도는 0
 TIM2->CCR3 = 0; //0~255
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 속도는 0%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  TIM2->CCR3 = 0;
	  }
	  //PA8을 누르면 속도는 78%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  TIM2->CCR3 = 200;
	  }
	  //PB2를 누르면 속도를 100%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  TIM2->CCR3 = 255;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.STM32에서 CCR에 입력하는 값으로 0~100을 입력했을때 DC모터의 속도가 0~100%구간으로 조절되도록 설정하시오!

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
 //무조건 정회전
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 //시작하자 마자 속도는 0
 TIM2->CCR3 = 0; //0~100
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 속도는 0%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  TIM2->CCR3 = 0;
	  }
	  //PA8을 누르면 속도는 50%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  TIM2->CCR3 = 80;
	  }
	  //PB2를 누르면 속도를 100%으로 설정
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  TIM2->CCR3 = 100;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.PA0에 연결된 가변저항의 노브를 0~100%사이로 조절했을때 DC모터의 속도가 결정되고, PB1을 누르면 역회전설정, PA8을 누르면 브레이크, PB1을 누르면 정회전으로 설정되도록 하시오!(주파수490hz)

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3);
 HAL_ADC_Start(&hadc1);
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 //시작하자 마자 속도는 0
 TIM2->CCR3 = 0; //0~255
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  TIM2->CCR3 = 255*adc_value0/4095; //0~255
	  }
	  HAL_Delay(10); //ADC입력간격으로 0.01초유지
	  //PB1을 누르면 역회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
	  }
	  //PA8을 누르면 브레이크
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
	  }
	  //PB2를 누르면 정회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.모터드라이버의 채널2번에 DC모터를 하나더 추가하고 예제5의 결과와 동일하게 바퀴 2개를 동시에 제어하시오!

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3); //모터1
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); //모터2
 HAL_ADC_Start(&hadc1);
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  TIM2->CCR3 = 255*adc_value0/4095; //0~255
		  TIM3->CCR1 = 255*adc_value0/4095; //0~255
	  }
	  HAL_Delay(10); //ADC입력간격으로 0.01초유지
	  //PB1을 누르면 역회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }

	  //PA8을 누르면 브레이크
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }
	  //PB2를 누르면 정회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.예제6번에서 PB6버튼을 누르면 모터1과 2가 둘다 정회전하고, PC5를 누르면 모터1과 모터2가 둘다 역회전하도록 하시오!

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3); //모터1
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); //모터2
 HAL_ADC_Start(&hadc1);
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  TIM2->CCR3 = 255*adc_value0/4095; //0~255
		  TIM3->CCR1 = 255*adc_value0/4095; //0~255
	  }
	  HAL_Delay(10); //ADC입력간격으로 0.01초유지
	  //PB1을 누르면 전진
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }

	  //PA8을 누르면 브레이크
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }
	  //PB2를 누르면 후진
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
	  }
	  //PB6를 누르면 g턴1
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }
	  //PC5를 누르면 g턴2
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.로터리엔코더를 시계방향으로 살짝 돌려서 팅구면 녹칸다의 자동차가 D모드가 되면서 모터1은 정회전, 모터2는 역회전하면서 전진한다, 반시계방향으로 딱 팅구면 R모드가 되면서 모터1은 역회전, 모터2는 정회전하면서 후진한다, 로터리엔코더를 누르면 P모드가 되면서 멈춘다!(녹칸다의 전기차)

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3); //모터1
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); //모터2
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
 //속도는 최대
 TIM2->CCR3 = 255; //0~255
 TIM3->CCR1 = 255; //0~255
 uint8_t old_rot_A = 0;
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1); //LED(P)
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //A핀의 rising edge를 검출한다
	  //rising edge가 발생했을때 B의 신호가 HIGH면 CCW, LOW면 CW방향!
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW R모드
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 1); //LED(R)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0); //LED(P)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0); //LED(D)
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4

		  }else{
			  //CW D모드
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 0); //LED(R)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0); //LED(P)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 1); //LED(D)
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
		  }
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(10); //로터리엔코더 노이즈 방지용
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  //P모드
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 0); //LED(R)
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1); //LED(P)
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0); //LED(D)
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.예제8에서 동일한 조건인데, 속도는 처음에 0으로 시작해서 로터리엔코더의 스위치를 계속 누르고 있으면 1씩 증가해서 최대 255까지 올라간다! 그리고 누르고있다가 떼면 감소해서 0으로 내려온다!

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3); //모터1
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); //모터2
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
 //속도는 0으로 시작
 int speed = 0;
 TIM2->CCR3 = 0; //0~255
 TIM3->CCR1 = 0; //0~255
 uint8_t old_rot_A = 0;
 HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1); //LED(P)
 int mode = 1; //0이면 R, 1이면 P, 2이면 D
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //A핀의 rising edge를 검출한다
	  //rising edge가 발생했을때 B의 신호가 HIGH면 CCW, LOW면 CW방향!
	  uint8_t now_rot_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_rot_A == 1 && old_rot_A == 0){
		  uint8_t now_rot_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_rot_B){
			  //CCW
			  mode--;
			  if(mode < 0) mode = 0;

		  }else{
			  //CW
			  mode++;
			  if(mode > 2) mode = 2;
		  }
		  if(mode == 0){
			  //R
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 1); //LED(R)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0); //LED(P)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0); //LED(D)
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
		  }else if(mode == 1){
			  //P
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 0); //LED(R)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1); //LED(P)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0); //LED(D)
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4

		  }else if(mode == 2){
			  //D
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, 0); //LED(R)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0); //LED(P)
			  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 1); //LED(D)
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
		  }
	  }
	  old_rot_A = now_rot_A;
	  HAL_Delay(10); //로터리엔코더 노이즈 방지용
	  if(mode == 1){
		  //속도0
		  speed = 0;
		  TIM2->CCR3 = 0; //0~255
		  TIM3->CCR1 = 0; //0~255
	  }else{
		  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
			  //누르고있음 속도가 1씩 증가(최대값255)
			  speed++;
			  if(speed > 255) speed = 255;
			  TIM2->CCR3 = speed; //0~255
			  TIM3->CCR1 = speed; //0~255
		  }else{
			  //안누르고있음 속도가 1씩 감소(최소값0)
			  speed--;
			  if(speed < 0) speed = 0;
			  TIM2->CCR3 = speed; //0~255
			  TIM3->CCR1 = speed; //0~255
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

10.녹칸다가 터미널에서 usart2로 문자 ‘0’을 전송하면 모터2개는 멈춘다! ‘1’을 전송하면 정회전하고 ‘2’를 전송하면 역회전하도록 하시오!(이때 속도는 최대속도)

/* USER CODE BEGIN 2 */
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_3); //모터1
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_1); //모터2
 //초기상태(브레이크, 속도0)
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
 TIM2->CCR3 = 255; //0~255
 TIM3->CCR1 = 255; //0~255
 char recv;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //시리얼입력으로 문자 1개를 받아서 '0','1','2'를 구분한다!
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  if(recv == '0'){
			  //브레이크
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
			  HAL_UART_Transmit(&huart2, "P mode!\n", 8, 100);


		  }else if(recv == '1'){
			  //정회전
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 0); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 0); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 1); //IN4
			  HAL_UART_Transmit(&huart2, "D mode!\n", 8, 100);
		  }else if(recv == '2'){
			  //역회전
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0); //IN1
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, 1); //IN2
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, 1); //IN3
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_9, 0); //IN4
			  HAL_UART_Transmit(&huart2, "R mode!\n", 8, 100);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#10] 스탭모터(28byj-48)를 폴링방식과 타이머인터럽트(TIM2 global interrupt)를 이용한 방식으로 각도제어 해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 12 Nov 2025 18:28:20 +0900

https://youtube.com/live/bcttbM80CgY

[STM32#10] 스탭모터(28byj-48)를 폴링방식과 타이머인터럽트(TIM2 global interrupt)를 이용한 방식으로 각도제어 해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3a1f238c87f_1_154#slide=id.g3a1f238c87f_1_154

이번편은 9편에 이어서 스탭모터(28byj-48)를 위치제어, 속도제어 해보도록 한다!

1.예를들어 버튼1을 계속 누르고 있으면 "누르고 있는 동안”에 스탭모터가 시계방향으로 회전하고 버튼2를 계속 누르고 있으면 “누르는 동안” 반시계방향으로 회전한다!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
//0이면 정지, 1이면 정회전, -1이면 역회전
int direct = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(direct == 1){
		//정회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
	}else if(direct == -1){
		//역회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 direct가 1이되고 안누르면 0이된다!
	  //PA8을 누르면 direct가 -1이되고 안누르면 0이된다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  //정회전
		  direct = 1;
	  }else if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  //역회전
		  direct = -1;
	  }else{
		  //정지
		  direct = 0;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.예제1에서 스탭모터의 현재 위치값을 100밀리초간격으로 시리얼출력해서 PC에서 스탭모터의 현재 위치를 알 수 있도록 하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
//0이면 정지, 1이면 정회전, -1이면 역회전
int direct = 0;
int32_t now_pos = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(direct == 1){
		//정회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
		now_pos++;
	}else if(direct == -1){
		//역회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
		now_pos--;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 uint32_t nockanda_t = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초 간격으로 전송한다
	  if(HAL_GetTick()-nockanda_t > 100){
		  nockanda_t = HAL_GetTick();
		  //녹칸다가 위치를 계속 올려서 32000정도를 넘겼을때 이상한값이 나온다면 %d가 아닌것이다!
		  sprintf(buff,"now_pos = %d\n",now_pos);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  //PB1을 누르면 direct가 1이되고 안누르면 0이된다!
	  //PA8을 누르면 direct가 -1이되고 안누르면 0이된다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  //정회전
		  direct = 1;
	  }else if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  //역회전
		  direct = -1;
	  }else{
		  //정지
		  direct = 0;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.로터리엔코더(PA11,PA12)를 시계방향으로 회전하면 스탭모터도 시계방향으로 회전하고 반시계방향이면 반시계방향으로 회전한다!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int32_t now_pos = 0;
int32_t target_pos = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(now_pos < target_pos){
		//정회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
		now_pos++;
	}else if(now_pos > target_pos){
		//역회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
		now_pos--;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 uint32_t nockanda_t = 0;
 char buff[50];
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초 간격으로 전송한다
	  if(HAL_GetTick()-nockanda_t > 100){
		  nockanda_t = HAL_GetTick();
		  //녹칸다가 위치를 계속 올려서 32000정도를 넘겼을때 이상한값이 나온다면 %d가 아닌것이다!
		  sprintf(buff,"now_pos = %d, target_pos = %d\n",now_pos, target_pos);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  //A의 상승엣지가 검출되었을때 B가 LOW면 시계방향, HIGH면 반시계방향
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_A == 1 && old_A == 0){
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_B == 0){
			  //시계
			  target_pos += 8;
		  }else{
			  //반시계
			  target_pos -= 8;
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.예제3번처럼 로터리엔코더를 돌리면 실시간으로 따라가는게 아니라 로터리엔코더에 붙어있는 스위치(PC7)를 눌렀을때 스탭모터가 회전되도록 하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int32_t now_pos = 0;
int32_t target_pos = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(now_pos < target_pos){
		//정회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
		now_pos++;
	}else if(now_pos > target_pos){
		//역회전 시퀀스를 전송한다
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
		now_pos--;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 uint32_t nockanda_t = 0;
 char buff[50];
 uint8_t old_A = 0;
 int32_t rotary_pos = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100밀리초 간격으로 전송한다
	  if(HAL_GetTick()-nockanda_t > 100){
		  nockanda_t = HAL_GetTick();
		  sprintf(buff,"now_pos = %d, rotary_pos = %d\n",now_pos, rotary_pos);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  //PC7을 누르면 rotary_pos가 target_pos로 copy된다
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  target_pos = rotary_pos;
	  }
	  //A의 상승엣지가 검출되었을때 B가 LOW면 시계방향, HIGH면 반시계방향
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_A == 1 && old_A == 0){
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_B == 0){
			  //시계
			  rotary_pos += 8;
		  }else{
			  //반시계
			  rotary_pos -= 8;
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.스탭모터가 시계방향으로 항상 회전을 하는데, 버튼1을 누르면 타이머인터럽트의 주기가 1.5밀리초로하고, 버튼2를 누르면 800마이크로초로하고, 버튼3을 누르면 10밀리초로 하시오!(TIM2의 ARR을 수정)

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	for(int i = 0;i<4;i++){
		HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
	}
	seq_num++;
	if(seq_num == 8) seq_num = 0;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 ARR이 1500-1이 된다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  TIM2->ARR = 1500-1;
	  }
	  //PA8을 누르면 ARR이 800-1이 된다
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  TIM2->ARR = 800-1;
	  }
	  //PB2을 누르면 ARR이 10000-1이 된다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  TIM2->ARR = 10000-1;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.버튼1을 누르면 스탭모터가 반시계방향으로 회전한다! 버튼2를 누르면 정지한다! 버튼3을 누르면 시계방향으로 회전한다! 이때 가변저항을 이용해서 속도를 0.8밀리초~10밀리초 범위로 조절하시오!(속도제어)

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int direct = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(direct == 1){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
	}else if(direct == -1){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 HAL_ADC_Start(&hadc1);
 uint16_t adc_value0 = 0;
 uint32_t nockanda_t = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GetTick() - nockanda_t > 100){
		  nockanda_t = HAL_GetTick();
		  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
		  {
			  // 값 처리
			  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
			  //0 ~ 4095구간을 10000 ~ 800으로 바꾼다
			  adc_value0 = 10000 - (10000-800) * adc_value0 / 4095.0;
			  sprintf(buff,"A0 = %d\n",adc_value0);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
			  if(adc_value0 >= 800 && adc_value0 <= 10000){
				  TIM2->ARR = adc_value0;
			  }
		  }
	  }
	  //PB1을 누르면 역회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  direct = -1;
	  }
	  //PA8을 누르면 정지
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  direct = 0;
	  }
	  //PB2을 누르면 정회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  direct = 1;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.녹칸다가 스탭모터의 목표위치를 putty에서 입력한다! 그 목표 위치대로 스탭모터가 회전하도록 하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int32_t now_pos = 0;
int32_t target_pos = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(now_pos < target_pos){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
		now_pos++;
	}else if(now_pos > target_pos){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
		now_pos--;
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 char rx_buff[50];
 char tx_buff[50];
 char recv = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //녹칸다가 입력한 숫자대로 스탭모터가 목표위치로 이동한다!
	  //녹칸다가 보낸 숫자를 그대로 echo해서 출력해라!
	  int rx_index = 0;
	  while(HAL_UART_Receive(&huart2, &recv, 1, 100) == HAL_OK){
		  rx_buff[rx_index] = recv;
		  rx_index++;
		  if(recv == '\r'){
			  //putty에서 마지막 종료문자가 왔다!
			  rx_buff[rx_index] = '\0';
			  sprintf(tx_buff,"SET TARGET_POS = %s\n",rx_buff);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			  target_pos = atoi(rx_buff);
			  break;
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.예제6에서 시계방향으로 회전할때 리미트스위치 역할을 버튼4가 하고, 반시계방향으로 회전할때 리미트스위치 역할을 버튼5가 할때 리미트스위치에 감지되면 스탭모터가 정지하도록 하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int32_t direct = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(direct == 1){
		if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 1){
			for(int i = 0;i<4;i++){
				HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
			}
			seq_num++;
			if(seq_num == 8) seq_num = 0;
		}
	}else if(direct == -1){
		if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 1){
			for(int i = 0;i<4;i++){
				HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
			}
			seq_num--;
			if(seq_num == -1) seq_num = 7;
		}
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 역회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  direct = -1;
	  }
	  //PA8을 누르면 정지
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  direct = 0;
	  }
	  //PB2을 누르면 정회전
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  direct = 1;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.로터리엔코더를 돌려서 LED 8개중 1개의 LED만 켜지도록 하고, LED가 현재 위치하고 있는 각도대로 스탭모터가 회전되도록 하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
		{0,0,0,1}, //1
		{0,0,1,1}, //2
		{0,0,1,0}, //3
		{0,1,1,0}, //4
		{0,1,0,0}, //5
		{1,1,0,0}, //6
		{1,0,0,0}, //7
		{1,0,0,1}  //8
};
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0; //0~7
int32_t now_pos = 0;
int32_t target_pos = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(now_pos < target_pos){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num++;
		if(seq_num == 8) seq_num = 0;
		now_pos++;
	}else if(now_pos > target_pos){
		for(int i = 0;i<4;i++){
			HAL_GPIO_WritePin(mygroup[i], mypin[i], seq[seq_num][i]);
		}
		seq_num--;
		if(seq_num == -1) seq_num = 7;
		now_pos--;
	}
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start_IT(&htim2);
 uint8_t old_A = 0;
 int32_t rotary_pos = 0;
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 char buff[50];
 int led_pos = 0;
 HAL_GPIO_WritePin(mygroup[0],mypin[0], 1);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
		  target_pos = rotary_pos;
	  }
	  //A의 상승엣지가 검출되었을때 B가 LOW면 시계방향, HIGH면 반시계방향
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(now_A == 1 && old_A == 0){
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(now_B == 0){
			  //시계
			  rotary_pos += 512;
			  led_pos++;
			  if(led_pos == 8) led_pos = 0;
		  }else{
			  //반시계
			  rotary_pos -= 512;
			  led_pos--;
			  if(led_pos == -1) led_pos = 7;
		  }
		  for(int i = 0;i<8;i++){
			  if(i == led_pos) HAL_GPIO_WritePin(mygroup[i],mypin[i], 1);
			  else HAL_GPIO_WritePin(mygroup[i],mypin[i], 0);
		  }
		  //현재 스탭모터의 각도(디그리)를 출력한다!
		  sprintf(buff,"degree = %d\n",360*rotary_pos/4096);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#09] 스탭모터(28byj-48)를 폴링방식과 타이머인터럽트(TIM2 global interrupt)를 이용한 방식으로 각도제어 해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 10 Nov 2025 23:13:50 +0900

https://youtube.com/live/p5zGr7EtAIY

[STM32#09] 스탭모터(28byj-48)를 폴링방식과 타이머인터럽트(TIM2 global interrupt)를 이용한 방식으로 각도제어 해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g3a1b0dc0a1e_1_75#slide=id.g3a1b0dc0a1e_1_75

이번편은 녹칸다의 STM32쉴드에 스탭모터(28bjy-48)와 드라이버(ULN2003)을 연결해서 각도를 제어해보도록 한다!

(스탭모터 제어신호)

(스탭모터 신호의 해석)

1.녹칸다가 제시한 표에서 빼기기호(-)가 있는건 HIGH신호이고 비워져있는건 LOW신호를 의미한다!
2.스탭모터제어에는 한 주기에 8개의 신호를 전송해야하는데, 1~8순으로 전송하면 시계(CW)방향, 8~1순으로 전송하면 반시계(CCW)방향으로 회전하게된다!
3.STM32에서는 HIGH신호를 숫자1로 해석하고, LOW신호를 숫자 0으로 해석한다!
4.그러면 보내줘야할 1번신호의 경우 IN1,IN2,IN3,IN4순서로 보았을때 IN1은 0, IN2는 0, IN3은 0, IN4는 1이라는 것을 전송해야함을 의미한다!
5.IN1이 PC10이고, IN2가 PC11이고, IN3이 PC12고, IN4가 PD2로 지정되어있으므로 해당되는 GPIO에 해당되는 신호가 타이밍에 맞게 출력되면 되는 것이다!
6.신호의 시퀀스를 빠르게 보내주면 모터가 빠르게 회전하고 천천히 보내주면 천천히 회전한다!
7.사용하는 스탭모터 자체가 고속으로 회전할수 없는 모터이기 때문에 하한값이 존재한다! (작동불능상태가 된다)
8.그러면 신호를 가장 빠르게 전송할 수 있는 간격이 몇이냐? (녹칸다도 모름)
9.시퀀스를 1~8순으로 순서대로 1개씩 보낼때 1씩 카운트를 한다면 4096회 전송했을때 스탭모터는 360도 회전한다!(한바퀴에 대한 스탭량이 4096이다)

(예제목차)

1.녹칸다와 함께 1차원배열과 2차원배열에 대해서 아주 간단히 알아보도록 하자!

//1-1)배열은 크기를 미리 정해두고 사용하는 것이다!
	//1-1)크기를 미리 정해두지 않더라도 추측이 가능하면 생략이 가능하다!
	uint8_t array1[8]; //8개의 배열을 생성하겠다!
	//배열을 생성하는데, 1부터 8까지 8개를 담을 배열을 만들어라!
	uint8_t array2[] = {1,2,3,4,5,6,7,8};
	//배열을 지정된 갯수대로 생성하고 초기값을 안넣어주면 확정적이지 않은 값이 들어갔다!
	//배열을 선언하면서 초기값으로 모두 0을 입력을 하고싶다!
	uint8_t array3[8] = {0};
	
	//메인함수 안에서는 배열값의 대입이 가능하지만, 밖에서는 불가능하다!
	array1[0] = 10;
	array1[1] = 20;

//1-2) 2차원배열은 엑셀과 같은 모양을 딱 떠올리면 된다!
 uint8_t array1[2][2]; //2*2 배열이 만들어진다!
 //2차원배열의 선언과 초기화는 두번째 차원의 갯수를 확정해야한다!
 //2차원배열의 두번째차원은 갯수가 가변적일 수 없다!
 uint8_t array2[][3] = {
		  {1,2,3},
		  {4,5,6}
 };
 //녹칸다가 array2에서 1,2,3과 4,5,6을 그릅으로 다루고자 한다면
 //아래와 같이 2중 loop로 순회할 수 있음!
 for(int i = 0;i<2;i++){
	  for(int j = 0;j<3;j++){
		  //array2[i][j]
		  //i=0,j=0 array2[0][0] : 1
		  //i=0,j=1 array2[0][1] : 2
		  //i=0,j=2 array2[0][2] : 3
		  /////////////////////////
		  //i=1,j=0 array2[1][0] : 4
		  //i=1,j=1 array2[1][1] : 5
		  //i=1,j=2 array2[1][2] : 6
	  }
 }

2.IOC에서 스탭모터 제어핀을 출력으로 설정하고 폴링방식으로 시계방향으로 한바퀴, 반시계방향으로 한바퀴 무한반복하는데 전송간격을 1밀리초로 하시오!

/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //시계방향으로 한바퀴 회전
	  //시퀀스 8개 보낸게 8회니까 8회세트를 512번하면 4096회이다!
	  for(int i = 0;i<512;i++){
		  for(int j =0;j<8;j++){
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_10,seq[j][0]);//IN1
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_11,seq[j][1]);//IN2
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_12,seq[j][2]);//IN3
			  HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,seq[j][3]);//IN4
			  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
		  }
	  }

	  //1초쉬고
	  HAL_Delay(1000);
	  //반시계방향으로 한바퀴 회전
	  for(int i = 0;i<512;i++){
		  for(int j =7;j>=0;j--){
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_10,seq[j][0]);//IN1
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_11,seq[j][1]);//IN2
			  HAL_GPIO_WritePin(GPIOC,GPIO_PIN_12,seq[j][2]);//IN3
			  HAL_GPIO_WritePin(GPIOD,GPIO_PIN_2,seq[j][3]);//IN4
			  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
		  }
	  }
	  //1초쉬고
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.예제2에서 IN1부터 IN4까지의 출력내용을 z-loop로 묶으시오!

/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
 uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //시계방향으로 한바퀴 회전
	  //시퀀스 8개 보낸게 8회니까 8회세트를 512번하면 4096회이다!
	  for(int i = 0;i<512;i++){
		  //시퀀스 1~8까지를 1밀리초 간격으로 연속으로 전송함!
		  for(int j =0;j<8;j++){
			  //IN1~IN4까지의 출력을 동시에 결정
			  for(int z = 0; z<4;z++){
				  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
			  }
			  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
		  }
	  }

	  //1초쉬고
	  HAL_Delay(1000);
	  //반시계방향으로 한바퀴 회전
	  for(int i = 0;i<512;i++){
		  for(int j =7;j>=0;j--){
			  for(int z = 0; z<4;z++){
				  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
			  }
			  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
		  }
	  }
	  //1초쉬고
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.기판에 붙어있는 버튼1번(PB1)을 누르면 스탭모터가 시계방향으로 360도 회전하고, 버튼2번(PA8)을 누르면 반시계방향으로 회전하는데, 버튼을 누를때마다 연속적으로 회전시키시오!( 블록킹 문제가 생기게됨)

/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
 uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 시계방향으로 회전한다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  for(int i = 0;i<512;i++){
			  //시퀀스 1~8까지를 1밀리초 간격으로 연속으로 전송함!
			  for(int j =0;j<8;j++){
				  //IN1~IN4까지의 출력을 동시에 결정
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
			  }
		  }
	  }


	  //PA8을 누르면 반시계방향으로 한바퀴 회전
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  for(int i = 0;i<512;i++){
			  for(int j =7;j>=0;j--){
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  HAL_Delay(1); //HAL_Delay가 지연할수 있는 최소 시간은 1밀리초이다!
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.예제4번에서 모터신호의 전송간격이 1밀리초인데, 더 내려서 최소로 보낼 수 있는 간격이 몇인지를 실험적으로 파악하시오!(모터마다 다를수있음)

#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
 return millis_cnt;
}
uint32_t micros() {
 return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
 if (us > 1) {
   uint32_t count = us * 7 - 6;
   while (count--);
 } else {
   uint32_t count = 2;
   while (count--);
 }
}

//delay_us관련 코드는 BEGIN 0쪽에 알아서 넣기~
/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
 uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 시계방향으로 회전한다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  for(int i = 0;i<512;i++){
			  //시퀀스 1~8까지를 1밀리초 간격으로 연속으로 전송함!
			  for(int j =0;j<8;j++){
				  //IN1~IN4까지의 출력을 동시에 결정
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }


	  //PA8을 누르면 반시계방향으로 한바퀴 회전
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  for(int i = 0;i<512;i++){
			  for(int j =7;j>=0;j--){
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.예제5번에서 버튼3(PB2)을 누르면 PB3에 연결된 LED가 ON되고, 버튼4(PB6)를 누르면 LED가 OFF되도록 하시오!(모터가 돌아가는중에닌 LED 제어가 안될텐데 일단 무시~)

/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
 uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,1);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,0);
	  }


	  //PB1을 누르면 시계방향으로 회전한다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  for(int i = 0;i<512;i++){
			  //시퀀스 1~8까지를 1밀리초 간격으로 연속으로 전송함!
			  for(int j =0;j<8;j++){
				  //IN1~IN4까지의 출력을 동시에 결정
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }
	  //PA8을 누르면 반시계방향으로 한바퀴 회전
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  for(int i = 0;i<512;i++){
			  for(int j =7;j>=0;j--){
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.예제6번에서 “버튼1,2를 누르면 스탭모터가 돌아간다”와 “버튼3,4를 누르면 LED가 제어된다”의 제어조건을 동시에 작동되도록 예시코드를 구현하시오!(EXIT를 활용함)

/* USER CODE BEGIN 0 */
#define delay_ms HAL_Delay
#define SYS_CLOCK    64
#define SYSTICK_LOAD 63999
uint32_t millis_cnt = 0;
uint32_t millis() {
return millis_cnt;
}
uint32_t micros() {
return (millis_cnt & 0x3FFFFF) * 1000 + (SYSTICK_LOAD - SysTick->VAL) / SYS_CLOCK;
}
void delay_us(uint32_t us) {  // 64MHz 보정
if (us > 1) {
  uint32_t count = us * 7 - 6;
  while (count--);
} else {
  uint32_t count = 2;
  while (count--);
}
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_2)
  {
      //버튼3에 대한 EXTI
	   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,1);
  }else if(GPIO_Pin == GPIO_PIN_6)
  {
	   //버튼4에 대한 EXTI
	   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,0);
  }
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
 GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
 uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
 /* USER CODE END 2 */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 시계방향으로 회전한다
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  for(int i = 0;i<512;i++){
			  //시퀀스 1~8까지를 1밀리초 간격으로 연속으로 전송함!
			  for(int j =0;j<8;j++){
				  //IN1~IN4까지의 출력을 동시에 결정
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }
	  //PA8을 누르면 반시계방향으로 한바퀴 회전
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  for(int i = 0;i<512;i++){
			  for(int j =7;j>=0;j--){
				  for(int z = 0; z<4;z++){
					  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[j][z]);
				  }
				  delay_us(750);
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.타이머인터럽트를 이용해서 스탭모터를 시계방향으로 항상 회전시키는 예시를 구현하시오!(IOC설정) 버튼3과 버튼4를 누르면 LED가 제어된다는 것을 메인함수에서 표현하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int seq_num = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //타이머 인터럽트 콜백함수
	//시퀀스 0 ~ 7까지 연속적으로 전송한다!
	//IN1~IN4까지의 출력을 동시에 결정
	for(int z = 0; z<4;z++){
	  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
	}
	seq_num++;
	if(seq_num >= 8) seq_num = 0;
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //타이머 인터럽트 실행
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,1);
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,0);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.버튼1을 누르면 스탭모터가 시작위치에서 시계방향으로 360도 회전하고, 버튼2를 누르면 반시계방향으로 360도 회전하도록 하시오!(절대위치제어)

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int now_pos = 0; //스탭모터가 알고있는 자기의 현재 위치
int target_pos = 0; //녹칸다가 설정한 목표위치
int seq_num = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //타이머 인터럽트 콜백함수
	if(now_pos < target_pos){
		//시계방향으로 회전해야하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num++;
		if(seq_num >= 8) seq_num = 0;
		now_pos++; //시퀀스 1회당 현재위치 1 증가
	}else if(now_pos > target_pos){
		//반시계방향으로 회전해야 하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num--;
		if(seq_num < 0) seq_num = 7;
		now_pos--; //시퀀스 1회당 현재위치 1 감소
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //타이머 인터럽트 실행
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  target_pos = 4096;
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  target_pos = 0;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

10.버튼1은 원점(0), 버튼2는 +90도, 버튼3은 +180도, 버튼4는 +360도, 버튼5는 -90도, 버튼6은 -180도, 버튼7은 -360도 회전하도록 설정하시오!

/* USER CODE BEGIN 0 */
uint8_t seq[][4]={
 		{0,0,0,1}, //1
 		{0,0,1,1}, //2
 		{0,0,1,0}, //3
 		{0,1,1,0}, //4
 		{0,1,0,0}, //5
 		{1,1,0,0}, //6
 		{1,0,0,0}, //7
 		{1,0,0,1}  //8
 };
GPIO_TypeDef *mygroup[] = {GPIOC,GPIOC,GPIOC,GPIOD};
uint16_t mypin[] = {GPIO_PIN_10,GPIO_PIN_11,GPIO_PIN_12,GPIO_PIN_2};
int now_pos = 0; //스탭모터가 알고있는 자기의 현재 위치
int target_pos = 0; //녹칸다가 설정한 목표위치
int seq_num = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
   //타이머 인터럽트 콜백함수
	if(now_pos < target_pos){
		//시계방향으로 회전해야하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num++;
		if(seq_num >= 8) seq_num = 0;
		now_pos++; //시퀀스 1회당 현재위치 1 증가
	}else if(now_pos > target_pos){
		//반시계방향으로 회전해야 하는 상황
		for(int z = 0; z<4;z++){
		  HAL_GPIO_WritePin(mygroup[z],mypin[z],seq[seq_num][z]);
		}
		seq_num--;
		if(seq_num < 0) seq_num = 7;
		now_pos--; //시퀀스 1회당 현재위치 1 감소
	}
}
/* USER CODE END 0 */

/* USER CODE BEGIN 2 */
 //타이머 인터럽트 실행
 HAL_TIM_Base_Start_IT(&htim2);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  target_pos = 0; //0
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  target_pos = 4096/4; //90
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
	  		  target_pos = 4096/2; //180
	  }
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
	  		  target_pos = 4096; //360
	  }
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0){
	  		  target_pos = -4096/4; //-90
	  }
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_7) == 0){
	  		  target_pos = -4096/2; //-180
	  }
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11) == 0){
	  		  target_pos = -4096; //-360
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#08] PWM의 듀티비를 변화시켜서 서보모터(SERVO)인 SG90의 각도를 제어하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 5 Nov 2025 16:22:37 +0900

https://youtube.com/live/IDd-IVeSmGE

[STM32#08] PWM의 듀티비를 변화시켜서 서보모터(SERVO)인 SG90의 각도를 제어하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39fc004f5bb_2_169#slide=id.g39fc004f5bb_2_169

이번편은 녹칸다의 STM32쉴드에 SG90을 연결해서 각도를 제어해보도록 한다!

(회로도)

1.서보모터(SG90)의 IOC설정을 하고 0도와 180도를 1초 간격으로 왔다갔다 하는 예제를 구현하시오!

/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //서보모터가 0도 위치로 이동한다!
	  TIM2->CCR4 = 600;
	  //1초쉰다!
	  HAL_Delay(1000);
	  //서보모터가 180도 위치로 이동한다!
	  TIM2->CCR4 = 2400;
	  //1초쉰다!
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.예제1번에서 0도부터 180도사이의 각도를 입력하면 각도대로 CCR4의 값을 설정하는 똑똑한 함수를 만들어보시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //서보모터가 0도 위치로 이동한다!
	  set_servo(0);
	  //1초쉰다!
	  HAL_Delay(1000);
	  //서보모터가 180도 위치로 이동한다!
	  set_servo(180);
	  //1초쉰다!
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.서보모터를 0도부터 180도까지 10밀리초간격으로 1도씩 올리고, 180도부터 0도까지 10밀리초간격으로 내려서 왔다갔다 하는 예제를 만드시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //0도부터 180도까지 1도씩 10밀리초간격으로 올라간다!
	  for(int i = 0;i<=180;i++){
		  set_servo(i);
		  HAL_Delay(10);
	  }
	  //180도부터 0도까지 1도씩 10밀리초간격으로 내려간다!
	  for(int i = 180;i>=0;i--){
		  set_servo(i);
		  HAL_Delay(10);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.버튼5개(PB1,PA8,PB2,PB6,PC5)를 사용해서 PB1은 0도위치, PA8은 45도위치, PB2는 90도위치, PB6은 135도위치, PC5는 180도위치로 이동하는 예제를 구현하시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 0도로 이동한다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  set_servo(0);
	  }
	  //PA8을 누르면 45도로 이동한다!
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  set_servo(45);
	  }
	  //PB2을 누르면 90도로 이동한다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2) == 0){
		  set_servo(90);
	  }
	  //PB6을 누르면 135도로 이동한다!
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6) == 0){
		  set_servo(135);
	  }
	  //PC5을 누르면 180도로 이동한다!
	  if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0){
		  set_servo(180);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.PA8버튼을 누르면 누르고 있는 동안에 서보모터의 각도가 1도씩 증가하고 최대 180을 넘지않는다! PB1을 누르면 각도가 1도씩 내려가고 0도이하로 내려가지는 않는다!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
//PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 int16_t degree = 0;
 set_servo(degree); //시작할때 서보모터는 0도 위치!
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 누르면 1도씩 내려간다!(하한값 0)
	  if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) == 0){
		  degree++;
		  if(degree > 180) degree = 180;
		  set_servo(degree);
		  HAL_Delay(10);
	  }
	  //PA8을 누르면 1도씩 증가한다! (상한값 180)
	  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == 0){
		  degree--;
		  if(degree < 0) degree = 0; //오류 발생!
		  set_servo(degree);
		  HAL_Delay(10);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.로터리엔코더(PA11,PA12)를 시계방향으로 돌리면 서보모터의 각도가 1도씩 올라가고, 반시계방향으로 돌리면 1도씩 내려가도록 하시오!(범위는 0~180도)

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
//PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 int16_t degree = 0;
 set_servo(degree); //시작할때 서보모터는 0도 위치!
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_12);
		  if(!now_B){
			  //시계
			  degree-=3; //원래 degree가 가지고있는값에 3을 뺀다!
			  if(degree < 0) degree = 0;
			  set_servo(degree);
		  }else{
			  //반시계
			  degree+=3; //원래 degree가 가지고있는값에 3을 더한다!
			  if(degree > 180) degree = 180;
			  set_servo(degree);
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.녹칸다가 사용하는 putty에서 ‘0’을 입력하면 0도, ‘1’을 입력하면 45도, ’2’를 입력하면 90도, ‘3’을 입력하면 135도, ‘4’를 입력하면 180도로 이동되도록 하시오! STM32가 현재 설정된 각도가 몇도인지를 시리얼로 피드백 하도록 하시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 set_servo(0); //시작할때 서보모터는 0도 위치!
 char recv;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 문자 1개가 수신되기로 약속되어있다!(0.5초 대기)
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  //recv PC에서 보낸 1개의 문자가 들어있는 상태
		  if(recv == '0'){
			  set_servo(0);
			  sprintf(buff,"NOW DEGREE = %d\n",0);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }else if(recv == '1'){
			  set_servo(45);
			  sprintf(buff,"NOW DEGREE = %d\n",45);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }else if(recv == '2'){
			  set_servo(90);
			  sprintf(buff,"NOW DEGREE = %d\n",90);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }else if(recv == '3'){
			  set_servo(135);
			  sprintf(buff,"NOW DEGREE = %d\n",135);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }else if(recv == '4'){
			  set_servo(180);
			  sprintf(buff,"NOW DEGREE = %d\n",180);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.녹칸다가 “0”부터 “180”까지의 각도값을 STM32로 전송하면 그 각도대로 서보모터가 회전되도록 하시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 set_servo(0); //시작할때 서보모터는 0도 위치!
 char recv;
 int rx_index = 0;
 char rx_buff[50];
 char tx_buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  rx_index = 0;
	  while(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  rx_buff[rx_index] = recv;
		  rx_index++;
		  if(recv == '\r'){
			  //PC에서 보낸 종료문자 확인!
			  rx_buff[rx_index] = '\0';
			  //rx_buff에 각도값이 들어있는건 알겠는데.. 숫자로 바꿔야하는데?
			  int degree = atoi(rx_buff);
			  //0~180도 사이로 입력이 되도록 설정
			  if(degree > 180) degree = 180;
			  if(degree < 0) degree = 0;
			  sprintf(tx_buff,"NOW DEGREE = %d\n",degree);
			  HAL_UART_Transmit(&huart2, tx_buff, strlen(tx_buff), 100);
			  set_servo(degree);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.PA0에 연결된 가변저항을 이용해서 서보모터의 각도를 회전시키시오!

/* USER CODE BEGIN 0 */
void set_servo(uint8_t degree){
	//degree는 0~180도 범위이고 CCR4는 600부터 2400의 범위이다!
	TIM2->CCR4 = (uint32_t)(600+(2400-600)*degree/180.0);
}
uint16_t map(uint16_t analog){
	return 180*analog/4095.0;
}
/* USER CODE END 0 */

//중략
/* USER CODE BEGIN 2 */
 //PB11이 사용하는 TIM2_CH4를 시작하겠다!
 HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_4);
 HAL_ADC_Start(&hadc1); //딱 한번만 호출(ADC1에 지정했을때)
 uint16_t adc_value0 = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //0~4095를 0~180도 범위로 조정해야한다!
		  set_servo(map(adc_value0));
	  }
	  HAL_Delay(10);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#07] TIM3의 ARR와 CCR을 설정하고 PWM출력을 해서 부저(buzzer) 사운드 재생하는 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 3 Nov 2025 23:05:38 +0900

https://youtube.com/live/QPbT5pfgztc

[STM32#07] TIM3의 ARR와 CCR을 설정하고 PWM출력을 해서 부저(buzzer) 사운드 재생하는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39f7ee2e2d4_1_0#slide=id.g39f7ee2e2d4_1_0

이번편은 녹칸다의 STM32쉴드에 붙어있는 부저를 작동시켜보도록 하자!

1.STM32에서 구조체와 포인터타입의 구조체에 대해서 차이를 알수있는 예시를 보이시오!

/* USER CODE BEGIN 2 */
 char buff[50];
 typedef struct{
 	uint16_t num1;
 	int32_t num2;
 }Mystruct;
 //Mystruct type의 구조체를 s1이라는 이름으로 만들겠다!
 Mystruct s1;
 //Mystruct type의 구조체의 주소를 담는 포인터를 생성한다!
 Mystruct *s2;
 //s2에다가 s1의 주소를 넣겠다!
 //s2는 s1을 참조하게된다!
 s2 = &s1;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //s1의 멤버인 num1에 10이라는 값을 대입하겠다!
	  s1.num1 = 10;
	  s1.num2 = 20;
	  sprintf(buff,"CASE1 num1=%d, num2=%d\n",s1.num1,s1.num2);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(1000);
	  //s2를 통해서 s1의 num1의 값을 30으로 바꾸고, num2의 값을 40으로 바꾼다!
	  (*s2).num1 = 30;
	  (*s2).num2 = 40;
	  sprintf(buff,"CASE2 num1=%d, num2=%d\n",s1.num1,s1.num2);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(1000);
	  s2->num1 = 50;
	  s2->num2 = 60;
	  sprintf(buff,"CASE3 num1=%d, num2=%d\n",s1.num1,s1.num2);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.IOC를 설정해서 부저에 1초 간격으로 440hz의 부저음이 발생할 수 있도록 하시오!(PWM은 제일 처음 1회 호출하는 코드가 있다)

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 //주파수값을 440hz로 설정한다
 Tone(440);
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //부저의 소리를 재생한다!(1초)
	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
	  HAL_Delay(1000);
	  //부저의 소리를 끈다!(1초)
	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.녹칸다가 쉴드에 붙혀놓은 8개의 버튼이 있다! 8개의 버튼을 도,레,미,파,솔,라,시,도까지를 버튼을 누를때 소리가 나오도록 하시오!(피아노 만들기)

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도

/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_C6);


	  }else if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_D6);
	  }else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_E6);
	  }else if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_6) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_F6);
	  }else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_5) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_G6);
	  }else if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_A6);
	  }else if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_B6);
	  }else if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_C7);
	  }else{
		  //소리를 끈다
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.로터리엔코더를 이용해서 로터리엔코더의 회전이 감지되면 감지될때마다 아주 짧은 비프음을 발생시키시오!(시계 6옥타브미, 반시계는 6옥타브솔,로터리엔코더눌려지면 7옥타브도)

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도

/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 uint8_t old_sensor_A  = 1;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */


while (1)
 {
	  uint8_t sensor_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11); //A값
	  if(sensor_A == 0 && old_sensor_A == 1){
		  //falling edge
		  uint8_t sensor_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12); //B값
		  if(sensor_B == 0){
			  //시계
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
			  Tone(NOTE_E6);
			  HAL_Delay(100);
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
		  }else{
			  //반시계
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
			  Tone(NOTE_G6);
			  HAL_Delay(100);
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
		  }
	  }
	  old_sensor_A = sensor_A;
	  //PC7이 눌려지면 7옥타브 도 음이 재생된다!
	  if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  Tone(NOTE_C7);
	  }else{
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.PA0에 연결된 가변저항을 이용해서 부저의 피치를 6옥타브도부터 7옥타브 도까지를 설정하는데, 버튼1인 PB1을 누르면 부저가 재생되고, 버튼2인 PA8을 누르면 부저가 재생되지 않도록 하시오!

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도

/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */



while (1)
 {
	  //PB1을 누르면 부저의 소리가 난다
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
	  }
	  //PA8을 누르면 부저의 소리가 꺼진다
	  if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  }
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //NOTE_C6 1047 ~ NOTE_C7 2094
		  adc_value0 = NOTE_C6+(NOTE_C7-NOTE_C6)*(adc_value0/4095.0);
		  Tone(adc_value0);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.예제5에서 했던 가변저항측정값을 CDS측정값으로 바꾸고, 빛의 세기에 따라서 음높이가 달라지는 예시를 구현하시오!

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도

/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */



while (1)
 {
	  //PB1을 누르면 부저의 소리가 난다
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
	  }
	  //PA8을 누르면 부저의 소리가 꺼진다
	  if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == 0){
		  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
	  }
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //NOTE_C6 1047 ~ NOTE_C7 2094
		  adc_value0 = NOTE_C6+(NOTE_C7-NOTE_C6)*(adc_value0/4095.0);
		  Tone(adc_value0);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PA1에 연결된 CDS의 아날로그 값을 측정해서 녹칸다가 센서를 손으로 가리면 부저의 소리가 발생하고 안가리면 소리가 안나도록 하시오!

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도

/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 Tone(NOTE_G6);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */




while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //측정값이 1000보다 크면 부저에 소리가 안나고
		  //그게 아니라면 소리가 난다
		  if(adc_value0 > 1000){
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
		  }else{
			  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 1);
		  }
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.로터리엔코더를 돌리면 세탁메뉴가 변경되는데 LED8개중에 1개가 선택되는것으로 시각화한다! 그리고 로터리엔코더의 스위치를 누르면 실행이 되었다는 의미로 세탁 완료음을 부저로 재생하시오! 그리고 로터리엔코더가 회전할때 회전하는 사운드도 추가하시오!

/* USER CODE BEGIN 0 */
static void Tone(uint32_t Frequency)
{
   TIM3->ARR = (1000000UL / Frequency) - 1; //주파수
   TIM3->CCR3 = (TIM3->ARR >> 1); //듀티비 50%
}
#define NOTE_C6  1047 //도
#define NOTE_D6  1175 //레
#define NOTE_E6  1319 //미
#define NOTE_F6  1397 //파
#define NOTE_G6  1568 //솔
#define NOTE_A6  1760 //라
#define NOTE_B6  1976 //시
#define NOTE_C7  2093 //도
#define NOTE_D7  2349 //레
void play_melody(){
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2,1);
	  Tone(NOTE_G6);
	  HAL_Delay(500);
	  Tone(NOTE_C7);
	  HAL_Delay(500/3);
	  Tone(NOTE_B6);
	  HAL_Delay(500/3);
	  Tone(NOTE_A6);
	  HAL_Delay(500/3);
	  Tone(NOTE_G6);
	  HAL_Delay(500);
	  Tone(NOTE_E6);
	  HAL_Delay(500);
	  //파솔라 레미파 미 솔
	  Tone(NOTE_F6);
	  HAL_Delay(500/3);

	  Tone(NOTE_G6);
	  HAL_Delay(500/3);
	  Tone(NOTE_A6);
	  HAL_Delay(500/3);
	  Tone(NOTE_D6);
	  HAL_Delay(500/3);
	  Tone(NOTE_E6);
	  HAL_Delay(500/3);
	  Tone(NOTE_F6);
	  HAL_Delay(500/3);
	  Tone(NOTE_E6);
	  HAL_Delay(500);
	  Tone(NOTE_G6);
	  HAL_Delay(500);
	  //
	  Tone(NOTE_G6);
	  HAL_Delay(500);
	  Tone(NOTE_C7);
	  HAL_Delay(500/3);
	  Tone(NOTE_B6);
	  HAL_Delay(500/3);
	  Tone(NOTE_A6);
	  HAL_Delay(500/3);
	  Tone(NOTE_G6);
	  HAL_Delay(500);
	  Tone(NOTE_C7);
	  HAL_Delay(500);
	  //도레도 시라시 도~
	  Tone(NOTE_C7);
	  HAL_Delay(500/3);
	  Tone(NOTE_D7);
	  HAL_Delay(500/3);
	  Tone(NOTE_C7);
	  HAL_Delay(500/3);
	  Tone(NOTE_B6);
	  HAL_Delay(500/3);

	  Tone(NOTE_A6);
	  HAL_Delay(500/3);
	  Tone(NOTE_B6);
	  HAL_Delay(500/3);
	  Tone(NOTE_C7);
	  HAL_Delay(1000);
	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2,0);
}
GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void set_led(int num){
	//LED의 상태 업데이트 현재 켜져야하는 LED는 CNT번째꺼
	  for(int i = 0;i<8;i++){
		  if(i == num){
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
		  }else{
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
		  }
	  }
	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2,1);
	  Tone(NOTE_G6);
	  HAL_Delay(100);
	  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2,0);
}
/* USER CODE END 0 */


/* USER CODE BEGIN 2 */
 //TIM3_CH3의 PWM기능을 활성화하겠습니다!
 HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
 //시작하면 일단 부저는 끈상태라
 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, 0);
 uint8_t old_A = 0;
 int cnt = 0;
   //시작하자마자 일단 12시방향의 LED는 1개 켜고 출발한다!
 HAL_GPIO_WritePin(mygroup[0],mypin[0],GPIO_PIN_SET);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  cnt--;
			  if(cnt < 0) cnt = 7;
			  set_led(cnt);

		  }else{
			 //시계
			  cnt++;
			  if(cnt > 7) cnt = 0;
			  set_led(cnt);
		  }
	  }
	  old_A = now_A;
	  //PC7을 누르면 세탁기 완료 사운드가 재생된다
	  if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7) == 0){
		  play_melody();
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#06] HAL_ADC_PollForConversion(),HAL_ADC_GetValue()을 이용해서 analog값 입력 방법 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 29 Oct 2025 16:20:14 +0900

https://youtube.com/live/tYoSbV1Dg9I

[STM32#06] HAL_ADC_PollForConversion(),HAL_ADC_GetValue()을 이용해서 아날로그(analog)값을 입력받는 방법 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g398060de84c_1_222#slide=id.g398060de84c_1_222

이번편에는 녹칸다의 STM32쉴드에 붙어있는 로터리엔코더를 작동시켜보도록 합니다~!

(STM32에서 아날로그입력시 알고있으면 좋은점!)
1.STM32에는 아날로그입력을 위한 ADC가 12bit가 적용된다!
2.아두이노 우노는 ADC가 10bit이고 측정값의 범위가 0~1023이다!
3.아하! 그러면 STM32는 0~4095의 범위를 가지는군요!(정답)
4.아두이노의 경우 analogRead(핀번호) 라고 하면 아주 간단하게 값 측정이 가능하나, STM32는 그렇게 간단하지 않다!
5.아날로그값을 1개로 측정할때와 2개이상을 동시에 측정할때는 접근법이 달라지게 되니 상황에 따른 방법론을 이해할 필요가 있음!
6.지금 사용하는 뉴클레오보드는 ADC1과 ADC2로 2개로 구성되어있고 이하에 IN이라는 여러개의 채널로 구성되어있다!
7.내가 사용할 핀을 ADC1이나 ADC2의 채널에 지정을 해서 사용할 수 있음!

(아날로그 3종세트 회로도)

(예제목차)
1.PB1과 PA8에 연결된 버튼을 EXTI로 설정한다음 PB1버튼을 누르면 PB3에 연결된 LED가 ON되고 PA8버튼을 누르면 OFF되도록 하는데, main loop에 10초간격으로 “NOCKANDA”라고 출력되는 시리얼출력 코드를 작성해서 인터럽트가 어떤 효과를 가지는지에 대해서 설명하시오!

/* USER CODE BEGIN 0 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
 if(GPIO_Pin == GPIO_PIN_1)
 {
	   //LED ON
	  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3, 1);
 }else if(GPIO_Pin == GPIO_PIN_8)
 {
	   //LED OFF
	  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3, 0);
 }
}
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN WHILE */
 while (1)
 {
	  HAL_UART_Transmit(&huart2, "NOCKANDA!!\n", 11, 100);
	  HAL_Delay(10000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.PA0에 연결된 가변저항값을 측정해서 100밀리초 간격으로 시리얼출력하시오!(ADC1 IN0에 지정)

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  sprintf(buff,"A0 = %d\n",adc_value0);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.측정한 가변저항이 대략 0~4095의 값이 나오는데, 이값을 이용해서 부착되어있는 LED 8개를 게이지 형태로 출력하시오!

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //0~4095의 범위를 0~7사이로 변환해라!
		  adc_value0 = 7 * adc_value0/4000.0;
		  sprintf(buff,"A0 = %d\n",adc_value0);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  //8개의 LED를 0~7사이에 나온 LED의 갯수만큼 켠다
		  for(int i = 0;i < 8;i++){
			  if(i <= adc_value0){
				  HAL_GPIO_WritePin(mygroup[i],mypin[i], 1);
			  }else{
				  HAL_GPIO_WritePin(mygroup[i],mypin[i], 0);
			  }
		  }
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.PA1에 연결되어있는 CDS의 값을 100밀리초 간격으로 측정해서 시리얼출력하시오!(ADC1 IN1에 지정)

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  sprintf(buff,"A1 = %d\n",adc_value0);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.측정한 CDS값이 1000을 넘으면 LED 8개를 모두 ON하고 1000보다 작으면 OFF하시오!

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  //CDS의 값이 1000미만이면 LED OFF고 1000이상이면 ON이다!
		  if(adc_value0 >= 1000){
			  for(int i = 0;i<8;i++){
				  HAL_GPIO_WritePin(mygroup[i], mypin[i], 0);
			  }
		  }else{
			  for(int i = 0;i<8;i++){
				  HAL_GPIO_WritePin(mygroup[i], mypin[i], 1);
			  }
		  }
		  sprintf(buff,"A1 = %d\n",adc_value0);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.측정한 CDS값을 전압으로 계산해서 100밀리초 간격으로 출력하시오!

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  float voltage = 3.3*(adc_value0/4095.0);
		  sprintf(buff,"Voltage = %f\n",voltage);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.PA4에 연결된 NTC서미스터의 온도값을 측정해서 100밀리초간격으로 출력하시오!(온도값을 소수점이하 2자리만 살리고 ‘C단위를 붙히시오)

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //측정할때마다 호출
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
		  R2 = R1 * (4095.0 / adc_value0 - 1.0);
		  logR2 = log(R2);
		  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
		  Tc = T - 273.15;
		  //온도값을 출력하는데 .2라는것은 소수점 이하 2자리만 출력하라는 것이다!
		  sprintf(buff,"Voltage = %.2f'C\n",Tc);
		  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  }
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.PA0과 PA1에 연결된 아날로그값을 ADC1과 ADC2로 분할해서 동시에 100밀리초 간격으로 출력하시오!

/* USER CODE BEGIN 2 */
 HAL_ADC_Start(&hadc1); //딱 한번만 호출
 HAL_ADC_Start(&hadc2); //딱 한번만 호출
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0
	  if(HAL_ADC_PollForConversion(&hadc1, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value0 = HAL_ADC_GetValue(&hadc1); //0~4095
	  }
	  //PA1
	  if(HAL_ADC_PollForConversion(&hadc2, 10) == HAL_OK)
	  {
		  // 값 처리
		  adc_value1 = HAL_ADC_GetValue(&hadc2); //0~4095
	  }
	  sprintf(buff,"PA0 = %d, PA1 = %d\n",adc_value0,adc_value1);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

9.PA0과 PA1에 연결된 아날로그값을 ADC1의 IN0과 IN1로 지정해서 동시에 출력하시오!

/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  sprintf(buff,"PA0 = %d, PA1 = %d\n",adc_value0,adc_value1);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

10.예제9의 방법으로 PA0, PA1, PA4의 값을 동시에 출력하시오!(PA4는 온도값으로 환산할 것)

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  sprintf(buff,"PA0 = %d, PA1 = %d, PA4 = %.2f'C\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

11.예제10에서 PA0의 값이 1000을 넘으면 PB3이 켜지고 그렇지않으면 꺼진다!, PA1의 값이 1000보다 크면 PB13의 LED가 켜지고 그렇지않으면 꺼지다! PA4에서 측정한 온도값이 20도를 넘으면 PB5의 LED가 켜지고 그렇지 않으면 꺼진다!

/* USER CODE BEGIN 0 */
#define R1 10000
#define c1 1.009249522e-03
#define c2 2.378405444e-04
#define c3 2.019202697e-07
/* USER CODE END 0 */
//중략
/* USER CODE BEGIN 2 */
 uint16_t adc_value0 = 0;
 uint16_t adc_value1 = 0;
 uint16_t adc_value2 = 0;
 char buff[50];
 float logR2, R2, T, Tc, Tf;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PA0 ADC1 RANK1
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value0 = HAL_ADC_GetValue(&hadc1);
	  //PA1 ADC1 RANK2
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value1 = HAL_ADC_GetValue(&hadc1);
	  //PA4 ADC1 RANK3
	  HAL_ADC_Start(&hadc1);
	  HAL_ADC_PollForConversion(&hadc1, 100);
	  adc_value2 = HAL_ADC_GetValue(&hadc1);
	  //온도계산
	  R2 = R1 * (4095.0 / adc_value2 - 1.0);
	  logR2 = log(R2);
	  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
	  Tc = T - 273.15;
	  if(adc_value0 > 1000){
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1);
	  }else{
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0);
	  }
	  if(adc_value1 > 1000){
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 1);
	  }else{
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, 0);
	  }
	  if(Tc > 20){
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 1);
	  }else{
		  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, 0);
	  }
	  sprintf(buff,"PA0 = %d, PA1 = %d, PA4 = %.2f'C\n",adc_value0,adc_value1,Tc);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(100);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#05] 로터리엔코더(rotary encoder)를 작동시키는 방법에 대해서 알아보고 GPIO 외부인터럽트(EXTI)를 활용해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 27 Oct 2025 23:21:25 +0900

https://youtube.com/live/CZO7eE0qtEg

[STM32#05] 로터리엔코더(rotary encoder)를 작동시키는 방법에 대해서 알아보고 GPIO 외부인터럽트(EXTI)를 활용해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39d2b1dd9a3_1_0#slide=id.g39d2b1dd9a3_1_0

이번편에는 녹칸다의 STM32쉴드에 붙어있는 로터리엔코더를 작동시켜보도록 합니다~!

로터리엔코더 회로도

(STM32쉴드회로도)

(직접연결할떄)

(로터리엔코더의 인식원리)

1.일단 기본적으로 로터리엔코더는 시계방향으로 회전하냐? 반시계방향으로 회전하냐? 를 알수있다!
2.회전방향과 몇스탭을 이동했는지? 스탭량을 알 수 있다!
3.시계방향으로 회전할때와 반시계방향으로 회전할때의 신호값이 다르게된다!
4.시계방향으로 1스탭 회전을 하게되면 A핀에 상승엣지가 발생하고 그때 B의 값은 LOW가 된다!
5.반시계방향으로 1스탭 회전을 하게되면 A핀에 상승엣지가 발생하고 그때 B의 값은 HIGH가 된다!

(예제목차)

1.PB1에 상승엣지와 하강엣지를 이용해서 버튼이 눌려졌는지를 검출해서 시리얼출력하시오!

/* USER CODE BEGIN 2 */
 //버튼을 안누르고 있을때가 기본상태이고 안누르고 있으면 HIGH신호가 나온다
 uint8_t old = 1;
 char * msg1 = "PB1 PRESSED!!\n";
 char * msg2 = "PB1 RELEASED!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1의 하강엣지 검출(버튼 눌러짐)
	  //PB1의 현재 값을 측정한다!
	  uint8_t now = HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1);
	  //now와 old가 공존하는 상태가 된다!
	  if(old == 1 && now == 0){
		  //이전값은 HIGH인데, 현재값은 LOW인 상황!(하강엣지)
		  HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
	  }else if(old == 0 && now == 1){
		  //이전값은 LOW이고, 현재값은 HIGH이다!(상승엣지)
		  HAL_UART_Transmit(&huart2, msg2, strlen(msg2), 100);
	  }
	  old = now;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.인터럽트를 위해서 함수에 대해서 기본적으로 예제로 표현해보시오!

/* USER CODE BEGIN 0 */
char *msg1 = "NOCKANDA\n";
char buff[100];
//입력도 없고 출력도 없는 함수
void function1(){
	//이함수가 호출되면 usart2로 "NOCKANDA\n"를 출력한다!
	HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
}
//입력이 있고 출력은 없는 함수
void function2(int num){
	//숫자를 1개 입력받아서 그 값을 출력하는 함수!
	//함수의 입력으로 들어온 값은 지역변수처럼 쓸수있다!
	sprintf(buff,"NUMBER=%d\n",num);
	HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
}
//입력이 없고 출력이 있는 함수
int function3(){
	//호출하면 5678이라는 값을 반환(return)하는 함수!
	return 5678;
}
//입력과 출력이 둘다 있는 함수
int function4(int num1, int num2){
	//num1과 num2를 더해서 반환하는 함수
	int output = num1+num2;
	return output;
}
/* USER CODE END 0 */

//중략

while (1)
 {
	  function1(); //함수를 호출한다(=콜한다)
	  function2(1234);
	  int test_num = function3();
	  sprintf(buff,"function3=%d\n",test_num);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  int test_num2 = function4(111,222);
	  sprintf(buff,"function4=%d\n",test_num2);
	  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
	  HAL_Delay(2000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.PB1을 IOC에서 외부인터럽트로 등록해서 버튼을 눌렀을때 눌려졌다는 문구를 시리얼출력하시오!(EXTI1)

/* USER CODE BEGIN 0 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	//EXTI1
  if(GPIO_Pin == GPIO_PIN_1)
  {
	   HAL_UART_Transmit(&huart2, "PB1 INTERRUPTS!\n", 16, 100);
  }
}
/* USER CODE END 0 */

////중략

while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.로터리엔코더를 폴링방식으로 처리해서 시계방향으로 회전하냐, 반시계방향으로 회전하냐, 스위치를 눌렀냐를 판별해서 시리얼출력하시오!

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "SW\n", 3, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  HAL_UART_Transmit(&huart2, "CCW\n", 4, 100);
		  }else{
			 //시계
			  HAL_UART_Transmit(&huart2, "CW\n", 3, 100);
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.녹칸다가 로터리엔코더를 돌렸을때 시계방향으로 회전시키면 값을 0에서 7까지 증가시키는데 7에서 8이 되는게 아니라 0이 된다!, 반시계방향으로 회전하면 7에서 0방향으로 감소시키는데 0에서 1감소되면 -1이 되는게 아니라 7이된다!

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 int cnt = 0;
 char buff[50];
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "SW\n", 3, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  cnt--;
			  if(cnt < 0) cnt = 7;
			  sprintf(buff,"CNT = %d\n",cnt);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }else{
			 //시계
			  cnt++;
			  if(cnt > 7) cnt = 0;
			  sprintf(buff,"CNT = %d\n",cnt);
			  HAL_UART_Transmit(&huart2, buff, strlen(buff), 100);
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.로터리 엔코더를 회전시킬때, LED가 12시방향에서 출발해서 시계방향으로 로터리엔코더를 돌리면 함께 회전하고, 반시계방향으로 회전시키면 반시계방향으로 1칸씩 이동하시오!

/* USER CODE BEGIN 0 */
GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void set_led(int num){
	//LED의 상태 업데이트 현재 켜져야하는 LED는 CNT번째꺼
	  for(int i = 0;i<8;i++){
		  if(i == num){
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
		  }else{
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
		  }
	  }
}
/* USER CODE END 0 */

//중략

/* USER CODE BEGIN 2 */
 uint8_t old_A = 0;
 int cnt = 0;
  //시작하자마자 일단 12시방향의 LED는 1개 켜고 출발한다!
  HAL_GPIO_WritePin(mygroup[0],mypin[0],GPIO_PIN_SET);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //녹칸다가 풀업방식으로 연결해놓음
	  uint8_t sw = HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7);
	  if(sw == 0){
		  HAL_UART_Transmit(&huart2, "SW\n", 3, 100);
		  HAL_Delay(200);
	  }
	  //PA11의 상승엣지가 발생했을때
	  uint8_t now_A = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11);
	  if(old_A == 0 && now_A == 1){
		  //PA12의 값을 측정해서 LOW면 시계, HIGH면 반시계
		  uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		  if(now_B){
			 //반시계
			  cnt--;
			  if(cnt < 0) cnt = 7;
			  set_led(cnt);
		  }else{
			 //시계
			  cnt++;
			  if(cnt > 7) cnt = 0;
			  set_led(cnt);
		  }
	  }
	  old_A = now_A;
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

7.이번에는 인터럽트를 이용해서 로터리엔코더의 회전방향을 시리얼로 출력하시오!

/* USER CODE BEGIN 0 */
volatile int direct = 0; //0이면 멈춤, 1이면 시계, -1이면 반시계
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_11)
  {
      //로터리엔코드의 A핀에 상승엣지가 검출됨!
	   //B핀의 상태만 확인하면됨!
	   uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
	   if(now_B){
		   //반시계
		   direct = -1;
	   }else{
		   //시계
		   direct = 1;
	   }
  }
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //어라? 로터리엔코더가 시계방향으로 돌아갔네?
	  if(direct == 1){
		  HAL_UART_Transmit(&huart2, "CW\n", 3, 100);
		  direct = 0;
	  }else if(direct == -1){
		  HAL_UART_Transmit(&huart2, "CCW\n", 4, 100);
		  direct = 0;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

8.인터럽트 방식으로 예제 6번에서 했던 LED 빙글빙글 회전시키는 예제를 구현하시오!

/* USER CODE BEGIN 0 */
volatile int direct = 0; //0이면 멈춤, 1이면 시계, -1이면 반시계
uint32_t nockanda_timer = 0;
//HAL_GetTick
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_Pin == GPIO_PIN_11)
  {
	   //로터리엔코더 인식부분을 1밀리초 간격으로 실행되도록 하겠다!
	   if(HAL_GetTick() - nockanda_timer > 1){
		   nockanda_timer = HAL_GetTick();
		   //로터리엔코드의 A핀에 상승엣지가 검출됨!
		   //B핀의 상태만 확인하면됨!
		   uint8_t now_B = HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12);
		   if(now_B){
			   //반시계
			   direct = -1;
		   }else{
			   //시계
			   direct = 1;
		   }
	   }
  }
}
GPIO_TypeDef *mygroup[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
void set_led(int num){
	//LED의 상태 업데이트 현재 켜져야하는 LED는 CNT번째꺼
	  for(int i = 0;i<8;i++){
		  if(i == num){
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
		  }else{
			  HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
		  }
	  }
}
/* USER CODE END 0 */
/* USER CODE BEGIN 2 */
 int cnt = 0;
 HAL_GPIO_WritePin(mygroup[0],mypin[0],GPIO_PIN_SET);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //어라? 로터리엔코더가 시계방향으로 돌아갔네?
	  if(direct == 1){
		  cnt++;
		  if(cnt > 7) cnt = 0;
		  set_led(cnt);
		  direct = 0;
	  }else if(direct == -1){
		  cnt--;
		  if(cnt < 0) cnt = 7;
		  set_led(cnt);
		  direct = 0;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#04] HAL_UART_Transmit(), HAL_UART_Receive() 함수를 이용해서 USART2 시리얼통신 계속 해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 22 Oct 2025 00:47:43 +0900

https://youtube.com/live/2mMDL1DBVEM

[STM32#04] HAL_UART_Transmit(), HAL_UART_Receive() 함수를 이용해서 USART2 시리얼통신 계속 해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39b3b733ade_1_225#slide=id.g39b3b733ade_1_225

기본 송수신은 되었고, 가변길이에 대한 송수신과 LED와 버튼을 제어해보는 예제를 만들어보도록 하자!

1.STM32의 PB1에 연결된 버튼을 누르면 usart2통신으로 PC에게 “PB1 PRESSED!!”라는 문자열이 버튼 누를때마다 전송되도록 하시오!

ex1.zip

0.00MB

/* USER CODE BEGIN 2 */
 char *msg = "PB1 PRESSED!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 눌렀다!
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
	  	  //usart2로 메시지를 전송한다!
		  HAL_UART_Transmit(&huart2, msg, strlen(msg), 100);
		  HAL_Delay(200); //채터링 방지를 위한 소량의 딜레이
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

2.10초간격으로 STM32가 PC쪽으로 “NOCKANDA!!”라는 문자열을 전송한다! 그리고 이때 PB1버튼을 누르면 “PB1 PRESSED!!”라는 문자열이 이전 조건과는 별개로 전송된다!(HAL_Delay를 사용하지 마십시요!)

ex2.zip

0.00MB

/* USER CODE BEGIN 2 */
 char *msg1 = "PB1 PRESSED!!\n";
 char *msg2 = "NOCKANDA\n";
 uint32_t t = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1을 눌렀다!
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
	  	  //usart2로 메시지를 전송한다!
		  HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
		  HAL_Delay(200); //채터링 방지를 위한 소량의 딜레이
	  }
	  //10000이라는 값을 인터벌로해서 인터벌마다 한번씩 걸리는 조건문!
	  if(HAL_GetTick() - t >= 10000){
		  t = HAL_GetTick();
		  //지정된 메시지를 10초간격으로 전송한다!
		  HAL_UART_Transmit(&huart2, msg2, strlen(msg2), 100);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

3.조건문의 재미난 특성에 대해서 간략한 예시를 구현하시오!(깨알지식)

ex3.zip

0.00MB

/* USER CODE BEGIN 2 */
 char *msg1 = "condition1 print!!\n";
 char *msg2 = "condition2 print!!\n";
 char *msg3 = "condition3 print!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //if는 괄호안에 들어가는 조건식이 참이면 중괄호 부분을 실행한다!
	  //조건식은 흔히 yes와 no같은 맞다 아니다로 해석하는데, 내부적으로는 참이 1이고 거짓이 0이다!
	  //참은 0이 아닌 숫자는 참으로 처리한다!
	  if(0){
		  HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
	  }
	  if(1){
		  HAL_UART_Transmit(&huart2, msg2, strlen(msg2), 100);
	  }
	  if(2){
		  HAL_UART_Transmit(&huart2, msg3, strlen(msg3), 100);
	  }
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.가변길이를 가지는 문자열 데이터를 PC에서 STM32로 전송했을때 수신을 하는 예시를 보이시오!(타임아웃을 기반으로 처리하기 버전1)

ex4.zip

0.00MB

/* USER CODE BEGIN 2 */
 char recv;
 char buff[100]; //수신메모리
 int pos = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 보낸 데이터가 있는가? 있다면 읽기 시작한다!
	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  //보낸 데이터가 있다면 1바이트씩 읽는다!
		  buff[0] = recv;
		  pos = 1;
		  while(1){
			  //만약 PC에서 데이터를 연속으로 보내다가 흐름이 0.5초정도 끊어지면 읽기를 종료한다!
			  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
				  //계속 데이터가 우체통에 있고~
				  buff[pos] = recv;
				  pos++;
			  }else{
				  //0.5초 기다려도 없네? 타임아웃이네?
				  //이 지점이 문자열의 끝지점인것을 의미한다!
				  buff[pos] = '\0';
				  //ECHO
				  HAL_UART_Transmit(&huart2, buff, pos, 100);
				  break;
			  }
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.가변길이를 가지는 문자열 데이터를 PC에서 STM32로 전송했을때 수신을 하는 예시를 보이시오!(타임아웃을 기반으로 처리하기 버전2)

ex5.zip

0.00MB

/* USER CODE BEGIN 2 */
 char recv;
 char buff[100]; //수신메모리
 int pos = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 뭔가 데이터를 보내면 while루프는 동작한다!
	  pos = 0;
	  while(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
		  buff[pos] = recv;
		  pos++;
	  }
	  buff[pos] = '\0';
	  //pos가 0이면 PC에서 온 데이터가 없고 0보다 크다면 있는것이다!
	  if(pos > 0){
		  //받은 데이터를 ECHO한다!
		  HAL_UART_Transmit(&huart2, buff, pos, 100);
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.이번에는 PC하고 STM32하고 종료문자를 라인피더(‘\n’)로 설정했을때 STM32에서 1개씩 데이터를 빼오다가 라인피더가 확인되면 거기까지를 한덩어리로 해서 PC쪽으로 반환하시오!(보내는 쪽에서 무조건 종료문자를 붙힌다) putty의 설정이 \n이 아니라 캐리지리턴인 \r로 되어있어서 수정함!

/* USER CODE BEGIN 2 */
  char recv;
  char buff[100]; //수신메모리
  int pos = 0;
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
 	  //PC에서 보낸 데이터가 있는가? 있다면 읽기 시작한다!
 	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 		  //보낸 데이터가 있다면 1바이트씩 읽는다!
 		  buff[0] = recv;
 		  pos = 1;
 		  while(1){
 			  //만약 PC에서 데이터를 연속으로 보내다가 흐름이 0.5초정도 끊어지면 읽기를 종료한다!
 			  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 				  //지금 읽은 데이터가 종료문자이냐? 이면 끝이고 아니면 계속 읽는다!
 				  if(recv == '\r'){
 					buff[pos] = '\0';
 					HAL_UART_Transmit(&huart2, buff, pos, 100);
 					break;
 				  }else{
 					buff[pos] = recv;
 					pos++;
 				  }
 			  }
 		  }
 	  }
    /* USER CODE END WHILE */
    /* USER CODE BEGIN 3 */
  }

7.녹칸다가 “LED ON”이라고 전송하면 PB3에 연결된 LED가 켜지고, “LED OFF”라고 전송하면 LED가 꺼지도록 하시오!

ex7.zip

0.00MB

/* USER CODE BEGIN 2 */
  char recv;
  char buff[100]; //수신메모리
  int pos = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
  while (1)
  {
 	  //PC에서 보낸 데이터가 있는가? 있다면 읽기 시작한다!
 	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 		  //보낸 데이터가 있다면 1바이트씩 읽는다!
 		  buff[0] = recv;
 		  pos = 1;
 		  while(1){
 			  //만약 PC에서 데이터를 연속으로 보내다가 흐름이 0.5초정도 끊어지면 읽기를 종료한다!
 			  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 				  //지금 읽은 데이터가 종료문자이냐? 이면 끝이고 아니면 계속 읽는다!
 				  if(recv == '\r'){
 					buff[pos] = '\0';
 					//LED ON이면 LED를 켜고 LED OFF면 끈다
 					if(strcmp(buff,"LED ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
 					}
 					break;
 				  }else{
 					buff[pos] = recv;
 					pos++;
 				  }
 			  }
 		  }
 	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
  }

8.STM32실습보드에 LED가 총 8개 연결되어있는데, LED다음에 번호를 1~8까지 붙히고 ON이면 켜지고 OFF면 꺼지도록 하시오! 예를들면 LED5 ON이라고 하면 다섯번째 LED가 켜지는 것이다!(LED가 만약 10개 이상이라면 숫자가 2자리가 되어서 복잡한데 지금은 한자리만 해석하면 되니까 간단!)

ex8.zip

0.00MB

/* USER CODE BEGIN 2 */
  char recv;
  char buff[100]; //수신메모리
  int pos = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
  while (1)
  {
 	  //PC에서 보낸 데이터가 있는가? 있다면 읽기 시작한다!
 	  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 		  //보낸 데이터가 있다면 1바이트씩 읽는다!
 		  buff[0] = recv;
 		  pos = 1;
 		  while(1){
 			  //만약 PC에서 데이터를 연속으로 보내다가 흐름이 0.5초정도 끊어지면 읽기를 종료한다!
 			  if(HAL_UART_Receive(&huart2, &recv, 1, 500) == HAL_OK){
 				  //지금 읽은 데이터가 종료문자이냐? 이면 끝이고 아니면 계속 읽는다!
 				  if(recv == '\r'){
 					buff[pos] = '\0';
 					//LED ON이면 LED를 켜고 LED OFF면 끈다
 					if(strcmp(buff,"LED1 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED1 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED2 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED2 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_13, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED3 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED3 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_5, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED4 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);


 					}else if(strcmp(buff,"LED4 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED5 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED5 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED6 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED6 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED7 ON") == 0){
 						HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED7 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_RESET);
 					}else if(strcmp(buff,"LED8 ON") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_SET);
 					}else if(strcmp(buff,"LED8 OFF") == 0){
 						HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET);
 					}
 					break;
 				  }else{
 					buff[pos] = recv;
 					pos++;
 				  }
 			  }
 		  }
 	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
  }

9.녹칸다가 LED1번부터 8번까지의 상태를 2진수로 전송한다! 0이면 OFF고 1이면 ON이다! 예를들어 11110000이라고 보내면 LED1~4까지는 ON이고 5~8까지는 OFF하라는 의미이다!(데이터가 고정길이다)

ex9.zip

0.00MB

/* USER CODE BEGIN 2 */
  char buff[100]; //수신메모리
  GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
  uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
  while (1)
  {
 	  //PC에서 보낸 데이터가 있는가? 있다면 읽기 시작한다!
 	  if(HAL_UART_Receive(&huart2, buff, 8, 500) == HAL_OK){
 		 //buff에 0~7까지 LED의 상태가 문자 '0'또는 '1'로 지정되어서 데이터가 왔다!
 		 //buff를 반복문으로 0~7까지 하나씩 순회하면서 문자로 해석한다!
 		 for(int i = 0;i < 8;i++){
 			 if(buff[i] == '0'){
 				 //i번째 LED가 OFF이다!
 				HAL_GPIO_WritePin(mygpio[i], mypin[i], GPIO_PIN_RESET);
 			 }else if(buff[i] == '1'){
 				 //i번째 LED가 ON이다!
 				HAL_GPIO_WritePin(mygpio[i], mypin[i], GPIO_PIN_SET);
 			 }
 		 }
 	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
  }

10.예제1번에서 연결해놓은 PB1버튼을 2초동안 누르면 길게눌렀다고 PC로 전송하고, 2초이내로 짧게 누르면 짧게 눌렀다고 전송하시오!

ex10.zip

0.00MB

/* USER CODE BEGIN 2 */
 char *msg1 = "LONG CLICK!!\n";
 char *msg2 = "SHORT CLICK!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
  while (1)
  {
	   //PB1을 눌렀다!
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
		  //눌렀던 버튼을 뗄때까지 무한루프를 돌려버린다
		  //루프가 작동한 시간을 측정한다!
		  uint32_t t = HAL_GetTick(); //while루프에 진입하기 직전의 시간!
		  uint8_t is_longclick = 0;
		  while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
			  if(HAL_GetTick() - t > 2000){
				  //버튼을 2초이상 눌렀다!
				  is_longclick = 1;
				  break;
			  }
		  }
		  if(is_longclick){
			  //길게 눌러서 while루프가 강제종료된 경우
			  HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
			  //버튼 뗄때까지 무한대기
			  while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET);
			  //버튼 뗀다음에 오류를 방지하기 위한 소량의 지연시간
			  HAL_Delay(200);
		  }else{
			  //2초 이내에 눌렀다가 떼서 자연스럽게 종료된경우
			  HAL_UART_Transmit(&huart2, msg2, strlen(msg2), 100);
			  HAL_Delay(200);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
  }

11.PB1버튼을 짧게누르면 모든 LED를 ON한다! PB1을 길게 누르면 모든 LED를 OFF한다!(예제10번내용 포함)

ex11.zip

0.00MB

/* USER CODE BEGIN 2 */
 char *msg1 = "LONG CLICK!!\n";
 char *msg2 = "SHORT CLICK!!\n";
 GPIO_TypeDef *mygpio[] = {GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOB,GPIOC,GPIOB};
 uint16_t mypin[] = {GPIO_PIN_3,GPIO_PIN_13,GPIO_PIN_5,GPIO_PIN_14,GPIO_PIN_4,GPIO_PIN_15,GPIO_PIN_4,GPIO_PIN_7};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
  while (1)
  {
	   //PB1을 눌렀다!
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
		  //눌렀던 버튼을 뗄때까지 무한루프를 돌려버린다
		  //루프가 작동한 시간을 측정한다!
		  uint32_t t = HAL_GetTick(); //while루프에 진입하기 직전의 시간!
		  uint8_t is_longclick = 0;
		  while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
			  if(HAL_GetTick() - t > 2000){
				  //버튼을 2초이상 눌렀다!
				  is_longclick = 1;
				  break;
			  }
		  }
		  if(is_longclick){
			  //길게 눌러서 while루프가 강제종료된 경우
			  HAL_UART_Transmit(&huart2, msg1, strlen(msg1), 100);
			  //LED컨트롤
			  for(int i = 0;i<8;i++){
				  HAL_GPIO_WritePin(mygpio[i], mypin[i], GPIO_PIN_RESET);
			  }
			  //버튼 뗄때까지 무한대기
			  while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET);
			  //버튼 뗀다음에 오류를 방지하기 위한 소량의 지연시간
			  HAL_Delay(200);
		  }else{
			  //2초 이내에 눌렀다가 떼서 자연스럽게 종료된경우
			  HAL_UART_Transmit(&huart2, msg2, strlen(msg2), 100);
			  for(int i = 0;i<8;i++){
				  HAL_GPIO_WritePin(mygpio[i], mypin[i], GPIO_PIN_SET);
			  }
			  HAL_Delay(200);
		  }
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
  }

[STM32#03] HAL_UART_Transmit(), HAL_UART_Receive() 함수를 이용해서 USART2 시리얼통신 해보기!(녹칸다 내맘대로 STM32)

덕력킹 — Mon, 20 Oct 2025 23:13:59 +0900

https://youtube.com/live/VzvWwM-p04Q

[STM32#03] STM32F103RB NUCLEO보드에서 HAL_UART_Transmit(), HAL_UART_Receive() 함수를 이용해서 USART2 시리얼통신 해보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g39af4024cdb_1_0#slide=id.g39af4024cdb_1_0

이번편에서는 STM32보드에 설정되어있는 USART2를 이용해서 PC와 시리얼통신을 해보도록 한다!

(아두이노와 비교해서 STM32가 더 좋다고 보는것 1)

1.아두이노는 코드를 작성하고 아두이노 보드에 “업로드”를 하게 되면 내가 작성한 코드가 어떻게 작동되는지 중간 현황을 전혀 알 수 없다!
2.아두이노 코드에 변수를 설정했는데, 현재 변수에 입력되어 있는 값을 알아내기 위해서는 디스플레이를 달거나 PC와 통신을 연결해서 PC쪽으로 값을 전송해야 알아낼 수 있다!
3.지금 녹칸다가 사용하는 STM32보드는 뉴클레오 보드이고, 뉴클레오 보드는 ST링크가 내장되어 있는 방식이기 때문에 “디버깅”모드가 지원됨!
4.디버깅모드를 활용하게 되면 STM32보드에 적용될 코드에 변수값이라던지, 작동되는 메커니즘 등을 STM32cubeIDE에서 바로바로 확인할 수 있다!

(예제목차)
1.STM32의 디버깅 기능을 이용해서 1초간격으로 1씩 증가하는 nockanda_cnt라는 변수의 값을 stm32cubeide에서 확인가능 하도록 하시오!

ex1.zip

0.00MB

/* USER CODE BEGIN 2 */
 int nockanda_cnt = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  nockanda_cnt++; //cnt값을 1씩 증가
	  HAL_Delay(1000); //1초 쉬기~
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */

2.버튼중에 PB1번 버튼을 누르면 nockanda_cnt가 1씩 증가하는데, 녹칸다가 버튼을 누른게 STM32에서 제대로 인식이 되었는지 아닌지를 디버깅모드에서 확인해보시오!

ex2.zip

0.00MB

/* USER CODE BEGIN 2 */
 int nockanda_cnt = 0;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PB1버튼을 누르면 CNT가 1씩 증가한다~
	  if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
		  nockanda_cnt++;
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */

3.STM32에서 PC쪽으로 1초간격으로 “Hello STM32!!”라는 문자열을 전송하고 PC에서 그 메시지를 받아서 출력하는 예제를 구현하시오!

ex3.zip

0.00MB

char text1[] = "hello stm32\n";
 char *text2 = "hello stm32\n"; //얘는 text2자체가 이미 포인터임
 int num = 10;
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //1초간격으로 "hello stm32\r"라는 문자열을 전송해라!
	  //그런데 여기서 제일 마지막에 캐리지리턴를 포함하라고 했다!
	  //if(HAL_UART_Transmit(&huart2, text1, sizeof(text1), 100) == HAL_OK){ // OK!
     //if(HAL_UART_Transmit(&huart2, text2, sizeof(text2), 100) == HAL_OK){ // BAD!
     //if(HAL_UART_Transmit(&huart2, text1, strlen(text1), 100) == HAL_OK){ // OK!
     if(HAL_UART_Transmit(&huart2, text2, strlen(text2), 100) == HAL_OK){ //OK!
		  //전송 성공!
	  }else{
		  //전송 실패!
	  }
	  HAL_Delay(1000); //1초 쉬기~
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.STM32내부에 1초간격으로 증가하는 nockanda_cnt라는 변수가 있는데, 이 변수의 현재 값을 “nockanda_cnt = 1234”와 같은 형식으로 putty로 전송해서 출력하시오!

ex4.zip

0.00MB

/* USER CODE BEGIN 2 */
 int nockanda_cnt = 0;
 char buff[100]; //아무리 길어도 100을 안넘겠지?
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //100개짜리 char배열에 nockanda_cnt = 1234와 같은 형식으로 데이터 집어넣기~
	  sprintf(buff,"nockanda_cnt = %d\n",nockanda_cnt);
	  if(HAL_UART_Transmit(&huart2, buff, strlen(buff), 100) == HAL_OK){
		  //성공~
	  }else{
		  //실패~
	  }
     nockanda_cnt++; //값증가~
	  HAL_Delay(1000); //1초 쉬기~
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.이번에는 putty에서 STM32쪽으로 고정되어있는 데이터를 전송할때 그 데이터를 수신해서 디버깅모드에서 확인하시오!(전송하는 데이터=hello nockanda!!) 그리고 정확히 hello nockanda!!인게 확인이 되면 OK를 응답하도록 하시오!

ex5.zip

0.00MB

/* USER CODE BEGIN 2 */
 char buff[100]; //수신한 데이터를 저장할 버퍼
 char text[] = "OK!!\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 우체통에 16개의 데이터를 넣어뒀는데 그것을 성공적으로 buff에 copy했다!
	  if(HAL_UART_Receive(&huart2, buff, 16, 500) == HAL_OK){
		 //성공
		 //내가 지금 수신한게 hello nockanda!!가 맞느냐?
		 if(strcmp(buff,"hello nockanda!!") == 0){
			 //일치
			 HAL_UART_Transmit(&huart2, text, strlen(text), 100);
		 }
	  }else{
		 //실패
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

6.녹칸다가 “data1”이라고 전송하면 stm32는 “nockanda”라고 응답하고 “data2”라고 전송하면 stm32는 “forever”라고 응답한다!

ex6.zip

0.00MB

/* USER CODE BEGIN 2 */
 char buff[100] = {'\0'}; //배열을 100개 만드는데 초기값은 모두 null 문자이다!
 char text1[] = "nockanda\n";
 char text2[] = "forever\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 데이터를 무조건 5개로 해서 보내줄거야~
	  if(HAL_UART_Receive(&huart2, buff, 5, 500) == HAL_OK){
		 //성공
		 //내가 지금 수신한게 hello nockanda!!가 맞느냐?
		 if(strcmp(buff,"data1") == 0){
			 //일치
			 HAL_UART_Transmit(&huart2, text1, strlen(text1), 100);
		 }else if(strcmp(buff,"data2") == 0){
			 //일치
			 HAL_UART_Transmit(&huart2, text2, strlen(text2), 100);
		 }
	  }else{
		 //실패
	  }
	/* USER CODE END WHILE */
	/* USER CODE BEGIN 3 */
 }

7.예제6과 동일한 결과를 유지하되, data1이면 PB3에 연결된 LED가 ON되고, data2라고 전송하면 OFF되도록 하시오!

ex7.zip

0.00MB

/* USER CODE BEGIN 2 */
 char buff[100] = {'\0'}; //배열을 100개 만드는데 초기값은 모두 null 문자이다!
 char text1[] = "nockanda\n";
 char text2[] = "forever\n";
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //PC에서 데이터를 무조건 5개로 해서 보내줄거야~
	  if(HAL_UART_Receive(&huart2, buff, 5, 500) == HAL_OK){
		 //성공
		 //내가 지금 수신한게 hello nockanda!!가 맞느냐?
		 if(strcmp(buff,"data1") == 0){
			 //일치
			 HAL_UART_Transmit(&huart2, text1, strlen(text1), 100);
			 //LED ON
			 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET);
		 }else if(strcmp(buff,"data2") == 0){
			 //일치
			 HAL_UART_Transmit(&huart2, text2, strlen(text2), 100);
			 //LED OFF
			 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET);
		 }
	  }else{
		 //실패
	  }
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

[STM32#02] 디지털출력함수인 HAL_GPIO_WritePin()과 디지털입력함수인 HAL_GPIO_ReadPin()에 대해서 알아보기!(녹칸다 내맘대로 STM32)

덕력킹 — Wed, 15 Oct 2025 18:43:50 +0900

https://youtube.com/live/YhnQJ5wZIKQ

[STM32#02] STM32F103RB NUCLEO보드에서 디지털출력 함수인 HAL_GPIO_WritePin()과 디지털입력함수인 HAL_GPIO_ReadPin()에 대해서 알아보기!(녹칸다 내맘대로 STM32)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.g38606a02edc_2_164#slide=id.g38606a02edc_2_164

이번편인 디지털입출력에 대해서 알아보도록 한다!
디지털출력은 LED를 제어하고, 디지털입력은 버튼의 누름상태를 확인하는 것으로 한다!
버튼을 누르면 LED가 제어되는 예제를 만들어보는 것이다!

LED 회로도

버튼 회로도

1.STM32에 LED 8개를 연결하고, LED를 1초 간격으로 On/Off를 반복하는데 HAL함수에서 토글시키는 함수를 이용해서 작동시키오!

while (1)
 {
	//모든 LED가 토글 제어된다!
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_3); //PB3
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_13); //PB13
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_5); //PB5
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_14); //PB14
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_4); //PB4
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_15); //PB15
	  HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_4); //PC4
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_7); //PB7
	//1초 쉰다
   HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex1.zip

0.00MB

2.홀수번쨰 LED와 짝수번째 LED가 서로 번갈아 가면서 토글제어 되도록 토글제어 함수를 이용해서 구현하시오!

/* USER CODE BEGIN 2 */
 //짝수번째 LED를 켠상태로 출발한다!
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_SET); //PB13
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_SET); //PB14
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET); //PB15
 HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET); //PB7
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	//모든 LED가 토글 제어된다!
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_3); //PB3
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_13); //PB13
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_5); //PB5
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_14); //PB14
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_4); //PB4
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_15); //PB15
	  HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_4); //PC4
	  HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_7); //PB7
	//1초 쉰다
   HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex2.zip

0.00MB

3.LED1번을 시작으로 1초간격으로 LED8까지 시계방향으로 순차적으로 빙글빙글 돌면서 LED를 켜시오!(가장 허접한 방법) (깜빡하고 예제파일 저장을 안함)

while (1)
 {
	//LED1만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
   	HAL_Delay(1000);
 	  //LED2만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_SET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
	//LED3만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_SET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
	//LED4만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_SET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);

	//LED5만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_SET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
	//LED6만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
	//LED7만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_SET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
	//LED8만 ON, 나머지는 OFF
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET); //PB3
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_13,GPIO_PIN_RESET); //PB13
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_5,GPIO_PIN_RESET); //PB5
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_14,GPIO_PIN_RESET); //PB14
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET); //PB4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_RESET); //PB15
	HAL_GPIO_WritePin(GPIOC,GPIO_PIN_4,GPIO_PIN_RESET); //PC4
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET); //PB7
	//1초 쉰다
	HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

4.예제3을 for루프를 이용해서 아주 현명하게 해결해보시오! (깜빡하고 예제파일 저장을 안함)

//포트그룹을 배열로 만드는데 8개니까 배열 8개 만들기~
 GPIO_TypeDef *mygroup[8];
 //핀번호가 8개니가 8개 만들기~
 uint16_t mypin[8];
 mygroup[0] = GPIOB;
 mygroup[1] = GPIOB;
 mygroup[2] = GPIOB;
 mygroup[3] = GPIOB;
 mygroup[4] = GPIOB;
 mygroup[5] = GPIOB;
 mygroup[6] = GPIOC;
 mygroup[7] = GPIOB;
 mypin[0] = GPIO_PIN_3;
 mypin[1] = GPIO_PIN_13;
 mypin[2] = GPIO_PIN_5;
 mypin[3] = GPIO_PIN_14;
 mypin[4] = GPIO_PIN_4;
 mypin[5] = GPIO_PIN_15;
 mypin[6] = GPIO_PIN_4;
 mypin[7] = GPIO_PIN_7;
 /* USER CODE END 2 */
 /* Infinite loop */

 /* USER CODE BEGIN WHILE */
 while (1)
 {
	//i는 현재 LED가 켜져야할 번호
	for(int i = 0; i<8 ; i++){
		//i가 0이라면 LED1면 켜져야 하는상황이고 현재 LED1은 배열의 번호가 0인 상황이다!
		//i가 1이라면 배열의 번호는 1인 녀석만 켜져야하고 나머지는 꺼져야한다!
		//i가 2이라면 배열 번호 2인 녀석이 켜져야한다
		//i가 j라면 배열번호 j인 녀석만 켜지고 나머지는 꺼져야한다!
		for(int j = 0;j<8;j++){
			if(i == j){
				HAL_GPIO_WritePin(mygroup[j],mypin[j],GPIO_PIN_SET);
			}else{
				HAL_GPIO_WritePin(mygroup[j],mypin[j],GPIO_PIN_RESET);
			}
		}
		HAL_Delay(1000);
	}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

5.STM32에 붙어있는 버튼 1번을 누르면 LED 1번이 켜지고, 버튼 2번을 누르면 LED1번이 꺼지는 예제를 구현하시오!

while (1)
 {
	//PB1을 누른게 감지된다면~
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
	   //PB3에 연결된 LED를 ON한다
	   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET);
	}
	//PA8을 누른게 감지된다면~
	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == GPIO_PIN_RESET){
	   //PB3에 연결된 LED를 OFF한다
	   HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET);
	}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex5.zip

0.00MB

6.STM32에 버튼 8개를 다 연결하고, 버튼1을 누르면 LED1이 토글되고, 버튼2를 누르면 LED2가 토글되는 방식으로 순서대로 8개의 LED를 8개의 버튼으로 토글제어하시오!

while (1)
 {
	//PB1/PB3, PA8/PB13, PB2/PB5, PB6/PB14, PC5/PB4, PC7/PB15, PA11/PC4, PA12/PB7
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_3);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_13);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_2) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_5);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_6) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_14);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_5) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_4);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_7) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_15);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_11) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_4);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_12) == GPIO_PIN_RESET){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_7);
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex6.zip

0.00MB

7.PB1에 연결된 버튼을 누를때마다 LED가 1번부터 8번방향으로 이동하고, PA8에 연결된 버튼을 누르면 반대방향으로 LED를 켜지도록 하시오!

/* USER CODE BEGIN 2 */
 //현재 켜져있어야할 LED의 번호
 int led_num = 0;
 //포트그룹을 배열로 만드는데 8개니까 배열 8개 만들기~
	GPIO_TypeDef *mygroup[8];
	//핀번호가 8개니가 8개 만들기~
	uint16_t mypin[8];
	mygroup[0] = GPIOB;
	mygroup[1] = GPIOB;
	mygroup[2] = GPIOB;
	mygroup[3] = GPIOB;
	mygroup[4] = GPIOB;
	mygroup[5] = GPIOB;
	mygroup[6] = GPIOC;
	mygroup[7] = GPIOB;
	mypin[0] = GPIO_PIN_3;
	mypin[1] = GPIO_PIN_13;
	mypin[2] = GPIO_PIN_5;
	mypin[3] = GPIO_PIN_14;
	mypin[4] = GPIO_PIN_4;
	mypin[5] = GPIO_PIN_15;
	mypin[6] = GPIO_PIN_4;
	mypin[7] = GPIO_PIN_7;
	//시작할때 LED1을 켜놓고 시작한다!
	HAL_GPIO_WritePin(mygroup[0],mypin[0],GPIO_PIN_SET);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */

 while (1)
 {
	//PB1을 누르면 LED가 시계방향으로 하나씩 켜진다
	if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_1) == GPIO_PIN_RESET){
		led_num++;
		//led번호는 8번이 되면 0으로 초기화한다!
		if(led_num > 7){
			led_num = 0;
		}
		//LED1~LED8까지의 작동상태를 설정한다
		for(int i = 0;i<8;i++){
			//i와 led_num이 같은 녀석만 켜지고 나머지는 꺼진다
			if(i == led_num){
				//ON
				HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
			}else{
				//OFF
				HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
			}
		}
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
	//PA8을 누르면 LED가 반시계방향으로 하나씩 켜진다
	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_8) == GPIO_PIN_RESET){
		led_num--;
		//LED번호를 하나씩 내리다가 0이되면 제일 마지막번호인 7인된다
		if(led_num < 0){
			led_num = 7;
		}
		for(int i = 0;i<8;i++){
			//i와 led_num이 같은 녀석만 켜지고 나머지는 꺼진다
			if(i == led_num){
				//ON
				HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_SET);
			}else{
				//OFF
				HAL_GPIO_WritePin(mygroup[i],mypin[i],GPIO_PIN_RESET);
			}
		}
		HAL_Delay(200);//0.2초 동안의 스파크는 무시하겠다!
	}
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex7.zip

0.00MB

[STM32#01] STM32F103RB NUCLEO보드와 STM32CubeIDE를 이용해서 시작해보기!(녹칸다 내맘대로 STM32/튜토리얼)

덕력킹 — Mon, 13 Oct 2025 23:14:14 +0900

https://youtube.com/live/ghofKLsPOV8

[STM32#01] STM32F103RB NUCLEO보드와 STM32CubeIDE를 이용해서 시작해보기!(녹칸다 내맘대로 STM32/튜토리얼)

심심한녹칸다의 내맘대로 STM32시리즈이다!

STM32시리즈의 모든 자료는 구글 슬라이드에 작성하고 모두에게 공유되어있음!
https://docs.google.com/presentation/d/1myA5iYbjuKsLWLqtRLKAiRfwUwvqB1d1RGjiMIIgp3I/edit?slide=id.p#slide=id.p

STM32시리즈에서 사용하는 보조도구는 아래 녹칸다의 블로그에 거버파일과 BOM이 있음!
https://bota.tistory.com/2442

이번편은 녹칸다의 내맘대로 STM32시리즈의 시작하기 편으로 어떻게 시리즈를 이끌어 나갈지를 알아보도록 한다!
그리고 기본적으로 필요한 준비물과 기능들을 알아보고 처음부터 차근차근 녹칸다와 함께 STM32를 해보도록 한다!

1.STM32의 작동이 되는지 테스트 하기 위해서 LED를 1개 1초 간격으로 ON/OFF하는 예제를 구현하시오!

while (1)
 {
	  //PB3 ON
	  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_SET); //ON
	  //1000ms delay
	  HAL_Delay(1000);
	  //PB3 OFF
	  HAL_GPIO_WritePin(GPIOB,GPIO_PIN_3,GPIO_PIN_RESET);  //OFF
	  //1000ms delay
	  HAL_Delay(1000);
	 
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex1.zip

0.00MB

2.IOC에서 PB3핀을 LED1이라는 별명을 붙혀서 예제 1과 동일하게 제어해보시오!

while (1)
 {
	  //PB3 ON
	  HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_SET); //ON
	  //1000ms delay
	  HAL_Delay(1000);
	  //PB3 OFF
	  HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_RESET);  //OFF
	  //1000ms delay
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex2.zip

0.00MB

3.녹칸다가 달아놓은 8개의 LED를 1초 간격으로 모두 ON/OFF하시오!

while (1)
 {
	  //ALL ON
	  HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED3_GPIO_Port,LED3_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED4_GPIO_Port,LED4_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED5_GPIO_Port,LED5_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED6_GPIO_Port,LED6_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED7_GPIO_Port,LED7_Pin,GPIO_PIN_SET); //ON
	  HAL_GPIO_WritePin(LED8_GPIO_Port,LED8_Pin,GPIO_PIN_SET); //ON
	  //1000ms delay
	  HAL_Delay(1000);
	  //ALL OFF
	  HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED3_GPIO_Port,LED3_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED4_GPIO_Port,LED4_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED5_GPIO_Port,LED5_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED6_GPIO_Port,LED6_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED7_GPIO_Port,LED7_Pin,GPIO_PIN_RESET); //ON
	  HAL_GPIO_WritePin(LED8_GPIO_Port,LED8_Pin,GPIO_PIN_RESET); //ON
	  //1000ms delay
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex3.zip

0.00MB

4.LED가 8개 있는데, 극단적으로 1000개쯤 된다고 하면 관리하기가 상당히 어렵겠지? 그러면 일괄적으로 동시에 ON/OFF하려면 어떻게 하면 좋을까?(반복문)

/* USER CODE BEGIN 2 */
 GPIO_TypeDef *Nockanda_port[] = {LED1_GPIO_Port,LED2_GPIO_Port,LED3_GPIO_Port,LED4_GPIO_Port,LED5_GPIO_Port,LED6_GPIO_Port,LED7_GPIO_Port,LED8_GPIO_Port};
 uint16_t Nockanda_pin[] = {LED1_Pin,LED2_Pin,LED3_Pin,LED4_Pin,LED5_Pin,LED6_Pin,LED7_Pin,LED8_Pin};
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
	  //ALL ON
	  for(int i = 0;i<8;i++){
		  HAL_GPIO_WritePin(Nockanda_port[i],Nockanda_pin[i],GPIO_PIN_SET); //ON
	  }
	  //1000ms delay
	  HAL_Delay(1000);
	  //ALL OFF
	  for(int i = 0;i<8;i++){
		  HAL_GPIO_WritePin(Nockanda_port[i],Nockanda_pin[i],GPIO_PIN_RESET); //OFF
	  }
	  //1000ms delay
	  HAL_Delay(1000);
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
 }

ex4.zip

0.00MB