MENU
  1. ホーム
  2. C 언어
  3. 임베디드 리눅스에서 쉘 스크립트와 C언어 결합하기

임베디드 리눅스에서 쉘 스크립트와 C언어 결합하기

C 언어

임베디드 리눅스 환경에서 시스템 자원을 효율적으로 관리하고 제어하는 것은 매우 중요합니다. 이를 위해 쉘 스크립트와 C언어를 조합하면 각각의 장점을 살리면서 강력하고 유연한 시스템 제어가 가능합니다. 쉘 스크립트는 높은 수준의 자동화와 간단한 작업 흐름을 제공하고, C언어는 저수준의 성능 최적화와 정밀한 제어가 가능합니다. 본 기사에서는 두 언어의 결합 방법과 실용적인 사례를 통해 임베디드 시스템에서의 효율적인 활용법을 알아봅니다.

목차
  1. 쉘 스크립트와 C언어의 장단점 비교
    1. 쉘 스크립트의 장점
    2. 쉘 스크립트의 단점
    3. C언어의 장점
    4. C언어의 단점
    5. 결합의 필요성
  2. 쉘 스크립트를 활용한 초기화 자동화
    1. 임베디드 시스템 부팅 과정에서의 역할
    2. 쉘 스크립트로 초기화 구성하기
    3. 초기화 스크립트 등록
    4. 장점과 유의점
  3. C언어로 작성된 프로그램 호출
    1. 쉘 스크립트에서 C언어 프로그램 실행
    2. 예제: C언어 프로그램 작성 및 호출
    3. 인수 전달 및 반환값 처리
    4. 활용 사례
  4. 환경 변수와 데이터 교환
    1. 환경 변수를 통한 데이터 전달
    2. 표준 입력/출력을 통한 데이터 교환
    3. 파일을 통한 데이터 교환
    4. 활용 사례
  5. C언어를 통한 고성능 처리
    1. 임베디드 시스템에서의 C언어 활용
    2. 고성능 처리의 필요성
    3. 고성능 작업 예제
    4. 최적화 기법
    5. 쉘 스크립트와의 조합
    6. 장점과 제한
  6. 실시간 처리와 인터럽트
    1. 임베디드 시스템에서 실시간 처리의 중요성
    2. 실시간 처리 구현
    3. 인터럽트 기반 처리
    4. 쉘 스크립트와의 역할 분담
    5. 예제: 실시간 데이터 처리 시스템
    6. 장점과 한계
  7. 결합 시 주의 사항
    1. 쉘 스크립트와 C언어 결합 시 발생 가능한 문제
    2. 1. 데이터 교환에서의 형식 불일치
    3. 2. 동기화 문제
    4. 3. 경로 및 권한 문제
    5. 4. 메모리 누수
    6. 5. 환경 변수 충돌
    7. 6. 디버깅의 어려움
    8. 최종 권장사항
  8. 사례 연구: 간단한 임베디드 애플리케이션
    1. 목표
    2. 구성
    3. 1. C언어로 센서 데이터 읽기
    4. 2. 쉘 스크립트로 실행 및 처리
    5. 3. 실행 및 결과
    6. 확장 가능성
    7. 장점
    8. 결론
  9. 요약

쉘 스크립트와 C언어의 장단점 비교

쉘 스크립트의 장점

  • 단순성과 가독성: 텍스트 기반으로 작성되어 코드가 직관적이고 수정이 용이합니다.
  • 빠른 개발: 간단한 작업 흐름 자동화와 시스템 명령 실행에 적합합니다.
  • 범용성: 다양한 유틸리티와 명령어를 조합해 복잡한 작업도 손쉽게 처리할 수 있습니다.

쉘 스크립트의 단점

  • 성능 제약: 반복문이나 복잡한 연산 처리에는 속도가 느립니다.
  • 확장성 부족: 대규모 프로그램 작성이나 정밀한 제어에는 부적합합니다.

C언어의 장점

  • 고성능 처리: 저수준 접근과 최적화로 빠르고 효율적인 실행이 가능합니다.
  • 정밀한 제어: 메모리 관리 및 하드웨어 레벨의 작업이 가능합니다.
  • 이식성: 다양한 플랫폼에서 컴파일 후 실행할 수 있어 임베디드 시스템에서 많이 사용됩니다.

