기록저장소

1초 간격으로 LED를 On/off를 하는 것은 이제 쉽다. 

https://pilimage.tistory.com/15

자동으로 말고 내가 버튼을 눌러서 LED를 제어할 수 없는가?

당연히 가능하다. 

먼저 STM32F746 회로도를 보면 유저가 사용할 수 있는 버튼이 있다. 

B_USER 버튼은 핀 PI11에 연결된 것을 확인할 수 있다. 

Pinout & Configuration 에서 PI11을 검색하여 핀 위치를 찾는다. 

PI11입장에서 버튼의 신호를 받아야 버튼이 눌렸는지 안눌렸는지 알 수 있기에 PI11을 클릭한 뒤, GPIO_Input으로 설정해준다. 

또한 코드 작성의 편의를 위해 PI11을 우클릭하여 Enter User Label을 눌러 BTN1로 이름을 붙인다. 

System Core - GPIO 항목을 눌러 핀 세팅을 확인하고 Code Generation을 한다. 

코드를 작성할 준비는 모두 끝났다

이번에 사용할 HAL 라이브러리의 함수는 2가지이다. 

GPIO를 읽는 Read와 GPIO를 쓰는 Write

즉 ,버튼의 입력을 확인하는 HAL_GPIO_ReadPin 과 LED출력을 조절할 HAL_GPIO_WritePin 이다.

GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)

HAL_GPIO_ReadPin은 GPIOx에는 GPIO 구조체의 포인터를, GPIO_Pin에는 해당 핀을 넣어 핀 상태인 GPIO_PinState ( 0 또는 1 )를 리턴한다. 

void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)

GPIOx에는 GPIO 구조체의 포인터를, GPIO_Pin에는 해당 핀을, PinState에는 출력을 할려면 1(=GPIO_PIN_SET) 아니면 0(GPIO_PIN_RESET)을 넣으면 된다.

먼저 버튼을 누른 상태에서만 LED가 켜지는 동작을 작성해 보자 

1. 메인 루프에서 BTN1의 상태를 계속 읽는다. 

2. BTN1이 눌려져 있으면, LED1을 On한다. 

3. BTN1이 안눌려져 있으면 LED1을 Off한다.

if문을 쓰기 싫다 코드를 한 줄로 줄이고 싶다면 다음과 같이 작성해도 된다.

1. 메인루프에서 LED1을 BTN1의 상태를 읽어 출력한다. 

HAL_GPIO_ReadPin이 GPIO_PinState를 리턴하므로 이렇게 한 줄로도 줄일 수 있다. 

끝

가장 쉬운 LED ON/OFF를 해보자 .

먼저 프로젝트를 만들고 Clock & Configuration에서 Clock을 설정하자 

HSI  : 내부 클럭 
HSE : 외부 클럭
PLLCLK : 내부 클럭 또는 외부 클럭을 적절히 곱하거나 나누어 원하는 클럭으로 만들어 사용 

클럭은 PLLCLK을 사용하여 32Mhz를 만들었다. 

(내부 16Mhz / 16 * 192 / 6 = 32 Mhz  ,  일단 APB~~등등은 동일하게 설정)

Pinout & Configuration에서 이제 LED Pin을 설정한다. 

먼저 사용할 LED인 LD1과 연결된 Pin을 회로도에서 확인한다. 

또한 회로도에서 LED 다이오드의 방향을 보면 PI1에서 Output을 출력해야 LED가 켜지는 것을 확인할 수 있다.

LD1은 PI1과 연결되어 있으므로 핀맵에서 PI1을 찾는다. 

직접 찾아도 되지만 아래 검색을 이용하면 더 쉽게 찾을 수 있다

PI1을 클릭하고 GPIO_Output으로 선택하면 해당 핀이 초록색으로 변하고 이름이 GPIO_Output으로 변한다.

코드를 작성할 때 편의를 위해서 해당 핀을 다시 우클릭하고 Enter User Label을 눌러 LED1로 이름을 바꿔준다.

