기록저장소

이동 평균 필터란?

->지정된 n개의 데이터만 가지고 평균을 구하는 방식

->새로운 데이터가 들어오면 가장 오래된 데이터는 버리고 n개로 평균을 구하는 방식

이번에도 굳이 구조체를 만들 필요는 없지만 구조체로 만들어보았다. 

만약 평균을 구할 데이터의 갯수 n이 정해져 있지 않고 사용자가 마음대로 초기화 할 수 있다고 가정하여, 

n이 정해지면 해당 갯수만큼 데이터를 담을 배열은 malloc을 사용하였다. 

#include <stdio.h>
#include <stdlib.h>
typedef struct 
{
    int cnt;
    int num;
    int *data;
    float preAvg;
    float nowAvg;
    int idx;
}mvAvg;

int init_mvAvgFilter(mvAvg *mvAvg, int num){
    mvAvg->cnt=0;
    mvAvg->num=num;
    mvAvg->data =(int*)malloc(sizeof(int)*num);
    mvAvg->preAvg=0;
    mvAvg->idx=0;
}

float mvAvgFilter(mvAvg *mvAvg,int data){
    if (mvAvg->cnt < mvAvg->num){
        mvAvg->data[mvAvg->cnt]=data;
        mvAvg->cnt++;
        
        int i=0;
        int sum=0;
        for (i=0;i<mvAvg->cnt;i++){
            sum+=mvAvg->data[i];
        }
        mvAvg->nowAvg=(float)sum/mvAvg->cnt;
        mvAvg->preAvg=mvAvg->nowAvg;
        return mvAvg->nowAvg;
    }

    mvAvg->nowAvg=(data-mvAvg->data[mvAvg->idx])/mvAvg->num+mvAvg->preAvg;
    mvAvg->data[mvAvg->idx]=data;
    mvAvg->idx++;
    if(mvAvg->idx == mvAvg->num){
        mvAvg->idx=0;
    }
    mvAvg->preAvg=mvAvg->nowAvg;
    return mvAvg->nowAvg;
}

int main(){
    mvAvg mvAvg;
    init_mvAvgFilter(&mvAvg,4);
    int i=0;
    for (i=1;i<=10;i++){
        printf("%d : %f\r\n",i,mvAvgFilter(&mvAvg,i));
    }
}

잘 되는 것 같은데.. 테스트가 부족하다.. 

끝

데이터들이 계속 들어올 때마다 평균을 갱신하는 AverageFilter 소스 

데이터의 수와 이전 평균만 전역 변수나 static 변수로 저장해도 되지만

구조체로 만들어보았다.

#include <stdio.h>

typedef struct 
{
    int dataCnt;
    float preAvg;
    float nowAvg;
}Avg;

float avgFilter(Avg *Avg,int data){
    if(Avg->dataCnt==0){
        Avg->dataCnt++;
        Avg->nowAvg=data;
        Avg->preAvg=data;
        return Avg->nowAvg;
    }
    Avg->preAvg=Avg->nowAvg;
    Avg->dataCnt++;
    Avg->nowAvg=(1 - (float)1/(Avg->dataCnt))*(Avg->preAvg)+((float)1/Avg->dataCnt)*data;
    return Avg->nowAvg;
}

int main(){
    Avg avg;
    avg.dataCnt = 0;
    avg.nowAvg = 0;
    avg.preAvg = 0;

    printf("%f\r\n", avgFilter(&avg,10));
    printf("%f\r\n", avgFilter(&avg,20));
    printf("%f\r\n", avgFilter(&avg,30));
    printf("%f\r\n", avgFilter(&avg,40));
    printf("%f\r\n", avgFilter(&avg,50));
    printf("%f\r\n", avgFilter(&avg,60));
    printf("%f %f\r\n",avg.preAvg,avg.nowAvg);
}

끝

링 버퍼란? 

고정된 크기의 큐의 양 끝을 이어 원형 모양처럼 사용하는 버퍼

데이터를 넣었다가 빼는 역할을 할 수 있다 

구현은 다음과 같이 하였다.

ring_buffer.h

#include <stdint.h>
#include <string.h>

typedef struct{
	uint8_t *buffer;
	int front;
	int rear;
	int maxlen;
}ring_buffer_t;