C언어의 단점

  • 복잡성: 코드 작성과 디버깅 과정이 상대적으로 복잡합니다.
  • 개발 속도 저하: 간단한 작업에도 많은 코드를 작성해야 합니다.

결합의 필요성


쉘 스크립트는 빠른 프로토타이핑과 작업 자동화에 적합하고, C언어는 성능과 정밀 제어가 필요한 부분에서 강점을 발휘합니다. 두 언어를 결합하면 장점을 극대화하여 임베디드 리눅스에서 최적의 효율을 얻을 수 있습니다.

쉘 스크립트를 활용한 초기화 자동화

임베디드 시스템 부팅 과정에서의 역할


임베디드 시스템은 부팅 시 여러 초기화 작업을 수행해야 합니다. 이러한 작업에는 디바이스 드라이버 로드, 네트워크 설정, 애플리케이션 실행 등이 포함됩니다. 쉘 스크립트를 사용하면 이러한 초기화 과정을 간단하고 체계적으로 자동화할 수 있습니다.

쉘 스크립트로 초기화 구성하기


다음은 간단한 쉘 스크립트를 사용하여 초기화 작업을 수행하는 예입니다:

#!/bin/sh
# 네트워크 초기화
ifconfig eth0 up
ifconfig eth0 192.168.1.100 netmask 255.255.255.0

# 디바이스 드라이버 로드
modprobe my_device_driver

# 애플리케이션 실행
/home/user/my_application &

초기화 스크립트 등록


초기화 스크립트를 시스템 부팅 과정에 포함하려면 다음과 같은 방법을 사용할 수 있습니다:

  1. /etc/rc.local 파일: 초기화 스크립트를 여기에 추가하면 부팅 시 실행됩니다.
  2. Systemd 서비스: 더 복잡한 초기화가 필요할 경우 Systemd 서비스를 만들어 관리할 수 있습니다.

장점과 유의점

  • 장점: 반복 작업 자동화, 코드 변경 용이성, 문제 발생 시 수정의 간편함.
  • 유의점: 잘못된 스크립트 작성 시 부팅 실패 가능성, 외부 의존성 문제 방지 필요.

이처럼 쉘 스크립트는 임베디드 리눅스 초기화를 간소화하고, 신속한 시스템 제어를 가능하게 해줍니다.

C언어로 작성된 프로그램 호출

쉘 스크립트에서 C언어 프로그램 실행


쉘 스크립트는 시스템 명령처럼 C언어로 작성된 바이너리 프로그램을 호출할 수 있습니다. 이를 통해 C언어의 고성능 처리를 활용하며 쉘 스크립트의 간단한 자동화와 결합할 수 있습니다.

예제: C언어 프로그램 작성 및 호출


다음은 C언어로 작성된 프로그램을 쉘 스크립트에서 호출하는 예제입니다.

  1. C언어 프로그램 작성
#include <stdio.h>
int main(int argc, char *argv[]) {
    if (argc > 1) {
        printf("Hello, %s!\n", argv[1]);
    } else {
        printf("Hello, World!\n");
    }
    return 0;
}

이 코드를 hello.c로 저장한 후 컴파일합니다:

gcc -o hello hello.c
  1. 쉘 스크립트에서 호출
#!/bin/sh
# C언어 프로그램 호출
./hello "Embedded Linux"

인수 전달 및 반환값 처리

  • 인수 전달: 쉘 스크립트에서 명령줄 인수를 C언어 프로그램에 전달할 수 있습니다.
  ./hello "Argument Test"
  • 반환값 처리: C언어 프로그램에서 return 값을 쉘 스크립트에서 처리 가능합니다.
  return 1;
  ./hello
  if [ $? -eq 1 ]; then
      echo "Program returned an error."
  fi

활용 사례

  • 센서 데이터 처리: 센서 데이터는 C언어로 빠르게 수집 및 처리하고, 쉘 스크립트로 이를 관리.
  • 로그 처리: C언어로 생성한 로그를 쉘 스크립트를 통해 저장 및 관리.

C언어 프로그램 호출은 성능과 유연성을 동시에 제공하여 복잡한 작업을 효율적으로 수행할 수 있게 합니다.

환경 변수와 데이터 교환

환경 변수를 통한 데이터 전달