핀 선택이 잘되었다 보고 싶으면 System Core의 GPIO 창을 눌러 확인한다. 

확인까지 하였으면 상단 메뉴의 톱니바퀴 모양인 Code Generation을 눌러 코드를 생성해보자

Core - Src - main.c 를 확인해보면 설정한 클럭과 GPIO핀(LED1)들이 main함수 시작에서 초기화 되는 것을 확인할 수 있다. 

이제 설정은 끝났고, HAL 라이브러리를 사용하여 설정한 LED를 조작해보자.

LED1은 GPIO핀으로 출력을 조절하여 LED를 On/Off 할 수 있고 다음 HAL 함수를 통해 GPIO 출력을 조절할 수 있다. 

void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)

GPIOx에는 GPIO 구조체의 포인터를, GPIO_Pin에는 해당 핀을, PinState에는 출력을 할려면 1(=GPIO_PIN_SET) 아니면 0(GPIO_PIN_RESET)을 넣으면 된다.

PI1핀의 이름을 LED1로 바꾸었기에 아래와 같이 메인 소스를 작성하면 1초 간격으로 LED가 On/off를 반복하는 것을 볼 수 있다. 

(이름을 바꾸지 않았다면 구조체는 GPIOI~ , 핀은 GPIO_PIN_1 등으로 설정되며 알아보기가 힘들 수도 있다. )

동작은 정말 간단한다. 

LED1에 출력을 High로 주었다가 Low로 주었다가를 반복하면 된다. 

해당 소스를 빌드해서 이제 넣으면 되는데 어떻게 넣을까? 

상단의 Run을 눌러도 되고 Debug를 눌러도 된다. (단 Debug의 경우 빌드를 먼저 해야함)

이 때 Debug Configurations 나 Run Configurations를 눌러 Debugger 설정을 할 수 있다. 

Debugger 설정을 다음과 같이 ST-Link로 해주면 전원을 넣는다고 연결한 USB를 통해서도 프로그램을 올릴 수 있다.  

이제 Run 버튼을 누르면 해당 프로그램이 올라간다. 

실제 보드가 1초 간격으로 On/Off 되는 것을 확인할 수 있다. 

끝

stm32이란 것이 아무것도 모르고 펌웨어 프로그램을 시작했다.

지금도 이론이나 기초는 터무니 없이 부족하며

단순히 필요한 것만 찾아서 그 때 그 때 어거지로 사용하고 있다고 생각한다.. 

그래서 처음부터 이것저것 천천히 다시 해보려고 한다. 

STM32F746G Discovery 보드와 STM32CubeIDE를 사용한다. 

먼저 갓 STM32CubeIDE를 아래 링크에서 설치하자

https://www.st.com/en/development-tools/stm32cubeide.html

앞으로 진행할 여러 실습을 위해 STM32F746G보드로 프로젝트 만들자.

프로젝트를 만들고 Debug폴더의 .ioc를 더블클릭하여 Configuration Tool을 연다.

Pinout & Configuration에서는 핀 세팅과 설정들을 변경할 수 있다. 

Clock Configuration을 누르면 Clock Tree가 나온다.

클럭을 설정하는 곳인데 HSI,HSE,PLLCLK 등등 이런저런? 것들이 나온다. 

쉽게 생각하면 다음과 같다.

HSI  : 내부 클럭 
HSE : 외부 클럭
PLLCLK : 내부 클럭 또는 외부 클럭을 적절히 곱하거나 나누어 원하는 클럭으로 만들어 사용 

여기서 원하는 클럭을 만들어 사용하면 된다. 

이렇게 클럭과 핀 등을 세팅하고 톱니바퀴 모양의 Code Generation 을 누르면 해당 설정들이 적용된 코드가 만들어진다. 

요약하자면 아래 와 같은 과정을 통해 stm32를 이용하여 원하는 코드를 작성하고 디버깅할 환경을 만들 수 있다. 

