Embeded-Korea

5. 아두이노 우노 Atmega328P 타이머로 1초 만들기.

18진수 — Thu, 30 Jan 2025 13:19:07 +0900

자. 저번 글에서 delay 함수를 통해 LED를 1초 간격으로 Blinking 하는 예제를 만들어보았다.

하지만 그 단점으로 delay 동안 다른 동작을 할 수 없으므로 사용할 때 조심해야 한다 했으며, 타이머라는 것을 통해 똑같이 Blinking 을 구현한다고 하였다.

타이머란 무엇인가?

말 그대로 타이머는 시간을 재는 것이다. 아래 그림을 봐보자. 도망가지 말도록하자. 딥하게 들어가는건 다음이지만 대충 Timer/Counter가 어떻게 해서 시간을 재는지 정도의 플로우만 이해했으면 해서 데이터 시트의 그림을 첨부했다.

아두이노 우노 보드를 자세히 보면, 아래와 같이 외부 발진기가 존재한다. 당연히 Atmega328P 칩 내에도 내부 발진기가 존재하나 외부 발진기가 안정성과 정확도가 더 높으므로 보통 보드를 사면 외부 발진기가 거의 존재한다.

외부 발진기에서 클럭을 생성하는데 Clock MultiPlexer의 역할은 간단하다. 다양한 외부 발진기들이 있는데 그 중 하나를 골라주는 것이다. 자, Multiplexer(분배기)에서 나온 클럭이 Prescaler(분주기)로 흘러들어간다. 프리스케일러는 무엇일까?

음... 어떻게 설명해야할까? 클럭 주파수를 쪼개어 더 긴 시간 간격을 잴 수 있게끔 하기 위한 장치라고 생각하면 이해를 할 수있을까? 아래 예시를 잠깐 들어보았는데, 이해하기 쉽지 않다. 그냥 클럭 주파수를 쪼갠다는 개념으로만 이해해줘도 크게 문제될건 없다. 구현하다보면서 자연스럽게 이해되기 때문이다.

16비트 타이머 예시:
=65,535 (16비트로 표현할 수 있는 가장 큰 값)
- 16MHz 클럭 → 4.096μs당 오버플로 → 0.27ms 밖에 측정 불가
- 분주기 1024 적용 → 16MHz/1024 = 15.625kHz → 4.194초 측정 가능

프리스케일러에서 출력된 클럭이 Control Unit에 들어가 최종 사용되는 타이머, ADC 등 여러 사용되는 곳이기 때문에 이 클럭 개념은 굉장히 중요하다.

타이머로 1초 만들기

회로는 저번이랑 동일하고 코드를 먼저 보여주겠다.

#define F_CPU 16000000UL  // CPU 클럭 속도
#include <avr/io.h>
#include <avr/interrupt.h>

#define LED_RED 2

void Timer1_Init() {
	TCCR1B |= (1 << WGM12);				  /* CTC 모드 설정 (Clear Timer on Compare Match) */
	TCCR1B |= (1 << CS12) | (1 << CS10);  /* 프리스케일러 1024 설정 */
	OCR1A = 15624;						  /* 비교 값 설정 (16MHz / 1024 / 1Hz - 1) */
	TIMSK1 |= (1 << OCIE1A);			  /* 비교 매치 인터럽트 활성화 */
}

void Task10ms_Init(){
	Timer1_Init();				/* 타이머 초기화 */
	
	DDRD |= (1 << LED_RED);		/* PD2 핀을 출력으로 설정 */
	PORTD &= ~(1 << LED_RED);   /* 초기 LED OFF */
	
}

void Task10ms_Main(){
	PORTD ^= (1 << LED_RED);  /* PD2 핀 토글 (LED ON/OFF) */
}

ISR(TIMER1_COMPA_vect) {
	Task10ms_Main();
}

int main(void) {
	Task10ms_Init();			
	sei();					/* 전역 인터럽트 활성화 */

	while (1) {
		
	}

	return 0;
}

코드는 Timer1_Init() 함수를 이해하면 오늘 포스팅도 끝이다.

void Timer1_Init() {
    TCCR1B |= (1 << WGM12);    // CTC 모드 활성화
    TCCR1B |= (1 << CS12) | (1 << CS10);  // 분주기 1024
    OCR1A = 15624;             // 비교값 설정
    TIMSK1 |= (1 << OCIE1A);   // 비교 매치 인터럽트 활성화
}

CTC 모드 : 타이머가 OCR1A 값 도달했을 때 자동 리셋되는 모드

분주기 계산은 아래와 같다.

분주된 클럭은 15,625인데 OCR1A는 15,624일까?

이유는 간단하다. 컴퓨터는 0부터 시작하기 때문이다.

아래 데이터 시트에 관련 챕터들을 필요한 부분만 체크하여 넣어놨으니 한 번 읽어보길 바란다.

ISR(TIMER1_COMPA_vect) {
	Task10ms_Main();
}

타이머가 1초를 지나면 인터럽트가 발생하여 ISR (인터럽트 서비스 루틴)을 발생시킨다. 이제 그 호출되는 함수에 LED 블링킹 로직을 추가하면 된다.

10ms, 100us 등 다양한 타이머를 계산하여 만들 수 있는데, 계산만 잘하면 충분히 구현할 수 있다. 하지만 데이터시트를 보게되면 다양한 모드들이 있는데 CTC 뿐만 아니라 FAST PWM 등 다양한 모드들이 있다. 결국 원리만 이해하여 데이터 시트만 잘 분석하면 누구든 설계를 할 수 있다. 원리는 시간을 잰다 그 이상 그 이하도 아니다.

참고

CTC 모드에 관해 올려두었으니 읽어보길 바란다.

4. 아두이노 우노 ATmega328P LED 출력하기 (DDR, PORT)

18진수 — Wed, 29 Jan 2025 02:42:33 +0900

처음 코딩 공부를 시작할 때, CMD 창에 Hello World!를 가장 먼저 출력해본다.

과연 임베디드 세계에서는 어떨까?

임베디드 설계에서 Hello World는 굉장히 어려운 일이다.

그렇다면 임베디드 공부를 처음 시작할 때, 해보는 것은 뭘까?

바로 LED 켜보기이다.

그래서 우리도 LED를 켜보려고 한다.

가장 싸고 흔한 발광 다이오드이다.

하나만 기억하자. 전기는 (+) → (-) 로 흐르는 것만 기억하고 저항이 없으면 LED가 버틸 수 없으므로 저항은 적당한거 하나 ANODE 쪽에 달아주자.

아래 그림처럼 회로를 구성하였다.

하나 main.c 코드를 복붙한 후, 빌드를 해보자. 빌드 Success가 뜨고 object, hex, elf 파일이 생겼을 것이다. 나중에 하나하나 설명할 것이니 일단은 넘어가자.

#define F_CPU 16000000L // CPU 클럭 속도
#include <avr/io.h>
#include <util/delay.h>

int main(void) {
	DDRD = 0x04U;			// PD2를 출력으로 설정

	while (1) {
		PORTD = 0x04U;		// LED ON
		_delay_ms(1000);    // 1초 대기
		PORTD = 0x0U;		// LED OFF
		_delay_ms(1000);    // 1초 대기
	}

	return 0;
}

AVRISP mkII ISP 프로그래머를 연결해본다. Apply를 눌러보면, Interface Settings에 ISP Clock이 제일 먼저 보일 것이다.

ISP는 SPI 라고 간단히 생각하고, 아래 문구를 보게 되면 device의 주파수의 1/4보다 낮은 값으로 설정하라고 한다. Atmega328P 칩은 내부 오실레이터 주파수가 8MHz 이므로 대략 2MHz보다 낮으면 된다. (하지만 아두이노 우노 보드의 경우, 외부 오실레이터 16MHz를 사용하나 Fuse bit를 설정하여 이를 조절할 수 있다. 근데 125kHz도 충분히 빠르니 내비두자.)

Memories 로 가보면 Flash (32KB) 가 보일 것이다. 실제 플레쉬 영역에 우리가 빌드한 Hex 파일을 ISP 방식으로 집어 넣는 것이다. Program을 누르면 Flash 영역을 한번 싹 0xFF로 밀어버린 후, Hex를 집어넣으므로 기존 아두이노 부트로더를 날라갈 것이다. 더 이상 우리가 알던 아두이노 방식으로는 개발을 할 수 없다. ㅋㄷ (ISP로 부트로더 다시 집어넣으면 됨)

https://youtube.com/shorts/vJ8pUajn1kU?si=OGNoKXAHvJf-BCJp

_delay_ms는 말 그대로 MCU를 강제로 지연시키는 것이고, 우리가 알아야 하는 키워드가 2가지가 있다.

DDR

DDR에 대해 알아보자. 이제는 Atmega328P의 데이터시트를 확인해야 한다.

DDR 설정

1: 출력 설정
0: 입력 설정

DDRB = 0xFF;  // PORTB의 모든 핀을 출력으로 설정
DDRC = 0x00;  // PORTC의 모든 핀을 입력으로 설정
DDRD |= (1 << PD7);  // PORTD의 7번 핀만 출력으로 설정
DDRD &= ~(1 << PD0);  // PORTD의 0번 핀만 입력으로 설정

위 처럼 사용된다고 생각하면 된다. 입출력 결정한다.

코드를 보면 나는 PD2를 출력 모드로 사용하였다.

PORT

출력모드일 때 (DDRx = 1)

PORT = 1: HIGH (5V) 출력
PORT = 0: LOW (0V) 출력

PD2번에 LED를 연결하여 제어하고 있으므로 당연히 PORTD2 비트만 제어하여 LED를 제어한다. 크게 어렵지 않다. 굳이 설명할 필요도 없달까?

하지만 굳이 LED Blinking을 먼저 테스트한 이유는 첫 빌드 목적도 있지만 delay_ms 때문이다.

MCU 입장에서 delay는 정말 조심해야하는 동작이다.

MCU도 결국 컴퓨터이다. 초소형 컴퓨터.

MCU는 클럭에 의해 움직이는데, 클럭을 사람의 심장 박동으로 비교한다. 몸을 움직이지 않을 때는 심장 박동수가 내려가고 달리기를 하면 심장 박동수가 급격하게 뛴다.

Atmega328P라는 MCU 칩은 8MHz 라는 클럭(심장 박동)을 가지고 있다. 1초에 8,000,000 번을 뛰는 것이다. (사람은 기껏해야 1초에 60 ~ 120번 정도 뛸 것이다. ) 그만큼 소형 칩일지언정 컴퓨터는 엄청난 속도로 연산을 하고 있다. 이 엄청난 속도로 인해 0, 1을 엄청나게 빠른 속도로 처리하므로 우리는 동시에 움직이는 것처럼 보인다.

자. 과연 이렇게 빠른 속도로 연산하는 MCU를 강제로 delay_ms(1000)를 통해 1초를 쉬게 한다. 사람 입장에서는 짧은 시간이지만 컴퓨터 입장에선 엄청난 시간 소요이다. 불필요한 동작인 셈이다.

delay를 했다고 해서 과연 MCU의 클럭 또한 1초 만큼 멈출까? 아니다. 1초 동안 아무것도 하지말고 쉬라는 동작을 컴퓨터에게 명령을 한 것이며, 1초라는 시간을 재기 위해 클럭은 계속해서 발생시킨다.

간단한 동작에는 상관없지만, 센서가 늘어나고 로직이 추가되면 잘못 사용된 delay는 굉장히 버그를 유발시킬 수 있으며 타이밍을 어긋나게 할 수 있다.

delay를 쓰지말라는 것이 아니다. 적재적소에 사용되면 상관없지만 이번 코드에는 적절치 못하다는 것을 이야기하고 싶은 것이다.

다음 글은 Timer 라는 것을 통해 똑같은 기능이지만 새로운 방법을 소개해보려한다. delay와 한 번 비교해보길 바란다.

3. 아두이노 우노 관련 자료 소개

18진수 — Tue, 28 Jan 2025 17:51:08 +0900

아두이노 우노를 사용하여 설계를 하려면 그 보드에 대해 자세히 공부할 필요가 있다.

아래에 소개를 해놓을테니 참고하길 바란다. 이는 나에게도 해당한다.

아두이노 우노로 시작하면 좋은 점이 다양한 참고 자료와 확장 보드가 많다는 점이라고 하였다. 그 외에도 추천하는 이유는 더 있다.

1. UART To Serial (USB) 가 존재한다. UART To Serial 모듈을 굳이 사지 않더라도 컴퓨터에 연결하여 UART 통신 테스트를 해볼 수 있다. 처음 공부하는 사람들에게는 큰 장점이라고 생각한다.

U1 (CP2102):
- USB-시리얼 변환기 IC로, USB 신호를 TTL 레벨의 UART 신호로 변환한다.
- 아두이노 또는 다른 MCU와 PC 간의 UART 통신을 가능하게 한다.
U2 (PIC16F688-I/ST):
- Microchip의 8비트 마이크로컨트롤러.
- 이 회로에서 주된 제어 작업을 수행하거나 아두이노와 UART 통신을 통해 데이터를 주고받는다.

2. 5V, 3.3V

센서마다 동작하는 전압이 다르다. 어떤 센서는 5V, 어떤 센서는 3.3V. 근데 아두이노는 이미 5V, 3.3V 출력 전압을 사용할 수 있다. 편하다.

굳이 단점을 뽑자면 UART가 하나이지만, 굳이 단점인가 싶다.

어차피 SPI나 I2C는 하나여도 충분하다.

1. 아두이노 우노 핀맵

2. 회로도

schematic (1).pdf

0.02MB

3. Atmega328P 데이터시트

https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf

데이터시트에 방대한 내용이 있지만 차근차근 하나씩 보면 될 듯하다.

우선, 가장 먼저 해볼 것은 스위치와 LED이다.

데이터시트와 함께 하나씩 봐보면 충분히 이해할 수 있다고 생각한다.

2. 아두이노 소개 & Atmel Studio7 프로젝트 생성하기

18진수 — Mon, 27 Jan 2025 13:14:25 +0900

앞서 말했듯이 아두이노로 공부하기 위해서 2가지 재료가 필요하다고 했다.

아두이노 2개, ISP 다운로더

아두이노 IDE는 알아서 하길 바란다. 나는 Atmel Studio를 통해 개발을 할려고 한다.

Atmel Studio를 설치해야겠지?

https://www.microchip.com/en-us/tools-resources/develop/microchip-studio#Downloads

설치는 그냥 Next 갈기면 된다.

파일 -> Project

프로젝트명을 아무거나 해주십다. GCC C Executable Project 선택해줍니다.

아두이노 칩은 ATmega328P 이므로 선택해준다.

옆에 지원하는 툴을 보면 다양하게 보여준다. STK500이 있다. 우리가 싸게 주고산 ISP 방식이 STK500이다.

이렇게 생성이 끝이다.

그래도 빌드해보고 헥사 한 번 넣어봐야지.

빌드 한 번 깔끔하게 해보자. 당연히 아무것도 없으니 Build는 성공이다.

우측, 솔루션 탐색기를 봐보면 우리가 빌드해서 생성한 헥사 파일 및 설정파일들이 있다.

.hex 파일을 ISP 다운로더를 통해 칩에 직접 넣는 것이므로 경로를 알아야 한다. 그 외의 파일들은 지금 당장 중요하지 않으므로 나중에 설명하도록 한다.

Tools 에서 Device Programming을 누른다.

Tool을 보면 우리의 ISP 다운로더를 찾을 수 있다. 선택하고 Apply를 누른다.

아직 아두이노 다운로드는 할게아니라서 제대로 연결만 되는지 확인해본다.

자. 연결됐다면 ATmega328P에 Hex file을 넣을 준비가 되었다.

다음 글에 아두이노에 간단하게 헥사 파일을 넣어보자.

1. 임베디드 SW 취업에 관심 있는 취준생을 위하여.

18진수 — Sun, 26 Jan 2025 19:24:12 +0900

임베디드 SW 로 취직을 하고 싶은 사람들을 위해...

별로 추천해주고 싶지 않은 업종이지만, 그럼에도 관심있는 사람들을 위하여 기본적으로 어떻게 공부해야하는지 방향성 정도를 제시하는 정도의 교육을 위해 작성해보려 한다.

추천해주고 싶지 않은 이유는 업무 강도 및 진입에 비해 연봉이 다른 개발직군에 비해 짠 편이다.

네카라쿠배당토 (네이버, 카카오, 라인, 쿠팡, 배달의 민족, 당근, 토스 등등...) 라고 IT 취업 시장이 한창 인기 있을 때 많이 들어보았을 것이다. (지금은 많이 식었다...)

과연 저기에 임베디드 분야가 있는가? 없다...

내 대학원 시절 선배가 임베디드 업계는 사람이 없어서 대우가 좋다는데... 쓰읍 전자의 말은 맞지만, 후자의 말은 틀렸다.

(그래도 업계에 사람이 적으므로, 나이 많이 먹고도 설계직군으로 우려먹을 수 있다는 장점이 있긴 하다.)

솔직히 이 때는 다들 학생 시절인데 무엇을 알겠는가.

임베디드 업계가 다른 업계에 비해 짠 이유는 나름의 생각을 정리해보았다.

1. 중국

중국 제품 및 부품들이 너무 싸기 때문에 국내 제품들이 가격 경쟁력을 잃어가고 있다. 이미 우리는 체감을 하고 있다. 찍어 내기식으로 알리, 테무 같은 플랫폼을 통해 무지하게 싼 가격으로 팔고 있다는 것을 알 수 있다. 그러므로 당연히 기업입장에서는 퀄리티 차이가 엄청 나지 않는다면 국내 부품사를 사용할 이유가 없는 것이다. 한국은 비싼 인건비, 재료비, 유통 등 중국과 경쟁을 할 수가 없다. 특히나 시진핑이 기업에게 전폭적인 지원을 통해 밀고 나가고 있으니... 말 다한 셈이다.

2. 제조업

임베디드 설계는 제조업과 엮일 수 밖에 없다. 네카라쿠배당토를 생각해보자. IT가 메인인 회사이다. 하지만 임베디드는 애초에 메인이 될 수 없다. 메인은 제조업이다. 제조업 특성 상, IT를 등한시하는 경향이 굉장히 크다. 회사 측면에서 금형, 제조, 메카가 메인이다. 금형이 잘못나오면 몇 억 손실이 나므로 다들 포커스가 그쪽으로 쏠린다. 하지만 이는 장기적으로 시간이 지났을 때, 나아질 수 있는 충분한 여지가 있다. 점점 제품들은 스마트해지므로 소프트 설계자들의 입지가 올라가고 있다. 지금 당장 우리회사만 보더라도 소프트웨어 설계자들의 대우가 나아지고 있다. 하지만 그 반대로 다른 직무 인원들의 반발도 같이 올라간다. 이 부분은 시간이 해결해줄 것이다.

그렇다면, 임베디드 설계는 정말 별로인가?

괜찮은 직무도 꽤 많다.

가전, 자동차 분야 쪽이다.

당장에서도 나는 전장부품(자동차 부품) 설계팀에 속해 있고 현재 설계해야할 제품이 넘치고 넘친다. 일 없어서 걱정할 필요가 없다. 그리고 다른 분야에 비해 설계자가 한참 부족하므로 나이먹고도 설계를 계속 해먹을 수 있다. 이건 정말 큰 장점인 듯하다.

임베디드는 진입 장벽이 굉장히 높다. 알아야 할 것들도 많고. 하지만 한 번 알아두면 내가 봤을 땐, 기존의 컴퓨터 체계(0, 1)가 바뀌지 않는다면 평생 써먹을 수 있는 지식들이다. 그리고 AI 가 다른 분야보다 대체하기 어렵다고 생각한다. 당연히 데이터시트를 대신 분석해주는 등 도우미 역할로는 좋지만, 오실로스코프나 멀티미터 등은 AI가 해줄 수 없기 때문이다.

고로 알아서 판단하길 바란다. 다른 설계자들의 자문도 구해보라. 난 잘 모르겠다. 만약 내가 말한 단점을 보고 이 분야에 관심이 사라졌다면 바로 나가길 바란다. 아래부터는 임베디드 SW를 공부하고 싶은데 뭘 해야할지 모르는 사람들을 위한 것이다. 나도 임베디드 공부를 하려고 했을 때 뭘 해야할지 몰랐다. 근데 다들 하는 말이 뭐든 만들라고 한다. 그게 쉬운게 아닌데 말들은 잘한다.

임베디드 공부를 할려면 뭐든 만들어야지.

그런데 어떻게 만들 수 있을까?

진입하기 가장 좋은 보드가 있다. 바로 아두이노 이다.

아두이노로 일단 오픈소스 라이브러리가 많고 커뮤니티가 활성화되어 있기 때문에 그냥 해보면 된다. 그냥 아두이노 키트사가지고 해보길 바란다.

자. 그렇다면 임베디드 공부가 시작했는가? 난 아니라고 생각한다.

레지스터 하나 설정해보지 않고, 칩 문서도 안 본 자는 임베디드 공부해봤다고 하면 안된다.

새로 보드를 사야하는가? 아니다.

아두이노는 Atmega328P라는 칩의 플래시 영역에 부트로더를 얹어 간단하게 만들 수 있도록 설계된 교육용 보드이다. 고로 핀꼽기도 편하고 확장 보드도 많다.

내가 공부하는 방향은 부트로더를 날려버리고 실제 레지스터로 제어해보는 것이다. (GPIO, PWM 등등)

자세히 재료부터 말해보겠다. 정품이고 뭐고 필요 없다. 그냥 스펙 동일한 싼 우노 보드를 2개 사라.

다운로드용 ISP 이다. 부트로더를 날린 아두이노는 더 이상 기존 방식으로는 다운로드할 수 없고 아래 ISP 다운로더를 통해 헥사를 다운로드해야 한다.

아두이노는 일반 오픈소스를 통해 한 번 만들어 본다. 온도 센서를 예시로, 구글에 아두이노 온도 센서라고만 쳐도 무수히 많은 라이브러리와 블로그가 있다. 그대로 따라해보라.

만약, 만들었다면 이제 부트로더를 날린 아두이노 보드를 그대로 따라해보자. 레지스터 하나하나 건드려서. 라이브러리가 이미 있지 않은가. 그걸 그대로 AVR 식으로 변경한다고 생각해보자. 당연히 어렵다. 하지만 우리에겐 칩 데이터시트도 있고, ChatGPT도 있다. 제어할 수 있는 센서나 통신이 하나씩 늘어난다면, 어느 순간 자신감이 쌓여있을 것이다. 어셈블리어, 회로도, 쓰레드, RTOS 등 더 딥한 세계를 찾게 될 것이다.

누군가를 알려줄만큼 설계를 잘하는 설계자는 아니다. 다만 적어도 프로젝트를 받았을 때 제품을 끝까지 수행할 수 있는 설계자라고 단언코 말할 수 있다. 이를 가능하게 했던건 질문과 공부였던 것 같다. 질문의 종류는 두 개 이다. 선배들한테 하는 질문, 나에게 하는 질문. 나에게 하는 질문은 무엇인가? 설계를 찍어내다 보면 내 스스로가 뭘 하고 있는지 모를 때가 많다. 특히, 자동화 툴이 많아짐에 따라 내가 뭘 모르는지 모를 때가 많다. 그 때 질문하는 것이다. 스스로에게 질문했을 때, 무언가 막히고 안개가 낀 것 같다면 그 부분을 공부를 하는 것이다. 그렇게 하다보면 일인분 하는 사람이 될 수 있지 않을까?

18. STM32 I2C 통신 - AM1008W-K-P 동작 구현

18진수 — Sun, 5 Jan 2025 15:14:03 +0900

이 전 글에서 AM1008W-K-P 데이터시트와 I2C HAL 함수들을 소개했다. 이번 글은 위 정보들을 이용하여 아두이노와 똑같이 재현하도록 하겠다. 우선 프로젝트를 생성한다. 프로젝트 생성에 대한 내용은 생략하겠다.

1. I2C 설정

I2C 동작을 구현하기 위해 레지스터를 설정해주어야 하는데, CUBE IDE에서는 간단하게 GUI를 통해 생성할 수 있다.

I2C1와 USART1을 각각 활성화시킨다. (생략, 이 전글들 참고 바람)

USART1는 기본 115200을 사용할 것이므로 별도의 설정을 할 필요는 없지만 I2C1은 속도를 설정해주어야 한다.

AM1008W-K-P 센서는 30kbps 이하에서 동작하는 것이 스펙이다.

I2C1은 default 설정으로 standard 모드로 100kbps이다.

100kbps는 오버 스피드이므로 통신 속도를 스펙대로 낮출 필요가 있다.

I2C Speed를 30,000Hz로 변경한다.

STM32F103은 마스터로 동작하기 때문에 Slave Features는 건드릴 필요가 없다.

GPIO 설정으로 들어가 I2C Maximum output 스피드가 기본 High로 되어 있는데 Medium이나 Low 로 떨춰주어야 한다.

해당 핀맵을 통해 내장 GPIO Pull-up이 없기에 외장 Pull-up 저항을 써야하는 것을 알 수 있다.

이렇게 되면 설정은 완료되었고 코드를 생성한다.

여기서 UART를 활성화한 이유는 UART to Serial 을 통해 컴퓨터에서 값을 확인하기 위해서이다.

2. AM1008W-P-K 라이브러리

우리는 아두이노 글에서 AM1008W-K-P를 테스트하였다.

운이 좋게도 github에 코드(아두이노 + C++)들이 올라와 있었고 우리는 이를 STM32 + C언어로 변경해주면 된다.

여기서 팁 하나.

https://github.com/neosarchizo/am1008w_k_i2c/tree/main/src

am1008w_k_i2c/src at main · neosarchizo/am1008w_k_i2c

CUBIC AM1008W-K I2C library. Contribute to neosarchizo/am1008w_k_i2c development by creating an account on GitHub.

github.com

이제 개발자들도 조금 개발하는 스타일을 조금 스마트하게 가져갈 필요가 있다.

그것은 바로 chatgpt 이용하는 방법이다.

우리는 C++로 설계된 라이브러리를 C언어로 변경해야 하는데 GPT에게 던지면 간단히 변경할 수 있다. (나는 GPT4를 사용하는데 3.5는 성능이 어느정도 인지는 잘모르겠다.)

방법은 간단하다. 코드를 그대로 던져서 변경해달라고 하면 된다. 사소한 내용들은 debug하면 된다.

gpt가 c언어로 변경한 소스코드들이다.

3. am1008w_k_i2c.h

/*
 * am1008w_k_i2c.h
 *
 *  Created on: Jul 17, 2024
 *      Author: Yoon
 */

#ifndef SRC_AM1008W_K_I2C_H_
#define SRC_AM1008W_K_I2C_H_

#include <stdint.h>
#include "main.h"

#define AM1008W_K_I2C_ADDRESS 0x28

#define AM1008W_K_I2C_FRAME_STX 0x16
#define AM1008W_K_I2C_LEN_READ_DATA_COMMAND 25

#define AM1008W_K_I2C_PSO_CLOSE 0x00
#define AM1008W_K_I2C_PSO_TIMING_MEASURING_MODE 0x05
#define AM1008W_K_I2C_PSO_DYNAMIC_MEASURING_MODE 0x06
#define AM1008W_K_I2C_PSO_CONTINOUS_MEASURING_MODE 0x0C
#define AM1008W_K_I2C_PSO_SINGLE_MEASURING_MODE 0x0D