쉘 스크립트와 C언어 간 데이터 교환의 간단한 방법은 환경 변수를 사용하는 것입니다. 환경 변수는 쉘에서 설정하여 C언어 프로그램에서 읽어올 수 있습니다.

  1. 쉘 스크립트에서 환경 변수 설정
#!/bin/sh
export DATA="Hello from Shell"
./read_env
  1. C언어에서 환경 변수 읽기
#include <stdio.h>
#include <stdlib.h>

int main() {
    char *data = getenv("DATA");
    if (data) {
        printf("Received environment variable: %s\n", data);
    } else {
        printf("No environment variable found.\n");
    }
    return 0;
}

표준 입력/출력을 통한 데이터 교환


C언어와 쉘 스크립트는 표준 입력과 출력을 사용하여 데이터를 교환할 수도 있습니다.

  1. C언어 프로그램 작성
#include <stdio.h>

int main() {
    char buffer[100];
    printf("Waiting for input:\n");
    if (fgets(buffer, sizeof(buffer), stdin)) {
        printf("Received: %s", buffer);
    }
    return 0;
}
  1. 쉘 스크립트에서 데이터 전달
#!/bin/sh
echo "Data from Shell" | ./read_stdin

파일을 통한 데이터 교환


쉘 스크립트와 C언어 간 대량의 데이터를 주고받을 때는 파일을 사용하는 것이 효율적입니다.

  1. 쉘 스크립트에서 데이터 생성
#!/bin/sh
echo "123,456,789" > input.txt
./process_file
  1. C언어에서 파일 읽기
#include <stdio.h>

int main() {
    FILE *file = fopen("input.txt", "r");
    if (file) {
        char buffer[100];
        while (fgets(buffer, sizeof(buffer), file)) {
            printf("Read line: %s", buffer);
        }
        fclose(file);
    } else {
        printf("Failed to open file.\n");
    }
    return 0;
}

활용 사례

  • 환경 변수: 시스템 설정 값 전달, 사용자 지정 옵션 전달.
  • 표준 입출력: 명령 결과 실시간 처리.
  • 파일 I/O: 대량 데이터 처리와 지속적 저장.

이러한 방법은 작업 유형에 따라 적절히 선택하여 데이터 교환을 효율적으로 구현할 수 있습니다.

C언어를 통한 고성능 처리

임베디드 시스템에서의 C언어 활용


임베디드 리눅스는 제한된 자원 환경에서 작동하는 경우가 많아 고성능 연산이 요구됩니다. C언어는 저수준 메모리 접근과 하드웨어 친화적인 특성으로 인해 임베디드 시스템에서 효율적인 성능을 제공합니다.

고성능 처리의 필요성

  • 데이터 처리 속도: 실시간 센서 데이터 수집 및 분석.
  • 메모리 최적화: 메모리 제한이 있는 시스템에서 동적 메모리 관리.
  • 하드웨어 직접 제어: 디바이스 드라이버 개발이나 레지스터 조작.

고성능 작업 예제

  1. 수학적 계산
    C언어는 복잡한 수학 계산을 고속으로 처리할 수 있습니다.
#include <stdio.h>
#include <math.h>

int main() {
    double result = pow(2.0, 10.0);
    printf("2^10 = %.2f\n", result);
    return 0;
}
  1. 센서 데이터 수집 및 처리
#include <stdio.h>
#include <unistd.h>

int main() {
    int sensor_data = 0;
    for (int i = 0; i < 5; i++) {
        // 센서 데이터 모의 수집
        sensor_data += i * 10;
        printf("Collected data: %d\n", sensor_data);
        usleep(500000); // 0.5초 대기
    }
    return 0;
}

최적화 기법

  • 컴파일러 최적화 옵션: GCC에서 -O2 또는 -O3 옵션을 사용해 실행 속도를 개선.
  gcc -O3 -o optimized_program program.c
  • 메모리 풀링: 메모리 할당/해제를 반복하는 대신 미리 할당된 메모리 풀을 사용.
  • 멀티스레딩: POSIX 스레드를 사용해 병렬 처리를 구현.
  #include <pthread.h>

쉘 스크립트와의 조합

  • 데이터 수집: 쉘 스크립트로 데이터 입력을 관리하고, C언어로 데이터를 처리.
  • 결과 저장: C언어에서 계산 결과를 생성하고, 쉘 스크립트로 결과 저장 및 보고.