1. 보드에 맞게 프로젝트 생성

2. 클럭 설정

3. 사용할 핀 세팅 및 설정 

4. Code Generation

끝

Stack이란?

: 데이터를 일시적으로 저장하는 방법

LIFO (Last In First Out, 후입선출)의 구조로나중에 들어온 데이터가 먼저 나가는 방식

배열을 크게 잡고 사용하여도 되지만 학습을 위하여 malloc을 사용하였다. 

typedef struct 
{
    int size;
    int idx;
    int *data;
}Stack;

void DelStack(Stack *s){
    free(s->data);
}


int initStack(Stack *s, int size){
    s->size=size;
    s->idx=-1;
    s->data=(int*)malloc(sizeof(int)*(s->size));
    if(s->data!=NULL){
        return 1; 
    }else{
        s->size=0;
        return 0; 
    }   
}

구조체 Stack의 멤버 변수로는 스택의 크기 : size , 데이터 index : idx , 데이터 : *data 

initStack을 통해 스택 구조체를 초기화한다. 

idx는 -1로 초기화하고 malloc이 실패했을때 initStack이 0을 리턴하도록 한다. 

int isFullStack(Stack *s){
    if(s->idx>=s->size-1){
        return 1;
    }else{
        return 0;
    }
}
int isEmptyStack(Stack *s){
    if(s->idx==-1){
        return 1;
    }else{
        return 0;
    }
}

int pushStack(Stack *s, int data){
    if(isFullStack(s)){
        // printf("Stack is Full\r\n");
        return 0;
    }else{
        s->idx++;
        s->data[s->idx]=data;
        return 1;
    }
    return 0;
}
int popStack(Stack *s){
    int val=0;
    if(isEmptyStack(s)){
        // printf("stack is Empty");
        return val;
    }else{
        val=s->data[s->idx];
        s->idx--;
        return val;
    }    
}

isFullStack : 스택이 가득 찼는지 확인

isEmptyStack: 스택이 비었는지 확인 

pushStack : 스택에 데이터 삽입

-> 스택이 가득 차지 않았을 경우, 데이터 인덱스를 옮기고 데이터를 넣는다.

idx를 -1로 초기화 하였기 때문에 idx를 먼저 더해서 옮기고 데이터를 넣었다. 만약 idx를 0으로 초기화하였다면 데이터를 넣고 idx를 더해주면 된다. 

popStack : 스택에서 데이터 출력

->스택이 비어있지 않을 경우, 데이터를 출력하고 인덱스를 옮긴다. 

int SearchStack(Stack *s, int data){
    int i;
    for(i=0;i<s->idx;i++){
        if(data==s->data[i]){
            return i;
        }
    }
    return -1;
}

조금의 응용으로  SearchStack은 스택에 찾으려는 데이터가 있으면 해당 인덱스를 없으면 -1을 리턴하도록 만들어보았다. 

만든 함수를 아래와 같이 테스트하였다.

int main(){
    int i;
    Stack stack;
    initStack(&stack,10);
    pushStack(&stack,1);
    pushStack(&stack,2);
    pushStack(&stack,3);
    pushStack(&stack,4);
    pushStack(&stack,5);
    pushStack(&stack,6);
    pushStack(&stack,7);
    pushStack(&stack,8);
    pushStack(&stack,9);
    pushStack(&stack,10);

    pushStack(&stack,11);
    printf("search %d %d\r\n",SearchStack(&stack,7),SearchStack(&stack,-1));    

    for(i=0;i<13;i++){
        printf("% d idx:%d\r\n",popStack(&stack),stack.idx);

    }
    DelStack(&stack);
    return 0;

}

1. 크기가 10인 사이즈를 만들고 11개의 데이터를 넣었다. - > Stack is Full 출력

2. 데이터가 7인 인덱스와 -1인 인덱스를 서치하였다 -> serach 6 -1 출력