#define AM1008W_K_I2C_CTRL_CLOSE_MEASUREMENT 0x01
#define AM1008W_K_I2C_CTRL_OPEN_MEASUREMENT 0x02
#define AM1008W_K_I2C_CTRL_CO2_CALIBRATION 0x03
#define AM1008W_K_I2C_CTRL_SET_UP_TIMING_MEASUREMENT 0x05
#define AM1008W_K_I2C_CTRL_SET_UP_DYNAMIC_MEASUREMENT 0x06
#define AM1008W_K_I2C_CTRL_SET_UP_PM_CALIBRATION_COEFFICIENT 0x07
#define AM1008W_K_I2C_CTRL_SET_UP_CONTINUOUSLY_MEASUREMENT 0x0C
#define AM1008W_K_I2C_CTRL_SET_UP_SINGLE_MEASUREMENT 0x0D

typedef union
{
    uint8_t value;
    struct
    {
        uint8_t fan_at_high_revolving_speed:1;
        uint8_t fan_at_low_revolving_speed:1;
        uint8_t working_temperature_is_high:1;
        uint8_t working_temperature_is_low:1;
    } bits;
} am1008w_k_i2c_status;

#ifdef __cplusplus
extern "C" {
#endif

void am1008w_k_i2c_begin(I2C_HandleTypeDef *hi2c);
uint8_t am1008w_k_i2c_pm_sensor_mode_close();
uint8_t am1008w_k_i2c_pm_sensor_mode_open();
uint8_t am1008w_k_i2c_pm_sensor_mode_single_measurement(uint16_t range);
uint8_t am1008w_k_i2c_pm_sensor_mode_continuously_measurement();
uint8_t am1008w_k_i2c_pm_sensor_mode_timing_measurement(uint16_t range);
uint8_t am1008w_k_i2c_pm_sensor_mode_dynamic_measurement();
uint8_t am1008w_k_i2c_set_pm_coefficient(uint8_t range);
uint8_t am1008w_k_i2c_calibrate_co2(uint16_t range);
uint8_t am1008w_k_i2c_read_data_command();
uint8_t am1008w_k_i2c_get_pm_operation_mode();
uint16_t am1008w_k_i2c_get_co2();
uint16_t am1008w_k_i2c_get_voc();
int am1008w_k_i2c_get_humidity();
int am1008w_k_i2c_get_temperature();
uint16_t am1008w_k_i2c_get_pm1p0();
uint16_t am1008w_k_i2c_get_pm2p5();
uint16_t am1008w_k_i2c_get_pm10();
uint16_t am1008w_k_i2c_get_voc_now_r_ref_r();
uint16_t am1008w_k_i2c_get_voc_ref_r();
uint16_t am1008w_k_i2c_get_voc_now_r();
am1008w_k_i2c_status am1008w_k_i2c_get_pm_sensor_status_alarm();

#ifdef __cplusplus
}
#endif

#endif /* SRC_AM1008W_K_I2C_H_ */

4. am1008w_k_i2c.c

/*
 * am1008w_k_i2c.c
 *
 *  Created on: Jul 17, 2024
 *      Author: Yoon
 */
#include "am1008w_k_i2c.h"

static I2C_HandleTypeDef *mhi2c;
static uint8_t _buffer[32];
static uint8_t _pm_operation_mode;
static uint16_t _co2;
static uint16_t _voc;
static int _humidity;
static int _temperature;
static uint16_t _pm1p0;
static uint16_t _pm2p5;
static uint16_t _pm10;
static uint16_t _voc_now_r_ref_r;
static uint16_t _voc_ref_r;
static uint16_t _voc_now_r;
static am1008w_k_i2c_status _pm_sensor_status_alarm;

void am1008w_k_i2c_begin(I2C_HandleTypeDef *hi2c) {
    mhi2c = hi2c;
}

uint8_t am1008w_k_i2c_send_command_data(uint8_t ctrl, uint16_t data) {
    uint8_t tx_data[7] = {0};
    tx_data[0] = AM1008W_K_I2C_FRAME_STX;
    tx_data[1] = 7; // FRAME LENGTH
    tx_data[2] = ctrl; // Control Command of the PM Sensor
    tx_data[3] = (data >> 8) & 0xff; // high byte of data
    tx_data[4] = data & 0xff; // low byte of data
    tx_data[5] = 0;

    uint8_t cs = tx_data[0];
    for (uint8_t i = 1; i < 6; i++) {
        cs ^= tx_data[i];
    }
    tx_data[6] = cs;

    HAL_I2C_Master_Transmit(mhi2c, AM1008W_K_I2C_ADDRESS << 1, tx_data, 7, HAL_MAX_DELAY);

    return 0;
}

uint8_t am1008w_k_i2c_pm_sensor_mode_close() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_CLOSE_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_open() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_OPEN_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_single_measurement(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_SINGLE_MEASUREMENT, range);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_continuously_measurement() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_CONTINUOUSLY_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_timing_measurement(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_TIMING_MEASUREMENT, range);
}

uint8_t am1008w_k_i2c_pm_sensor_mode_dynamic_measurement() {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_DYNAMIC_MEASUREMENT, 0);
}

uint8_t am1008w_k_i2c_set_pm_coefficient(uint8_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_SET_UP_PM_CALIBRATION_COEFFICIENT, range);
}

uint8_t am1008w_k_i2c_calibrate_co2(uint16_t range) {
    return am1008w_k_i2c_send_command_data(AM1008W_K_I2C_CTRL_CO2_CALIBRATION, range);
}

uint8_t am1008w_k_i2c_read_data_command() {

    HAL_I2C_Master_Receive(mhi2c, (AM1008W_K_I2C_ADDRESS << 1) | 1, _buffer, 25, HAL_MAX_DELAY);

    uint8_t idx = 0;

    if (_buffer[0] != AM1008W_K_I2C_FRAME_STX) {
        return 2; // Frame header different
    }

    if (_buffer[1] != AM1008W_K_I2C_LEN_READ_DATA_COMMAND) {
        return 3; // Frame length different
    }

    uint8_t check_code = _buffer[0];
    for (uint8_t i = 1; i < AM1008W_K_I2C_LEN_READ_DATA_COMMAND - 1; i++) {
        check_code ^= _buffer[i];
    }

    if (_buffer[AM1008W_K_I2C_LEN_READ_DATA_COMMAND - 1] != check_code) {
        return 4; // Checksum wrong
    }

    _pm_operation_mode = _buffer[2];
    _co2 = (_buffer[3] << 8) + _buffer[4];
    _voc = (_buffer[5] << 8) + _buffer[6];
    _humidity = ((_buffer[7] << 8) + _buffer[8]);
    _temperature = ((_buffer[9] << 8) + _buffer[10] - 500);
    _pm1p0 = (_buffer[11] << 8) + _buffer[12];
    _pm2p5 = (_buffer[13] << 8) + _buffer[14];
    _pm10 = (_buffer[15] << 8) + _buffer[16];
    _voc_now_r_ref_r = (_buffer[17] << 8) + _buffer[18];
    _voc_ref_r = (_buffer[19] << 8) + _buffer[20];
    _voc_now_r = (_buffer[21] << 8) + _buffer[22];
    _pm_sensor_status_alarm.value = _buffer[23];

    return 0;
}

uint8_t am1008w_k_i2c_get_pm_operation_mode() {
    return _pm_operation_mode;
}

uint16_t am1008w_k_i2c_get_co2() {
    return _co2;
}

uint16_t am1008w_k_i2c_get_voc() {
    return _voc;
}

int am1008w_k_i2c_get_humidity() {
    return _humidity;
}

int am1008w_k_i2c_get_temperature() {
    return _temperature;
}

uint16_t am1008w_k_i2c_get_pm1p0() {
    return _pm1p0;
}

uint16_t am1008w_k_i2c_get_pm2p5() {
    return _pm2p5;
}

uint16_t am1008w_k_i2c_get_pm10() {
    return _pm10;
}

uint16_t am1008w_k_i2c_get_voc_now_r_ref_r() {
    return _voc_now_r_ref_r;
}

uint16_t am1008w_k_i2c_get_voc_ref_r() {
    return _voc_ref_r;
}

uint16_t am1008w_k_i2c_get_voc_now_r() {
    return _voc_now_r;
}

am1008w_k_i2c_status am1008w_k_i2c_get_pm_sensor_status_alarm() {
    return _pm_sensor_status_alarm;
}

5. main.c

#include "main.h"
#include am1008w_k_i2c.h

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

...

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

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

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

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_I2C1_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  am1008w_k_i2c_begin(&hi2c1);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  char buffer[100];

  while (1)
  {

	  am1008w_k_i2c_read_data_command();

	  int humidity = am1008w_k_i2c_get_humidity();
	  int temperature = am1008w_k_i2c_get_temperature();

	  uint16_t voc = am1008w_k_i2c_get_voc();
	  uint16_t co2 = am1008w_k_i2c_get_co2();
	  uint16_t pm1p0 = am1008w_k_i2c_get_pm1p0();
	  uint16_t pm2p5 = am1008w_k_i2c_get_pm2p5();
	  uint16_t pm10  = am1008w_k_i2c_get_pm10();

	  sprintf(buffer, "Humidity: %d.%02d %%, Temperature: %d.%02d C\r\n",
			  humidity / 10, humidity % 10, temperature / 10, temperature % 10);

	  HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), 1000);

	  sprintf(buffer, "CO2: %d ppm, VOC: %d ppb, PM1.0: %d, PM2.5: %d, PM10: %d\r\n",
	                  co2, voc, pm1p0, pm2p5, pm10);

	  HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), 1000);
	  HAL_Delay(1000);


    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */
}

아예 GPT가 생성해준 코드를 그대로 갖다쓴건 아니고, 내가 어느 정도 디버깅을 한 코드들이다.

6. 회로 구성

이 회로와 똑같이 구성을 해주었다. 다만 10K옴을 4.7K옴으로 대체하였다. (외부 풀업 저항을 사용해야 함.)

7. 동작 확인

정상적으로 동작하는 것을 확인하였으며 모니터를 통해 데이터가 제대로 출력되는 것을 확인한다.

https://youtube.com/shorts/TRYy-_zhIGg?si=BBddmJtvnHsqUXOM

다음 글로는 FTDI 를 블루투스로 대체하고, 현재 String으로 데이터를 표출하는데 패킷을 절약할 수 있게끔 코드를 변경할 예정이다.

또한 블루투스는 무선 통신이니 그 패킷에 가능하다면 Checksum 로직을 추가하여 데이터의 신뢰성을 높여볼 것이다.

내가 생성한 라이브러리는 첨부파일로 추가해놓으니 참고하면 좋을 것 같다.

am1008w_k_i2c.zip

0.00MB

[STM32] 17. I2C 통신 함수 종류

18진수 — Thu, 5 Dec 2024 01:14:45 +0900

1. 주요 I2C HAL 함수

STM32Cube HAL 기능을 기반으로 차단 모드, 인터럽트 모드 또는 DMA 모드의 3가지 모드로 I2C 데이터 전송을 수행할 수 있다.

⚙️ 1. Blocking Mode

통신은 폴링 모드로 수행되며, 모든 데이터 처리 상태는 전송 완료 후 동일한 기능으로 반환된다.

HAL_I2C_Master_Transmit()
HAL_I2C_Master_Receive()
HAL_I2C_Slave_Transmit()
HAL_I2C_Slave_Receive()
HAL_I2C_Mem_Write()
HAL_I2C_Mem_Read()

⚙️ 2. Non-Blocking Mode

통신은 Interrupts 또는 DMA를 사용하여 수행되며, 이러한 함수는 전송 시작 상태를 반환한다.

인터럽트 모드를 사용할 때는 전용 I2C IRQ를 통해, DMA 모드를 사용할 때는 DMA IRQ를 통해 데이터 처리가 종료됨을 알 수 있다.

Interrupt Mode

HAL_I2C_Master_Transmit_IT()
HAL_I2C_Master_Receive_IT()
HAL_I2C_Slave_Transmit_IT()
HAL_I2C_Slave_Receive_IT()
HAL_I2C_Mem_Write_IT()
HAL_I2C_Mem_Read_IT()

DMA Mode

HAL_I2C_Master_Transmit_DMA()
HAL_I2C_Master_Receive_DMA()
HAL_I2C_Slave_Transmit_DMA()
HAL_I2C_Slave_Receive_DMA()
HAL_I2C_Mem_Write_DMA()
HAL_I2C_Mem_Read_DMA()

2. I2C 설정

⚙️ 1. STM32CubeMX 프로젝트 열기

⚙️ 2. I2C 설정

⚙️ 3. I2C 파라미터 설정

3. 코드

1. HAL_StatusTypeDef

HAL_I2C 함수들의 반환 자료형인 StatusTypeDef의 정의는 다음과 같다.

typedef enum{
  HAL_I2C_STATE_RESET             = 0x00U,   /*!< Peripheral is not yet Initialized         */
  HAL_I2C_STATE_READY             = 0x20U,   /*!< Peripheral Initialized and ready for use  */
  HAL_I2C_STATE_BUSY              = 0x24U,   /*!< An internal process is ongoing            */
  HAL_I2C_STATE_BUSY_TX           = 0x21U,   /*!< Data Transmission process is ongoing      */
  HAL_I2C_STATE_BUSY_RX           = 0x22U,   /*!< Data Reception process is ongoing         */
  HAL_I2C_STATE_LISTEN            = 0x28U,   /*!< Address Listen Mode is ongoing            */
  HAL_I2C_STATE_BUSY_TX_LISTEN    = 0x29U,   /*!< Address Listen Mode and Data Transmission
                                                 process is ongoing                         */
  HAL_I2C_STATE_BUSY_RX_LISTEN    = 0x2AU,   /*!< Address Listen Mode and Data Reception
                                                 process is ongoing                         */
  HAL_I2C_STATE_ABORT             = 0x60U,   /*!< Abort user request ongoing                */
  HAL_I2C_STATE_TIMEOUT           = 0xA0U,   /*!< Timeout state                             */
  HAL_I2C_STATE_ERROR             = 0xE0U    /*!< Error                                     */

}HAL_I2C_StateTypeDef;

2. HAL_I2C_Master_Transmit

특정 I2C Slave에 바이트 데이터를 보내는 함수이다.

HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)

hi2c: I2C 핸들의 주소
DevAddress: I2C Slave의 8bit 주소
pData: 버퍼 배열의 주소
Size: 전송할 데이터의 바이트 수
Timeout: 최대 지연 시간 [ms]

3. HAL_I2C_Mem_Write

I2C를 통하여 Repeated Start 명령을 주기 위해서는 다음과 같은 함수들을 이용한다.
단순히 HAL_I2C_Master_Write와 HAL_I2C_Master_Read를 연달아 호출하는 것으로는 정상 작동 하지 않는다.
하지만 다음과 같은 함수를 통하여 쉽게 사용할 수 있다.

HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)

hi2c : I2C 핸들의 주소
DevAddress : I2C Slave의 주소MemAddress : I2C Slave에서 쓰기 할 레지스터의 주소
MemAddSize : 주소의 바이트 수(1byte->1, 2byte->2)
pData : 버퍼 배열의 주소
Size : 레지스터에 쓰기 할 바이트 수
Timeout : 최대 지연 시간 [ms]

4. HAL_I2C_GetState

현재 I2C Peripheral의 상태를 반환한다.

HAL_I2C_StateTypeDef HAL_I2C_GetState(I2C_HandleTypeDef *hi2c)
#define SLAVE_ADDR 0x27 << 1
HAL_StatusTypeDef error;
uint8_t buffer[128] = {0x3F, 0xDD, 0x54};
error = HAL_I2C_Master_Transmit(&hi2c1, SLAVE_ADDR, buffer, 3, HAL_MAX_DELAY);
if (error != HAL_OK) while();

// I2C의 전송이 완료될 때까지 대기
while(HAL_I2C_GetState(&hi2c1) != HAL_I2C_STATE_READY);

HAL_I2C_GetError

정수 형태의 에러 코드를 반환하는 코드이다.

uint32_t HAL_I2C_GetError(I2C_HandleTypeDef *hi2c)

#define HAL_I2C_ERROR_NONE       0x00000000U    /*!< No error           */
#define HAL_I2C_ERROR_BERR       0x00000001U    /*!< BERR error         */
#define HAL_I2C_ERROR_ARLO       0x00000002U    /*!< ARLO error         */
#define HAL_I2C_ERROR_AF         0x00000004U    /*!< AF error           */
#define HAL_I2C_ERROR_OVR        0x00000008U    /*!< OVR error          */
#define HAL_I2C_ERROR_DMA        0x00000010U    /*!< DMA transfer error */
#define HAL_I2C_ERROR_TIMEOUT    0x00000020U    /*!< Timeout Error      */

[STM32] 16. I2C 센서 소개 (미세먼지/이산화탄소 복합 공기질 센서 CUBIC - AM1008W-K-P)

18진수 — Wed, 4 Dec 2024 23:37:06 +0900

STM32 I2C 통신을 이용해 테스트를 해볼 센서는 복합 공기질 센서 AM1008W-K-P 모델이다.

해당 센서는 주위 미세먼지와 이산화탄소 농도를 알려주는 복합 공기질 센서이며, 미세먼지 (PM), VOC, 이산화탄소, 온습도 측정이 가능하다.

➡️ 1. Features

미세먼지(GRIMM 방식), 이산화탄소, VOC, 온습도
공급 전압 : 5V
노이즈 방지를 위한 금속 차폐
통신 방식 : I2C, UART
크기 : 80(W) x 50(H) x 13.6(D) [mm]

➡️ 2. Application Ideas

Air Purifier
Air Quality Monitor
Air Conditioner
Ventilation System
Consumer electronic products
Environmental monitoring

➡️ 3. Specification

Operating principle	CO2: NDIR technology PM: laser scattering technology VOC: semiconductor
Measurement range	PM: 0 ~ 1,000ug/m³ CO2: 0 ~ 5,000ppm VOC: 0 ~ 3 level Temperature: -40°C~85°C RH: 5 ~ 95%RH
Maximum consistency error for PM1.0/PM2.5	≤100ug/m³, ±10ug/m³ >100ug/m³, ±10% ofreading Condition: 25 ±2°C, 50±10%RH, Reference instrument: GRIMM 11-A Dust Source: Cigarette + Arizona A1
Maximum consistency error for PM10	0 ~ 100ug/m³, ±25ug/m³ 101 ~ 1,000ug/m³, ±25% reading Condition: 25 ±2°C,50±10%RH, Reference instrument: GRIMM 11-A Dust Source: Cigarette + Arizona A1
CO2 measurement accuracy	± (50ppm+5% of reading) @25 ±2°C, 50 ±10%RH ± (50ppm+3%of reading) @25 ±2°C, 50 ±10%RH(Option)
Temperature accuracy	±0.4 °C (max), –10 ~ 85 °C
Humidity accuracy	± 3% RH (max), 0~ 80% RH
PM preheating time	≤8 sec
CO2 preheating time	≤30 sec
VOC preheating time	≤120 sec
Data refresh rate	1 sec
Working condition	-10 ~ 50°C, 0 ~ 99%RH (Non-condensing)
Storage condition	-20 ~ 60°C, 0 ~ 99%RH (Non-condensing)
Working voltage	DC 5V ±0.1V, ripple wave < 50mV
Average working current	≤300mA
Signal output	UART TTL (3.3V TTL), I2C
Dimension	W80mm ×H50mm ×D13.6mm
Life span	MTTF of PM sensor= 110,000Hrs (continuous turn on) CO2 ≥10 years VOC ≥10 years

해당 센서를 STM32 I2C 통신을 이용해 제어하기 위해선 간단히 데이터시트를 참고할 필요가 있다. 구현에 중요한 부분은 간단히 설명하고자 한다.

자세히 보고 싶다면 해당 첨부파일을 참고하길 바란다.

Complex_air_quality_measurement_module_AM1008W-K_Specification_210312.pdf

0.78MB

제품의 케이스를 벗기게 되면 아래 사진과 같이 PCB 상태의 센서를 확인할 수 있다.

선을 연결하기 위해선 아래와 같이 구성해야 한다.

검정색 - GND
흰색 - SDA
초록색 - SCL
빨강색 - VCC (5V)

데이터시트에 친절하게 3.3V MCU와 5V로 동작하는 센서를 제어할 때 구현해야할 회로도를 넣어주었다. 회로도를 보니 HOST MCU(나의 경우 : STM32F103)에 외부 풀업저항을 통해 I2C 통신을 제어하는 것과 해당 센서는 5V로 동작하는 것을 확인하였다. 회로도에서는 10K옴을 사용하였는데 나의 경우 4.7K옴을 사용하였다.

주의 사항을 확인한다. UART와 I2C 통신을 하기 위해선 전원 공급 이 후 10초라는 대기시간이 필요한 듯 싶다. 이 글에서 가장 중요한 문구가 다음에 나온다. 기본 구매했을 때 제품은 UART 통신을 사용하며 점퍼를 이용해 UART와 I2C 모드를 선택하라고 한다.

해당 사진을 보면 간단히 알 수 있다. UART를 사용하기 위해선 해당 핀을 쇼트시키고, I2C를 사용하기 위해선 점퍼를 제거하라고 한다. 우린 I2C 통신을 사용하니 점퍼를 아래 사진과 같이 제거하였다.

그 다음으로 가장 중요한 것은 이제 이 센서(슬레이브)의 주소이다.

쭉쭉 내려다 보면 센서의 주소를 알 수 있다.

해당 센서에게 Write 명령을 하기 위해서는 0x50을 쏘라고 한다.

해당 선서에게 Read 명령을 하기 위해서는 0x51을 쏘라고 한다.

여기서 우리들은 센서의 주소를 알기 위해 계산을 조금해야 한다. 이 전 글에서 7bit 주소와 1bit W/R 플레그로 구성된 것으로 공부했다.

그 때 계산이 (7bit 주소 << 1) | W/R Flag 였다. 이제 역으로 계산하면 해당 센서의 주소를 알 수 있다.

0x50에서 오른쪽으로 쉬프트 연산을 한 번 하면 주소이다. 0x28이 주소임을 확인했다.

우리는 데이터시트에서 얻은 정보를 통해 STM32 I2C 통신으로 제어할 준비가 50%가 되었다. 나머지 50%는 바로 소스코드이다. STM32 CubeIDE를 통해 간단히 구현할 수 있지만, 임베디드에서 처음 구매한 센서를 뚫는 것은 만만치 않은 작업이다.

가장 베스트는 누군가 이미 만들어 놓은 소스 코드를 참고하여 만드는 것이다.

해당 제품은 운이 좋게도 Github에 아두이노로 구현된 라이브러리가 이미 존재한다. 다음 글은 간단히 라이브러리를 이용하여 아두이노로 센서를 테스트해보겠다.

[STM32] 15. I2C 통신 개요

18진수 — Wed, 4 Dec 2024 23:23:41 +0900

1. I2C(Inter-Integrated Circuit)란 무엇인가?

I2C는 원래 1982년 필립스 반도체가 만든 집적 회로 사이에 사용되는 2선 직렬 통신 시스템이다.
I2C는 다중 마스터, 다중 슬레이브, 동기식, 양방향, 반이중 직렬 통신 버스이다.

SDA(Serial Data)는 마스터와 슬레이브가 정보(비트 시퀀스)를 전송하거나 수신하는 라인이다.
SCL(Serial Clock)은 데이터 흐름 동기화를 위한 클럭 전용 라인이다.

I2C 통신 회로

SDA 및 SCL 라인은 저항으로 끌어올려야 한다. 이 저항의 값은 버스 길이(버스 커패시턴스)와 전송 속도에 따라 달라진다. 보통 4.7K옴에서 10K옴 사이를 사용한다.
위 I2C 통신 회로도를 보면, VDD(전원) 측에 Rp(저항)이 풀업으로 달려있는 것을 확인할 수 있다. 이는 IDLE 상태(통신을 하고 있지 않을 때)에서 신호가 HIGH 레벨을 유지하고 있으며, 통신을 개시하면 신호가 LOW 레벨로 떨어지는 것을 의미한다. 소프트웨어 구현하는 것도 중요하지만 I2C는 풀업 저항이 굉장히 중요하므로 이를 간과해서는 안된다.

I2C는 세가지 모드를 지원한다. 대부분 I2C를 지원하는 MCU는 Fast Mode를 지원한다.

최대 100kbit/s의 비트 전송률을 가진 표준 모드(Standard mode)
최대 400kbit/s의 비트 전송 속도를 제공하는 Fm(Fast-Mode)
최대 1Mbit/s의 비트 전송 속도를 제공하는 Fm+(Fast-Mode Plus)

2. I2C 데이터 전송 포맷

I2C 통신에서는 하기 신호들을 통해 마스터와 슬레이브가 통신을 한다.

Start Condition (S)
Stop Condition (P)
Repeated Start (Restart) Condition (Sr)
Acknowledge ACK (A)
Not Acknowledge NACK (/A)

⚙️ 1. Start Condition (S)

Start Condition은 I2C 통신이 시작될 때 생성된다.
마스터 장치가 데이터 전송을 시작할 때 SCL이 HIGH인 동안 SDA 라인이 HIGH에서 LOW로 전환된다.
이 신호는 모든 슬레이브 장치에게 데이터 전송이 시작되었음을 알린다.

⚙️ 2. Stop Condition (P)

Stop Condition은 I2C 통신이 종료될 때 생성된다.
마스터 장치가 데이터 전송을 종료할 때 SCL이 HIGH인 동안 SDA 라인이 LOW에서 HIGH로 전환된다.
이 신호는 모든 슬레이브 장치에게 데이터 전송이 끝났음을 알린다.

⚙️ 3. Repeated Start (Restart) Condition (Sr)

Repeated Start Condition은 통신 중에 연속된 데이터 전송을 위해 사용된다.
마스터 장치가 데이터 전송을 중단하지 않고 다음 전송을 시작하고자 할 때 사용된다.
이는 일반적인 Start Condition과 동일하게 SCL이 HIGH인 동안 SDA 라인이 HIGH에서 LOW로 전환된다.
Repeated Start는 슬레이브 장치에게 통신이 계속 진행 중임을 알리며, 새로운 주소나 데이터 전송을 시작할 수 있게 한다.

⚙️ 4. Acknowledge ACK (A)

Acknowledge는 수신 장치가 데이터를 성공적으로 수신했음을 나타내는 신호이다.
데이터 바이트가 전송된 후 수신 장치는 SCL의 HIGH 동안 SDA 라인을 LOW로 유지하여 ACK 신호를 보낸다.
이는 마스터에게 데이터가 올바르게 수신되었음을 알린다.

⚙️ 5. Not Acknowledge NACK (/A)

Not Acknowledge는 수신 장치가 데이터를 성공적으로 수신하지 못했거나 더 이상 데이터를 받을 준비가 되지 않았음을 나타내는 신호이다.
데이터 바이트가 전송된 후 수신 장치는 SCL의 HIGH 동안 SDA 라인을 HIGH로 유지하여 NACK 신호를 보낸다.
이는 마스터에게 데이터가 제대로 수신되지 않았음을 알리거나, 통신을 종료하도록 요청하는 신호이다.