장점과 제한

  • 장점: 고속 연산, 정밀한 하드웨어 제어, 적은 리소스 소모.
  • 제한: 개발 난이도 증가, 디버깅의 복잡성.

C언어는 성능 중심의 작업에서 필수적인 도구로, 임베디드 리눅스 환경에서 쉘 스크립트와 조합해 강력한 시스템을 구현할 수 있습니다.

실시간 처리와 인터럽트

임베디드 시스템에서 실시간 처리의 중요성


임베디드 시스템은 센서 데이터 처리, 모터 제어, 네트워크 패킷 처리 등 실시간 응답이 필요한 작업을 수행합니다. 이러한 실시간 요구를 충족하려면 정밀한 제어와 빠른 처리가 가능한 C언어와 스크립트의 유기적 조합이 필수적입니다.

실시간 처리 구현


C언어는 실시간 처리를 위한 정확한 타이밍과 하드웨어 제어를 지원합니다.

  1. 정밀 타이머 활용
    C언어의 clock_gettime 함수는 나노초 단위의 정확도를 제공합니다.
#include <stdio.h>
#include <time.h>

void delay_ns(long nanoseconds) {
    struct timespec req = {0};
    req.tv_sec = nanoseconds / 1000000000;
    req.tv_nsec = nanoseconds % 1000000000;
    nanosleep(&req, NULL);
}

int main() {
    printf("Starting delay...\n");
    delay_ns(500000000); // 500ms
    printf("Delay completed.\n");
    return 0;
}
  1. 멀티스레드와 우선순위 스케줄링
    POSIX 스레드를 사용해 병렬 처리와 실시간 스케줄링을 구현할 수 있습니다.
#include <pthread.h>
#include <stdio.h>