3. 13개의 데이터를 출력하였다 -> 10 idx : 9~~ stack is Empty 0 idx : -1 출력 

끝

디버깅 혹은 출력을 보기 위해 stm에서 printf가 필요할 때가 엄~~~청 많은 것 같다.

Uart가 있다면 HAL_UART_Transmit을 통해 아주 쉽게 printf와 비슷한 효과를 낼 수 있다. 

어떻게 ?

바로 그냥 문자열을 HAL_UART_Transmit을 이용하여 전송하면 된다. 

void print_str(char *str) {
	HAL_UART_Transmit(&huart1, str, strlen(str), 500);
}

int main(){
...

print_str("START\r\n")
...
}

만약 문자열이 아니라 변수의 값을 출력해보고 싶다면?

itoa 함수를 이용하면 출력할 수 있다. 

void print_val(char *strtemp, int val) {
	static char temp[128];
	char *ptr;
	ptr = temp;
	memset(temp, 0x00, 128);
	strcpy(temp, strtemp);
	ptr += strlen(temp);
	itoa(val, ptr, 10);
	HAL_UART_Transmit(&huart1, temp, strlen(temp), 500);
}

int main(){
...
a=10;
print_val("state : ",a);
...
}

간단한 출력할 때 유용하게 사용하는 중.. 

Hex로 된 데이터를 HexString으로, HexString을 Hex로 변환하는 경우가 종종 있었다. 

그럴때 마다 Hex convert to Hexstring ~~ 등등 구글링을 했었는데....

이번에 만든 걸로 쓸 곳에 쓰고 정리를 해보았다.

Hex 를 HexString으로 변환은 말그대로 Hex형태로 된 데이터를 HexString으로 변환하는 것이다.

쉽게 말하면 아래와 같다. 

Hex로 된 데이터가 있다. 

uint8_t hex[16]={0xA1,0xA2,0xA3,0xA4,0xB5,0xB6,0xB7,0xB8,0xC9,0xC0,0xCA,0xCB,0xDC,0xDD,0xDE,0xDF};

현재는 한 바이트당 hex로 표시된 것을 말 그대로 스트링형태로 바꾸는 것이다. 

예를 들어 0xA1의 경우 1바이트 Hex로 표시되어 있다.

이 때, A와 1을 문자형태로 만들어 0xA1이란 1바이트 Hex를 A1이란 2바이트의 문자열(0x41,0x31)로 만드는 것이다. 

반대로 HexString 은 A1이란 스트링을 보이는 그대로 0xA1이란 Hex로 만드는 것이다. 

설명이 애매한가....? 난 이해가 되니깐.. ㅎ 

먼저 Hex를 HexString으로 바꾸는 건 아래와 같다. 

int hex_convert_hexstring(uint8_t* data, uint8_t len, uint8_t* result){
	int i=0;
	int idx=0;
	for(i=0;i<len;i++){
		result[idx++]=(*(data+i))>>4 & 0x0f;
		result[idx++]=(*(data+i))& 0x0f;
	}

	for(i=0;i<idx;i++){
		if(result[i]>=10){
			result[i]=result[i]-10+'A';
		}else{
			result[i]=result[i]+'0';
		}
	}
    return idx;
}

data에는 변환할 Hex 데이터, len에는 data의 길이, result는 결과를 저장할 배열을 넣는다. 

변환된 후, result의 데이터 길이가 retrun된다. 

간단히 설명하자면..... 

Hex 값을 4비트씩 나누어서  result에 넣고, 문자열로 표현하기에 result에 넣은 값을 문자열 형태로 변환해주면 된다.

이 때, 10이 hex로 표현되면 A로 표현되므로 문자열로 변환하기 위해서 10이상의 값은 10을 빼주고 문자 'A'만큼 더해준다. 

이렇게 되면 10일 경우는 문자 'A', 11인경우 11-10+'A' 가 되므로 'A'+1 인 'B'가 된다. 