3. I2C 데이터 전송 시퀀스

시작: Start Condition (S)
- 주소 전송: 슬레이브 주소 (7비트) + R/W 비트 (0: Wirte)
- 0x28u 주소를 가지는 슬레이브에게 Write를 하고 싶다면, 아래와 같이 주소를 쉬프트 하면 된다.
- 0x28u << 1 = 0x50u
- 0x28u 주소를 가지는 슬레이브에게 Read를 하고 싶다면, 아래와 같이 주소를 쉬프트하고 LSB를 0x1로 OR 연산을 하면 된다.
- (0x28u << 1) | 0x01u = 0x51u
슬레이브 ACK: 슬레이브가 ACK 전송
데이터 전송: 데이터 바이트 (8비트)
슬레이브 ACK: 슬레이브가 ACK 전송
추가 데이터 전송 (필요 시): 반복적으로 데이터 바이트와 ACK 전송
종료: Stop Condition (P)

이해하고 나면 별거 없다. STM32로 위 정보들을 이해할 수 있다면 충분히 MCU로 I2C 통신을 사용하는 센서들을 충분히 제어할 수 있다. 다음 글은 I2C 통신을 사용하는 센서 하나를 소개하고자 한다. 남들처럼 LCD 제어, RTC, EEPROM이 아닌 재미난걸 소개하려 한다.

[STM32] 14. 콜백 함수 호출 과정

18진수 — Sat, 30 Nov 2024 15:57:49 +0900

이 전 포스팅에서 HAL 라이브러리가 제공하는 인터페이스(HAL_UART_RxCpltCallback)를 사용하여 UART Interrupt를 간단한 기능을 구현하였다. HAL_UART_RxCpltCallback 함수는 STM32 HAL 라이브러리에서 UART 데이터를 수신할 때 사용되는 콜백 함수이다. 이 함수는 UART 인터럽트를 사용하여 데이터를 비동기적으로 수신할 때 호출된다. 임베디드 시스템 관점에서 이 콜백 함수가 호출되는 과정을 간단히 설명하겠다.

1. HAL_UART_RxCpltCallback 함수 호출 과정

1. UART 인터럽트 활성화: 먼저, UART 인터럽트를 활성화한다. 이는 HAL_UART_Receive_IT 함수를 호출하여 UART 모듈이 데이터를 수신할 때 인터럽트를 발생시킬 수 있도록 설정한다.

이 동작은 소프트웨어적으로 수행되지만, 이 설정이 하드웨어 레벨에서 UART 인터럽트 기능을 활성화한다.

HAL_UART_Receive_IT(&huart1, &received_byte, 1);

2. 데이터 수신 준비: UART 모듈은 설정된 비트레이트, 데이터 비트, 패리티 비트 등을 기반으로 데이터를 수신할 준비를 한다.

3. 데이터 수신: UART 모듈이 데이터를 수신(UART 모듈의 Rx 핀으로 시리얼 데이터가 들어옴)하면, 수신 버퍼에 데이터가 저장된다. UART 모듈은 수신이 완료되었음을 알리기 위해 UART 인터럽트를 발생시킨다.

4. 인터럽트 발생: UART 데이터 수신이 완료되면, UART 하드웨어는 인터럽트를 발생시킨다. 이 인터럽트는 프로세서를 중단시키고 인터럽트 서비스 루틴(ISR)으로 제어를 이동시킨다.

5. 인터럽트 서비스 루틴(ISR): USARTx_IRQHandler 함수는 UART 인터럽트가 발생했을 때 호출되는 ISR이다. 이 함수는 HAL 라이브러리의 HAL_UART_IRQHandler 함수를 호출하여 인터럽트를 처리한다. (MCU의 현재 실행을 중단시키고, 관련 인터럽트 벡터로 제어를 이동시킨다.)

void USART1_IRQHandler(void)
{
    HAL_UART_IRQHandler(&huart1);
}

6. 콜백 함수 호출: HAL_UART_IRQHandler 함수는 인터럽트를 처리하는 동안, 데이터 수신이 완료되었음을 감지하고 HAL_UART_RxCpltCallback 콜백 함수를 호출한다.

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
    // 인터럽트 처리 코드
    // ...

    if (/* 수신 완료 조건 */)
    {
        HAL_UART_RxCpltCallback(huart);
    }
}

7. 콜백 함수 실행: HAL_UART_RxCpltCallback 함수는 사용자가 정의한 동작을 수행한다. 예를 들어, 수신된 데이터를 처리하고, 다음 데이터를 수신하기 위해 HAL_UART_Receive_IT 함수를 다시 호출하여 인터럽트를 재설정할 수 있다.

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1)
    {
        // 수신된 데이터를 처리하는 코드
        // ...

        // 다음 수신을 위한 인터럽트 재설정
        HAL_UART_Receive_IT(huart, &received_byte, 1);
    }
}

이 과정은 UART 데이터를 비동기적으로 수신하고 처리하는 방법을 간단히 설명한 것이다. HAL_UART_RxCpltCallback 콜백 함수는 데이터 수신이 완료될 때마다 자동으로 호출되며, 이를 통해 데이터를 효율적으로 처리할 수 있다.

[STM32] 13. UART Interrupt 구현

18진수 — Sat, 30 Nov 2024 15:37:15 +0900

UART 통신에서 Polling 방식은 간단하지만 효율성이 떨어질 수 있다. 이를 해결하기 위해 Interrupt 방식과 DMA 방식을 사용할 수 있다. 이 번 포스팅은 Interrupt 방식을 통해 이 전 포스팅인 Polling 방식 기능을 그대로 구현하는 방식으로 진행한다.

이전 포스팅 : https://blog.naver.com/younjung1996/223477638132

12. STM32 시리얼 모니터를 위한 UART 통신 구현 (2)

기본적인 UART 통신은 폴링(Polling) 방식으로 수행할 수 있다. 폴링 방식에서는 MCU가 계속해서 ...

blog.naver.com

사용된 보드는 STM32F103이며, UART 1번을 사용한다. (PA10 - UART1_RX, PA9 - UART1_TX)

1. Polling 방식의 문제점

CPU 자원 소모: Polling 방식에서는 CPU가 지속적으로 UART 상태 레지스터를 확인해야 한다. 이는 CPU 자원을 많이 소모하여 다른 작업을 수행할 시간이 줄어든다.
응답 시간 지연: 데이터가 준비될 때까지 대기해야 하므로, 실시간 응답이 필요한 시스템에서는 비효율적이다.
전력 소모: CPU가 계속해서 UART 상태를 확인해야 하므로, 저전력 모드로 전환하기 어렵다.

2. Interrupt 방식

Interrupt 방식은 UART 전송이나 수신이 완료될 때마다 인터럽트가 발생하여, 인터럽트 서비스 루틴(ISR)이 실행되어 데이터를 처리한다. 이는 Polling 방식의 문제점을 해결할 수 있다.

장점

효율적인 CPU 사용: 데이터 전송이나 수신이 완료될 때까지 CPU가 다른 작업을 수행할 수 있다.
실시간 처리: 데이터 전송이나 수신이 완료될 때 즉시 인터럽트가 발생하여 실시간으로 데이터를 처리할 수 있다.
전력 절감: CPU가 필요할 때만 깨어나므로, 저전력 모드로 전환하기 쉽다.

단점

구현 복잡성: 인터럽트 기반 코드는 Polling 방식보다 구현이 다소 복잡할 수 있다.
인터럽트 오버헤드: 인터럽트가 빈번하게 발생하면 인터럽트 오버헤드가 발생할 수 있다.

⚙️ 3. 레지스터 설정

[Pin&Out Configuration] - [Connectivity] - [USART1]을 설정하는 것은 이전 포스팅(Polling 방식)과 동일하다. 다만, 차이가 있다면 global interrupt를 활성화시켜 주어야 한다.

[Pin&Out Configuration] - [System Core] - [NVIC] - [USART1 global Interrupt] - Enabled 체크

위 처럼 설정을 완료했다면, UART Interrupt를 사용할 준비가 끝났다.

⚙️ 4. 코드

[Core] -[Src] - [stm32f1xx_it.c 파일]에 USART1_IRQHandler 함수에 UART1이 연결되어있는 것을 확인할 수 있다. 해당 함수에서 인터럽트 핸들러에 직접 코드를 작성하여 수동으로 관리할 수 있으나 복잡성이 증가할 수 있고, 다른 STM32 시리즈에서는 사용할 수 없는 문제가 발생할 수 있으므로 이는 추천하지 않는 방법이다.

/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */

  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

추천하는 방법으로 HAL 라이브러리가 아래와 같이 제공하는 하드웨어 인터페이스를 사용하는 것이다. (이번 포스팅은 HAL_UART_RxCpltCallback 콜백함수만 사용할 예정이다.)

HAL_UART_RxCpltCallback, HAL_UART_TxCpltCallback

콜백함수의 장점은 아래와 같다.

추상화와 유연성: HAL 라이브러리는 하드웨어 추상화 계층을 제공하여 다양한 STM32 장치에서 일관된 인터페이스를 제공한다. HAL_UART_RxCpltCallback을 사용하면 코드가 더 유연하고 이식성이 높아진다.
안정성: HAL 라이브러리는 많은 경우에 대해 이미 검증되어 있으며, 잘 테스트된 코드를 제공한다. 직접 인터럽트 핸들러에서 코드를 작성하는 것보다 안정적이다.
코드 유지보수: 콜백을 사용하면 코드가 더 모듈화되어 유지보수가 용이하다. 인터럽트 핸들러는 보통 HAL 라이브러리에서 관리하므로, 콜백 함수만 관리하면 된다.
중첩 인터럽트 관리: HAL 라이브러리는 중첩 인터럽트를 관리하는 기능을 제공하므로, 콜백 함수 내에서 추가적인 처리를 수행할 때 안전하다.

콜백함수 사용하는 방법은 간단하다.

[Driver] - [stm32f1xx_hal_uart.c]에서 정의된 콜백함수를 찾을 수 있다.

/**
  * @brief  Rx Transfer completed callbacks.
  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(huart);
  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_UART_RxCpltCallback could be implemented in the user file
   */
}

해당 콜백함수를 main 함수에서 재정의하여 사용하면 된다.

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// Define buffer
#define MAX_BUFFER_SIZE 100
uint8_t enterKey = '\r'; // Enter key is carriage return (0x0D)
uint8_t inputBuffer[MAX_BUFFER_SIZE];
uint16_t bufferIndex = 0;
uint8_t received_byte;

...
...
...

int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

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

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

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_UART_Receive_IT(&huart1, &received_byte, 1);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

...
...
...

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1)
    {
        if (received_byte == enterKey)
        {
            // 스페이스바 입력 시 버퍼에 저장된 문자열 출력
        	HAL_UART_Transmit_IT(&huart1, inputBuffer, bufferIndex);
            // 새로운 줄 추가
            uint8_t newline[] = "\r\n";
            HAL_UART_Transmit_IT(&huart1, newline, 2);
            // 버퍼 인덱스 초기화
            bufferIndex = 0;
        }
        else
        {
            // 버퍼에 문자 저장
            if (bufferIndex < MAX_BUFFER_SIZE)
            {
                inputBuffer[bufferIndex++] = received_byte;
            }
        }

        // 다음 문자 수신 시작
        HAL_UART_Receive_IT(&huart1, &received_byte, 1);
    }
}

// UART transmit complete callback function
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	/* Reserved */
}
/* USER CODE END 4 */

테스트했을 때 제대로 동작하는 것을 확인할 수 있다.

HAL_UART_RxCpltCallback를 재정의 해주면, 간단하게 UART Interrupt를 구현할 수 있다.

다음 포스팅은 UART Interrupt 동작 순서에 대해 자세히 포스팅해볼 예정이다.

[BLE 실내 측위 프로젝트] 7. NRF51822 비콘 테스트 및 초기 설정

18진수 — Mon, 25 Nov 2024 23:45:38 +0900

드디어 알리에서 구매한 NRF51822 BLE4.2 비콘이 도착했다. 개당 6000원에 배터리 4개 정도 해서 3만 원 정도에 구매했다. 다음 글로 삼변측량에 대해 포스팅할 예정이지만, 비콘으로 실내 측위를 위해선 최소 3개의 비콘이 필요하다.

조립은 간단하다 배터리 장착 후 나사 3개만 조여주면 된다.

beacon 구매 후 beacon을 초기 설정할 필요가 있다. 설정 방법은 제작사에서 제공하는 Holyiot-beacon을 설치하면 된다.

Holyiot-beacon

우선, 하나의 비콘만 동작 중이며 다운로드한 앱을 실행할 경우 아래와 같이 화면에 표시된다.

Device Scanner

비콘의 연결을 위해선 최초의 비밀번호를 요구한다. 내가 구매한 비콘의 경우 초기 비밀번호는 aa14061112 이다.

Password

비콘을 연결하고 나면, password, major, minor, MAC 주소 등 다양한 값을 변경할 수 있다.

Feature List

내게 필요한 정보는 name, Tx Power, advertising interval이며, 변경할 수 있다. 아직은 Tx power와 advertisng interval은 필요 없으므로 건들지 않고, 비콘을 구별하기 위해 이름을 변경한다.

아래 그림과 같이 이름을 Anchor0로 변경했다.

이제 위 세 개의 비콘으로 실내 측위 프로젝트를 수행할 예정이다.

[BLE 실내 측위 프로젝트] 6. RSSI 변동을 해결하기 위한 이동 평균 필터

18진수 — Mon, 25 Nov 2024 23:39:21 +0900

BLE RSSI의 문제점은 위 그림과 같다.

4.5m 이상에서는 제대로 된 거리를 계산할 수 없음. (나중에는 통신 거리가 더 길어진 BLE5.0에 대해 알아볼 예정)
실제 환경에서는 많은 외부 요인으로 인해 RSSI 변동이 발생해 거리의 오차가 발생함.

1. 이동 평균 필터

RSSI 변동을 해결하기 위한 방법은 여러 가지가 있는데 그 중 가장 간단한 이동평균 필터이다.

원리는 간단하다. 하나의 윈도우 사이즈만큼 그룹을 묶는다.
그룹의 평균 값을 대푯값으로 잡는다.
한 칸씩 이동한다. (Convolution 1D와 같은 원리)

이 간단한 방법으로 스무딩 효과를 낼 수 있다. RSSI 값이 확 튀었을 때 이를 완화시켜주는 효과를 낸다.

당연히 단점도 존재한다.

delay가 발생한다. 윈도우 사이즈만큼 평균 내기 때문에 현재의 값이 바로 반영되지 않음. 윈도우 사이즈가 크면 클수록 delay는 점점 더 늘어난다.

delay를 해결하기 위해 현재의 값에 가중치를 곱할 수 있고, 칼만 필터를 이용할 수도 있다.

2. Code

  var movingAverageWindow = [];

  num movingAverageFilter(int rssi, int windowSize) {
    if (movingAverageWindow.length != windowSize) {
      movingAverageWindow.add(rssi);
    } else {
      movingAverageWindow.add(rssi);
      movingAverageWindow.removeAt(0);
    }
    return (movingAverageWindow.reduce((a, b) => (a + b)) / windowSize);
  }

[BLE 실내 측위 프로젝트] 5. BLE Beacon의 RSSI 값에서 거리를 계산하는 방법 (feat.log distance path los

18진수 — Sun, 24 Nov 2024 22:56:00 +0900

1. Log distance path loss model

RSSI는 수신 신호 강도 표시기를 나타낸다. 스마트폰과 같은 수신 장치에서 볼 수 있는 비콘의 신호 강도이다. 신호 강도는 거리와 전송 세기에 따라 다르다.

RSSI를 이용하여 거리를 구하는 식은 아래와 같다.

d : distance(거리)
n : 보정 상수 (2~4: 보통 2를 사용)
α : 1m에서 측정된 RSSI
RSSI : 측정된 현재 RSSI

2. Code

import "dart:math";

void main() {
  int n = 2;        // constant N
  int alpha = -63;  // rssi at 1m
  int rssi = -80;   // measured rssi
  num m = pow(10.0,((alpha-rssi)/(10*n)));
  print(m);
}

// result
// 3.548133892335755 [m]

3. 한계

흡수, 간섭 또는 회절과 같은 전파에 영향을 미치는 외부 요인으로 인해 RSSI는 변동하는 경향이 있다. 장치가 비콘에서 멀어질수록 RSSI가 더 불안정해진다.

위 그래프는 예전에 실험으로 측정한 비콘과 스마트폰 사이의 거리 별 RSSI를 boxplot으로 표시한 것이다.

4.5m부터 7m 구간의 boxplot을 보게 되면 정확한 거리를 계산할 수 없을 뿐더러, 무선 신호는 non-line of sight, 흡수, 간섭 등의 외부 요인에 굉장에 취약하다.

이를 해결하기 위해서는 여러 방법이 있다.

비콘을 최대한 촘촘히 설치한다. (다다익선) ➡️ 비용 문제
핑거 프린팅 ➡️ 사전 준비 필요
필터 사용 (이동 평균 필터, 칼만 필터 등)
맵 매칭 ➡️ 사전 준비 필요
인공지능 ➡️ 사전 데이터 필요

[BLE 실내 측위 프로젝트] 4. BLE advertising packet 기본 구성

18진수 — Sun, 24 Nov 2024 22:45:30 +0900

1. BLE Packet

BLE의 패킷 타입은 두 가지가 있다.

Advertising channl PDUs : 기기 감지 및 브로드캐스팅
Data channel PDUs : 데이터 전송용

실내 측위에서는 데이터 전송이 따로 필요 없으므로 Advertising channel PDUs에 대해서만 언급한다.

Packet types은 아래 테이블과 같다.

보통 비콘의 타입은 ADV_IND가 일반적이다. 특정 중앙 장치를 특정하지 않고 모든 주변 기기와 연결할 수 있다.

Payload는 최대 37바이트 중에서 6바이트는 Advertisement Address, 나머지 0 ~ 31바이트는 Advertisement Data이다.

BLE 비콘에는 각 제조사에 따라 다양한 패킷 포맷을 가진다. 그중 가장 유명한 것이 애플의 iBeacon, 구글의 EddyStone이다.

이 글은 iBeacon의 패킷에 대해 이야기한다.

2. iBeacon - Apple

iBeacon 비콘 packet format (모든 BLE 비콘이 위 패킷 포맷을 따라가지 않는다.)

iBeacon의 패킷에서는 다양한 값을 알 수 있다.

눈여겨봐야 하는 것은 Manufacturer data와 TX power이다. 플래그, 데이터 길이를 제외하고 대부분은 비콘의 고유 주소라고 봐도 무방하다. (제조사, 기기 번호 등등)

Manufacturer data는 개발자들이 임의로 넣을 수 있는 패킷 공간이다. iBeacon이 아닌 자신만의 BLE 비콘을 만들어도 되지만, 나는 RSSI만 필요하므로 기존의 비콘을 사용한다.

그리고 TX Power는 비콘의 송신 세기이다. 이는 실내 측위 분석에 있어 중요한 파라미터가 될 수 있다.

이 전 코드에서는 기기 ID, Mac address, RSSI 정도만 볼 수 있었다면 이 번 코드는 Payload에서 manufacturer data, UUID, TX Power를 확인할 수 있다.

플러터를 공부한 지 일주일이 넘어갔는데, 여러 가지 애로사항이 있었다. 패킷 구조를 C의 Struct 구조와 같이 만들고 싶었는데, Dart에서는 struct이 없다고 한다. 그냥 class를 사용하라고 하는데, 그냥 배열 선언해서 무식하게 접근했다. 누가 이 글을 보고 조언해주면 좋겠다.

새롭게 추가한 것은 provider이다. flutter에서 관리 용이성을 위해 전역 공간을 하나 만들어 준 것이다.

[BLE 실내 측위 프로젝트] 3. Flutter BLE Scan Demo Program, RSSI monitoring

18진수 — Sun, 24 Nov 2024 22:35:31 +0900

하이제니스 님의 포스팅에 포함된 코드를 일부 수정하였습니다.

https://blog.naver.com/chandong83/222414483554

BLE 통신 스케줄 및 안드로이드 동작에 관한 포스팅을 보고 와야 어느 정도 이해하기 편하다.

1. 패키지 설치 및 설정

flutter_blue 대신 flutter_blue_plus 패키지를 설치한다.

flutter_blue는 더 이상 업데이트하지 않고 안드로이드 12 권한 이슈가 있으므로, flutter_blue_plus를 설치한다.

$ flutter pub add flutter_blue_plus

설치하게 되면 알아서 dependecies가 추가된다.

⚙️ 1. android/app/build.gradle : SDK 최소 버전 19로 설정

Android {
  defaultConfig {
     minSdkVersion: 19

⚙️ 2. android/app/src/main/AndroidManifest.xml : Bluetooth 권한 설정

 <uses-permission android:name="android.permission.BLUETOOTH" />  
	 <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />  
	 <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>  
 <application

2. Code

하이 제닉스님 같은 경우는 버튼을 누르고 4초 동안 스캔하고, 결과가 보인다면, 내 코드는 스캔을 계속 진행하면서, RSSI 변화량을 모니터링하는 것이다.

코드에서 큰 차이는 없지만, startScan 함수에서 allowDuplicates 파라미터를 true 설정한 것이다.

allowDuplicates는 기본 false로, 한 번 발견된 기기는 더 이상 업데이트되지 않고 RSSI 값이 고정된다.

이를 true로 설정하게 되면, 이미 발견된 기기라 할지라도 업데이트되므로 RSSI 변화량을 확인할 수 있다.

ScanMode는 실내 측위를 위해 LowLatency를 사용했다. 모드의 동작을 확인하고 싶으면 목차에서 두번 째 글을 보면 된다.

import 'package:flutter/material.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  final title = 'Flutter BLE Scan Demo';
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: title,
      home: MyHomePage(title: title),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);
  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  FlutterBluePlus flutterBlue = FlutterBluePlus.instance;
  List<ScanResult> scanResultList = [];
  
  int scan_mode = 2;   // scan mode
  bool isScanning = false;

  /* 생성자 */
  @override
  void initState() {
    super.initState();
  }

  /* 시작, 정지 */
  void toggleState() {
    isScanning = !isScanning;

    if (isScanning) {
      flutterBlue.startScan(
          scanMode: ScanMode(scan_mode), allowDuplicates: true);
      scan();
    } else {
      flutterBlue.stopScan();
    }
    setState(() {});
  }

  /* 
  Scan Mode
  Ts = scan interval 
  Ds = duration of every scan window
             | Ts [s] | Ds [s]
  LowPower   | 5.120  | 1.024
  BALANCED   | 4.096  | 1.024
  LowLatency | 4.096  | 4.096

  LowPower = ScanMode(0);
  BALANCED = ScanMode(1);
  LowLatency = ScanMode(2);

  opportunistic = ScanMode(-1);
   */

  /* Scan */
  void scan() async {
    if (isScanning) {
      // Listen to scan results

      flutterBlue.scanResults.listen((results) {
        // do something with scan results
        scanResultList = results;
        // update state
        setState(() {});
      });
    }
  }

  /* 장치의 RSSI */
  Widget deviceSignal(ScanResult r) {
    return Text(r.rssi.toString());
  }

  /* 장치의 MAC 주소 위젯  */
  Widget deviceMacAddress(ScanResult r) {
    return Text(r.device.id.id);
  }

  /* 장치의 명 위젯  */
  Widget deviceName(ScanResult r) {
    String name;

    if (r.device.name.isNotEmpty) {
      // device.name에 값이 있다면
      name = r.device.name;
    } else if (r.advertisementData.localName.isNotEmpty) {
      // advertisementData.localName에 값이 있다면
      name = r.advertisementData.localName;
    } else {
      // 둘다 없다면 이름 알 수 없음...
      name = 'N/A';
    }
    return Text(name);
  }

  /* BLE 아이콘 위젯 */
  Widget leading(ScanResult r) {
    return const CircleAvatar(
      backgroundColor: Colors.cyan,
      child: Icon(
        Icons.bluetooth,
        color: Colors.white,
      ),
    );
  }

  /* 장치 아이템을 탭 했을때 호출 되는 함수 */
  void onTap(ScanResult r) {
    // 단순히 이름만 출력
    print('${r.device.name}');
  }

  /* 장치 아이템 위젯 */
  Widget listItem(ScanResult r) {
    return ListTile(
      onTap: () => onTap(r),
      leading: leading(r),
      title: deviceName(r),
      subtitle: deviceMacAddress(r),
      trailing: deviceSignal(r),
    );
  }

  /* UI */
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        /* 장치 리스트 출력 */
        child: ListView.separated(
          itemCount: scanResultList.length,
          itemBuilder: (context, index) {
            return listItem(scanResultList[index]);
          },
          separatorBuilder: (BuildContext context, int index) {
            return const Divider();
          },
        ),
      ),
      /* 장치 검색 or 검색 중지  */
      floatingActionButton: FloatingActionButton(
        onPressed: toggleState,
        // 스캔 중이라면 stop 아이콘을, 정지상태라면 search 아이콘으로 표시
        child: Icon(isScanning ? Icons.stop : Icons.search),
      ),
    );
  }
}

3. Demo Video

https://www.youtube.com/shorts/vdjfelsk_Ug

[BLE 실내 측위 프로젝트] 2. Bluetooth Low Energy(BLE) 통신 스케줄, 안드로이드 함께 이해하기

18진수 — Sun, 24 Nov 2024 22:25:24 +0900

BLE 통신을 하기 전에 통신 스케줄에 대해 이해하고 가면 좋다.

BLE의 물리 계층 먼저 간단하게 짚고 간다.

BLE는 2.4GHz 대역을 사용하며, (2.402 GHz ~ 2.4835 GHz) : 2 MHz 간격으로 40개 채널로 구성된다.

Advertising 채널은 37, 38, 39 (2402 MHz, 2426 MHz, 2480 MHz)를, Adaptive Frequency Hopping 방식을 사용한다.

실내 측위 (Indoor Positioning)

Advertiser은 송신부, Scanner는 수신부라고 생각하면 편하다. 실내 측위 프로젝트는 따로 기기 간 연결을 필요로 하지 않고, Device discovery 모드만 사용한다.

실내 측위에 간략히 설명하자면, Advertiser가 모든 방향으로 Advertising 패킷을 브로드캐스팅하면, 수신 받는 Scanner는 패킷에 대한 RSS(수신신호세기)를 얻을 수 있다.

알려진 Log distance path loss model을 이용해 RSS로 거리를 구할 수 있다. 그리고 최소 3개 이상의 거리가 있으면, 삼변 측량을 통해 위치를 구하는 방식이다.

BLE device discovery

아래 그림은 통신(device discovery) 스케줄에 대한 도식이다.

Ad = advertiser
Sc = scanner
ch = channel

Advertising은 advertising interval, advertising delay라는 값을 가진다.

위 도식은 advertising delay가 0인 상태로 가장 빠르게 많은 패킷을 전송한다고 볼 수 있다. 그러므로 advertising interval 동안 패킷을 지속적으로 송신한다. 특징으로 한 advertising interval 동안 패킷을 채널을 37, 38, 39로 변경해가면서 전송한다.