void* task(void* arg) {
    printf("Executing real-time task...\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, task, NULL);
    pthread_join(thread, NULL);
    return 0;
}

인터럽트 기반 처리


임베디드 시스템은 인터럽트를 활용해 하드웨어 이벤트에 신속히 응답합니다.

  • GPIO 인터럽트: 디바이스가 입력 신호를 받을 때 처리 루틴 실행.
  • C언어 구현: 디바이스 드라이버를 작성하거나 poll() 또는 select()와 같은 함수로 인터럽트를 처리합니다.

쉘 스크립트와의 역할 분담


쉘 스크립트는 실시간 처리에 관여하기보다 환경 설정 및 데이터 관리 작업을 맡습니다.

  • C언어 처리 결과 관리: C 프로그램에서 생성된 데이터를 쉘 스크립트로 저장 및 전송.
  • 자동화: 스크립트를 통해 실시간 처리를 위한 프로그램 실행 및 로그 분석.

예제: 실시간 데이터 처리 시스템

  1. C언어 프로그램: 데이터를 실시간으로 처리.
  2. 쉘 스크립트: 실행 환경 설정 및 결과 저장.
#!/bin/sh
# 환경 설정
export SENSOR_PORT=/dev/ttyS0

# 실시간 데이터 처리 실행
./realtime_process > output.log

장점과 한계

  • 장점: 빠른 응답, 정확한 타이밍 관리, 하드웨어 최적화.
  • 한계: 복잡한 코딩 요구, 인터럽트와 타이머 관리의 어려움.

실시간 처리와 인터럽트는 C언어가 주도하고, 쉘 스크립트가 이를 보조하는 구조를 통해 임베디드 시스템의 성능과 안정성을 크게 향상시킬 수 있습니다.

결합 시 주의 사항

쉘 스크립트와 C언어 결합 시 발생 가능한 문제


쉘 스크립트와 C언어를 조합하면 강력한 기능을 제공하지만, 이 과정에서 여러 문제점이 발생할 수 있습니다. 이러한 문제를 이해하고 사전에 대비하면 시스템 안정성을 높일 수 있습니다.

1. 데이터 교환에서의 형식 불일치


쉘 스크립트와 C언어는 데이터 처리 방식이 다르므로, 교환되는 데이터의 형식 불일치 문제가 발생할 수 있습니다.

  • 예시: 쉘 스크립트에서 문자열 데이터를 전달했으나, C언어에서 숫자 형식으로 읽으려 할 때 오류 발생.
  • 해결 방법: 데이터 형식을 명확히 정의하고 입력 데이터 유효성을 검사합니다.
  #include <stdio.h>
  #include <stdlib.h>

  int main(int argc, char *argv[]) {
      if (argc < 2) {
          printf("Error: Missing input\n");
          return 1;
      }
      int value = atoi(argv[1]);
      printf("Processed value: %d\n", value);
      return 0;
  }

2. 동기화 문제


C언어 프로그램이 종료되지 않은 상태에서 쉘 스크립트가 다음 명령을 실행하면, 의도치 않은 동작이 발생할 수 있습니다.

  • 해결 방법: 쉘 스크립트에서 wait 명령으로 프로세스가 완료될 때까지 대기.
  ./long_running_process &
  wait
  echo "Process completed."

3. 경로 및 권한 문제


쉘 스크립트가 C언어로 작성된 실행 파일을 호출할 때 경로나 실행 권한 문제로 오류가 발생할 수 있습니다.

  • 해결 방법:
  • 절대 경로를 사용하여 실행 파일을 호출.
  • 실행 권한 부여: chmod +x program_name.

4. 메모리 누수


C언어에서 동적 메모리를 제대로 해제하지 않으면 메모리 누수가 발생하여 시스템 안정성을 저하시킬 수 있습니다.

  • 해결 방법:
  • 동적 메모리를 사용한 후 반드시 free()를 호출.
  • 쉘 스크립트로 메모리 누수 검사: valgrind 같은 도구 사용.

5. 환경 변수 충돌


쉘 스크립트에서 설정된 환경 변수가 다른 C언어 프로그램과 충돌할 수 있습니다.

  • 해결 방법: 쉘 스크립트에서 환경 변수를 명확히 정의하고 필요한 경우 종료 후 해제.
  export TEMP_VAR="value"
  ./program
  unset TEMP_VAR

6. 디버깅의 어려움


쉘 스크립트와 C언어 간 데이터 전달 과정에서 문제가 발생하면 원인을 추적하기 어렵습니다.

  • 해결 방법:
  • 디버깅 메시지를 추가하여 각 단계의 실행 상태를 기록.
  • strace와 같은 도구로 시스템 호출을 추적.

최종 권장사항

  • 테스트 자동화: 모든 결합 과정에서 오류를 사전에 발견할 수 있도록 테스트 스크립트를 작성합니다.
  • 문서화: 데이터 교환 방식, 실행 파일 위치, 환경 변수 설정 등을 문서화하여 협업 중 발생할 수 있는 혼란을 최소화합니다.

이러한 주의 사항을 철저히 고려하면 쉘 스크립트와 C언어의 조합으로 안정적이고 효율적인 시스템을 구현할 수 있습니다.

사례 연구: 간단한 임베디드 애플리케이션

목표


쉘 스크립트와 C언어를 결합해 임베디드 리눅스 시스템에서 간단한 온도 모니터링 애플리케이션을 구현합니다. 이 애플리케이션은 센서 데이터를 읽고 특정 임계값을 초과하면 알림을 생성합니다.

구성

  1. C언어: 센서 데이터를 읽고 임계값 비교.
  2. 쉘 스크립트: 프로그램 실행, 결과 로그 작성 및 경고 처리.

1. C언어로 센서 데이터 읽기

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

#define THRESHOLD 50 // 임계값

int main() {
    srand(time(NULL)); // 난수 생성 초기화
    int sensor_value = rand() % 100; // 0~99 사이의 값 모의 생성

    printf("Sensor value: %d\n", sensor_value);

    if (sensor_value > THRESHOLD) {
        printf("ALERT: Value exceeded threshold!\n");
        return 1; // 경고 반환값
    }

    return 0; // 정상 반환값
}

이 코드를 sensor_monitor.c로 저장한 후 컴파일합니다.

gcc -o sensor_monitor sensor_monitor.c

2. 쉘 스크립트로 실행 및 처리

#!/bin/sh

# 센서 모니터링 실행
./sensor_monitor > sensor_log.txt 2>&1
result=$?

# 결과 확인 및 경고 처리
if [ $result -eq 1 ]; then
    echo "Warning: Threshold exceeded!" >> sensor_log.txt
    echo "Sending alert to system administrator..."
    # 알림 발송(예: 이메일, 로그 서버 등)
else
    echo "System operating normally." >> sensor_log.txt
fi

# 로그 출력
cat sensor_log.txt

스크립트를 monitor.sh로 저장한 후 실행 권한을 부여합니다.

chmod +x monitor.sh

3. 실행 및 결과


쉘 스크립트를 실행하면 센서 데이터를 모니터링하고 로그를 생성합니다.

./monitor.sh
  • 로그 파일 내용 예시
Sensor value: 72
ALERT: Value exceeded threshold!
Warning: Threshold exceeded!
Sending alert to system administrator...

확장 가능성

  • 실시간 데이터 처리: 센서 데이터를 지속적으로 읽기 위해 cron 또는 systemd로 주기적 실행 설정.
  • 알림 통합: 이메일 또는 메시징 서비스를 통해 알림 전송.
  • GUI 추가: HTML 또는 대시보드 애플리케이션으로 결과 시각화.

장점

  • C언어: 센서 데이터의 빠른 처리와 조건 평가.
  • 쉘 스크립트: 결과 관리와 알림 발송의 자동화.

결론


이 간단한 애플리케이션은 쉘 스크립트와 C언어의 결합을 통해 실용적인 임베디드 시스템의 기본 기능을 효과적으로 구현하는 방법을 보여줍니다. 이를 기반으로 복잡한 시스템에도 확장 가능합니다.

요약


본 기사에서는 임베디드 리눅스 환경에서 쉘 스크립트와 C언어를 결합하여 효율적으로 시스템을 제어하는 방법을 다뤘습니다. 쉘 스크립트는 작업 자동화와 간단한 흐름 관리에 적합하며, C언어는 고성능 처리와 하드웨어 제어에 강점을 보입니다. 데이터 교환, 실시간 처리, 그리고 사례 연구를 통해 두 언어를 조합한 실제 구현 방법과 주의 사항을 살펴보았습니다. 이러한 결합은 시스템 효율성과 유연성을 크게 향상시킬 수 있습니다.

C 언어
C언어 쉘 스크립트 임베디드 리눅스
목차
  1. 쉘 스크립트와 C언어의 장단점 비교
    1. 쉘 스크립트의 장점
    2. 쉘 스크립트의 단점
    3. C언어의 장점
    4. C언어의 단점
    5. 결합의 필요성
  2. 쉘 스크립트를 활용한 초기화 자동화
    1. 임베디드 시스템 부팅 과정에서의 역할
    2. 쉘 스크립트로 초기화 구성하기
    3. 초기화 스크립트 등록
    4. 장점과 유의점
  3. C언어로 작성된 프로그램 호출
    1. 쉘 스크립트에서 C언어 프로그램 실행
    2. 예제: C언어 프로그램 작성 및 호출
    3. 인수 전달 및 반환값 처리
    4. 활용 사례
  4. 환경 변수와 데이터 교환
    1. 환경 변수를 통한 데이터 전달
    2. 표준 입력/출력을 통한 데이터 교환
    3. 파일을 통한 데이터 교환
    4. 활용 사례
  5. C언어를 통한 고성능 처리
    1. 임베디드 시스템에서의 C언어 활용
    2. 고성능 처리의 필요성
    3. 고성능 작업 예제
    4. 최적화 기법
    5. 쉘 스크립트와의 조합
    6. 장점과 제한
  6. 실시간 처리와 인터럽트
    1. 임베디드 시스템에서 실시간 처리의 중요성
    2. 실시간 처리 구현
    3. 인터럽트 기반 처리
    4. 쉘 스크립트와의 역할 분담
    5. 예제: 실시간 데이터 처리 시스템
    6. 장점과 한계
  7. 결합 시 주의 사항
    1. 쉘 스크립트와 C언어 결합 시 발생 가능한 문제
    2. 1. 데이터 교환에서의 형식 불일치
    3. 2. 동기화 문제
    4. 3. 경로 및 권한 문제
    5. 4. 메모리 누수
    6. 5. 환경 변수 충돌
    7. 6. 디버깅의 어려움
    8. 최종 권장사항
  8. 사례 연구: 간단한 임베디드 애플리케이션
    1. 목표
    2. 구성
    3. 1. C언어로 센서 데이터 읽기
    4. 2. 쉘 스크립트로 실행 및 처리
    5. 3. 실행 및 결과
    6. 확장 가능성
    7. 장점
    8. 결론
  9. 요약