void ring_buf_init(ring_buffer_t *rbuf, uint8_t *buffer, int size);
uint8_t ring_buf_push(ring_buffer_t *rbuf, uint8_t data);
uint8_t ring_buf_pop(ring_buffer_t *rubf, uint8_t *data);
uint8_t ring_buf_is_full(ring_buffer_t *rbuf);
uint8_t ring_buf_is_empty(ring_buffer_t *rbuf);
void ring_buf_clear(ring_buffer_t *rbuf);

ring_buffer_t는

사용할 버퍼를 담을 uint_t *buffer 와 큐를 사용하기 위한 fornt, rear와 사용할 버퍼의 크기를 maxlen으로 한다.  

ring_buffer.c

#include <stdint.h>
#include <string.h>

void ring_buf_init(ring_buffer_t *rbuf, uint8_t *buffer, int size){
	memset(rbuf, 0x00, sizeof(ring_buffer_t));
	rbuf->buffer=buffer;
	rbuf->maxlen=size;
}

uint8_t ring_buf_is_full(ring_buffer_t *rbuf){
	if(rbuf->rear == ( rbuf->front+1 ) % rbuf->maxlen) return 1;
	else return 0;
}
uint8_t ring_buf_is_empty(ring_buffer_t *rbuf){
	if( rbuf->rear == rbuf->front) return 1;
	else return 0;
}

uint8_t ring_buf_push(ring_buffer_t *rbuf, uint8_t data){
	if( ring_buf_is_full(rbuf) ) return 0;
	rbuf->buffer[rbuf->front] = data;
	rbuf->front = ( rbuf->front + 1) % rbuf->maxlen;
	return 1;

}
uint8_t ring_buf_pop(ring_buffer_t *rbuf, uint8_t *data){
	if( ring_buf_is_empty(rbuf) ) return 0;
	*data=rbuf->buffer[rbuf->rear];
	rbuf->rear = (rbuf->rear + 1) % rbuf->maxlen;
	return 1;
}

void ring_buf_clear(ring_buffer_t *rbuf){
	rbuf->front=0;
	rbuf->rear=0;
}

사용 예시

#include <stdio.h>
#include <stdint.h>
#include "ring_buffer.h"

int main(){
    uint8_t  i=0;
    uint8_t pop_data=0;
    ring_buffer_t ring_buffer;
    uint8_t rbuf[3];

    ring_buf_init(&ring_buffer, rbuf, 3);

    for(i=0;i<5;i++){
        if (ring_buf_push(&ring_buffer, i)){
             printf("push data : %d\r\n",i );
        }
    }

    for(i=0;i<5;i++){
        if (ring_buf_pop(&ring_buffer,&pop_data)){
            printf("pop %d \r\n", pop_data);
        }
    }
    return 0;
}

1. ring_buf_init(&ring_buffer, rbuf, 3);

    -> ring_buffer 구조체에 rbuf로 초기화 한다. 

2. 0~5를 ring buffer에 순차적으로 push 한다.

3.  ring_buffer의 데이터를 pop_data에 5번 pop한다. 

결과 

rbuf의 크기는 3인데 데이터는 2개를 넣은 후, 3개째에서 링 버퍼가 가득 찼다고 나온다. 

이는 링 버퍼의 경우,  empty와 full을 구분하기 위해 full의 경우 한 칸을 비워두기 때문이다.

나는 3개를 만들었으면 3개를 다 쓰고 싶다고 한다면 ring_buffer.h에서 ring_buffer_init 할 때 maxlen을 버퍼의 크기보다 1개 더 크게 해주면 된다. 

void ring_buf_init(ring_buffer_t* rbuf, uint8_t* buffer, uint16_t size){
    memset(rbuf,0x00,sizeof(ring_buffer_t));
    rbuf->buffer = buffer;
    rbuf->maxlen = size+1;
}

이렇게 고치고 똑같이 테스트를 하면

버퍼의 크기만큼 모두 이용할 수 있다. 

물론 테스트를 많이 안해봐서 오류가 있을 수도.....

끝

LED를 버튼으로도 제어를 할 수 있게 되었다. 

https://pilimage.tistory.com/17

버튼을 손으로 누르는 것 말고 PC로 제어를 할 수 있을까? 