Scanner는 scan window, scan interval이라는 값을 가진다. scan window는 실제 패킷을 받는 시간이며, scan interval은 반복되는 횟수이다.

그러므로 scan window는 scan interval보다 큰 값을 가질 수 없다. 특징으로 scan window는 한 채널에 대해서만 열린다.

ex) Advertiser가 37, 38, 39 채널에 대한 패킷을 보냈다 하더라도, Scan window의 채널이 37이라면, 37에 대한 패킷만을 받을 수 있다.

Android

안드로이드 BLE 개발 공식 문서를 보면 Scan window, Scan interval, channel은 변경하지 못하고, mode로 선택할 수 있다.

Ta = advertising interval
Ts = scan interval
Ds = scan window

안드로이드 개발에서는 전력 소모에 따라 모드를 나눠 놓았다.

도식으로 간단히 표현할 수 있다.

Low Power

Balanced Power

Low Latency

scan interval이 길면 길수록, 수신 받을 수 있는 패킷의 양은 늘어나지만 전력 소모는 크다.

scan interval이 짧으면 짧을수록, 수신 받을 수 있는 패킷의 양은 줄어들지만 전력 소모는 작다.

PDR (Packet Delivery Ratio)

Low power mode < Balanced mode < Low latency

Power efficiency

Low power mode > Balanced mode > Low latency

당연히 애플리케이션에 알맞은 모드를 사용하는 것이 좋다. 하지만 실내 측위의 같은 경우 PDR에 따라 성능을 크게 차지하므로, Low latency 모드를 사용하는 것이 더 좋다.

[BLE 실내 측위 프로젝트] 1. Flutter_blue 설정 (feat.안드로이드12 권한 이슈)

18진수 — Sun, 24 Nov 2024 22:05:16 +0900

개인 프로젝트인 BLE 실내 측위 첫 글이다.

우선, flutter에서 ble 관련 패키지를 설치한다. 대표적으로 ble 관련 패키지는 3개가 있다.

flutter_ble_lib
flutter_reactive_ble
flutter_blue

flutter_ble_lib는 업데이트가 느려, 2번과 3번 중 골라야 하는데, 오늘 자 기준으로 flutter_blue가 최신 버전이 있어 flutter_blue를 사용한다.

flutter 패키지는 pub.dev에서 설치할 수 있다. 혹은 아래 명령어를 통해 설치할 수 있다.

$ flutter pub add flutter_blue

설치하게 되면 자동적으로 pubspec.yaml 파일의 dependecies에 추가된다.

하지만, flutter_blue의 경우 안드로이드 12에서 권한 이슈가 있다. 안타깝게도 내 스마트폰도 안드로이드 12였고 AndroidManifest.xml에 별에 별짓을 다했지만 되지 않았다. 결국 아래 git에서 다른 방법으로 문제를 해결했다.

https://github.com/pauldemarco/flutter_blue/issues/864

pubspec.yaml 파일에 아래와 같이 수정했다.

  flutter_blue:
    git: https://github.com/espresso3389/flutter_blue

문제를 해결했지만, 별로 내가 좋아하지 않는 방법이다.

다시 구글링해서 찾아보니 내가 바보 같은 짓을 했다.

flutter_blue는 0.8.0에서 개발을 멈춘 상태이고, flutter_blue_plus 최신 버전이 있다는 것을 인제야 알게 되었다.

https://pub.dev/packages/flutter_blue_plus

flutter_blue_plus | Flutter package

Flutter plugin for connecting and communicationg with Bluetooth Low Energy devices, on Android, iOS, and MacOS.

pub.dev

아래 명령어로 flutter_blue_plus를 설치할 수 있다.

$ flutter pub add flutter_blue_plus

자동적으로 pubspec.yaml 파일의 depencies에 추가된다.

dependencies:
  flutter_blue_plus: ^1.1.3

plus를 사용하니 안드로이드 12 권한 문제도 자동으로 해결된다.

android/app/build.gradle 버전

Android {
  defaultConfig {
     minSdkVersion: 19

android/app/src/main/AndroidManifest.xml 권한 추가

<uses-permission android:name="android.permission.BLUETOOTH" />  
	 <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />  
	 <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>  
 <application

flutter_blue_plus 관련 이슈는 아래 링크에서 참고하여 해결할 수 있다.

https://flutterrepos.com/lib/boskokg-flutter_blue_plus

해당 프로젝트는 2022년에 진행한 것으로 버전 차이가 존재할 수 있다.

[STM32] 12. 시리얼 모니터를 위한 UART 통신 구현 (2)

18진수 — Fri, 22 Nov 2024 15:23:59 +0900

⚙️ 1. UART 설정

기본적인 UART 통신은 폴링(Polling) 방식으로 수행할 수 있다. 폴링 방식에서는 MCU가 계속해서 UART 상태 레지스터를 확인하여 데이터가 수신되었는지 또는 전송이 완료되었는지를 확인한다. 하지만 폴링 방식은 MCU 리소스를 많이 소비하므로 보통은 Interrut 방식이나 DMA 방식을 주로 사용한다. 이번 글은 폴링 방식으로 간단히 구현할 수 있으므로 소개해보려 한다.

이번 예제는 UART 1번을 사용한다. (PA10 - UART1_RX, PA9 - UART1_TX)

사용된 보드는 STM32F103이다.

설정은 아래와 같다. 폴링 방식을 사용하기 때문에 아래 테이블 이외에 별도로 설정할건 없다.

Baud Rate	115200 Bit/s
World Length	8 Bits (including Parity)
Parity	None
Stop Bits	1
Data Directions	Receive and Transmit
Over Sampling	16 Samples

2. 코드

이 코드는 사용자가 엔터 키를 누를 때마다 입력된 문자열을 전송하고, 그 뒤에 줄바꿈 문자를 추가하여 터미널 창에서 출력이 깔끔하게 줄바꿈되도록 한다.

  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  uint8_t received = '\0';
  HAL_StatusTypeDef rcvStat;
  uint8_t enterKey = '\r'; 
  uint8_t newLine[] = "\r\n"; 

  #define MAX_BUFFER_SIZE 100
  uint8_t inputBuffer[MAX_BUFFER_SIZE];
  uint16_t bufferIndex = 0;

  while (1)
  {
	  //HAL_UART_Transmit(&huart1, buf, strlen(buf), 1000);
	  //HAL_Delay(1000);
	    rcvStat = HAL_UART_Receive(&huart1, &received, 1, 10);
	    if(rcvStat == HAL_OK)
	    {
	        // If received character is Enter key
	        if(received == enterKey)
	        {
	            // Transmit the buffered string
	            HAL_UART_Transmit(&huart1, inputBuffer, bufferIndex, 1000);
	            HAL_UART_Transmit(&huart1, newLine, 2, 1000);
	            // Clear the buffer
	            bufferIndex = 0;
	        }
	        else
	        {
	            // Store received character in buffer
	            if(bufferIndex < MAX_BUFFER_SIZE)
	            {
	                inputBuffer[bufferIndex++] = received;
	            }
	        }
	    }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }

엔터 키 처리: 수신된 문자가 엔터 키 (\r)일 경우, 버퍼에 저장된 문자열을 UART로 전송한 후, 개행 (\r\n) 문자를 추가로 전송한다.
개행 문자 추가: 문자열 뒤에 개행(\r\n) 문자를 추가하여 터미널 창에서 줄바꿈을 보장한다.
버퍼 관리: 문자열 전송 후 버퍼를 초기화하여 다음 입력을 받을 준비를 한다.

STM32와 FTDI의 연결은 Tx, Rx 서로 역으로 연결하고 VCC는 별도로 연결하지 않아도 통신은 된다. (USB로 전원이 들어가는 듯 하다.)

하지만 VCC는 연결하지 않더라도 GND는 무조건 연결해야 한다. (기준점이 있어야 5V, 0V를 구분할 수 있음.)

이제 PC에서 시리얼 모니터를 할 수 있는 프로그램을 설치해야 한다. 보통 Putty나 XShell 등을 많이 사용하는데 나는 개인적으로 MobaXterm을 주로 애용한다.

STM32에서 동일하게 설정한 것과 같이 시리얼 모니터링 프로그램에서도 설정한다.

https://mobaxterm.mobatek.net/

MobaXterm free Xserver and tabbed SSH client for Windows

The ultimate toolbox for remote computing - includes X server, enhanced SSH client and much more!

mobaxterm.mobatek.net

3. 결과

시리얼 모니터에 값이 입력한대로 출력되는 것을 확인할 수 있다.

[STM32] 11. 시리얼 모니터를 위한 UART 통신 구현 (1) FTDI (UART To USB)

18진수 — Fri, 22 Nov 2024 15:08:28 +0900

FTDI (Future Technology Devices International Ltd.)는 주로 UART (Universal Asynchronous Receiver-Transmitter) 신호를 USB (Universal Serial Bus)로 변환하는데 사용되는 IC (Integrated Circuit) 칩을 제조하는 회사이다. FTDI 칩을 사용하면 UART를 사용하는 장치를 USB 포트에 연결할 수 있다.

임베디드 시스템에서 printf 함수를 사용하는 것은 디버깅, 로깅, 상태 확인 등을 위해 매우 유용하다. printf 함수는 표준 C 라이브러리 함수로, 포맷된 출력을 생성하여 콘솔이나 터미널에 문자열을 출력하는데 사용된다. 그러나 임베디드 시스템에서는 일반적으로 디스플레이나 콘솔이 없기 때문에, UART (Universal Asynchronous Receiver-Transmitter) 인터페이스를 통해 시리얼 통신을 사용하여 출력을 컴퓨터나 다른 디버깅 장치로 전송하는 경우가 많다.

하드웨어 설정
- 마이크로컨트롤러의 UART 핀을 FTDI 칩의 UART 핀에 연결한다.
- FTDI 칩의 USB 포트를 컴퓨터에 연결하여, 컴퓨터가 USB를 통해 시리얼 데이터를 수신할 수 있도록 한다.
드라이버 설치
- 컴퓨터에 FTDI 드라이버를 설치한다. 드라이버는 FTDI의 공식 웹사이트에서 다운로드할 수 있다. 드라이버를 설치하면 컴퓨터의 장치 관리자에서 가상 COM 포트로 FTDI 장치가 나타난다.
소프트웨어 설정
- 임베디드 시스템의 펌웨어에서 UART를 초기화한다. UART 초기화 과정은 UART 속도(baud rate), 데이터 비트, 패리티 비트, 정지 비트 등을 설정하는 것이다.

보통 STM32를 통해 콘솔에서 명령어를 주고 받을 때 보통 아래와 그림과 같다. UART To USB가 UART 테스트를 할 때, 굉장히 좋은 점은 FTDI를 연결했을 때, 컴퓨터에서 장치 관리자로 손쉽게 접근하여 제어할 수 있다는 점이다.

장치 관리자

아래는 FTDI 제품이다.

이 제품의 장점으로는 VCC (5V, 3.3V) 고를 수 있다는 장점이 있고, FTDI에서 Tx, Rx Signal이 들어올 때마다 해당 LED가 불이 들어와서 디버깅할 때 편하다.

다음 글은 해당 FTDI 제품을 이용하여 UART 테스트를 진행해보려 한다.

[STM32] 10. UART, USART 동작 원리 설명

18진수 — Fri, 22 Nov 2024 14:55:13 +0900

UART/USART 설명

1. UART (Universal Asynchronous Receiver/Transmitter) 란?

UART는 Universal Asynchronous Receiver/Transmitter의 약자로, 직렬 통신을 위한 하드웨어 프로토콜이다. UART는 데이터를 두 개의 핀, 송신(Tx)과 수신(Rx)을 통해 비동기적으로 전송한다. 비동기식 통신이란 송신 측과 수신 측 간의 동기화를 위해 별도의 클럭 신호가 필요하지 않은 통신 방식을 의미한다. 보통 기본 C언어에서 printf를 구현할 때 많이들 소개하므로 기본적인 동작을 알아두면 좋다.

기본 UART 회로 구성

2. UART의 기본 작동 원리

비동기 통신: 별도의 클럭 신호 없이 송신기와 수신기가 동일한 전송 속도(baud rate)로 설정되어야 한다.
전송 속도(Baud Rate): 일반적으로 9600, 19200, 38400, 57600, 115200 baud 등이 사용된다.
단방향 또는 양방향 통신: UART는 반이중(half-duplex) 또는 전이중(full-duplex) 통신을 지원한다.
단순한 배선: 데이터 전송을 위해 두 개의 핀만 필요하다.

비동기 통신을 이용할 때 전송 속도에 따른 비트를 구분하는 타이밍 문제

3. 보안 고려사항

많은 산업용 시스템에서 UART 포트는 디버깅 및 유지보수를 위해 사용되지만, 보안 취약점을 막기 위해 다음과 같은 조치를 취하는 경우가 많다.

디버깅 포트 비활성화: 제품 출하 시, 디버깅 포트를 비활성화하거나 제거한다.
펌웨어 보안: UART를 통한 펌웨어 업데이트 시, 디지털 서명 및 암호화된 펌웨어를 사용한다.
네트워크 방화벽: 네트워크 연결된 UART의 경우, 방화벽을 설정하여 불법 접근을 방지한다.

4. USART (Universal Synchronous/Asynchronous Receiver/Transmitter) 란?

USART는 Universal Synchronous/Asynchronous Receiver/Transmitter의 약자로, 비동기 통신(UART)와 다르게 동기 통신을 지원하는 직렬 통신 인터페이스이다. USART는 클럭 신호를 사용하여 송신기와 수신기를 동기화함으로써 더 빠르고 안정적인 데이터 전송을 제공한다.

동기 통신에서는 데이터 전송을 위해 추가적인 클럭 신호를 사용한다. USART는 송신기와 수신기 간의 클럭 신호를 통해 정확한 타이밍으로 데이터를 전송하고 수신할 수 있다.

동기/비동기 통신 지원: USART는 클럭 신호를 사용한 동기 통신과 클럭 신호 없이 데이터 전송 속도(baud rate)로 설정된 비동기 통신(UART)을 모두 지원한다.
더 빠른 전송 속도: 동기 통신에서는 클럭 신호를 사용하여 데이터 전송이 이루어지므로, 비동기 통신보다 더 빠르고 안정적인 데이터 전송이 가능하다.
Full-duplex 통신: 동기 모드에서는 송신과 수신이 동시에 이루어질 수 있다.
클럭 신호 라인: 동기 통신에서는 추가적인 클럭 신호 라인(예: SCLK)이 필요하다.

CLOCK 선을 통한 동기 방식

5. 동기 통신의 장단점

⚙️ 장점

높은 전송 속도: 클럭 신호를 사용하여 더 높은 데이터 전송 속도를 구현할 수 있다.
안정성: 클럭 신호에 의해 동기화되므로 데이터 전송의 안정성이 높다.
노이즈 저항성: 동기화된 클럭 신호로 인해 외부 노이즈에 강하다.

⚙️ 단점

복잡성: 추가적인 클럭 신호 라인이 필요하여 배선이 복잡해질 수 있다.
하드웨어 요구 사항: 클럭 신호 생성 및 처리를 위한 추가적인 하드웨어가 필요하다.

6. UART와 USART 비교

UART: 클럭 신호 없이 비동기 통신만 지원.
USART: 클럭 신호를 사용한 동기 통신과 클럭 신호 없이 비동기 통신을 모두 지원.
USART는 동기 통신의 장점을 살려 더 높은 전송 속도와 안정성을 제공하며, 다양한 산업용 애플리케이션에서 널리 사용된다. 반면, 단순한 배선과 구현의 용이성을 원한다면 UART가 더 적합할 수 있다.

[STM32] 9. Volatile 키워드

18진수 — Fri, 22 Nov 2024 14:33:05 +0900

Volatile 키워드

C 언어에서 volatile 키워드는 임베디드 소프트웨어 개발에서 중요한 역할을 한다. 이 키워드는 변수가 최적화 과정에서 컴파일러에 의해 수정되지 않도록 보장하며, 프로그램의 실행 도중에 변수의 값이 예상치 못하게 변경될 수 있다는 것을 컴파일러에 알린다. 이러한 변경은 외부 이벤트나 하드웨어 등에 의해 발생할 수 있다.

C 언어에서 volatile 키워드는 임베디드 소프트웨어 개발에서 중요한 역할을 한다. 이 키워드는 변수가 최적화 과정에서 컴파일러에 의해 수정되지 않도록 보장하며, 프로그램의 실행 도중에 변수의 값이 예상치 못하게 변경될 수 있다는 것을 컴파일러에 알린다. 이러한 변경은 외부 이벤트나 하드웨어 등에 의해 발생할 수 있다.

1. volatile의 중요성

메모리 맵핑된 입출력: 임베디드 시스템에서는 하드웨어 장치를 메모리 주소에 매핑하여 제어하는 경우가 많다. volatile은 이러한 메모리 주소에 위치한 데이터가 언제든지 변경될 수 있음을 나타내므로, 컴파일러가 해당 변수에 대한 접근을 최적화하지 않도록 한다.
인터럽트 서비스 루틴: 인터럽트 서비스 루틴(ISR)에서 사용되는 변수는 인터럽트에 의해 언제든지 변경될 수 있다. 이런 변수들을 volatile로 선언함으로써, 컴파일러는 이 변수들을 캐싱하지 않고 항상 메모리에서 직접 읽거나 쓰도록 처리한다.
멀티 스레딩: 여러 스레드나 프로세스가 동일한 변수를 공유할 때, 한 스레드에서의 변경이 다른 스레드에 즉시 보이도록 하기 위해 volatile을 사용할 수 있다. 그러나, volatile은 동시성을 완전히 관리하지는 못하므로 일반적으로는 락이나 다른 동기화 메커니즘과 함께 사용해야 한다.

2. 코드

다음은 volatile 키워드가 사용된 C 코드의 예제이다.

이 코드에서 flag 변수는 외부 이벤트(가정된 인터럽트)에 의해 언제든지 변경될 수 있으므로 volatile로 선언되어 있다. 이는 컴파일러에게 flag 변수의 값을 캐시하지 말고 매번 메모리에서 직접 읽어야 함을 알린다.

#include <stdio.h>

// 가정: 외부 하드웨어 이벤트에 의해 변경될 수 있는 변수
volatile int flag = 0;

// 인터럽트 서비스 루틴이라고 가정
void interrupt_handler() {
    flag = 1;  // 인터럽트 발생 시 flag를 1로 설정
}

int main() {
    while (flag == 0) {
        // flag 값이 변경될 때까지 기다림
    }
    printf("Flag was set!\n");
    return 0;
}

만약 코드에서 flag 변수를 volatile로 선언하지 않는다면, 컴파일러가 최적화 과정에서 이 변수의 사용 방식을 잘못 해석할 수 있다. 컴파일러는 코드를 최적화할 때 변수 값이 변경되지 않을 것으로 예측하여, 메모리에서 매번 변수를 읽지 않고 대신 레지스터에 값을 저장할 수 있다. 이 경우, flag 변수의 값이 외부 이벤트(예를 들어, 인터럽트)에 의해 변경되었음에도 불구하고, 메인 함수의 while 루프는 레지스터에 저장된 구식 값에 의존하여 계속해서 무한 루프에 빠질 수 있다.

이는 프로그램이 flag 변수의 변화를 감지하지 못하고, while 루프에서 탈출하지 못하는 상황으로 이어질 수 있다. 결과적으로 프로그램이 "hang"되거나 예상치 못한 동작을 할 수 있다.

3. 주의사항

불필요한 사용: volatile은 필요한 곳에만 사용해야 한다. 불필요하게 사용하면 프로그램의 성능이 저하될 수 있다.
동시성 제어 미흡: volatile만으로는 멀티 스레딩 환경에서의 동시성 문제를 해결할 수 없다. 동기화 메커니즘이 필요하다.
컴파일러 의존성: volatile의 효과는 컴파일러마다 약간씩 다를 수 있으므로, 사용하는 컴파일러의 문서를 참고하는 것이 좋다.

volatile 키워드의 사용은 임베디드 시스템의 신뢰성을 높이고 하드웨어와의 상호 작용을 정확하게 제어하는 데 중요한 역할을 한다.

1. UDS(통합 진단 서비스) 소개

18진수 — Tue, 19 Nov 2024 00:50:33 +0900

UDS(Unified Diagnostic Services) : 통합 진단 서비스

UDS(Unified Diagnostic Services)는 차량의 전장 소프트웨어(ECU 소프트웨어) 개발 및 유지보수에서 매우 중요한 역할을 한다. 전장 SW 개발에서 UDS의 역할은 다음과 같다.

⚙️ 1. UDS 소개

현재 자동차들은 아래 사진과 같이 다양한 ECU(Electronic Cotrol Unit)들로 차량 곳곳에 도배가 되어 있다. ECU가 늘어날수록 전장(전자 장비) 회사도 다양해지며, 각 부품마다 제조하는 회사가 달라 규격이 서로 달랐다. 각 부품을 모아 자동차를 조립하기 때문에 같은 규격으로 개발할 필요가 있었다.

자동차를 완성시키는 전장 부품들

Unified Diagnostic Services (UDS : 통합 진단 서비스)는 차량 내 통신 네트워크를 통해 전자 제어 장치(ECUs) 사이의 진단 통신을 표준화한 국제 표준인 ISO 14229에 정의되어 있다. 이 서비스는 차량의 진단, 프로그래밍, 모니터링 등 다양한 기능을 수행하도록 설계되었다. UDS는 차량의 고장 진단, 소프트웨어 업데이트 및 매개변수 조정 등을 가능하게 하는 광범위한 명령 집합을 제공한다.

UDS

UDS는 아래와 같이 다양한 기능을 제공한다.

1. 차량 진단 및 오류 관리
UDS는 차량의 전자 제어 장치(ECU)에서 발생하는 오류를 진단하고 관리하는 표준 프로토콜이다. 오류가 발생했을 때, 이를 확인하고 수정하기 위해 UDS를 사용하여 DTC(Diagnostic Trouble Codes)를 읽어내고 분석할 수 있다. 이를 통해 차량 소프트웨어가 예상대로 작동하지 않을 때 신속한 문제 해결이 가능하다.
2. 서비스 및 유지보수
UDS는 차량 서비스 및 유지보수 작업에서 필수적인 도구이다. 서비스 센터에서는 UDS 프로토콜을 통해 정비 데이터를 얻고, 차량의 특정 구성 요소를 점검하거나 리셋할 수 있다. 이를 통해 차량의 성능을 유지하고 정확한 유지보수를 수행할 수 있다.
3. ECU 재프로그래밍
UDS를 사용하여 ECU의 펌웨어 업데이트나 소프트웨어 재프로그래밍을 수행한다. 이는 차량의 새로운 기능을 추가하거나, 버그 수정 및 최적화를 위한 중요한 과정이다. 이를 통해 차량의 기능성을 향상시키고 최신 상태로 유지할 수 있다.
4. 보안성 강화
최신 차량의 ECU 소프트웨어는 보안이 중요한 요소이며, UDS는 보안 진단 서비스를 통해 ECU에 안전하게 접근할 수 있는 방법을 제공한다. 인증된 장치만이 특정 진단 명령을 수행할 수 있도록 보안을 강화할 수 있으며, 이를 통해 해킹 및 비인가 접근을 방지할 수 있다.
5. 차량 네트워크 및 통신 관리
UDS는 차량 내부 네트워크(CAN, LIN, FlexRay 등)를 통해 ECU 간에 통신을 관리한다. 차량의 전장 SW 개발 시, UDS를 사용하여 ECU 상태를 모니터링하고 제어할 수 있으며, 통신 오류 발생 시 이를 감지하고 수정하는 데 사용된다.

⚙️ 2. UDS와 ISO 14229

ISO 14229는 UDS 프로토콜의 사양을 정의하는 국제 표준이다. 이 표준은 진단 서비스의 프레임워크, 메시지 형식, 타이밍 요구 사항 등을 명시하여, 차량 진단 시스템의 설계와 구현을 지원한다. ISO 14229 표준은 차량 진단과 관련된 다양한 작업을 위한 명확한 지침을 제공함으로써, 전 세계 차량 제조사 및 장비 공급업체들이 일관된 진단 접근 방식을 채택할 수 있도록 돕는다.

⚙️ 3. UDS와 ISO 14229

UDS는 차량의 제품 수명 주기(PLC: Product Lifecycle) 동안 다양한 기능을 제공한다. 제조 단계에서는 차량의 초기 프로그래밍과 구성을 지원하고, 운영 단계에서는 정기적인 진단 검사, 오류 코드 해석, 소프트웨어 업데이트 등을 수행한다. 또한, 차량 폐기 단계에서도 중요한 정보 추출과 재설정을 가능하게 한다. 이러한 기능을 통해 UDS는 차량의 효율적인 관리와 유지보수에 필수적인 역할을 수행한다.

[STM32] 8. 스위치 채터링 (소프트웨어 디바운싱)

18진수 — Mon, 18 Nov 2024 23:58:58 +0900

스위치 채터링

푸쉬 리턴 스위치를 누를 때 발생할 수 있는 노이즈나 불안정한 신호로 인해 스위치가 여러 번 눌렸다고 인식되는 현상을 "채터링" 또는 "디바운싱" 문제라고 한다. 이를 해결하기 위해 디바운싱 필터링을 적용해야 한다. 디바운싱을 효과적으로 처리하는 방법에는 하드웨어적 방법과 소프트웨어적 방법이 있다. 이번 포스팅은 소프트웨어 디바운싱을 통해 채터링 문제를 해결 방법을 소개하려 한다.

소프트웨어 디바운싱은 코드로 디바운싱을 구현하는 방법아다. 주로 타이머를 이용하여 일정 시간 동안 신호가 안정적인지 확인하는 방식으로 처리한다.

1. 코드

/* USER CODE BEGIN PTD */
#define DEBOUNCE_DELAY 30 /* 30ms */
/* USER CODE END PTD */

...

/* USER CODE BEGIN 0 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin);

volatile uint32_t lastInterruptTime = 0;
/* USER CODE END 0 */

...

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin == BTN_Pin)
	{
		 uint32_t currentTime = HAL_GetTick(); /* check current time */
		 if ((currentTime - lastInterruptTime) > DEBOUNCE_DELAY){ /* check filtering 30ms time */
			 lastInterruptTime = currentTime; /* update interrupt time */
			 if (HAL_GPIO_ReadPin(GPIOA, BTN_Pin) == GPIO_PIN_SET){
				 HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, GPIO_PIN_SET);
			 }else{
				 HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, GPIO_PIN_RESET);
			 }
		 }
	}
}
/* USER CODE END 4 */

타이머 사용: HAL_GetTick() 함수를 사용하여 현재 시간을 가져온다. 이 함수는 시스템이 부팅된 이후의 밀리초(ms) 단위 시간을 반환한다.
인터럽트 핸들러에서 디바운싱 적용: 인터럽트가 발생할 때마다 현재 시간과 마지막 인터럽트 발생 시간을 비교하여 디바운싱 시간을 초과한 경우에만 버튼 입력을 처리한다.
디바운싱 시간 설정: DEBOUNCE_DELAY 매크로를 사용하여 디바운싱 시간을 설정한다. 여기서는 50ms로 설정하였다.