10보다 작을 때는 문자 '0'을 더해주어 0~9를 문자 형태로 변환한다. 

아스키 코드 표를 보면서 하면 더 쉽게 이해가 될 것이다. 

다음으로는 HexString에서 Hex로 변환하는 법이다. 

int hexstring_convert_hex(uint8_t* data,uint8_t len,uint8_t* result){
	int idx=0;
	int i=0;
	for (i=0;i<len;i++){
		if(*(data+i)>='A'){
			*(data+i)=*(data+i)-'A'+10;
		}else{
			*(data+i)=*(data+i)-'0';
		}
	}
	i=0;
	for(idx=0;idx<len/2;idx++){
		result[idx]=*(data+i++)<<4  | *(data+i++) & 0x0f;
	}
    return idx;
}

data에 hexstring을 넣고, len에 hexstirng의 길이를 넣고, result에 hex결과를 저장할 배열을 넣는다. 

변환된 후, hex데이터의 길이가 return 된다.

아까와는 반대로 hexString의 문자를 hex로 만들고, 2바이트씩 합쳐준다. 

실행 예시는 다음과 같다. 

int main(){
    int i=0;
    int string_len=0;
    int hex_len=0;
    uint8_t hex[16]={0xA1,0xA2,0xA3,0xA4,0xB5,0xB6,0xB7,0xB8,0xC9,0xC0,0xCA,0xCB,0xDC,0xDD,0xDE,0xDF};
    uint8_t hex_string[64];
    uint8_t hex_result[64];

    string_len=hex_convert_hexstring(hex,sizeof(hex),hex_string);

    for(i=0;i<string_len;i++){
        printf("%C ",hex_string[i]);
    }
    printf("\r\n");
    printf("%s\r\n",hex_string); //A1A2A3A4B5B6B7B8C9C0CACBDCDDDEDF

    hex_len=hexstring_convert_hex(hex_string,string_len,hex_result);
    
    for(i=0;i<hex_len;i++){
        printf("%02X ",hex_result[i]); //A1 A2 A3 A4 B5 B6 B7 B8 C9 C0 CA CB DC DD DE DF
    }
    printf("\r\n");
    return 0;

}

주석처리가 실제 프린트된 내용인데 잘 변환된 것 같다.

끝 !

Linux에서 Golang 으로 GPIO를 제어해보았다. 

GPIO란? GPIO(General Purpose Input Output)는 일반적인 용도의 입출력 포트를 의미한다. 

NewGPIO로 구조체를 만들고, Pin(string)으로 제어할 GPIO 핀번호를 정한다. 

Out , In 으로 dir을 정하고 , High, Low로 값을 정하고, PinRead 로 해당 GPIO 값이 0인지 1인지 읽을 수 있다. 

PinUnexport로 사용을 종료할 수도 있다. 

핀을 초기화하고, 방향과 Low,High를 정해 사용할 수 있다. 

예를 들면

g:=NewGPIO()

g.Pin("1")

g.Out().High()

g.In().Low() 등등 

전체코드는 다음과 같다.

// gpio.go
package gpio

import (
	"io/ioutil"
	"log"
	"os"
)

const (
	gpioBasePath     = "/sys/class/gpio"
	gpioExportPath   = "/sys/class/gpio/export"
	gpioUnexportPath = "/sys/class/gpio/unexport"
)

type GPIO struct {
	pin string
}

func NewGPIO() GPIO {
	return GPIO{}
}

func (g GPIO) Pin(pin string) GPIO {
	g.pin = pin
	if _, err := os.Stat(gpioBasePath + "/gpio" + g.pin); os.IsNotExist(err) {
		err := ioutil.WriteFile(gpioExportPath, []byte(g.pin), 0666)
		if err != nil {
			log.Println(err)
		}
	}
	return g
}

func (g GPIO) Out() GPIO {
	err := ioutil.WriteFile(gpioBasePath+"/gpio"+g.pin+"/direction", []byte("out"), 0666)
	if err != nil {
		log.Println(err)
	}
	return g
}