당연히 가능하다.

Uart 통신을 이용하여 on이 들어오면 LED가 켜지고, off가 들어오면 LED가 꺼지도록 해보겠다. 

USB 컨버터가 없어도 STM32F746은 문제 없다. 

우리에겐 전원 겸 디버깅 용인 ST-LINK가 있다. 

ST-LINK에 VCP포트가 있다.

VCP란 Virtual COM Port로 USB를 통해 PC와 시리얼 통신을 가능하게 해준다.

그러므로 ST-LINK의 VCP_TX/RX를 Uart로 이용하면 된다. 

회로도에서 VCP_TX는 PA9 , VCP_RX는 PB7 인 것을 확인하고 해당 번호의 핀을 클릭하여 각각 USART1_TX, USART1_RX로 선택한다. (선택시 해당 핀 노란색으로 변화)

이제 핀 맵 왼쪽의 Connectivity 항목에서 USART1을 선택하고 Mode를 Asynchronous(비동기)로 선택한다. 

파라미터는 기본적으로 Baudrate는 115200 , word length는 8 bits , Paritiy 는 None , Stop Bits는 1로 설정한다.

그리고 Code Generation을 누르면 환경 설정은 끝이난다. 

그리고 이제 다음 상황을 생각하여 소스를 작성하였다.

a. on이 입력되면 LED가 켜지고 off가 들어오면 LED가 꺼지도록 함

b.  on / off 만 정확히 입력되어야 LED 제어, 그외의 입력은 무시 

 -> ex) onnnnn, offff, onoff 등은 동작 무시

c.  테스트에 minicom을 사용하여 키보드로 엔터를 입력할 시 개행문자로 \r (CR)로 입력받음

 -> 터미널마다, 운영체제마다 엔터를 눌렀을 때, 개행문자가 \r :  (CR), \n : (LF) , \r\n : (CRLF)로 다르게 입력

d.  minicom을 이용한 터미널에서 입력한 글씨를 출력하고 가독성을 위해 \n을 추가하여 Uart Transmit을 사용

1. HAL_UART_Receive 함수를 사용하여 rcv_data라는 변수에 1바이트씩 데이터를 받아 data_arr라는 버퍼에 저장시켰다. 

2. 받은 데이터가 '\r'이면 문자열의 끝을 알려주는 \0을 추가하였다.

3. strcmp를 사용하여 정확히 on , off만 입력되었을 때 기능이 동작하도록 하였다. 

4. 입력받은 데이터에 \n을 붙여 다시 pc로 전송하여 터미널에서 입력한 데이터를 볼 수 있도록 하였다.

5. 문자열 비교가 끝나면 다음 입력을 위해 idx=0으로 하여 버퍼를 재사용할 수 있도록 한다.

위의 소스코드대도 빌드하면 on이 입력되면 LED가 켜지고, off가 입력되면 LED가 꺼진다. 

원하는 대로 동작을 시켰지만 특정상황에서만 (\r로 개행될 때) 동작하는 것이 좀 찜찜할 수 도 있다. 

그 예로, echo on > /dev/ttyACM0 처럼 에코를 이용하여 on 또는 off를 보내면 \n이 마지막에 보내져서 기능이 동작하지 않는다..

그래서 \r이나 \n을 만나면 판단을 하도록 하였다. 

on인지 off인지 비교하는 부분에서 strcmp대신 strncmp를 이용하여 정해진 길이만큼만 비교하여 on인지 off인지 구분하였다. 

strncmp를 사용하여 문자열의 처음부분만 비교를 하다보니 onoff나 ontime 등도 on으로 인식한다는 문제가 있다.

strstr로 문자열을 검색하는 것 보다는 처음부분 비교하는게 좀 더 나을것 같아서 strncmp를 이용하였다. 

on/off를 입력하여 LED도 제어를 해보았다. 

이번 과정에서 가장 큰 문제점은 무엇일까?

메인의 while문에 HAL_UART_Receive를 사용하였기에 데이터가 들어올 때까지 timeout(위에서는 100ms)의 시간동안 대기한다. 