2. 특징

디바운싱 시간 선택: 너무 짧으면 채터링을 완전히 제거하지 못하고, 너무 길면 버튼 입력에 대한 응답성이 떨어질 수 있다. 일반적으로 10ms에서 50ms 사이의 값이 적절하다.
타이머 사용: 소프트웨어 디바운싱을 구현할 때 타이머를 사용하여 인터럽트 발생 후 일정 시간 동안 버튼 입력을 무시할 수 있다.
상태 확인: 버튼의 현재 상태를 저장하고, 일정 시간 동안 상태가 변하지 않는 경우에만 입력을 처리하는 방법도 있다.

이러한 방법들을 통해 버튼의 채터링 문제를 효과적으로 해결할 수 있다. 소프트웨어 디바운싱은 코드로 간단히 구현할 수 있다. 코드를 자세히 보면 volatile 키워드를 사용한 것을 확인할 수 있다. 다음 포스팅은 volatile 키워드에 대해 소개해보려 한다.

[STM32] 7. 외부 인터럽트(External Interrupt)

18진수 — Mon, 18 Nov 2024 23:42:45 +0900

외부 인터럽트

외부 인터럽트는 마이크로컨트롤러가 외부 신호(예: 버튼 입력, 센서 신호 등)에 의해 프로그램의 흐름을 중단하고, 특정 인터럽트 서비스 루틴(ISR, Interrupt Service Routine)을 실행하도록 하는 메커니즘이다. STM32 마이크로컨트롤러에서도 이러한 외부 인터럽트를 효과적으로 사용할 수 있다.

1. 외부 인터럽트 란?

외부 인터럽트는 마이크로컨트롤러의 특정 핀으로 들어오는 신호를 감지하여 발생하는 인터럽트이다. 이러한 인터럽트는 다음과 같은 경우에 유용하다.

버튼 누름 감지
센서의 신호 변화 감지
외부 장치와의 통신 신호 감지

외부 인터럽트는 일반적으로 다음과 같은 방식으로 설정되고 사용된다.

인터럽트 소스 설정: 특정 GPIO 핀을 인터럽트 소스로 설정한다.
인터럽트 모드 설정: 상승 엣지, 하강 엣지, 또는 양엽(둘 다)을 감지하도록 설정한다.
인터럽트 활성화: NVIC(중앙 인터럽트 컨트롤러)에서 해당 인터럽트를 활성화한다.
인터럽트 서비스 루틴(ISR) 작성: 인터럽트가 발생했을 때 실행될 코드를 작성한다.

인터럽트 소스 설정

상승 엣지, 하강 엣지, 또는 양엽(둘 다)을 감지하도록 설정

인터럽트 활성화

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin == BTN_Pin)
	{
		 if (HAL_GPIO_ReadPin(GPIOA, BTN_Pin) == GPIO_PIN_SET){
			 HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, GPIO_PIN_SET);
		 }else{
			 HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, GPIO_PIN_RESET);
		 }
	}
}
/* USER CODE END 4 */

2. 외부 인터럽트를 사용하는 이유

실시간 응답: 외부 이벤트에 대해 즉각적으로 응답할 수 있다. 프로그램의 메인 루프를 기다릴 필요 없이 바로 처리할 수 있다.
전력 효율성: 저전력 모드에서 마이크로컨트롤러가 대기 상태로 있다가 인터럽트가 발생하면 깨어나서 처리할 수 있다.
효율적인 자원 사용: 지속적으로 이벤트를 폴링(polling)하는 대신, 인터럽트를 사용하면 CPU 시간을 절약할 수 있다.

3. while문 대신 외부 인터럽트를 사용하는 이유

일반적인 프로그램에서는 메인 루프(while 문)에서 특정 조건을 지속적으로 확인하는 방식으로 버튼 입력을 처리할 수 있다. 그러나 이는 비효율적이다. 폴링 방식으로 버튼 입력을 확인하면 CPU 자원을 낭비하게 된다. 다음은 외부 인터럽트를 사용하는 이유이다.

[STM32] 6. 풀업 저항 기본 원리

18진수 — Mon, 18 Nov 2024 00:50:28 +0900

풀업 저항 (Pull-Up)

풀업 저항은 디지털 회로에서 입력 핀의 기본 상태를 높은 전압(논리적 '1')으로 설정하기 위해 사용된다. 풀업 저항이 없으면 입력 핀이 떠다니는 상태(floating)가 되어 예기치 않은 전압 값을 가질 수 있다. 풀업 저항을 사용하면 입력 핀이 안정된 높은 전압 상태를 유지하게 된다.

1. 풀업 저항의 역할

기본 상태 유지: 풀업 저항은 입력 핀이 아무 신호도 받지 않을 때 기본적으로 논리 '1' 상태(높은 전압)를 유지하도록 한다.
안정성 향상: 회로의 안정성을 높여, 입력 핀이 불안정한 상태(플로팅 현상)에서 예기치 않은 동작을 방지한다.

풀업 저항(R): 저항이 INPUT 핀과 Vcc(+5V) 사이에 연결된다.
스위치: 스위치가 닫히면 INPUT 핀은 GND와 연결되어 논리 '0'이 된다.
기본 상태: 스위치가 열려 있으면 풀업 저항에 의해 INPUT 핀은 논리 '1' 상태를 유지한다.

2. 풀업 저항 예시

스위치를 사용한 입력 회로
센서 입력 회로
I2C 통신 회로 등

요즘 임베디드는 전장 업계가 호황인데, 대게 자동차 부품에 스위치가 있다면 내가 말하는 대부분의 회로 구성이 아닐까 싶다. 자동차 배터리는 +12V 이므로 5V나 3.3V 동작하는 MCU를 위해 전압 강하를 하고, 그 사이에 풀업 저항을 통해 스위치를 제어한다. 차량이 IGN1이나 Engine On 상태일 때, MCU는 Normal 모드로 동작하며 스위치가 눌리지 않는 상태에서는 해당 스위치의 GPIO Input 핀에 동작 전압(5V 및 3.3V, Output High)이 흐르다가 스위치가 눌리게 되면 Input 핀에는 0V(Output Low)가 흐른다. (정확히는 실제 Input 핀에 오실로스코프를 이용하여 전압을 측정하면 0V가 아닌 0V(10mV~ 100mV)에 가까운 전압이다.) 이는 스위치가 눌리지 않았을 때 Output High이고, 스위치가 눌렸을 때 Output Low 이므로, 이를 Active Low라고 한다. 나는 소프트웨어 개발자로 회로 설계자 만큼 깊은 지식을 소유하고 있지는 않지만, 회로 설계자가 회로도를 제공했을 때, 소프트쟁이가 읽어야만 하는 몇 안되는 기본 회로(전압 분배, 스위칭 회로, 필터 회로 등) 중 하나라 생각한다.

3. 풀업 저항과 플로팅 현상

플로팅(Floating) 현상
디지털 회로에서 입력 핀이 플로팅 상태가 되면 핀이 어떠한 고정된 전압 수준(논리 '1' 또는 논리 '0')으로 연결되지 않아 불안정한 상태에 놓이게 된다. 이는 입력 핀이 외부 신호에 의해 드라이브되지 않을 때 발생한다. 이러한 상태에서는 입력 핀이 노이즈에 민감해지고, 임의의 전압 수준을 가지게 되어 예기치 않은 동작이 발생할 수 있다.
풀업 저항(Pull-up Resistor)
풀업 저항은 입력 핀을 전원 전압(Vcc)에 연결하여 기본적으로 높은 전압 수준(논리 '1')을 유지하도록 하는 저항이다. 이를 통해 입력 핀이 플로팅 상태에 놓이는 것을 방지한다.

4. 장점

안정적인 신호 유지: 풀업 저항을 사용하면 입력 핀이 항상 안정된 전압 수준을 유지하여 신호의 일관성을 보장한다.
디지털 회로 보호: 풀업 저항은 입력 핀이 불안정한 상태에서 발생할 수 있는 불안정한 신호로 인한 회로 오작동을 방지한다.
전력 소모 최소화: 적절한 저항 값을 사용하면 전력 소모를 최소화하면서도 안정적인 입력 신호를 유지할 수 있다.
노이즈 방지: 플로팅 상태의 입력 핀은 환경 노이즈에 민감하므로, 풀업 저항을 사용하면 이러한 노이즈 영향을 최소화할 수 있다.
예측 가능한 동작: 입력 핀이 항상 논리 '1' 상태를 유지하도록 하여 예기치 않은 동작을 방지할 수 있다.

5. 팁

내부 풀업 저항 사용: STM32의 GPIO 설정에서 내부 풀업 저항을 활성화하면 외부 저항 없이 회로를 간단하게 만들 수 있다.
디바운싱 처리: 스위치를 사용할 때 노이즈로 인해 잘못된 입력이 발생할 수 있으므로 디바운싱(SW, HW) 처리를 고려해야 한다.
적절한 저항 값 선택: 외부 풀업 저항을 사용할 경우, 저항 값은 일반적으로 4.7~10kΩ 정도가 적당하지만 회로 요구사항에 따라 다를 수 있다.

[STM32] 5. 내장 스위치 제어

18진수 — Sun, 17 Nov 2024 23:51:12 +0900

STM32 내장 스위치 제어

이번 포스팅은 STM32 보드에 있는 내장 스위치의 기능을 설명하고, 스위치 입력을 받아 처리하는 간단한 프로젝트를 포함한다. 하기 이미지와 같이 Arduino UNO, ATMega328P, STM32 Board 등 대부분의 개발 보드들은 테스트를 해볼 수 있게끔 스위치를 내장하고 있다. 다음 포스팅에 소개할 예정이지만 이런 보드들의 스위치들은 풀업 저항 회로로 구성되어 있다. 풀업 저항은 전원단에 저항이 있는 회로로 노이즈에 강하다는 장점을 가지고 있으며 대부분의 양산 제품들이 이 회로를 사용하고 있다.

NUCLEO-64 STM32U083RC EVAL BRD

풀업 저항 회로

1. STM32 내장 스위치

스위치의 역할: 스위치는 사용자가 전자 장치에 명령을 내릴 수 있는 간단하고 직관적인 인터페이스를 제공한다.
물리적 구성: 대부분의 STM32 보드에는 일반적으로 "USER" 라벨이 붙은 누를 수 있는 버튼 형태의 스위치가 하나 이상 포함되어 있다.

2. STM32에서 스위치 연결

보드의 스위치 핀 위치와 기능 확인: STM32 보드의 데이터시트 또는 사용자 매뉴얼을 통해 스위치가 연결된 GPIO 핀을 확인한다. 예를 들어, 많은 STM32F4 Discovery 보드에서는 스위치가 PA0 핀에 연결되어 있다.
스위치의 전기적 특성: 대부분의 스위치는 기본적으로 풀업(pull-up) 저항과 연결되어 있어, 스위치가 눌리지 않은 상태에서는 핀이 높은 전압(HIGH) 상태를 유지하고, 눌렸을 때는 낮은 전압(LOW) 상태가 된다.

3. 스위치 입력을 위한 GPIO 설정

Cube IDE에서 GPIO 설정:
- Mode: Input (입력 모드로 설정)
- Pull: Pull-up (내부 풀업 저항 활성화)

위 이미지처럼 설정하면 하기와 같이 코드가 자동생성된다.

4. Configuration Code 설명

/* GPIO_SW_Pin 핀을 구성하는 코드 */
GPIO_InitStruct.Pin = GPIO_SW_Pin;  // GPIO 초기화 구조체에서 제어할 핀을 지정 (GPIO_SW_Pin)
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  // 핀의 모드를 입력 모드 (Input Mode)로 설정
GPIO_InitStruct.Pull = GPIO_PULLUP;  // 내부 풀업 저항을 활성화하여 기본적으로 핀이 HIGH 상태가 되도록 설정
HAL_GPIO_Init(GPIO_SW_GPIO_Port, &GPIO_InitStruct);  // HAL 라이브러리의 초기화 함수 호출, 설정된 구조체를 사용하여 GPIO_SW_GPIO_Port의 핀을 초기화

GPIO_InitStruct.Pin = GPIO_SW_Pin;

GPIO_InitStruct는 GPIO_InitTypeDef라는 구조체이며, GPIO 핀의 설정을 정의하는 데 사용된다.
Pin 필드는 설정하려는 특정 핀을 지정한다. 여기서는 GPIO_SW_Pin이 스위치에 연결된 핀을 나타낸다.

GPIO_InitStruct.Mode = GPIO_MODE_INPUT;

Mode 필드는 핀의 동작 모드를 지정한다.
GPIO_MODE_INPUT은 핀을 입력 모드로 설정하며, 외부 신호(스위치)를 읽을 수 있도록 한다.

GPIO_InitStruct.Pull = GPIO_PULLUP;

Pull 필드는 핀의 내부 풀업 또는 풀다운 저항을 활성화할지 설정한다.
GPIO_PULLUP을 설정하면 내부 풀업 저항이 활성화되어 핀의 기본 상태가 HIGH(1)로 유지된다.
스위치가 눌리지 않았을 때 핀의 상태가 HIGH로 유지되며, 스위치를 누르면 LOW(0)로 전환된다. (Active Low)

HAL_GPIO_Init(GPIO_SW_GPIO_Port, &GPIO_InitStruct);

HAL_GPIO_Init() 함수는 설정된 구조체(GPIO_InitStruct)를 사용하여 지정된 포트에서 핀을 초기화한다.
첫 번째 인자 GPIO_SW_GPIO_Port는 초기화할 포트의 레지스터 주소이며, 두 번째 인자는 초기화 설정이 포함된 구조체의 포인터이다.
이를 통해 입력 핀의 모드와 풀업 저항 설정을 적용한다.

5. Switch 로직 설명

해당 코드는 내장 스위치가 눌렸을 때, 내장 LED를 제어하는 코드이다.

// GPIO 포트를 읽어 스위치 상태에 따라 LED를 제어하는 코드
if(!HAL_GPIO_ReadPin(GPIO_SW_GPIO_Port, GPIO_SW_Pin)) {
    // HAL_GPIO_ReadPin() 함수는 지정된 GPIO 포트의 핀 상태를 읽음
    // 여기서는 GPIO_SW_GPIO_Port 포트의 GPIO_SW_Pin 핀의 상태를 읽음
    // HAL_GPIO_ReadPin()은 핀의 상태가 LOW(0)일 경우 0을 반환
    // 조건문에서 '!'(논리 NOT)를 사용하여 핀이 LOW일 때 조건이 참이 되도록 설정

    HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, 0);
    // HAL_GPIO_WritePin() 함수는 지정된 GPIO 포트의 핀 상태를 설정함
    // 여기서는 GPIO_LED_GPIO_Port 포트의 GPIO_LED_Pin 핀을 LOW(0)으로 설정하여 LED를 켬
} else {
    HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, 1);
    // 스위치 핀이 HIGH(1)일 경우, GPIO_LED_GPIO_Port의 GPIO_LED_Pin을 HIGH(1)으로 설정하여 LED를 끔
}

HAL_GPIO_ReadPin(GPIO_SW_GPIO_Port, GPIO_SW_Pin)

지정된 포트(GPIO_SW_GPIO_Port)의 핀(GPIO_SW_Pin)에서 현재 상태를 읽는다.
- 반환 값이 0일 때 핀의 상태가 LOW(0)이며, 스위치가 눌려진 상태임을 의미합니다.
- 반환 값이 1일 때 핀의 상태가 HIGH(1)이며, 스위치가 눌리지 않은 상태입니다.

HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, 0)

LED 제어 핀을 LOW로 설정하여 LED를 켠다.

HAL_GPIO_WritePin(GPIO_LED_GPIO_Port, GPIO_LED_Pin, 1)

LED 제어 핀을 HIGH로 설정하여 LED를 끈다.

이 방식을 사용하면 간단하게 GPIO_INPUT, OUTPUT을 간단하게 제어할 수 있다.

[C/C++ Tip] 30. C언어 Unit Test 종류

18진수 — Tue, 12 Nov 2024 00:13:59 +0900

단위 테스트 종류

위 테스트의 각 유형을 좀 더 상세하게 설명하고, 각 유형이 어떤 문제를 잡기 위해 사용되는지, 그리고 각각에 대한 깔끔한 코드 예제를 제공하겠다. 여기서는 간단한 함수를 사용하여 여러 단위 테스트에 대해 설명한다.

⭐ 1. 대상 함수

// calculateDiscount 함수는 구매 금액(amount)에 따라 할인율을 적용함.
// 100 이상일 때는 10% 할인, 50 이상 100 미만일 때는 5% 할인, 그 외에는 할인 없음.
double calculateDiscount(double amount) {
    if (amount >= 100) return amount * 0.9;
    else if (amount >= 50) return amount * 0.95;
    else return amount;
}

⭐ 2. Positive UT

긍정 테스트는 함수가 올바른 입력에 대해 예상된 동작을 수행하는지 확인하기 위해 사용된다. 이는 기본적으로 함수의 "정상적인" 사용 사례를 테스트한다.

void testCalculateDiscountPositive() {
    assert(calculateDiscount(150) == 135);  // 100 이상의 금액에 대해 10% 할인이 적용되어야 함.
    assert(calculateDiscount(75) == 71.25);  // 50 이상 100 미만의 금액에 대해 5% 할인이 적용되어야 함.
    assert(calculateDiscount(25) == 25);     // 50 미만의 금액에는 할인이 적용되지 않아야 함.
    printf("Positive tests passed.\n");
}

⭐ 3. Negative UT

부정 테스트는 함수가 잘못된 입력이나 예외적인 상황을 적절하게 처리하는지 확인하기 위해 사용된다. 이는 함수의 오류 처리 능력을 테스트한다.

void testCalculateDiscountNegative() {
    // 이 함수는 잘못된 입력에 대한 예외 처리를 구현하지 않았기 때문에, 의도적으로 오류 상황을 만들어 볼 수 없음.
    // 만약 calculateDiscount 함수가 음수 입력에 대해 에러를 반환하도록 설계되었다면, 그것을 테스트하는 코드가 여기에 위치할 것임.
}

⭐ 4. Boundary UT

경계 테스트는 입력 값이나 출력 값이 경계에 위치할 때 함수의 동작을 검증하기 위해 사용된다. 이는 함수가 경계 조건에서도 올바르게 동작하는지 확인한다.

void testCalculateDiscountBoundary() {
    assert(calculateDiscount(100) == 90);   // 정확히 100인 경우, 10% 할인이 적용되어야 함.
    assert(calculateDiscount(50) == 47.5);  // 정확히 50인 경우, 5% 할인이 적용되어야 함.
    assert(calculateDiscount(49.99) == 49.99); // 50 미만의 경계값에서 할인이 적용되지 않아야 함.
    printf("Boundary tests passed.\n");
}

⭐ 5. Equivalence Partitioning UT

동등 분할 테스트는 입력 데이터를 유효한 값의 집합(할인이 적용되는 금액 범위)과 유효하지 않은 값의 집합(할인이 적용되지 않는 금액 범위)으로 나뉜다. 여기서는 모든 입력이 유효하므로, 할인율이 적용되는 범위를 기준으로 나눌 수 있다.

void testCalculateDiscountEquivalence() {
    assert(calculateDiscount(25) == 25);     // 할인 없음
    assert(calculateDiscount(75) == 71.25);  // 5% 할인 적용
    assert(calculateDiscount(150) == 135);   // 10% 할인 적용
    printf("Equivalence partitioning tests passed.\n");
}

⭐ 6. Min/Max Unit Test

경계 테스트는 할인율 변경점 근처의 값들을 테스트한다. 또한, Min/Max 테스트로는 구매 금액의 합리적인 최소값과 최대값을 고려할 수 있다.

void testCalculateDiscountBoundary() {
    assert(calculateDiscount(0) == 0);       // 최소값 테스트
    assert(calculateDiscount(1000) == 900);  // 예시로 든 최대값 테스트
    printf("Boundary and Min/Max tests passed.\n");
}

⭐ 7. Fault Injection Unit Test

고의적으로 함수에 잘못된 값을 주입하여, 함수가 예외 상황을 적절히 처리하는지 확인하는 테스트이다. calculateDiscount 함수의 경우, 음수 금액을 처리하는 능력을 테스트할 수 있다. 하지만 현재 함수 구현에서는 음수 입력에 대한 명시적 처리가 없으므로, 이 예제는 함수가 예외를 처리하도록 설계된 상황을 가정하고 작성된다.

void testCalculateDiscountFaultInjection() {
    // 가정: 음수 금액에 대해서는 0을 반환하도록 함수가 수정되었다고 가정
    assert(calculateDiscount(-50) == 0);  // 잘못된 입력 처리 테스트
    printf("Fault injection tests passed.\n");
}

실제 개발 환경에서는 이러한 테스트들을 통해 함수의 다양한 측면을 검증하여, 오류 가능성을 줄이고 코드의 신뢰성을 높일 수 있다. Fault Injection의 경우, 실제 구현에 따라 다르게 적용될 수 있으며, 함수가 예외 상황을 올바르게 처리할 수 있도록 보장하는 중요한 방법 중 하나이다.

[C/C++ Tip] 29. C언어 Unit Test

18진수 — Tue, 12 Nov 2024 00:03:32 +0900

Unit Test

C언어에서 단위 테스트(Unit Test)를 구현하는 방법 중 하나는 간단한 함수와 함께 assert 매크로를 사용하는 것이다. assert 매크로는 조건이 참이 아닐 경우 프로그램을 종료시키므로, 예상된 결과가 실제 결과와 일치하는지 검증하는 데 유용하다. 더 복잡한 테스트 요구 사항이 있는 경우, C언어용 테스트 프레임워크(예: CUnit, Unity, CMocka 등)를 사용할 수 있다.

여기에는 간단한 add 함수와 이 함수에 대한 단위 테스트 예제가 포함되어 있다. 이 예제는 assert를 사용하여 구현된다.

asset 함수를 사용하기 위해선 assert.h를 include 해야 한다.

#include <stdio.h>
#include <assert.h>

// 간단한 덧셈 함수 정의
int add(int a, int b) {
    return a + b;
}

// add 함수를 테스트하기 위한 단위 테스트 함수
void test_add() {
    assert(add(0, 0) == 0); // 0 + 0 = 0
    assert(add(-1, 1) == 0); // -1 + 1 = 0
    assert(add(10, 20) == 30); // 10 + 20 = 30
    assert(add(-5, -10) == -15); // -5 + -10 = -15
    // 테스트가 여기까지 진행되면 모든 assert 조건이 참이라는 의미이며, 함수가 예상대로 작동한다는 것을 의미합니다.
    printf("All tests passed.\n");
}

int main() {
    test_add(); // 단위 테스트 실행
    return 0;
}

이 예제에서 add 함수는 두 정수를 입력받아 그 합을 반환한다. test_add 함수는 add 함수가 올바르게 작동하는지 검증하기 위해 몇 가지 사례를 테스트한다. 각 assert 호출은 add 함수에 특정 입력을 제공하고, 예상되는 출력과 실제 출력이 일치하는지 확인한다. 만약 일치하지 않는 경우, assert는 프로그램을 즉시 종료시키며, 이는 테스트 실패를 의미한다.

단위 테스트는 코드의 각 부분이 예상대로 작동하는지 확인하는 데 매우 중요하다. 이는 특히 프로젝트 규모가 커짐에 따라 더욱 중요해지며, 이를 통해 더 복잡한 시스템에서도 신뢰할 수 있는 코드를 유지할 수 있다.

이 포스팅을 Unit Test에 대해 간단히 소개했다. 하지만 Unit Test에도 다양한 종류가 있으며 이를 통해 자신이 설계한 코드의 신뢰성을 높이는 것은 중요한 작업이다.

[C/C++ Tip] 28. C언어 포인터의 다양한 표현들

18진수 — Mon, 11 Nov 2024 23:56:18 +0900

포인터의 다양한 표현

C언어의 포인터를 이해하고 활용하는 것은 처음 접하는 사람들에게 다소 어려울 수 있는데, 그 중 하나의 원인은 여러가지 다양한 표현법 때문이다. 특히, 같은 메모리 주소를 가리키는 다양한 방법이 존재하는데, 이는 때로는 혼란을 줄 수 있다. 여기 몇 가지 대표적인 예시를 들어본다.

⭐ 1. 배열의 첫 번째 요소의 주소

int A[10];

표현법 1: A
- 배열의 이름만 사용하면, 배열의 첫 번째 요소의 주소를 나타낸다.
표현법 2: &A[0]
- 배열의 첫 번째 요소의 주소를 명시적으로 나타낸다.

⭐ 2. 함수 포인터

int func(int x) {
  return x * 2;
}

표현법 1: func
- 함수 이름만을 사용하여 해당 함수의 주소를 나타낸다.
표현법 2: &func
- 함수의 주소를 명시적으로 나타내기 위해 함수 이름 앞에 &를 붙여 사용한다.

⭐ 3. 구조체 멤버의 주소

struct MyStruct {
  int x;
};

struct MyStruct *ptr = &myStruct;

표현법 1: (*ptr).x
- 구조체 멤버 x의 주소를 직접 나타낸다.
표현법 2: ptr->x
- 구조체의 시작 주소를 int *로 캐스팅하여, 첫 번째 멤버 x의 주소를 얻는다. 이는 구조체가 x로 시작한다고 가정할 때 유효하다.

⭐ 4. 포인터를 통한 배열 접근

int arr[3] = {10, 20, 30};
int *ptr = arr;

표현법 1: ptr[0]
- 포인터를 배열처럼 인덱싱하여 첫 번째 요소에 접근한다.
표현법 2: *ptr
- 포인터를 역참조하여 첫 번째 요소의 값을 얻는다.

⭐ 5. 문자열과 포인터

char *str = "Hello";

표현법 1: str
- 포인터 변수 str을 사용하여 문자열의 첫 번째 문자의 주소를 나타낸다.
표현법 2: &str[0]
- 문자열의 첫 번째 문자의 주소를 명시적으로 나타낸다.

이러한 예시들은 C언어에서 포인터와 관련된 다양한 표현법들이 어떻게 유사한 결과를 제공할 수 있는지를 보여준다. 포인터는 강력하지만, 그 사용법을 정확히 이해하고 사용하는 것이 중요하다.

[C/C++ Tip] 27. C언어 데이터 형식 범위

18진수 — Mon, 11 Nov 2024 23:44:21 +0900

데이터 형식의 범위

C언어는 다양한 데이터 타입을 제공하며, 이러한 데이터 타입들은 메모리의 효율적 사용과 연산의 정확성을 위해 설계되었다. 각 데이터 타입은 표현할 수 있는 값의 범위가 정해져 있으며, 이는 해당 타입이 메모리에서 차지하는 바이트 크기에 의해 결정된. C언어의 기본 단위는 1바이트이며, 여기서 1바이트는 8비트와 동일하다.

아래에서는 몇 가지 주요 데이터 타입의 최소값과 최대값을 살펴보겠다. 이 값들은 데이터 타입이 양수만을 저장할 수 있는지(부호 없음, unsigned), 아니면 음수와 양수 모두를 저장할 수 있는지(부호 있음, signed)에 따라 달라진다. 이 예시에서는 일반적인 32비트 및 64비트 시스템을 기준으로 설명한다.