func (g GPIO) In() GPIO {
	err := ioutil.WriteFile(gpioBasePath+"/gpio"+g.pin+"/direction", []byte("in"), 0666)
	if err != nil {
		log.Println(err)
	}
	return g
}

func (g GPIO) High() bool {
	err := ioutil.WriteFile(gpioBasePath+"/gpio"+g.pin+"/value", []byte("1"), 0666)
	if err != nil {
		log.Println(err)
		return false
	}
	return true
}

func (g GPIO) Low() bool {
	err := ioutil.WriteFile(gpioBasePath+"/gpio"+g.pin+"/value", []byte("0"), 0666)
	if err != nil {
		log.Println(err)
		return false
	}
	return true
}

func (g GPIO) PinRead(pin string) byte {
	value, err := ioutil.ReadFile(gpioBasePath + "/gpio" + pin + "/value")
	if err != nil {
		log.Println(err)
	}

	return value[0] - 48
}

func (g GPIO) PinUnexport(pin string) bool {
	err := ioutil.WriteFile(gpioUnexportPath, []byte(pin), 0666)
	if err != nil {
		log.Println(err)
		return false
	}
	return true
}

끝 !

리눅스를 쓰기 시작하면서 윈도우와는 달리 키보드를 더 많이 쓰게 되었다....

정말 기초 중의 기초이면서 가장 먼저하고 거의 매일하는 일은 터미널 창 띄우기가 아닐까..?

터미널 창을 이용하여 이것저것하면서 내가 실제 터미널 관련해서 쓰는 단축키들은 아래와 같다. 

먼저 터미널 창을 띄워야 한다. 

터미널 창 띄우기 : CTRL + ALT + T

터미널 창을 띄우는 것으로 터미널 관련 사용법의 반을 익혔다.

작업을 하다보면 터미널 창이 많아지는 경우가 있는데 터미널 창을 많이 열다 보면 찾기도 힘들고 보기도 힘들다

그래서 1개의 터미널 창에 인터넷 브라우저와 같이 Tab을 만든다. 

터미널 탭 만들기 : CTRL + SHIFT + T

탭 창을 만들었으니 터미널 창 자체를 여러개 만들지 않고 1로 깔끔하게 쓸 수 있게 되었다.

여러개의 탭을 만들었으면 앞에서 부터 1,2,3 번호가 있다고 생각하고 아래의 단축키를 누르면 해당 탭으로 이동할 수있다. 

터미널 탭 바꾸기 : ALT + 해당 탭 창 번호

작업이 끝나서 탭을 닫아야할 경우 해당 탭으로 이동해서 터미널 탭 종료를 한다.

터미널 탭 종료 : CTRL + SHIFT + W

작업하는 터미널 창 크기가 작아서 내용이 짤리는가? 문제없다.

터미널 창 최대화 : ALT + F10

창을 다시 줄이려면 ALT + F10을 한번 더 눌러주자.

터미널 창 자체를 닫는 건 국룰인 ALT + F4 또는 CTRL + SHIFT + Q

터미널 창 안의 내용을 복사하려면 복사할 부분을 드래그 등으로 선택한 후, 

터미널 창 내에서 복사 : CTRL + SHIFT + C

터미널 창 내에 붙여넣기를 하고 싶다면?

터미널 창 내에 붙여넣기 : CTRL +SHIFT + V

로그 파일을 따로 만들지 못해 터미널 출력에서 특정 단어를 찾아야한다면 ? 

터미널 창 내에서 찾기 : CTRL + SHIFT + F

터미널 창을 열고 닫고, 탭을 만들고 이동하고 닫고,  창을 키우고 줄일 수 있고,

복사하고, 붙여넣고, 특정 문자를 찾을 수 있는 정도면 불편함없이 사용하는 것 같다. 

기초이지만 자주쓰는 터미널 창 명령어

끝 !