즉, 계속해서 Uart를 체크하는 Polling방식을 사용하였기 때문에 데이터가 들어올때까지 대기하는 시간동안은 버튼을 눌러도 동작하지 않는다.  HAL_UART_Receive의 timeout 시간을 길게하면 확실히 볼 수 있다.

이러한 현상을 막는 방법은 없을까?

당연히 있다. 

바로 인터럽트를 이용하는 방법이다. 

인터럽트를 사용한 방법은 다음 글로...

끝

버튼을 누르고 있으면 LED가 On되고 버튼을 떼면 LED가 Off되는 것은 이제 쉽다. 

https://pilimage.tistory.com/16

버튼을 한 번 누르면 LED가 켜지고 다시 한 번 더 누르면 LED가 꺼질 수는 없는가?

당연히 가능하다. 

버튼이 눌렸다는 인식은 여러가지 방법으로 가능하겠지만 인터럽트를 사용하지 않고 폴링으로 해보겠다. 

폴링 방식이란 무엇인가?

버튼의 상태를 주기적으로 확인하는 방식으로 메인 루프에서 버튼의 상태를 계속 확인하면서 버튼이 눌려졌다는 상황을 판단한다.

버튼을 확인하는 방법은 버튼이 눌렸을 때의 tick과 버튼이 떨어졌을 때의 tick을 이용하여 

버튼이 떨어졌을 때 동작하도록 만들었다. 

btn_state는 버튼의 상태를 의미하고 초기값은 0이다. 

push_btn은 버튼이 눌린 상태를 표시하는 flag로 초기값은 0이다

stable_time은 채터링 방지 시간으로 초기값은 100ms로 하였다

1. push_btn의 초기값이 0이므로 if문에 해당된다. 

2. 버튼이 눌려져 btn_state가 1이되면 push_btn을 1로 바꾸고 그 때의 tick을 얻는다.

3. push_btn이 1이므로 else 구문으로 들어간다. 

4. 버튼이 떨어져서 btn_state가 0이 되면 그 때의 tick과 버튼을 눌렀을 때의 tick을 비교하여 stable_time보다 크면 LED를 반전 시켰다. 

5.  stable_time보다 작으면 push_btn = 0으로 바꾸어 초기 상태로 돌아간다. 

* Chattering (채터링)이란? 

버튼(=스위치)를 누르거나 떨어질 때, 0(LOW) -> 1(HIGH) 또는 1(HIGH)->0(LOW) 으로 한순간에 변하는 것이 아니라 떨어졌다 붙었다 하는 현상을 말한다. 

* void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

 GPIO 핀의 출력을 반전시키는 함수로 LED의 ON/OFF에 사용하였다.

끝

가장 쉬운 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 되는 것을 확인할 수 있다. 

끝

만들었던 Stack 함수들을 이용하여 괄호 문제를 풀어보았다. 

Stack 함수 : https://pilimage.tistory.com/12

int main(){
    int num;
    int i,j;
    int err=0;

    scanf("%d",&num);
    char input[50];

    int *errList;
    errList=(int*)malloc(sizeof(int)*num);
    Stack s;
    
    for(i=0;i<num;i++){
        memset(input,0x00,sizeof(input));
        scanf("%s",input);
        initStack(&s,strlen(input));
        for(j=0;j<strlen(input);j++){
            if(input[j]=='('){
                pushStack(&s,input[j]);
            }else{
                if(popStack(&s)==0){
                    errList[i]=1;
                }
            }
        }
        if (!isEmptyStack(&s)){
            errList[i]=1;
        }
        DelStack(&s);
    }

    for(i=0;i<num;i++){
        if(errList[i]){
            printf("NO\n");
        }else{
            printf("YES\n");
        }
    }
    free(errList);
    return 0;
}

입력을 받아서 ' ( '를 만나면 스택에 push하고 ' ) '를 만나면 pop을 하도록하였다. 

' ) '을 만나서 pop을 할때, ' ( '와 ' ) '는 한 쌍이므로 ' ) '를 만났는데 스택에 ' ( '가 없어서 pop을 하지 못한다면 에러로 처리하였다. 

입력을 다 서치하고, 스택에 데이터인 ' ( '가 남아 있다면 에러로 처리하였다.

err flag과 errList를 이용하여 마지막에 결과를 출력하도록 하였다.

끝

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 출력 

끝