⭐ 1. unsigned char

크기: 1바이트 (8비트)
범위: 0 ~ 255
설명: unsigned char는 부호 없는 8비트 정수로, 0부터 255까지의 값을 저장할 수 있다.

⭐ 2. signed char

크기: 1바이트 (8비트)
범위: -128 ~ 127
설명: signed char는 부호 있는 8비트 정수로, -128부터 127까지의 값을 저장할 수 있다.

⭐ 3. int16_t (또는 short)

크기: 2바이트 (16비트)
범위: -32,768 ~ 32,767
설명: int16_t는 부호 있는 16비트 정수로, -32,768부터 32,767까지의 값을 저장할 수 있다.

⭐ 4. int32_t (또는 int)

크기: 4바이트 (32비트)
범위: -2,147,483,648 ~ 2,147,483,647
설명: int32_t는 부호 있는 32비트 정수로, 약 -2.1억부터 2.1억까지의 값을 저장할 수 있다.

⭐ 5. uint32_t (또는 unsigned int)

크기: 4바이트 (32비트)
범위: 0 ~ 4,294,967,295
설명: uint32_t는 부호 없는 32비트 정수로, 0부터 약 42억까지의 값을 저장할 수 있다.

⭐ 6. float

크기: 4바이트 (32비트)
범위: 대략 -3.4E+38 ~ 3.4E+38 (유효 숫자 약 7자리)
설명: float는 부동 소수점 수로, 매우 크거나 매우 작은 수를 표현할 수 있으며, 주로 과학 계산에 사용된다. float는 유효 숫자가 약 7자리인 실수 값을 저장할 수 있다.

⭐ 7. 고려사항

메모리 사용 최적화: 가능한 한 적은 메모리를 사용하는 타입을 선택하세요. 예를 들어, 값의 범위가 0~255 사이라면 unsigned char를 사용하는 것이 좋다.
수치 범위 고려: 변수가 저장해야 할 값의 범위를 고려하여 적절한 타입을 선택하세요. 예를 들어, 양수만 필요한 경우 unsigned 타입을 고려해야 한다.
표준 타입 사용: 표준화된 데이터 타입(int16_t, uint32_t 등)을 사용하면 코드의 이식성이 향상된다.
성능 고려: 목표 플랫폼에서의 연산 성능도 고려하세요. 일부 시스템에서는 특정 크기의 데이터 타입을 더 효율적으로 처리할 수 있다.

각 데이터 타입의 선택은 애플리케이션의 요구 사항, 메모리 효율성, 처리 속도 등 여러 요소를 고려해야 한다. C언어 프로그래밍에서 올바른 데이터 타입을 선택하는 것은 프로그램의 성능과 안정성을 크게 향상시킬 수 있다.

[C/C++ Tip] 26. Char, String 기본 사용법

18진수 — Sun, 10 Nov 2024 19:43:44 +0900

char, string

C언어에서 char과 string의 개념은 상당히 기본적이면서도 중요하다. 이 두 가지는 데이터를 다룰 때 자주 사용되기 때문에 그 차이점을 이해하는 것이 중요하다.

⭐ 1. char

char은 C언어에서 한 개의 문자를 저장하기 위한 데이터 타입이다.
메모리에서 1바이트(대부분의 시스템에서)를 차지한다.
단일 따옴표(' ')를 사용하여 표현한다. 예: char letter = 'A';

⭐ 2. string

C언어는 원래 string 타입을 지원하지 않는다. 대신, 문자열은 char 타입의 배열로 표현된다.
문자열은 끝에 널 문자(\0)를 포함하여 이것이 문자열의 끝임을 나타낸다.
문자열은 쌍따옴표(" ")로 둘러싸여 표현된다. 예: char name[] = "Hello";

⭐ 3. Code

#include <stdio.h>

int main() {
    // char 예시
    char letter = 'A';
    printf("The letter is: %c\n", letter);

    // string (char 배열) 예시
    char name[] = "Hello";
    printf("The name is: %s\n", name);

    return 0;
}

⭐ 4. 주의사항

문자열을 다룰 때 널 문자(\0, null)의 존재를 항상 기억해야 한다. 이것이 없으면 문자열이 제대로 끝나지 않아 예기치 않은 동작을 일으킬 수 있다.
char 배열을 사용하여 문자열을 다룰 때는 배열의 크기가 저장하려는 문자열의 길이보다 크거나 같아야 한다.
char 사용: 단일 문자 처리가 필요할 때 사용한다. 예를 들어, 사용자 입력에서 특정 문자를 검사하거나, 문자를 하나씩 조작할 필요가 있을 때 유용하다.
string (char 배열) 사용: 사용자 이름, 주소 등과 같이 여러 문자로 이루어진 데이터를 저장하고 싶을 때 사용한다. 또한, 파일에서 텍스트를 읽거나 콘솔에 메시지를 출력할 때도 자주 사용된다.

[C/C++ Tip] 25. C언어 2차원 배열

18진수 — Sun, 10 Nov 2024 19:15:22 +0900

2차원 배열

C언어에서 2차원 배열을 다루는 것은 프로그래밍의 기본이면서도, 다양한 응용 분야에서 필수적으로 사용되는 중요한 개념이다. 이 글에서는 2차원 배열의 기본적인 사용법, 몇 가지 팁과 코드 예시를 통해 이해를 돕는다.

⭐ 1. 2차원 배열 구조

2차원 배열은 데이터를 행렬의 형태로 저장할 때 사용되며, 타입 배열이름[행의 개수][열의 개수];의 형태로 선언한다. 예를 들어, 3행 4열의 정수형 2차원 배열은 다음과 같이 선언한다.

int matrix[3][4];

⭐ 2. 초기화

2차원 배열은 선언과 동시에 초기화할 수 있다. 배열을 초기화할 때는 중괄호 {}를 사용하여 각 행의 요소를 나열한다.

int matrix[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

⭐ 3. 배열의 접근

2차원 배열의 각 요소에 접근하려면 두 개의 인덱스를 사용한다. 첫 번째 인덱스는 행을, 두 번째 인덱스는 열을 가리킨다. 다음은 2차원 배열의 모든 값을 출력하는 예제이다.

for(int i = 0; i < 3; i++) {
    for(int j = 0; j < 4; j++) {
        printf("%d ", matrix[i][j]);
    }
    printf("\n");
}

⭐ 4. 동적 할당

고정된 크기의 배열 대신, 프로그램 실행 중에 배열의 크기를 결정해야 하는 경우가 있다. 이럴 때는 malloc 또는 calloc 함수를 사용하여 2차원 배열을 동적으로 할당할 수 있다. ex) 행렬 계산

int **matrix = (int **)malloc(3 * sizeof(int *));
for(int i = 0; i < 3; i++) {
    matrix[i] = (int *)malloc(4 * sizeof(int));
}

⭐ 5. 배열의 포인터

2차원 배열을 함수의 인자로 전달할 때는, 배열의 포인터를 사용하는 것이 효율적이다. 이를 통해 큰 데이터의 복사 없이 배열에 접근할 수 있다.

#include <stdio.h>
#include <stdlib.h>

void printMatrix(int* matrix[4], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int* matrix[4];
    for (int i = 0; i < 4; i++) {
        matrix[i] = (int*)malloc(4 * sizeof(int)); // 각 행을 동적으로 할당
        for (int j = 0; j < 4; j++) {
            matrix[i][j] = i * 4 + j; // 예시 데이터
        }
    }

    printMatrix(matrix, 4);

    // 할당 해제
    for (int i = 0; i < 4; i++) {
        free(matrix[i]);
    }

    return 0;
}

2차원 배열은 데이터를 구조화하고, 다루는 데 있어 매우 유용하다. C언어를 사용하여 2차원 배열을 효과적으로 활용하려면, 배열의 선언과 초기화, 메모리 할당, 그리고 함수와의 상호작용 방법을 정확히 이해하는 것이 중요하다.

[C/C++ Tip] 24. C언어 파일 입출력

18진수 — Sat, 9 Nov 2024 13:17:14 +0900

파일 입출력

이번 포스팅은 간단한 사용자 정보(이름, 나이, 이메일)를 CSV 형식으로 txt 파일에 저장하고, 저장된 파일을 다시 읽어와서 화면에 출력하는 예제를 다룬다. 실제 C언어에서 파일 입출력을 사용한 적은 크게 없다. 하지만 파일이 쓰고 읽히는 기본 원리를 이해하기 위해 작성하게 되었다.

⭐ 1. 파일 쓰기 예제

먼저 사용자 정보를 txt 파일에 저장하는 예제부터 시작한다. 파일에 데이터를 쓰기 위해 fprintf 함수를 사용한다. 각 필드는 쉼표로 구분하고, 각 레코드는 새로운 줄에 위치한다.

#include <stdio.h>

int main() {
    // 파일 포인터 선언
    FILE *fp = fopen("test.txt", "w");
    if (fp == NULL) {
        perror("파일 열기 실패");
        return -1;
    }

    // 데이터 쓰기 (이름, 나이, 이메일)
    fprintf(fp, "이름,나이,이메일\n"); // 헤더 작성
    fprintf(fp, "홍길동,30,hong@example.com\n");
    fprintf(fp, "김철수,25,kim@example.com\n");

    // 파일 닫기
    fclose(fp);

    printf("데이터가 성공적으로 저장되었습니다.\n");

    return 0;
}

모드	설명
r	읽기 전용으로 파일 열기. 파일이 존재하지 않으면 열기 실패.
w	쓰기 전용으로 파일 열기. 파일이 이미 존재하면 내용을 지우고, 없으면 새 파일 생성.
a	추가 모드로 파일 열기. 파일이 이미 존재하면 데이터를 파일 끝에 추가하고, 없으면 새 파일 생성.
r+	읽기/쓰기 모드로 파일 열기. 파일이 존재하지 않으면 열기 실패.
w+	읽기/쓰기 모드로 파일 열기. 파일이 이미 존재하면 내용을 지우고, 없으면 새 파일 생성.
a+	추가/읽기 모드로 파일 열기. 파일 끝에 데이터를 추가하고, 파일이 없으면 새 파일 생성.
rb, wb, ab, rb+, wb+, ab+	위 모드들에 b를 추가하여 이진 파일로 작업할 때 사용. 예: rb는 이진 파일을 읽기 전용으로 열기.

이 코드는 test.txt라는 파일을 생성하고, 파일에 이름, 나이, 이메일 정보를 쉼표로 구분하여 차례로 파일에 쓴다. 위 코드에서 중요한 포인트는 순서이다. 우선, 파일을 열어야 한다. 파일이 열렸다면 이제는 파일에 읽기 쓰기를 할 준비가 된 셈이다. 그리고 데이터를 순서대로 파일에 쓴다. 쓰기 작업이 마무리가 되었다면, 꼭 파일을 닫아야 한다. 제대로 닫지 않은 상태에서 프로그램을 종료한다면 파일이 깨지거나 올바르게 저장되지 않을 수 있다. 이 원리는 c언어는 고사하고 파이썬, 자바와 동일하니 꼭 기억해야 한다.

⭐ 2. 파일 읽기 예제

다음으로 저장된 txt 파일을 읽어와 콘솔에 출력한다. 파일로부터 데이터를 읽기 위해 fscanf 함수를 사용한다. 파일의 끝에 도달할 때까지 반복하여 데이터를 읽는다.

#include <stdio.h>

int main() {
    // 파일 포인터 선언
    FILE *fp = fopen("users.csv", "r");
    if (fp == NULL) {
        perror("파일 열기 실패");
        return -1;
    }

    char name[100], email[100];
    int age;

    // 헤더 읽기
    fscanf(fp, "%*s %*s %*s\n"); // 첫 번째 줄(헤더)는 건너뜁니다.

    // 데이터 읽기 (이름, 나이, 이메일)
    while (fscanf(fp, "%[^,],%d,%[^,\n]\n", name, &age, email) != EOF) {
        printf("이름: %s, 나이: %d, 이메일: %s\n", name, age, email);
    }

    // 파일 닫기
    fclose(fp);

    return 0;
}

⭐ 3. 주의사항

◆ 잘못된 예시 코드

#include <stdio.h>

int main() {
    FILE *file;
    char buffer[100];

    // 파일 열기 (파일 포인터 NULL 체크 없음)
    file = fopen("example.txt", "r");

    // 파일로부터 데이터 읽기 (파일 포인터가 NULL인지 확인하지 않음)
    fscanf(file, "%s", buffer);
    printf("파일 내용: %s\n", buffer);

    // 파일 닫기 (fclose 없음)
    return 0;
}

위 코드는 다음과 같은 문제가 있다:

파일 포인터 NULL 검사 없음: fopen() 함수가 실패할 경우 file 포인터는 NULL이 되는데, 이를 확인하지 않으면 프로그램이 비정상적으로 동작할 수 있다.
파일 닫기(fclose) 없음: 파일 작업이 끝난 후 fclose()를 호출하지 않으면 파일 리소스가 반환되지 않아 메모리 누수가 발생할 수 있다.

◇ 올바른 예시 코드

아래는 파일을 성공적으로 열었는지 확인하고, 작업 후 파일을 제대로 닫는 수정된 코드이다.

#include <stdio.h>

int main() {
    FILE *file;
    char buffer[100];

    // 파일 열기
    file = fopen("example.txt", "r");
    
    // 파일 포인터 NULL 검사
    if (file == NULL) {
        perror("파일 열기 오류");
        return 1; // 파일 열기에 실패한 경우 프로그램 종료
    }

    // 파일로부터 데이터 읽기
    if (fscanf(file, "%99s", buffer) == 1) {
        printf("파일 내용: %s\n", buffer);
    } else {
        printf("파일 읽기 실패 또는 빈 파일입니다.\n");
    }

    // 파일 닫기
    fclose(file);

    return 0;
}

이 수정된 코드는 다음과 같은 점에서 수정되었다.

파일 포인터 NULL 검사: fopen()이 실패할 경우 file이 NULL이 되므로, if (file == NULL)을 통해 파일이 제대로 열렸는지 확인한다. 실패 시 오류 메시지를 출력하고 프로그램을 종료한다.
fclose 사용: 파일 작업이 끝난 후 반드시 fclose(file)을 호출하여 파일을 닫고, 리소스를 반환한다.
입력 데이터 제한: fscanf(file, "%99s", buffer)로 최대 입력 크기를 지정하여 버퍼 오버플로우를 방지했다.

이 코드는 파일 작업을 안전하게 처리하여 파일 입출력 중 발생할 수 있는 오류를 방지한다.

[C/C++ Tip] 23. 지역 변수, 전역 변수, 정적 변수

18진수 — Sat, 9 Nov 2024 13:00:18 +0900

지역 변수, 전역 변수, 정적 변수

C언어에서 변수의 유효 범위와 수명은 프로그램의 동작을 이해하고 제어하는 데 중요한 역할을 한다. 이 글에서는 C언어에서 사용되는 세 가지 주요 변수 유형인 지역 변수(Local Variables), 전역 변수(Global Variables), 정적 변수(Static Variables)에 대해 설명한다.

⭐ 1. 지역 변수 (Local Variables)

지역 변수는 함수 내부에서 선언되며, 해당 함수 내에서만 접근할 수 있다. 함수의 호출이 시작될 때 메모리에 할당되고, 함수의 실행이 끝나면 메모리에서 해제된다. 이러한 특성 때문에 지역 변수는 함수의 독립성과 재사용성을 높이는 데 기여한다.

void function() {
    int localVariable = 5; // 지역 변수 선언
    printf("%d\n", localVariable); // 지역 변수 사용
}

⭐ 2. 전역 변수 (Global Variables)

전역 변수는 함수 외부에서 선언되며, 프로그램의 어느 곳에서나 접근할 수 있다. 프로그램의 시작 시 메모리에 할당되고 프로그램이 종료될 때까지 유지된다. 전역 변수는 여러 함수들 사이에서 데이터를 공유할 필요가 있을 때 유용하지만, 과도한 사용은 프로그램의 복잡성을 증가시키고 디버깅을 어렵게 할 수 있다.

int globalVariable = 10; // 전역 변수 선언

void function() {
    printf("%d\n", globalVariable); // 전역 변수 사용
}

⭐ 3. 정적 변수 (Static Variables)

정적 변수는 static 키워드를 사용하여 선언된다. 정적 변수는 지역 정적 변수와 전역 정적 변수의 두 가지 형태로 나뉜다.

1. 지역 정적 변수: 함수 내부에 선언되며, 프로그램 실행이 시작될 때 메모리에 할당되고 프로그램이 종료될 때까지 유지된다. 그러나 해당 변수는 선언된 함수 내에서만 접근할 수 있다. 함수 호출 간에 변수의 값이 유지된다. 실제 프로젝트에서는 사용해본 적 없는 케이스이다.

void function() {
    static int staticLocalVariable = 0; // 지역 정적 변수 선언
    staticLocalVariable++;
    printf("%d\n", staticLocalVariable); // 값은 함수 호출 간 유지됨
}

2. 전역 정적 변수: 함수 외부에 선언되지만 파일 내부에서만 접근할 수 있다. 프로그램의 다른 파일들에서는 접근할 수 없어, 해당 변수를 사용하는 코드의 범위를 제한하는 데 도움이 된다.

static int staticGlobalVariable = 20; // 전역 정적 변수 선언

void function() {
    printf("%d\n", staticGlobalVariable); // 전역 정적 변수 사용
}

⭐ 4. Code

#include <stdio.h>

// 전역 변수 선언
int globalVariable = 10;

// 전역 정적 변수 선언: 이 파일 내에서만 접근 가능
static int staticGlobalVariable = 20;

// 함수 선언
void function(void);
void staticFunction(void);

int main() {
    printf("전역 변수 초기값: %d\n", globalVariable);
    printf("전역 정적 변수 초기값: %d\n\n", staticGlobalVariable);

    function();
    function();
    function();

    staticFunction();
    staticFunction();

    return 0;
}

void function() {
    // 지역 변수 선언
    int localVariable = 5;
    printf("지역 변수: %d\n", localVariable);

    // 지역 정적 변수 선언: 함수 호출 간 값 유지
    static int staticLocalVariable = 0;
    staticLocalVariable++;
    printf("지역 정적 변수: %d\n", staticLocalVariable);

    // 전역 변수와 전역 정적 변수 사용
    globalVariable += 10;
    staticGlobalVariable += 10;
    printf("전역 변수: %d\n", globalVariable);
    printf("전역 정적 변수: %d\n\n", staticGlobalVariable);
}

void staticFunction() {
    // 이 함수는 전역 변수와 전역 정적 변수의 현재 값을 보여준다.
    printf("staticFunction에서 본 전역 변수: %d\n", globalVariable);
    printf("staticFunction에서 본 전역 정적 변수: %d\n\n", staticGlobalVariable);
}

지역 변수, 전역 변수, 정적 변수는 각각 다른 유효 범위와 수명을 가지며, C언어 프로그래밍에서 중요한 역할을 한다. 지역 변수는 함수의 독립성을 지원하고, 전역 변수는 데이터 공유를 용이하게 하며, 정적 변수는 메모리의 효율적 사용과 변수의 접근 범위를 제한하는 데 사용된다. 이러한 변수들을 적절히 사용하는 것은 프로그램의 효율성과 유지보수성을 높이는 데 기여한다.

[C/C++ Tip] 22. C언어 반복문 : While문

18진수 — Sat, 9 Nov 2024 12:51:09 +0900

반복문 : While문

C언어에서 while문은 주어진 조건이 참(true)인 동안 코드 블록을 반복 실행하는 데 사용된다. while문은 조건이 반복의 시작에 평가되므로, 조건이 처음부터 거짓인 경우 코드 블록은 한 번도 실행되지 않을 수 있다.

⭐ 1. While문의 기본 구조

While문의 기본 구조는 다음과 같다.

while (조건) {
    // 조건이 참인 동안 실행할 코드
}

조건: 반복문의 계속 여부를 결정하는 조건이다. 이 조건이 거짓이 되면 반복문이 종료된다.

#include <stdio.h>

int main() {
    int i = 0; // 반복문 제어를 위한 변수 초기화

    while (i < 5) {
        printf("%d\n", i);
        i++; // 변수를 증가시켜 eventually 반복문 종료 조건에 도달하게 함
    }

    return 0;
}

위의 코드는 i가 5보다 작은 동안 i의 값을 출력하고, i를 하나씩 증가시킨다. i가 5에 도달하면 조건이 거짓이 되어 while 반복문이 종료된다.

⭐ 2. Break

break 문은 while 반복문 (또는 다른 반복문) 내부에서 반복을 즉시 종료시키는 데 사용된다. 이는 특정 조건이 충족될 때 반복문을 빠져나오고 싶을 때 유용하게 활용된다. 예를 들어, 사용자로부터 입력을 받아 특정 값이 입력되면 반복을 중단하는 상황에서 break를 사용할 수 있다.
다음은 break 문을 사용하는 간단한 C 코드 예시이다. 이 예제에서는 사용자가 0을 입력할 때까지 숫자를 계속 입력받아 그 합을 출력한다. 사용자가 0을 입력하면, break 문이 실행되어 while 반복문을 즉시 종료한다.

#include <stdio.h>

int main() {
    int sum = 0, number;

    while (1) { // 무한 루프
        printf("숫자를 입력하세요 (종료하려면 0을 입력): ");
        scanf("%d", &number);

        if (number == 0) {
            break; // 사용자가 0을 입력하면 반복문을 빠져나옴
        }

        sum += number; // 사용자가 0이 아닌 수를 입력하면 sum에 더함
    }

    printf("입력한 숫자의 합은: %d\n", sum);
    return 0;
}

⭐ 3. Continue

continue 문은 C언어에서 반복문 (for, while, do-while) 내에서 현재 반복을 즉시 종료하고, 다음 반복으로 넘어가게 하는 데 사용된다. 이는 특정 조건 하에서 반복문의 나머지 부분을 건너뛰고 싶을 때 유용하다. 반복문의 조건 평가로 직접 이동하여 다음 반복이 시작된다.
다음 예제는 0부터 9까지 숫자 중에서 홀수만 출력하는 간단한 while 반복문을 보여준다. 여기서 continue 문은 짝수일 경우 반복문의 나머지 부분을 실행하지 않고 다음 반복으로 넘어가도록 한다.

#include <stdio.h>

int main() {
    int i = 0;

    while (i < 10) {
        i++; // 먼저 증가시키면 홀수 판별 가능
        if (i % 2 == 0) {
            continue; // i가 짝수이면 출력을 건너뛰고 다음 반복으로 넘어감
        }
        printf("%d\n", i); // 홀수인 경우에만 실행됨
    }

    return 0;
}

⭐ 4. 주의사항

#include <stdio.h>

int main() {
    int count = 0;

    // 예시 1: 무한 루프 발생
    while (count >= 0) { // count가 0보다 크거나 같기 때문에 종료되지 않음
        printf("무한 루프 예시: count = %d\n", count);
        // count를 업데이트하지 않아서 무한 루프 발생
    }

    // 예시 2: 조건 업데이트 누락
    int limit = 5;
    while (limit > 0) {
        printf("조건 업데이트 누락 예시: limit = %d\n", limit);
        // limit 값을 업데이트하지 않아서 무한 루프에 빠질 수 있음
    }

    // 예시 3: 복잡한 조건 사용
    int x = 10, y = 20;
    while ((x > 0 && y > 0) || (x % 2 == 0 && y % 3 != 1) || (x - y != 10)) {
        printf("복잡한 조건 예시: x = %d, y = %d\n", x, y);
        x--;  // x는 감소하지만 조건이 너무 복잡하여 가독성이 떨어짐
    }

    // 예시 4: break와 continue의 부적절한 사용
    int i = 0;
    while (i < 10) {
        printf("break와 continue 예시: i = %d\n", i);
        if (i % 2 == 0) {
            continue; // i를 업데이트하기 전에 continue 실행 -> 무한 루프 발생 가능
        }
        if (i > 5) {
            break; // 불필요한 지점에서 break를 사용하여 반복문의 흐름을 혼란스럽게 함
        }
        i++; // i를 적절히 업데이트하지 않아 반복문이 제대로 동작하지 않음
    }

    return 0;
}

이 코드의 문제점은 다음과 같다.

무한 루프 발생: count를 업데이트하지 않거나 조건이 항상 참이 되어 무한 루프가 발생한다.
조건 업데이트 누락: limit 값을 반복문 내부에서 업데이트하지 않아 무한 루프에 빠질 수 있다.
복잡한 조건 사용: 조건식이 너무 복잡해서 코드의 흐름이 이해하기 어려워지고, 유지보수성이 떨어진다.
break와 continue의 부적절한 사용: continue와 break를 잘못 사용하여 변수 업데이트가 누락되거나, 불필요한 지점에서 반복문이 종료될 수 있다.

이와 같은 실수를 피하려면, while문을 사용할 때 조건과 변수 업데이트를 명확하게 작성하는 것이 중요하다.

[C/C++ Tip] 21. C언어 반복문: For문

18진수 — Sat, 9 Nov 2024 12:37:23 +0900

반복문: For문

C언어에서 for문은 반복적인 작업을 처리하는 데 필수적인 도구이다. 강력하고 유연한 이 반복문을 통해 코드의 효율성을 극대화하고, 가독성을 향상시킬 수 있다. 이 포스팅에서는 for문의 기본 사용법, 고급 활용법, 그리고 주의사항을 포함한 종합 가이드를 제공한다.

⭐ 1. For문의 기본 구조

for문의 기본 구조는 다음과 같다.

for (초기화; 조건; 증감) {
    // 반복할 코드 블록
}

초기화: 반복문이 시작할 때 한 번 실행되며, 반복문의 제어 변수를 초기화한다.
조건: 반복문의 계속 여부를 결정하는 조건이다. 이 조건이 거짓이 되면 반복문이 종료된다.
증감: 반복문의 각 반복이 끝날 때마다 실행되어 제어 변수를 증가시키거나 감소시킨다.

⭐ 2. Code

#include <stdio.h>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int sum = 0;
    
    for (int i = 0; i < 5; i++) {
        sum += numbers[i];
    }
    
    printf("Sum: %d\n", sum);
    return 0;
}

이 예제는 배열의 모든 요소를 합하는 간단한 프로그램이다. for문을 사용하여 배열의 각 요소에 접근하고, sum 변수에 누적하여 최종 합을 구한다.

⭐ 3. For문 주의사항

#include <stdio.h>

int main() {
    // 예시 1: 무한 루프 발생
    for (int i = 0; i >= 0; i++) { // i가 항상 0 이상이므로 종료되지 않음
        printf("무한 루프: i = %d\n", i);
    }

    // 예시 2: 복잡한 조건문 사용
    int limit = 10;
    for (int i = 0; i < limit * 2 && (i % 3 != 0 || i % 2 == 0); i++) { 
        // 복잡한 조건식으로 가독성이 떨어짐
        printf("복잡한 조건문: i = %d\n", i);
    }

    // 예시 3: 증감 부분의 잘못된 활용
    for (int i = 0; i < 10; i = i + 2 * 3 - 1) { // 증감 부분이 복잡하여 반복문 흐름이 명확하지 않음
        printf("복잡한 증감 부분: i = %d\n", i);
    }

    return 0;
}

이 코드에서는 다음과 같은 문제점이 있다:

무한 루프 발생: for (int i = 0; i >= 0; i++)처럼 종료 조건을 설정하지 않으면, i가 항상 0 이상이기 때문에 무한히 반복될 수 있다.
복잡한 조건문 사용: 조건문이 지나치게 복잡하여 코드 가독성이 떨어집니다. 이로 인해 반복문이 어떻게 동작하는지 이해하기 어렵다.
증감 부분의 잘못된 활용: 증감 부분이 지나치게 복잡해서 반복문의 흐름이 명확하지 않으며, 예기치 않은 결과를 초래할 수 있다.

이와 같은 실수를 피하려면, for문을 간결하고 명확하게 작성하는 것이 좋다.

⭐ 4. 반복문과 조건문 결합

for문은 다중 반복문과 조건문과 결합하여 더 복잡한 반복 구조를 만들 수 있다. 예를 들어, 2차원 배열을 처리하거나, 특정 조건에 따라 반복문을 조기 종료하는 등의 작업이 가능하다.

for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
        if (someCondition) {
            break; // 내부 반복문 종료
        }
        // 반복 작업 수행
    }
}

이 코드는 2중 for문을 사용한 예제로, 특정 조건이 만족되면 내부 반복문을 종료한다. 이와 같은 방식으로 for문을 활용하면, 복잡한 데이터 구조를 효과적으로 다룰 수 있다. for문은 C언어에서 반복 작업을 수행하기 위한 강력한 도구이다. 그러나 그 효율성과 유용성을 극대화하기 위해서는 주의사항을 잘 지키며 사용해야 한다.

[C/C++ Tip] 20. C언어 조건문 마스터하기 : Switch문

18진수 — Tue, 5 Nov 2024 00:51:39 +0900

Switch문

C언어에서 switch문은 여러 조건 분기를 관리하는 데 있어 매우 유용한 도구이다. 특히, 하나의 변수를 여러 값과 비교해야 할 때 if-else문보다 더 간결하고 명확한 코드를 작성할 수 있게 해준다. 이번 포스팅에서는 switch문의 기본 사용법, 장점, 그리고 주의해야 할 사항에 대해 자세히 알아보겠다.

⭐ 1. Switch문 기본 사용법

switch문은 표현식의 결과값에 따라 다양한 분기(case)로 코드의 실행 경로를 결정한다. 기본 구조는 다음과 같다.

switch (표현식) {
    case 값1:
        // 값1일 때 실행할 코드
        break;
    case 값2:
        // 값2일 때 실행할 코드
        break;
    // 여러 case 추가 가능
    default:
        // 어떤 case도 매칭되지 않을 때 실행할 코드
}

⭐ 2. Switch문 장점

가독성: switch문은 여러 if-else문을 사용하는 것보다 훨씬 가독성이 좋은 코드를 작성할 수 있게 한다.
효율성: 컴파일러는 switch문을 최적화하여, 조건 분기를 더 효율적으로 처리할 수 있다.

⭐ 3. 주의사항

switch문에서 사용할 수 있는 표현식은 정수형 타입이나 열거형(enum)으로 평가될 수 있는 것에 한정된다.
각 case 뒤에는 반드시 break문을 사용하여, 다음 case로의 실행이 이어지지 않도록 해야 한다. break문을 생략하면, 아래의 case로 "fall through"되어 의도하지 않은 결과를 초래할 수 있다.
default는 모든 case와 매칭되지 않을 때 실행되는 선택적인 부분이다. 모든 경우를 다루고 싶다면 default를 사용하는 것이 좋다.

⭐ 4. 코드

#include <stdio.h>

int main() {
    int day = 3;
    switch (day) {
        case 1:
            printf("Monday\n");
            break;
        case 2:
            printf("Tuesday\n");
            break;
        case 3:
            printf("Wednesday\n");
            break;
        case 4:
            printf("Thursday\n");
            break;
        case 5:
            printf("Friday\n");
            break;
        case 6:
            printf("Saturday\n");
            break;
        case 7:
            printf("Sunday\n");
            break;
        default:
            printf("Invalid day\n");
    }
    return 0;
}

⭐ 5. Fall Through

Fall through는 때때로 다음과 같은 상황에서 유용하게 사용됩니다.

여러 case 조건이 같은 동작을 수행해야 할 때 코드 중복을 피하기 위해
한 case에서 추가 작업을 수행한 후 공통 작업을 수행하는 다음 case로 진행해야 할 때

주의사항은 아래와 같다.

<ul"text-align: left;" data-ke-list-type="disc">

Fall through는 코드의 의도를 명확히 하기 위해 주석을 달아 사용 의도를 명시하는 것이 좋다.
복잡한 switch 문에서는 가독성을 저하시키고 오류를 유발할 수 있으므로, 사용 시 주의가 필요하다.

#include <stdio.h>

int main() {
    int userChoice;
    
    printf("메뉴를 선택하세요:\n");
    printf("1 - 기본 정보 보기\n");
    printf("2 - 상세 정보 보기\n");
    printf("3 - 추가 정보 보기\n");
    printf("4 - 프로그램 종료\n");
    scanf("%d", &userChoice);
    
    switch (userChoice) {
        case 1:
            printf("기본 정보를 출력합니다.\n");
            // 여기에 기본 정보 출력 로직을 추가합니다.
            // break가 없으므로 case 2로 fall through합니다.
        case 2:
            printf("상세 정보를 출력합니다.\n");
            // 여기에 상세 정보 출력 로직을 추가합니다.
            // case 1을 선택한 경우 기본 정보와 상세 정보 모두 출력됩니다.
            // break가 없으므로 case 3로 fall through합니다.
        case 3:
            printf("추가 정보를 출력합니다.\n");
            // 여기에 추가 정보 출력 로직을 추가합니다.
            // case 1 또는 2를 선택한 경우, 상응하는 정보와 함께 추가 정보도 출력됩니다.
            break;
        case 4:
            printf("프로그램을 종료합니다.\n");
            break;
        default:
            printf("잘못된 선택입니다. 다시 시도해주세요.\n");
    }
    
    return 0;
}

switch문은 특정 변수가 다양한 값을 가질 수 있을 때, 각각의 경우에 대해 별도의 로직을 실행하고 싶을 때 매우 유용하다. 특히, 가능한 값이 많고, 그 중 하나를 선택해야 할 때 if-else문보다 훨씬 깔끔한 코드를 작성할 수 있다. 그러나, 사용 시에는 break문을 적절히 사용하는 것과 정수형 또는 열거형으로 평가될 수 있는 표현식만을 사용하는 것을 기억해야 한다.

[C/C++ Tip] 19. C언어 조건문 마스터하기 : 삼항연산자

18진수 — Tue, 5 Nov 2024 00:14:38 +0900

삼항연산자

C언어에서 삼항 연산자는 조건문을 더 간결하게 표현할 수 있는 유용한 도구이다. 기본 구조는 조건 ? 참일 때의 값 : 거짓일 때의 값으로, 조건이 참이면 첫 번째 값을, 거짓이면 두 번째 값을 반환한다. 이 포스팅에서는 삼항 연산자의 사용법과 if문과 비교했을 때의 장단점을 살펴본다.

⭐1. 삼항 연산자 사용법

삼항 연산자는 주로 간단한 조건에 따른 값을 선택할 때 사용된다. 예를 들어, 두 수 중 큰 수를 찾거나, 조건에 따라 변수에 다른 값을 할당하는 경우 등에 사용할 수 있다

int max = (a > b) ? a : b; // a와 b 중 더 큰 값을 max에 할당

⭐2. 삼항 연산자 장점

간결성: 삼항 연산자는 if-else문에 비해 더 간결한 코드를 작성할 수 있다.
표현력: 한 줄로 조건에 따른 값을 표현할 수 있어, 코드의 의도를 명확하게 전달할 수 있다.

⭐3. 고려사항

삼항 연산자는 간단한 조건 판단에 유용하지만, 복잡한 로직이나 여러 조건을 평가해야 하는 경우에는 if-else문을 사용하는 것이 더 적합하다.
가독성이 중요한 상황에서는 삼항 연산자의 과도한 사용이 코드를 이해하기 어렵게 만들 수 있다. 따라서, 사용 시에는 가독성을 유지하는 것이 중요하다.

⭐4. 코드

간단한 조건부 값 할당

int age = 20;
const char* status = (age >= 18) ? "adult" : "minor";

조건에 따른 함수 호출(비추천)

printf("%s", (isTrue) ? 1 : 0);

중첩 사용 시 주의(비추천)

int value = 10;
const char* result = (value > 0) ? "positive" : (value == 0) ? "zero" : "negative";

삼항 연산자는 C언어에서 간결한 조건문을 작성할 때 유용하다. 하지만, 간단한 조건에 한정되어야 하며, 복잡한 로직에서는 if-else문의 사용을 해야한다.

[C/C++ Tip] 18. C언어 조건문 마스터하기 : if문의 모든 것!

18진수 — Tue, 5 Nov 2024 00:05:20 +0900

조건문 IF문

조건문은 프로그래밍에서 데이터에 따른 의사 결정을 가능하게 하는 핵심적인 요소이다. C언어에서는 if문, 삼항 연산자, switch문 등 다양한 조건문을 제공한다. 이 중 if문은 가장 기본적이면서도 언어 상관 여부 없이 가장 중요한 문법이다. 오늘은 if문의 구조, 사용 방법, 그리고 실제 예제를 통해 if문의 모든 것을 살펴본다.

⭐1. if문의 중요성

조건문은 프로그램의 흐름을 제어하는데 있어 필수적인 요소이다. if문은 주어진 조건이 참인 경우에만 특정 코드 블록을 실행하게 한다. 이는 데이터에 따른 다른 동작을 해야 할 때, 예를 들어 사용자 입력 검증이나 오류 처리 등에서 매우 유용하게 사용된다. (C언어는 try catch 문이 없음.)

⭐2. if문의 구조

if문은 다음과 같은 기본 구조를 가진다:

if (조건) {
    // 조건이 참일 때 실행될 코드
}

조건은 참(true) 또는 거짓(false)을 평가할 수 있는 표현식이어야 한다. C언어에서는 0이 아닌 모든 값이 참으로, 0은 거짓으로 평가된다.

C89(또는 ANSI C)와 C90 표준에서는 bool 타입이 공식적으로 정의되어 있지 않다. 이 표준들에서 논리적 값은 일반적으로 int 타입을 사용하여 표현되며, 0은 거짓(false)을 나타내고, 0이 아닌 모든 값은 참(true)으로 간주한다.

⭐3. if문의 권장 사항

위 If문의 구조는 참에 대한 if만 있으며, 거짓에 대한 else는 없다. 거짓에 대한 동작이 없을 때 else에 대한 실행 코드가 없을 경우, 보통 작성하지 않기 마련이다. 하지만 아래 예시 코드처럼 실행 코드가 없다하더라도 /* Intended Design */ 라고 주석이라도 남기는 것을 추천한다. 현업에서 코드 분석을 진행할 때 else가 없는 조건문에 대해 설계 의도라고 명확하게 해주어야 한다.

if (조건) {
    // 조건이 참일 때 실행될 코드
}else{
    /* Intended Design */
}

⭐4. else if

if문은 더 복잡한 조건 판단을 위해 else if와 else와 함께 사용될 수 있다.

if (조건1) {
    // 조건1이 참일 때 실행될 코드
} else if (조건2) {
    // 조건1이 거짓이고 조건2가 참일 때 실행될 코드
} else {
    // 모든 조건이 거짓일 때 실행될 코드
}

이 구조는 여러 조건을 순차적으로 평가하고, 해당하는 조건의 코드 블록을 실행한다.

⭐5. 예제

#include <stdio.h>

int main() {
    int userInput;

    printf("Enter your input (1-3): ");
    scanf("%d", &userInput);

    if (userChoice == 1) {
        printf("You chose Option 1.\n");
    } else if (userChoice == 2) {
        printf("You chose Option 2.\n");
    } else if (userChoice == 3) {
        printf("You chose Option 3.\n");
    } else {
        printf("Invalid input.\n");
    }

    return 0;
}

이 예제는 사용자로부터 입력 받은 숫자에 따라 다른 메시지를 출력한다. 1, 2, 3 이외의 숫자가 입력되면 Invalid Input을 출력한다.

if문은 프로그래밍에서 가장 기본적이면서도 강력한 조건 판단 도구이다. 그것은 단순한 조건부터 복잡한 조건 판단까지, 프로그램의 로직을 정교하게 제어할 수 있게 한다. 사용 방법은 간단하지만 제대로 사용하지 못하면 스파게티 코드가 될 수 있는 무서운 문법 중 하나이다. 그러므로 설계를 진행할 때, 자신이 설계하고자 하는 사양에 대해 정확히 파악하고 조건문을 추가할 것을 권장한다.

[C/C++ Tip] 17. Static 변수와 Extern 변수의 차이점

18진수 — Sat, 2 Nov 2024 11:28:05 +0900

extern (고급)

Static 변수와 Extern 변수는 C언어에서 변수의 스코프(visibility)와 생명 주기(lifetime)를 관리하는 데 사용되는 키워드이다. 이 둘의 주요 차이점은 다음과 같다:

Static 변수:

스코프: Static 변수는 선언된 범위(함수 내부 또는 파일 내부)에 제한된다.
생명 주기: 프로그램 실행 시작 시 할당되고 프로그램 종료 시 해제된다.
목적: 같은 파일 내에서만 접근 가능한 변수를 만들거나, 함수 호출 간 상태를 유지할 수 있는 지역 변수를 선언하는 데 사용된다.

Extern 변수:

스코프: Extern 키워드는 다른 파일에 정의된 전역 변수나 함수를 참조하는 데 사용된다.
생명 주기: 해당 변수가 정의된 파일 내에서 프로그램 실행 시작 시 할당되고 프로그램 종료 시 해제된다.
목적: 프로그램의 다른 파일들 간에 공유되는 전역 변수에 접근하거나, 다른 파일에 정의된 함수를 호출하는 데 사용된다.

⭐1. Static 변수

static_example.c

#include <stdio.h>

void incrementCounter() {
    static int counter = 0; // static 지역 변수
    counter++;
    printf("Counter: %d\n", counter);
}

int main() {
    incrementCounter(); // 출력: Counter: 1
    incrementCounter(); // 출력: Counter: 2
    return 0;
}

이 예시에서 counter 변수는 incrementCounter 함수 내에 static으로 선언되어 있다. 따라서 함수가 호출될 때마다 counter의 값은 유지되며, 함수의 실행이 끝나도 counter의 값은 사라지지 않는다.

⭐2. Extern 변수

shared_var.c

int sharedVar = 10; // 다른 파일에서 접근할 전역 변수

main.c

#include <stdio.h>

extern int sharedVar; // 다른 파일에 정의된 전역 변수를 참조

int main() {
    printf("Shared Variable: %d\n", sharedVar); // 출력: Shared Variable: 10
    return 0;
}

이 예시에서 counter 변수는 incrementCounter 함수 내에 static으로 선언되어 있다. 따라서 함수가 호출될 때마다 counter의 값은 유지되며, 함수의 실행이 끝나도 counter의 값은 사라지지 않는다.

sharedVar 변수는 shared_var.c 파일에 전역 변수로 정의되어 있으며, main.c에서는 extern 키워드를 사용하여 이 변수를 참조한다. 이를 통해 main.c 파일 내에서 sharedVar 변수의 값을 접근하고 사용할 수 있다.

Static 변수와 Extern 변수는 서로 다른 목적과 사용 사례를 가지고 있다. Static 변수는 주로 함수 내부에서 상태를 유지하거나, 파일 내부에서만 접근할 수 있는 변수를 만들고자 할 때 사용된다. 반면, Extern 변수는 프로그램의 여러 파일 간에 공유되어야 하는 전역 변수에 대한 접근을 제공하기 위해 사용된다.

[C/C++ Tip] 16. Extern 중복 문제 해결 (Include Guard)

18진수 — Sat, 2 Nov 2024 11:18:16 +0900

C언어 extern (중급)

C언어에서 헤더 파일의 중복 포함은 다양한 문제를 일으킬 수 있다. 예를 들어, 프로젝트 단위가 커져 같은 헤더 파일이 여러 번 포함되면 변수나 함수 선언이 중복되어 컴파일 오류가 발생할 수 있다. 이를 방지하기 위해 "Include Guard"라는 기법이 널리 사용된다. Include Guard는 전처리기(preprocessor) 지시문을 사용하여 헤더 파일이 한 번만 포함되도록 보장한다. 가장 일반적인 방법은 #ifndef, #define, #endif 지시문을 사용하는 것이다.

중복 포함 방지: 헤더 파일이 여러 번 포함되는 것을 방지하여, 중복 선언으로 인한 컴파일 오류를 예방한다.
프로그램 구조 개선: 코드의 모듈화와 재사용성을 높이며, 프로그램의 구조를 명확하게 한다.
컴파일 시간 단축: 불필요한 헤더 파일의 재처리를 방지함으로써, 전체 컴파일 시간을 단축할 수 있다.

⭐코드

다음은 Include Guard를 사용한 헤더 파일의 예시이다.

myheader.h

#ifndef MYHEADER_H // MYHEADER_H가 정의되지 않았다면
#define MYHEADER_H // MYHEADER_H를 정의

// 여기에 함수 선언, 타입 정의, 매크로 정의 등을 포함
extern int sharedVariable;

void myFunction();

#endif // MYHEADER_H의 끝

main.c

#include "myheader.h" // 첫 번째 포함
#include "myheader.h" // 두 번째 포함 - Include Guard에 의해 실제로는 무시됨

int main() {
    sharedVariable = 5;
    myFunction();
    return 0;
}

이 예시에서 myheader.h 헤더 파일은 Include Guard에 의해 한 번만 포함된다. 만약 main.c 또는 다른 파일에서 myheader.h를 여러 번 포함하더라도, MYHEADER_H 매크로가 이미 정의되어 있기 때문에 헤더 파일의 내용이 중복으로 처리되지 않는다.

헤더 파일 이름을 기반으로 한 고유한 매크로 사용: Include Guard를 위한 매크로 이름으로 파일 이름을 기반으로 한 고유한 이름을 사용하면 이름 충돌을 방지할 수 있다.
프로젝트 전체에서 일관된 규칙 적용: 모든 헤더 파일에 대해 일관된 Include Guard 규칙을 적용하여 코드의 일관성을 유지해야 한다.
모던 C++에서는 #pragma once 고려: C++에서는 #pragma once 지시문을 사용하는 것도 하나의 옵션이다. 이 지시문은 헤더 파일이 한 번만 포함되도록 하는 간단하고 효율적인 방법을 제공하지만, C에서는 표준이 아니며, 모든 컴파일러에서 지원되는 것은 아니다.

Include Guard는 C 프로그래밍에서 코드를 안정적으로 관리하는 데 필수적인 기법이다. 이를 통해 프로그램의 안정성을 높이고 컴파일 오류를 방지할 수 있다.

[C/C++ Tip] 15. extern 기본

18진수 — Sat, 2 Nov 2024 11:04:25 +0900

Extern (초급)

C언어에서 extern 키워드는 다른 파일에 정의된 전역 변수나 함수를 참조할 수 있도록 해준다. 이는 프로그램의 여러 파일 간에 변수나 함수를 공유할 때 매우 유용하다. extern의 사용은 큰 프로젝트에서 소스 코드를 모듈화하고 관리하기 쉽게 만들어 준다.

⭐1. extern 사용 예제

다음 예제에서는 두 개의 파일을 사용하여 extern의 기본적인 사용 방법을 보여준다.

main.c

#include <stdio.h>

// 다른 파일에서 정의된 변수를 참조하기 위해 extern 사용
extern int sharedVar;

int main() {
    printf("Shared Variable: %d\n", sharedVar);
    return 0;
}

shared.c

// sharedVar는 이 파일에서 정의되며, 다른 파일에서 extern을 사용해 접근할 수 있다.
int sharedVar = 10;

이 예제에서 sharedVar는 shared.c 파일에서 정의되고 초기화되며, main.c 파일에서 extern 키워드를 사용하여 접근된다. 이를 통해, 프로그램의 다른 부분에서도 sharedVar를 사용할 수 있게 된다.

⭐2. extern 장점

모듈화: extern을 사용하면 코드를 여러 파일로 분리하여 각각 관리할 수 있다. 이는 프로그램의 모듈화를 촉진하며, 유지보수성과 가독성을 향상시킨다.
재사용성: 공통으로 사용되는 변수나 함수를 별도의 파일에 정의하고 extern으로 참조함으로써 코드의 재사용성을 높일 수 있다.
연결: extern은 프로그램의 다른 부분에서 정의된 심볼(변수나 함수)에 대한 연결을 생성한다. 컴파일러와 링커가 이러한 심볼들을 올바르게 연결해주므로, 프로그램의 전체 구조를 이해하는 데 도움이 된다.

extern 키워드의 올바른 사용은 크고 복잡한 C 프로그램을 효과적으로 관리하는 데 중요한 역할을 한다.

[C/C++ Tip] 14. 동적 메모리 할당

18진수 — Tue, 29 Oct 2024 19:06:08 +0900

동적 메모리 할당

C언어에서 동적 배열은 프로그램 실행 중에 배열의 크기를 결정하고 메모리를 할당할 수 있게 해주는 매우 유용한 기능이다. 동적 배열은 malloc, calloc, 또는 realloc 함수를 사용하여 힙(Heap) 영역에 메모리를 할당함으로써 생성된다. 이러한 방식은 정적 배열과 달리, 실행 시간에 배열의 크기를 유연하게 조절할 수 있게 해준다.

⭐1. 필요성

유연성: 프로그램 실행 중에 배열의 크기를 결정할 수 있으므로, 사용자 입력이나 다른 실행 시간 데이터에 기반한 메모리 할당이 가능하다.
메모리 효율성: 필요한 만큼의 메모리만 할당하여 사용하므로, 메모리 낭비를 줄일 수 있다.

⭐2. 메모리적인 관리의 장점 및 단점

2.1. 장점

메모리 최적화: 정적 배열과 달리, 필요한 만큼의 메모리만 사용하기 때문에 전체 프로그램의 메모리 효율성이 향상된다.
확장성: 필요에 따라 realloc 함수를 사용하여 배열의 크기를 증가시킬 수 있다.

2.2. 단점

메모리 관리 부담: 동적 할당된 메모리는 개발자가 직접 해제해주어야 합니다(free 함수 사용). 이를 소홀히 하면 메모리 누수가 발생할 수 있다.
Fragmentation 문제: 잦은 할당과 해제는 메모리 단편화를 초래할 수 있으며, 이는 프로그램의 성능 저하로 이어질 수 있다.

⭐3. 메모리의 구분

스택(Stack): 함수 호출 시 생성되는 지역 변수가 저장되는 영역입니다. 함수가 종료되면 자동으로 메모리가 해제된다.
힙(Heap): 동적 메모리 할당에 사용되는 영역입니다. 프로그래머가 직접 할당하고 해제해야 한다.

메모리 영역

⭐4. Code

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    int n;

    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // 동적 배열 생성
    arr = (int*)malloc(n * sizeof(int));

    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // 배열 사용
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }

    // 배열에 저장된 값 출력
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 메모리 해제
    free(arr);

    return 0;
}

이 코드는 유저로부터 입력 받은 숫자 만큼의 배열 크기를 동적으로 할당하고, 각 요소에 값을 할당한 후 출력하고 마지막으로 할당된 메모리를 해제한다. 동적 배열을 사용함으로써, 프로그램의 유연성과 메모리 사용의 효율성을 높일 수 있다. 그러나 동적 메모리 관리를 잘못하면 메모리 누수와 같은 문제가 발생할 수 있으므로 주의가 필요하다.

동적할당을 크게 요구하는 프로젝트에 참가한 적이 없지만, 메모리 구조 공부를 위해 알 필요는 있다.

[C/C++ Tip] 13. MCU 제어를 위한 비트 연산

18진수 — Tue, 29 Oct 2024 18:46:28 +0900

MCU 제어를 위한 비트 연산

펌웨어는 하드웨어를 제어하는 소프트웨어로, 보통 임베디드 시스템, 마이크로컨트롤러, 다양한 전자 장비 등에서 작동한다.

펌웨어 개발에서 하드웨어의 세밀한 제어가 필요할 때, 비트 연산은 그 대표적인 방법중 하나이다. C언어의 비트 연산자를 사용하면 레지스터 설정과 같은 저수준 작업을 효율적으로 처리할 수 있다. 이러한 연산자에는 AND(&), OR(|), XOR(^), NOT(~), 비트 시프트(<<, >>) 등이 있다. 각 연산자의 사용 예를 통해, 어떻게 이들을 활용하여 펌웨어 코드를 작성하는지 살펴본다.

⭐1. 비트 연산의 장점

직접적인 하드웨어 제어: 비트 단위로 하드웨어 레지스터를 직접 조작할 수 있다.
메모리 및 처리 속도 효율성: 불필요한 메모리 접근을 줄이고, CPU의 비트 연산 처리 속도를 활용할 수 있다.
코드 최적화: 컴파일러가 최적화하기 쉬워져, 실행 효율이 향상된다.

⭐2. 비트 연산자 예제

2.1. AND 연산 (&)

특정 비트를 0으로 설정하거나 상태를 확인할 때 사용한다. (특정 기능을 비활성화시킬 때 주로 사용됨.)

unsigned char reg = 0b11110000; // 초기 레지스터 값
unsigned char mask = 0b11111100; // 마스크: 하위 2비트를 제외한 모든 비트를 유지
reg = reg & mask; // 하위 2비트를 0으로 설정

2.2. OR 연산 (|)

특정 비트를 1로 설정할 때 사용한다. (특정 기능을 활성화시킬 때 주로 사용됨.)

unsigned char reg = 0b11001100; // 초기 레지스터 값
unsigned char mask = 0b00000011; // 마스크: 하위 2비트를 1로 설정
reg = reg | mask; // 하위 2비트를 1로 설정

2.3. XOR 연산 (^)

특정 비트를 토글(반전)할 때 사용한다.

unsigned char reg = 0b11001100; // 초기 레지스터 값
unsigned char mask = 0b00000011; // 마스크: 하위 2비트를 토글
reg = reg ^ mask; // 하위 2비트를 반전

2.4. NOT 연산 (~)

모든 비트를 반전시킬 때 사용한다.

unsigned char reg = 0b11001100; // 초기 레지스터 값
reg = ~reg; // 모든 비트 반전

2.5. 비트 시프트 연산 (<<, >>)

비트를 좌측 혹은 우측으로 이동시킨다.

unsigned char reg = 0b00000001; // 초기 레지스터 값
reg = reg << 4; // 4비트 왼쪽으로 시프트, 결과: 0b00010000

비트 연산자의 소개는 종종 C언어 교재의 초반부에서 이루어지지만, 실질적으로 펌웨어 개발 외의 분야에서 그 활용도는 상대적으로 낮은 편이다. 컴퓨터 공학 교육 과정에서 아두이노와 같은 플랫폼을 통해 하드웨어 개발의 기초를 다지는 과정에서도, 비트 연산의 사용은 드물게 나타난다. 아두이노가 교육용으로 AVR을 기반으로 개발되었음에도 불구하고, 이는 대부분의 작업에서 레지스터 직접 제어를 요구하지 않기 때문이다. AVR이나 ARM 같은 보다 전문화된 하드웨어 개발에서야 비로소 레지스터를 직접 조작할 필요성이 생긴다. 그럼에도 불구하고, 비트 연산은 컴퓨터 공학의 기본 원리 중 하나로서, 그 이해는 필수적이다.

⭐3. 예시

하기 AVR 타이머 예제와 같이 비트 연산자가 사용된다 .

#include <mega128.h>
unsigned int cnt=0;

void main()
{

   TIMSK = 0b00000001;    // TOIE0 = 1; 타이머/카운터0 OVF 모드 인터럽트 인에이블
    TCCR0 = 0b00000111;    // 일반모드, 프리스케일 = CK/1024
    TCNT0 = 0b00000000;    // 타이머/카운터0 레지스터 초기값 == 0;
 
    SREG = 0b10000000;    // 전역 인터럽트 인에이블 비트 I 셋
}

// 1/16us x 1024 x 256 = 16.384ms
interrupt [TIM0_OVF] void timer_int0(void)		//타이머/카운터0 인터럽트 문
{                    
    cnt++;
    if(cnt == 31) {  					// 16.384ms x 31 = 0.5sec
        led = led ^ 0xFF;          			// led 토글 (xor연산)
        PORTA = led;              			// PORTA에 넣어줘야 LED켜짐
        cnt = 0;					// cnt 0으로 초기화
    }
}

위 코드는 깃허브에서 아무거나 가져온 코드이다. 하지만 .잘 짜여진 코드는 아니다. main 함수를 아래와 같이 시프트 연산자를 이용해 변경할 수 있다.

void main()
{
    // TOIE0 = 1; 타이머/카운터0 OVF 모드 인터럽트 인에이블
    TIMSK = 1 << TOIE0; // TOIE0의 정의가 0이라고 가정할 때

    // 일반모드, 프리스케일 = CK/1024
    // CS02, CS01, CS00 비트를 설정하여 프리스케일 값을 설정
    TCCR0 = (1 << CS02) | (1 << CS00); // CS02가 2, CS00이 0으로 정의된 것으로 가정

    // 타이머/카운터0 레지스터 초기값 == 0;
    TCNT0 = 0; // 시프트 연산자 필요 없음

    // 전역 인터럽트 인에이블 비트 I 셋
    SREG = 1 << 7; // I 비트가 7번째 위치한다고 가정
}

아래 코드는 시프트 연산자가 아닌 AND, OR 연산자를 이용해 표현했다.

void main()
{
    // TOIE0 = 1; 타이머/카운터0 OVF 모드 인터럽트 인에이블
    // OR 연산자(|)를 사용하여 특정 비트만을 1로 설정
    TIMSK |= 1 << TOIE0; // TOIE0의 정의가 0이라고 가정할 때

    // TCCR0 레지스터 설정을 위해 먼저 모든 관련 비트를 0으로 클리어하고 필요한 비트를 1로 설정
    // AND 연산자(&)와 NOT 연산자(~)를 사용하여 특정 비트 클리어
    // 이 예제에서는 프리스케일 관련 비트만 조작하기 때문에 별도의 AND 연산으로 클리어하는 과정은 생략
    // OR 연산자(|)를 사용하여 프리스케일 값을 설정하는 비트를 1로 설정
    TCCR0 |= (1 << CS02) | (1 << CS00); // CS02가 2, CS00이 0으로 정의된 것으로 가정

    // TCNT0 레지스터 초기값 == 0; 비트 연산 필요 없음
    TCNT0 = 0;

    // 전역 인터럽트 인에이블 비트 I 셋
    // OR 연산자(|)를 사용하여 특정 비트만을 1로 설정
    SREG |= 1 << 7; // I 비트가 7번째 위치한다고 가정
}

본 예제를 통해 보았듯이, 시프트 연산자와 함께 AND 및 OR 연산자를 사용하는 방법은 레지스터에 특정 비트 값을 설정하거나 클리어하는 데 매우 효과적이다. 비록 컴퓨터 공학 교육 과정이나 아두이노와 같은 교육용 하드웨어 개발에서 비트 연산의 사용 빈도가 높지 않을 수 있지만, AVR, ARM과 같은 전문화된 하드웨어 개발과 컴퓨터 구조의 이해를 위해선 이러한 비트 연산이 중요한 역할을 한다.

[C/C++ Tip] 12. 포인터가 헷갈릴 수 밖에 없는 이유: 별(*)의 종류와 정체

18진수 — Sat, 21 Sep 2024 12:09:00 +0900

C언어 포인터의 이해 2편

C언어를 배우면서 가장 많이 혼란을 겪는 주제 중 하나가 바로 포인터이다. 특히 * 기호의 다양한 역할이 이 혼란의 주범이다. 이 포스팅에서는 * 기호가 가지는 세 가지 역할을 친절하게 설명함으로써 포인터에 대한 당신의 이해를 한 단계 업그레이드시킬 것이다.

⭐1. 포인터 변수 선언: *의 첫 번째 정체

포인터를 선언할 때 *를 사용하는 이유는, 단순히 "이 변수는 메모리 주소를 저장한다"는 사실을 나타내기 위함이다. int* ptr;라고 선언하면, "ptr은 정수의 주소를 저장하는 변수"라는 의미가 된다. 여기서 *는 포인터 변수의 타입 부분에 포함되어, 이 변수가 "주소"를 저장하는 특별한 종류의 변수임을 알려주는 역할을 한다.

⭐2. 역참조 연산자: *의 두 번째 정체

변수 앞에 *가 사용되면, 그것은 "역참조 연산자"가 됩니다. 역참조 연산자는 포인터가 가리키는 메모리 위치에 저장된 값을 접근하게 해준다. 예를 들어, *ptr = 10;은 ptr이 가리키는 메모리 위치에 10을 저장한다. 만약 ptr이 int var의 주소를 가지고 있다면, 이 연산은 사실상 var = 10;과 같은 효과를 가진다. 여기서 *는 "ptr이 가리키는 위치에..."라는 의미로 변신한다.

⭐3. 곱셈 : *의 세 번째 정체

이제 수학 시간으로 돌아간다. C언어에서 *는 두 수를 곱하는 곱셈 연산자로도 사용된다. 이 경우, *는 포인터와 전혀 관련이 없으며, 단순히 두 값을 곱하려는 용도로 사용된다. 예를 들어, int result = 4 * 5;는 result 변수에 20을 저장한다. 이 때 *는 "곱하기"의 기호로 사용되며, 우리가 평소에 수학에서 보던 그 곱셈과 같다.

⭐4. (*)의 이해

이 세 가지 역할을 명확히 이해하는 것은 C언어에서 포인터를 다루는 데 있어 필수적이다. 특히, * 기호의 역할이 문맥에 따라 달라지므로, 코드를 읽을 때는 주변 코드와 함께 *의 사용 방식을 정확히 파악해야 한다.

포인터 변수를 선언할 때는 *가 타입의 일부로서 "이 변수는 주소를 저장하는 포인터"임을 나타낸다.
변수 앞에서 *를 사용할 때는, 그것이 역참조 연산자로 작동하여 포인터가 가리키는 메모리의 값을 읽거나 쓰는 역할을 한다.
수학적 연산에서는, *는 단순한 곱셈 연산자이다.

포인터를 다루면서 헷갈리지 않기 위한 꿀팁을 하나 공유하자면, 포인터 선언과 역참조 시 *의 위치에 주의하는 것이다. 이를 명확히 구분하는 것은 코드를 더 읽기 쉽게 만들고, 의도하지 않은 오류를 방지하는 데 큰 도움이 된다.

**4.1. 포인터 선언: 변수형 앞에 * 붙이기**

포인터 변수를 선언할 때는, 변수 타입 앞에 *를 붙여 해당 변수가 포인터임을 나타낸다. 이 방식은 선언하는 변수가 일반 변수가 아닌 메모리 주소를 저장하는 포인터임을 명확히 한다. 예를 들어, int형 값을 가리키는 포인터를 선언하고 싶다면, int* ptr;와 같이 작성한다. 여기서 int*는 "정수형 주소를 가리키는 포인터"라는 의미를 가지며, ptr은 그러한 포인터 변수의 이름이다.

**4.2. 역참조: 변수명 앞에 * 붙이기**

포인터를 통해 가리키는 변수의 값을 접근하거나 수정할 때는 변수명 앞에 *를 붙여 역참조한다. 이는 포인터가 가리키는 메모리 위치에 저장된 실제 값을 의미한다. 예를 들어, *ptr = 5;라고 하면, ptr이 가리키는 메모리 위치에 5를 저장하는 것이다. 역참조를 통해 포인터로 가리키는 변수의 값을 읽거나 변경할 수 있다.

#include <stdio.h>

int main() {
    // 1. 포인터 변수 선언: *가 포인터 타입을 나타냄
    int value = 10;
    int* ptr = &value; // ptr은 value의 주소를 가리킴

    // 2. 역참조 연산자: *를 사용해 포인터가 가리키는 값을 접근 및 수정
    printf("Before: %d\n", *ptr); // ptr이 가리키는 메모리(즉, value)의 값을 출력
    *ptr = 20; // ptr을 통해 value의 값을 변경
    printf("After: %d\n", value); // 변경된 value의 값을 출력

    // 3. 곱셈 연산자: *를 사용한 수학적 곱셈
    int a = 5;
    int b = 4;
    int result = a * b; // a와 b의 곱셈
    printf("Multiplication: %d\n", result);

    return 0;
}

이렇게 다양한 역할을 하는 *를 올바르게 이해하고 사용하면, 포인터의 개념도 훨씬 명확해질 것이다. 초기 혼란을 극복하고 *의 이러한 다양한 사용법에 익숙해지면, 포인터는 C언어 프로그래밍의 강력한 도구로서 여러분의 코드를 더욱 효율적이고 강력하게 만들어 줄 것이다.

[C/C++ Tip] 11. C언어 포인터 기본 사용법

18진수 — Thu, 19 Sep 2024 20:11:18 +0900

C언어 포인터의 이해 1편

포인터는 C언어를 배우는 사람에게는 종종 어려움을 주는 주제 중 하나이다. 복잡해 보이지만 한 번 이해하면 강력한 도구가 될 수 있다. 이 포스팅에서는 포인터의 기본 개념을 쉽게 풀어 설명하고, 몇 가지 팁과 함께 실제 코드 예시를 통해 그 사용법을 알아보겠다.

⭐1. 포인터란 무엇인가?

포인터는 간단히 말해, 메모리 주소를 저장하는 변수이다. 즉, 포인터를 통해 다른 변수의 위치를 알고, 그 위치에 접근하여 값을 읽거나 변경할 수 있다. C언어에서 포인터는 데이터의 동적 관리와 복잡한 데이터 구조의 구현에 필수적인 요소이다.

⭐2. 포인터의 선언

포인터를 선언하는 방법은 다음과 같다.

타입 *포인터변수명;

예를 들어, int형 데이터를 가리키는 포인터를 선언하고 싶다면 다음과 같다.

int *ptr;

이 코드는 ptr이라는 이름의 포인터 변수를 선언한 것으로, int형 변수의 주소를 저장할 수 있음을 의미한다.

하지만 이와 같이 변수에 *을 붙이는 것은 포인터의 이해에 혼란을 가중시킨다.
실제로, 포인터도 변수이며, *는 그 변수가 포인터임을 나타내는 표시이다. 주소를 저장하는 변수이므로 아래와 같이 사용하는 것을 추천한다.

int* ptr;

⭐3. 포인터의 기본 사용

포인터를 사용하기 위해선 먼저 포인터에 주소를 할당해야 한다. 이는 & 연산자를 사용해 변수의 주소를 얻어, 포인터에 할당하는 방식으로 이루어진다.

int var = 10;
int* ptr = &var;

이제 ptr은 var의 메모리 주소를 가리키게 된다. var의 값을 포인터를 통해 접근하려면, 역참조 연산자 *를 사용한다.

printf("%d", *ptr);  // 10 출력

아래 사진과 같이 이해하면 편한 것 같다.

포인터

사용자가 어디를 가리킬지 결정하는 행위 = 포인터를 선언(참조)
사용자가 가리키는 곳을 실제 레이저를 쏴서 가리키는 행위 = 해당 주소에 저장된 변수에 값을 가져오는 것(역참조)

[C/C++ Tip] 10. Call by Value vs Call by Reference

18진수 — Sat, 14 Sep 2024 12:12:19 +0900

Call by Value Vs Call by Reference

프로그래밍, 특히 C언어에서 'Call by Value'와 'Call by Reference'의 개념은 기본적이면서도 핵심적인 부분이다. 이 두 호출 방식의 차이점을 이해하는 것은 다음과 같은 이유로 중요하다.

1. 코드의 안정성 보장
'Call by Value'는 함수에 변수의 복사본을 전달함으로써 원본 데이터를 안전하게 보호한다. 이는 원하지 않는 데이터 변경으로부터 값들을 보호하는 데 필수적이다. 반면, 'Call by Reference'는 원본 데이터에 직접 영향을 줄 수 있기 때문에, 데이터를 의도적으로 변경하고자 할 때 유용하다. 이 두 방식을 적절히 사용함으로써 프로그램의 안정성과 예측 가능성을 높일 수 있다.

2. 메모리와 성능 최적화
특히 대용량 데이터를 다루는 프로그램에서 'Call by Value' 방식은 복사본을 만들기 때문에 메모리 사용량이 증가하고, 성능에 부정적인 영향을 줄 수 있다. 반면, 'Call by Reference'는 데이터의 복사본을 생성하지 않고 직접 참조하여 작업하기 때문에 메모리 사용량을 줄이고 프로그램의 성능을 향상시킬 수 있다.

3. 유지보수의 용이성
함수가 데이터를 어떻게 다루는지 명확히 이해하면, 코드의 가독성이 향상되고 유지보수가 쉬워진다. 특히, 여러 개발자가 작업하는 대규모 프로젝트에서는 이러한 이해가 프로젝트의 성공에 결정적인 역할을 할 수 있다.

Call by Value vs Call by Reference

⭐1. Call by Value (값에 의한 호출)

Call by Value는 함수에 인자를 전달할 때 인자의 실제 값을 복사하여 함수의 매개변수로 전달하는 방식이다. 이 경우, 함수 내부에서 매개변수의 값을 변경해도 원래 변수의 값에는 영향을 주지 않는다.

#include <stdio.h>

void addTen(int a) {
    a += 10;
    printf("Inside addTen: %d\n", a);
}

int main() {
    int num = 5;
    addTen(num);
    printf("In main: %d\n", num); // num 값은 변경되지 않음
    return 0;
}

이 예시에서 addTen 함수는 num 변수의 값을 10 증가시키려 시도하지만, num의 값은 main 함수 내에서 변경되지 않는다.

⭐2. Call by Reference (참조에 의한 호출)

Call by Reference는 함수에 인자를 전달할 때 인자의 주소를 전달하는 방식이다. 따라서 함수 내에서 매개변수의 값을 변경하면, 그 변경사항이 원본 변수에도 반영된다.

#include <stdio.h>

void addTen(int *a) {
    *a += 10;
    printf("Inside addTen: %d\n", *a);
}

int main() {
    int num = 5;
    addTen(&num);
    printf("In main: %d\n", num); // num 값이 변경됨
    return 0;
}

이 예시에서는 addTen 함수가 num 변수의 실제 메모리 주소를 받아, 그 값을 변경한다. 결과적으로, main 함수 내의 num 값도 변경된다.

⭐3. 차이점

Call by Value는 값의 복사본을 작업하므로 원본 데이터를 보호할 수 있다. 하지만, 큰 데이터를 복사할 때 성능 저하가 발생할 수 있다.
Call by Reference는 메모리 주소를 전달하므로, 데이터의 복사본을 만들지 않아 성능이 더 좋다. 하지만, 함수 내에서 원본 데이터를 변경할 수 있으므로 주의가 필요하다.

⭐4. 장단점

Call by Value
- 장점: 원본 데이터 보호
- 단점: 큰 데이터를 복사할 때 비효율적
Call by Reference
- 장점: 메모리와 시간 효율성
- 단점: 원본 데이터가 변경될 위험성

[C/C++ Tip] 9. memset, memcpy

18진수 — Sun, 8 Sep 2024 21:33:10 +0900

C언어 memset, memcpy 함수 사용법

C언어에서 배열을 다루기 위한 여러 함수들이 있으며, 이 중에서 memset과 memcpy는 가장 기본적이면서도 중요한 함수이다. 이들 함수는 메모리 관리와 배열 조작을 효율적으로 수행할 수 있도록 도와준다.

⭐1. memset 함수

void *memset(void *ptr, int value, size_t num);

ptr: 설정하고자 하는 메모리의 시작 주소
value: 메모리에 설정할 값. int형으로 전달되지만, 실제로는 unsigned char로 변환되어 메모리에 저장된다.
num: value로 설정할 바이트의 수

#include <stdio.h>
#include <string.h>

int main() {
    int array[10];
    memset(array, 0, sizeof(array));
    
    for(int i = 0; i < 10; i++) {
        printf("%d ", array[i]);
    }
    return 0;
}

이 예시에서 memset은 array의 모든 요소를 0으로 초기화한다.

주의 사항으로 int array[10] = {0,}; 이 코드 또한 결과 값은 0이다. 기본적으로 컴파일러는 사용자가 배열을 초기화하지 않을 경우, 0으로 초기화하기 때문이다. int array[10] = {0, }; 이 코드는 첫 번째 요소의 값만 사용자가 0으로 초기화하고 나머지 요소들은 컴파일러에 의해 0으로 초기화하기 때문에 절대 좋은 초기화 방법이라고 할 수 없다.

⭐2. memcpy 함수

memcpy 함수는 메모리의 일정 구역을 다른 메모리로 복사할 때 사용한다. 이 함수도 <string.h> 헤더 파일에 선언되어 있다. 함수의 원형은 다음과 같다.

void *memcpy(void *dest, const void *src, size_t num);

dest: 데이터가 복사될 목적지 메모리의 시작 주소
src: 복사할 데이터가 위치한 원본 메모리의 시작 주소
num: 복사할 바이트의 수

#include <stdio.h>
#include <string.h>

int main() {
    int src[] = {1, 2, 3, 4, 5};
    int dest[5];
    
    memcpy(dest, src, sizeof(src));
    
    for(int i = 0; i < 5; i++) {
        printf("%d ", dest[i]);
    }
    return 0;
}

이 예시에서 memcpy는 src 배열의 모든 요소를 dest 배열로 복사한다.

⭐3. 장점

성능: memset과 memcpy는 저수준에서 최적화되어 있어서 대량의 데이터를 초기화하거나 복사할 때 빠른 성능을 제공한다.
간결성: 이 함수들을 사용하면 복잡한 반복문 없이도 메모리의 대량의 데이터를 쉽고 빠르게 처리할 수 있다.
직접적인 메모리 접근: 이러한 함수들은 메모리에 직접 접근하여 작업을 수행하기 때문에, 메모리 조작과 관련된 다양한 작업에서 매우 유용하다.

[STM32] 4. GPIO Output 설명

18진수 — Sat, 7 Sep 2024 16:55:08 +0900

STM32CubeIDE에서 GPIO 설정을 할 때 여러 옵션이 제공되는데, 각각의 설정 옵션에 대해 간단히 설명한다. 이 설정들은 CubeMX 통합 환경에서 GPIO 핀의 기능과 특성을 정의하는 데 사용된다. 이 전 포스팅에서 STM32 내장 LED를 제어하기 위해 GPIO Output을 설정하였으니 참고하길 바란다.

1. GPIO Output Level

GPIO 출력 레벨은 핀이 출력 모드일 때 초기 출력 상태(높음 또는 낮음)를 설정한다. 이 설정은 핀이 디지털 출력으로 구성될 때 중요하며, 기기가 리셋되거나 전원이 켜질 때 핀의 상태를 결정한다.

High (높음): 핀의 초기 상태를 높은 전압(보통 VDD)으로 설정한다.
Low (낮음): 핀의 초기 상태를 낮은 전압(GND)으로 설정한다.

이 설정은 GPIO 핀의 초기 출력 상태를 높은 전압(보통 VDD에 해당)으로 설정한다. 프로세서가 리셋되거나 전원이 처음 켜질 때, 이 핀은 높은 상태로 시작된다. 이것은 핀이 구성을 완료하기 전의 초기 상태를 정의한다.

2. GPIO Mode

GPIO 모드는 핀의 작동 모드를 정의한다. 이는 핀이 데이터를 입력받을지, 출력할지 또는 다른 특별한 기능을 수행할지를 결정한다.

Input (입력): 핀이 입력 모드로 설정되어 외부 신호를 받을 수 있다.
Output PP (푸시-풀 출력): 핀이 디지털 출력으로 설정되며, 푸시-풀 드라이버를 사용한다.
Output OD (오픈 드레인 출력): 핀이 오픈 드레인 출력으로 설정되며, 외부 풀업 저항이 필요하다.
Alternate Function (대체 기능): 핀이 특정 페리페럴(예: SPI, I2C)에 할당되도록 설정된다.
Analog (아날로그): 핀이 아날로그 모드로 설정되어 ADC와 같은 아날로그 주변 장치에 사용된다.

GPIO Mode : Output Push Pull
Output Push Pull 모드는 GPIO 핀을 일반적인 디지털 출력으로 설정한다. 이 모드에서 핀은 출력 신호를 양방향으로 제어할 수 있다. 즉, 핀은 전원(VDD)과 접지(GND) 사이를 스위칭 할 수 있어, 연결된 부하(예: LED)를 직접 드라이브할 수 있다.

3. GPIO Pull-up/Pull-down

핀의 내부 풀업 또는 풀다운 저항을 활성화하여 불필요한 입력 노이즈나 불확실한 상태를 방지한다.

No Pull-up/Pull-down (풀업/풀다운 없음): 저항 없이 설정되어 있어 외부에서 명확한 신호 레벨을 제공해야 한다.
Pull-up (풀업): 내부 풀업 저항을 활성화하여 핀을 기본적으로 높은 상태로 유지한다.
Pull-down (풀다운): 내부 풀다운 저항을 활성화하여 핀을 기본적으로 낮은 상태로 유지한다.

GPIO Pull-up/Pull-down 설정: Pull-down
풀다운 저항을 활성화하는 설정이다. 이 설정은 핀을 기본적으로 낮은 상태로 유지하도록 내부적으로 저항을 연결한다. 그러나 LED 제어의 경우, 풀다운 설정은 종종 사용되지 않거나 필요하지 않는다. 왜냐하면 LED를 켜고 끄는 제어는 핀의 High와 Low 상태에 의해 결정되기 때문이다. 이 설정은 주로 입력 모드에서 떠돌이 전압을 방지하기 위해 사용된다.

4. Maximum Output Speed

최대 출력 속도는 핀의 전환 속도(저속, 중속, 고속, 매우 고속)를 설정한다. 이는 신호의 빈도와 전류 요구 사항에 따라 선택된다.

Low Speed
Medium Speed
High Speed
Very High Speed

5. User Label

사용자 라벨은 핀에 사용자 정의 이름을 할당하여 프로젝트 내에서 핀을 더 쉽게 식별하고 참조할 수 있도록 하는 기능이다. 이 이름은 코드에서 해당 핀을 참조할 때 사용되며, 코드의 가독성과 유지 관리를 향상시키는 데 도움이 된다.
이러한 설정들은 STM32 마이크로컨트롤러의 GPIO 핀을 정확하고 효과적으로 구성하여 다양한 하드웨어 기능과 상호작용할 수 있게 해준다.

Embeded-Korea

5. 아두이노 우노 Atmega328P 타이머로 1초 만들기.

타이머로 1초 만들기

참고

4. 아두이노 우노 ATmega328P LED 출력하기 (DDR, PORT)

DDR

DDR 설정

PORT

3. 아두이노 우노 관련 자료 소개

1. 아두이노 우노 핀맵

2. 회로도

3. Atmega328P 데이터시트

2. 아두이노 소개 & Atmel Studio7 프로젝트 생성하기

1. 임베디드 SW 취업에 관심 있는 취준생을 위하여.

18. STM32 I2C 통신 - AM1008W-K-P 동작 구현

1. I2C 설정

2. AM1008W-P-K 라이브러리

3. am1008w_k_i2c.h

4. am1008w_k_i2c.c

5. main.c

6. 회로 구성

7. 동작 확인

[STM32] 17. I2C 통신 함수 종류

1. 주요 I2C HAL 함수

⚙️ 1. Blocking Mode

⚙️ 2. Non-Blocking Mode

2. I2C 설정

⚙️ 1. STM32CubeMX 프로젝트 열기

⚙️ 2. I2C 설정

⚙️ 3. I2C 파라미터 설정

3. 코드

1. HAL_StatusTypeDef

2. HAL_I2C_Master_Transmit

3. HAL_I2C_Mem_Write

4. HAL_I2C_GetState

[STM32] 16. I2C 센서 소개 (미세먼지/이산화탄소 복합 공기질 센서 CUBIC - AM1008W-K-P)

➡️ 1. Features

➡️ 2. Application Ideas

➡️ 3. Specification

[STM32] 15. I2C 통신 개요

1. I2C(Inter-Integrated Circuit)란 무엇인가?

2. I2C 데이터 전송 포맷

⚙️ 1. Start Condition (S)

⚙️ 2. Stop Condition (P)

⚙️ 3. Repeated Start (Restart) Condition (Sr)

⚙️ 4. Acknowledge ACK (A)

⚙️ 5. Not Acknowledge NACK (/A)

3. I2C 데이터 전송 시퀀스

[STM32] 14. 콜백 함수 호출 과정

1. HAL_UART_RxCpltCallback 함수 호출 과정

[STM32] 13. UART Interrupt 구현

1. Polling 방식의 문제점

2. Interrupt 방식

⚙️ 3. 레지스터 설정

⚙️ 4. 코드

[BLE 실내 측위 프로젝트] 7. NRF51822 비콘 테스트 및 초기 설정

[BLE 실내 측위 프로젝트] 6. RSSI 변동을 해결하기 위한 이동 평균 필터

1. 이동 평균 필터

2. Code

[BLE 실내 측위 프로젝트] 5. BLE Beacon의 RSSI 값에서 거리를 계산하는 방법 (feat.log distance path los

1. Log distance path loss model

2. Code

3. 한계

[BLE 실내 측위 프로젝트] 4. BLE advertising packet 기본 구성

1. BLE Packet

2. iBeacon - Apple

[BLE 실내 측위 프로젝트] 3. Flutter BLE Scan Demo Program, RSSI monitoring

​1. 패키지 설치 및 설정

⚙️ 1. android/app/build.gradle : SDK 최소 버전 19로 설정

⚙️ 2. android/app/src/main/AndroidManifest.xml : Bluetooth 권한 설정

2. Code

3. Demo Video

[BLE 실내 측위 프로젝트] 2. Bluetooth Low Energy(BLE) 통신 스케줄, 안드로이드 함께 이해하기

실내 측위 (Indoor Positioning)

BLE device discovery

Android

Low Power

Balanced Power

Low Latency

PDR (Packet Delivery Ratio)

1. 패키지 설치 및 설정