Node.js : Chrome V8 JavaScript 엔진으로 빌드 된 JavaScript 런타임(실행기), 서버와 같은 네트워크 프로그램을 만들기 위한 S/W 플랫폼 JavaScript : Javascript를 실행하기 위해서는 웹 브라우저가 필요하다. Javascript는 브라우저라는 특정한 프로그램 안에서 동작하기 때문에 브라우저 없이 javascript를 실행하려면 실행환경이 필요하다.

Node.js를 쓰는 이유는 브라우저 없이 javascript를 실행하여 서버 프로그램을 만들기 위하여

특징

1. 단일 쓰레드, 이벤트 루프
2. 비동기 Non-Blocking I/O 처리
3. 이벤트 발생시 서버에 메세지 형태로 전달

장점

1. javascript를 사용해서 서버를 만들 수 있다.
2. npm를 통해 다양한 모듈을 사용가능하다.

단점

1. 단일 쓰레드이기 때문에 작업 자체가 많이 걸리는 서비스 형태의 경우에는 사용불가

활용

1. 간단한 서버 로직
2. 빠른 응답시간 요구
3. 빠른 개발 요구
4. 비동기 방식에 어울리는 스트리밍 서비스, 채팅 서비스에 적합

스케줄러

특정 시점에 기능을 수행할 수 있도록 하기 위해 사용된다. 서버를 자주 운영되는 리눅스에서 사용된다.

Cron 이란?

Cron : 유닉스 계열의 잡 스케줄러

Cron 표현식

특수 문자 정리

● * : 모든 값
● ? : 특정한 값이 없음
● - : 범위 (ex) 월요일에서 수요일까지는 MON-WED로 표현한다.
● , : 특별한 값일 때만 동작 (ex) 월,수,금 MON,WED,FRI 
● / : 시작시간 / 단위  (ex) 0분부터 매 5분 0/5
● L : 일에서 사용하면 마지막 일, 요일에서는 마지막 요일(토요일)
● W : 가장 가까운 평일 (ex) 15W는 15일에서 가장 가까운 평일 (월 ~ 금)을 찾음
● # : 몇째주의 무슨 요일을 표현 (ex) 3#2 : 2번째주 수요일

CICD 환경의 이해(with Jenkins)

CICD : 애플리케이션 개발 단계를 자동화하여 애플리케이션 개발을 보다 짧은 주기로 고객에게 제공하는 방법, 개발 과 운영팀에서 발생하는 소통 문제를 해결한다.

Test Case

Test Case : 동작에 조건을 붙여 잘 실행되는지 테스트 하는 것

테스트 기반

명세 기반 : 문장(text)로 이루어진 자료 ex) 기능설명서, 사용자 스토리 구조 기반 : 구조적 데이터로 이루어진 자료 ex) 코드, 제어흐름

DB 설계 : 효율적으로 DB를 관리하기 위해서

1. 파급효과 : 백업을 하기 위해서 연결되어 있는 서비스 때문에, 먼 과거까지 백업을 해야할 수 있다.
2. 데이터 품질(고급)
3. 간결함 : 관련자들이 동일하게 작업을 진행하기 위한 데이터 모델, 의사소통이 목적

ERD

ERD(Entity Relationship Diagram) : tool이다. 테이블간의 관계를 설명해주는 다이어그램으로, DB 설계를 하기위해 효율적으로 사용되는 구조도이다. 의사소통이 주된 목적이다.

Index

인덱스 : 추가적인 쓰기 작업과 저장 공간을 활용하여 데이터베이스 테이블의 검색속도를 향상 시키기 위한 자료구조

query가 index 타는지 확인 하는 방법

explain을 query문 앞에 붙여준다.

인덱스를 탄다 = 인덱스를 걸은 컬럼 기준으로 데이터를 정렬시키고 정렬되어 있는 데이터를 트리구조로 빠르게 탐색한다

DB 데이터 적재

실무 프로젝트시 데이터 이행

1. 실제 데이터를 운영 DB에 반영하는 작업
2. 대량 데이터일 경우 증분 데이터만 반영

   데이터 적재 시점

3. 서버 Down 타임에 적재
4. 사전 적재
5. 서비스 운영 중에 적재

적재 방법

1. DB 백업본으로 이관
2. 텍스트 데이터로 이관
3. DB to DB로 이관
4. Restful API로 이관

주의) 필요한 데이터 가공 및 텍스트 속성값 확인할것

참고 사이트

import export

느낀점

1. 엑셀파일(.xlsx) 등을 import 할 수는 없고 .csv 파일로 변경해야한다.
2. .csv 변경시 연결 프로그램을 메모장으로 설정 후 다른 이름으로 저장으로 통해 utf-8로 저장해줘야 정상 저장이 된다.
3. column명을 .csv 파일과 table 과 동일시 해줘야한다.
4. import 중 column 명이 한글로 되어있을 경우 에러가 발생한다.
5. export 할 때 파일명 혹은 경로가 한글로 되어있을 경우 에러가 발생한다.

RC Car에서 작업 디렉토리 이동 후 vi ./app.py후 해당 코드를 테스트 해보자!

import mysql.connector

db = mysql.connector.connect(host='AWS IP 주소`, user=`관리자 계정 ID', password='관리자 PW', database='생성한 스키마명', auth_plugin='mysql_native_password')
cur = db.cursor()

#query
cur.execute("select * from command")

#print
for (id, time, cmd_string, arg_string, is_finish) in cur:
    print(id, time, cmd_string, arg_string, is_finish)

cur.close()
db.close()

Timer 사용하기

임베디드에서 Timer는 Thread가 아니라 Interrupt로 동작됩니다. 이와 달리, Python 에서 Timer는 Threading으로 동작되어, Main Thread와 Timer Thread가 동시에 동작 됩니다.

import mysql.connector
from threading import Timer
from time import sleep

def polling():
    print("HI")

    timer = Timer(2, polling)
    timer.start()

polling()

while True: pass

명령어 미리 받기 위한 Timer

다음 코드를 응용하여

Polling Thread : Command Query 로 받은 데이터를 “ready” 객체에 저장한다. Main Thread : “ready” 객체에 저장된 명령을 수행한다. (Motor 제어)

와 같이 구현할 예정입니다.

import mysql.connector
from threading import Timer
from time import sleep
import signal
import sys

def closeDB(signal, frame):
    print("BYE")
    timer.cancel()
    sys.exit(0)

def polling():
    print("HI")   
    global timer
    timer = Timer(2, polling)
    timer.start()

timer = None
signal.signal(signal.SIGINT, closeDB)
polling()

while True: 
    print("MAIN")
    sleep(0.5)
    pass

지속적으로 Query 받기

 import mysql.connector
from threading import Timer
from time import sleep
import signal
import sys

def closeDB(signal, frame):
    print("BYE")
    cur.close()
    db.close()
    timer.cancel()
    sys.exit(0)

def polling():
    global cur, db

    # 가장 최근의 레코드를 지속적으로 가져오는 소스코드
    cur.execute("select * from command order by time desc limit 1") 
    for (id, time, cmd_string, arg_string, is_finish) in cur:
        print(cmd_string, arg_string)

    db.commit()

    global timer
    timer = Timer(1, polling)
    timer.start()

#init
db = mysql.connector.connect(host='AWS IP 주소`, user=`관리자 계정 ID', password='관리자 PW', database='생성한 스키마명', auth_plugin='mysql_native_password')
cur = db.cursor()
timer = None
signal.signal(signal.SIGINT, closeDB)
polling()

#main thread
while True:
    print("KFC MAIN")
    sleep(0.5)
    pass

코드

import mysql.connector
from threading import Timer
from time import sleep
import signal
import sys

def closeDB(signal, frame): # 신호시 종료
    print("BYE")
    cur.close()
    db.close()
    timer.cancel()
    sys.exit(0)

def polling(): # 최근 명령어 가져오기
    global cur, db, ready

    cur.execute("select * from command order by time desc limit 1")
    for (id, time, cmd_string, arg_string, is_finish) in cur:
        if is_finish == 1 : break
        ready = (cmd_string, arg_string)
        cur.execute("update command set is_finish=1 where is_finish=0") # is_finish 1로 셋팅

    db.commit()

    global timer
    timer = Timer(0.1, polling)
    timer.start()

def go():
    print("go")

def back():
    print("back")

def stop():
    print("stop")

def left():
    print("left")

def mid():
    print("mid")

def right():
    print("right")

#init
db = mysql.connector.connect(host='13.125.225.160', user='mincoding', password='1234', database='minDB', auth_plugin='mysql_native_password')
cur = db.cursor()
ready = None
timer = None
signal.signal(signal.SIGINT, closeDB)
polling()

#main thread
while True:
    sleep(0.1)
    if ready == None : continue

    cmd, arg = ready
    ready = None

    if cmd == "go" : go()
    if cmd == "back" : back()
    if cmd == "stop" : stop()
    if cmd == "left" : left()
    if cmd == "mid" : mid()
    if cmd == "right" : right()

RC카 라즈베리파이를 SSH로 접속합니다. 기본 도구인 apt-update, vim과 rdate를 설치합니다. 그리고 시간 세팅을 하여 DB에 정확한 시간 값을 저장할 수 있도록 합니다.

sudo apt update
sudo apt install rdate vim -y
sudo rdate -s time.bora.net
sudo ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
date

작업 디렉토리 생성 후 테스트

mkdir를 통해 작업 디렉토리 생성하기! MySQL 접속을 위한 pip로 설치하기!

python3 -m pip install mysql-connector
python3 -m pip install mysql-connector-python

작업 디렉토리 접근후 테스트 해보기

DB 테스틑

1_db_test.py

import mysql.connector

db = mysql.connector.connect(host='AWS IP 주소`, user=`관리자 계정 ID', password='관리자 PW', database='생성한 스키마명', auth_plugin='mysql_native_password')
cur = db.cursor()

#query
cur.execute("select * from command")

#print
for (id, time, cmd_string, arg_string, is_finish) in cur:
    print(id, time, cmd_string, arg_string, is_finish)

cur.close()
db.close()

Sense Hat Test

sudo apt-get install sense-hat을 통해 센스햇 Library 2_sensehat_test.py

from sense_hat import SenseHat
sen = SenseHat()
sen.show_message('HELLO')

압력,온도,습도 센서 Test

3_sensor_test.py

from sense_hat import SenseHat
from time import sleep

sense = SenseHat()

while True:
  pressure = sense.get_pressure()
  temp = sense.get_temperature()
  humidity = sense.get_humidity()

  p = round(pressure, 2)
  t = round(temp, 2)
  h = round(humidity, 2)

  msg = "Press : " + str(p) + "  Temp : " + str(t) + "  Humid : " + str(h)
  print(msg)
  sleep(0.1)

조이스틱 test

4_eyebbong_test.py

from sense_hat import SenseHat

sense = SenseHat()
sense.clear(255, 255, 255) 

def red():
  sense.clear(255, 0, 0)

def blue():
  sense.clear(0, 0, 255)

def green():
  sense.clear(0, 255, 0)

def yellow():
  sense.clear(255, 255, 0)

sense.stick.direction_up = red
sense.stick.direction_down = blue
sense.stick.direction_left = green
sense.stick.direction_right = yellow
sense.stick.direction_middle = sense.clear

#infinity loop
while True:
  pass

모터 세팅하기

Motor Driver(Motor Hat)을 사용하면, GPIO 로 간단히 DC Motor, Servo Motor를 제어할 수 있습니다.

Motor Library 다운 후 압축 풀기

cd ~/bbqcar
wget http://raspberrypiwiki.com/images/a/ac/Raspi-MotorHAT-python3.zip --no-check-certificate
unzip ./Raspi-MotorHAT-python3.zip

필요한 라이브러리 작업 디렉토리로 복사하기

cp ./DCTest.py ~/bbqcar/test/5_DCTest.py
cp ./Raspi_I2C.py ~/bbqcar/test/
cp ./Raspi_MotorHAT.py ~/bbqcar/test/
cp ./Raspi_PWM_Servo_Driver.py ~/bbqcar/test/

DC모터 테스트

vi 5_DCTest.py에서 DC모터가 연결된 채널을 확인한 후 myMotor = mh.getMotor(연결된 채널)을 수정해줍니다!

서보모터 테스트

```py from Raspi_PWM_Servo_Driver import PWM import time

pwm = PWM(0x6F) pwm.setPWMFreq(60)

while True: value = int(input('PWM VALUE : ')) if value <= 200 or value >= 500 : print("WARNING") continue pwm.setPWM(0, 0, value) ```

이름, APP(Quick Start를 통한 생성), 키페어 생성(유출 조심), 스토리지 설정(프리 티어는 30GB까지 무료) 등을 모두 해줍니다.

인스턴스 ID를 클릭을 통해 추가 셋팅을 해줍니다. 퍼블릭 IPv4 주소에 접근가능한다.

포트 개방

DataBase를 사용하기 위해 포트를 개방시켜줘야 합니다.

보안 > 보안그룹 > 인바운드 규칙 편집 > 규칙 추가에서 ICMP와 mySQL 포트 개방하기! 인바운드 : 외부에서 서버로 들어오는 신호를 허용할지 말지 결정하는 보안 규칙 ICMP : 서버가 정상적으로 동작되는지 확인하기 위해 Ping을 날리는 행위 0.0.0.0/0 : 어떠한 IP라도 접속 허용하겠다는 IP mysql 포트 : 3306

우분투 기본 세팅

apt 패키지 관리자 사용을 위한 업데이트 : sudo apt update vim 설치 : sudo apt install rdate vim -y

데이터 센싱을 원활하게 하기 위한 시간 세팅

LG U+ 타임 서버에서 시간 값 가져오기 : sudo rdate -s time.bora.net 서울로 셋팅 : sudo ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime

MYSQL 설치 및 세팅

MYSQL 설치 : sudo apt install mysql-server -y

관리자 계정 생성

sudo mysql use mysql; create user '아이디'@'%' identified with mysql_native_password by '비밀번호';

%는 어느 IP 접속 가능 with mysql_native_password는 키 인증 방식이 아닌 password 인증 방식을 사용하겠다는 의미

스키마 생성 및 권한 부여

스키마(엑셀 파일), Table(Sheet) 스키마 생성 : create database [DB스키마이름]; 모든 권한 부여 : grant all privileges on [DB스키마이름].* to '아이디'@'%';

테스트 및 추가 설정

quit으로 sql을 종료 후 mysql -u '아이디' -p을 통해 테스트하기 mysql을 ssh 뿐만 아니라 외부 접속도 가능케 하기 : sudo vi /etc/mysql/mysql.conf.d/mysqld.cnf에서 bind-address를 0.0.0.0으로 설정하기! 재시작하여 설정 내용 적용하기 : sudo service mysql restart

MYSQL 접속

MYSQL Workbench 설치후 +을 통해 계정 생성하기! 제목, AWS에서 생성한 IPv4 주소, 생성한 관리자 계정을 입력하여 접속 테스트 후 접속하기! 2개의 테이블을 생성할 것입니다. 클라우드 Sever로 부터 원격 조정기를 통해 보내온 명령어를 읽는 명령어 Table 과 RC Car가 센서로 부터 읽은 데이터를 클라우드 Server에 보낼 sensing Table을 생성합니다.

스키마 더블클릭하여 스키마에 접근 후 다음 SQL문을 입력하여 테이블 생성하기!

CREATE TABLE `command` (
    `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    `time` DATETIME NULL,
    `cmd_string` VARCHAR(50) NULL DEFAULT NULL,
    `arg_string` VARCHAR(50) NULL DEFAULT NULL,
    `is_finish` INT NULL
);

CREATE TABLE `sensing` (
    `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    `time` DATETIME NULL,
    `num1` DOUBLE NULL DEFAULT NULL,
    `num2` DOUBLE NULL DEFAULT NULL,
    `num3` DOUBLE NULL DEFAULT NULL,
    `meta_string` VARCHAR(50) NULL DEFAULT NULL,
    `is_finish` INT NULL
);

원격조정기

원격조정기를 통해 제어 명령어를 클라우드 서버에 전송하면, RC카가 해당 명령어를 읽어 들여 명령어에 맞게 작동되게 설계하였습니다.

개발 PC로 Windows 환경인 파이참에서 PySide6로 원격조정기를 개발합니다. 개발 및 Test가 완료 후에는 소스코드를 Raspberry Pi 에서 가져간 뒤, PySide2로 변경하여 App을 실행합니다.

Pyside 6 설치 및 셋팅

프로젝트를 하나 생성합니다. 폴더 경로에 한글이 포함되어있다면, 에러가 발생합니다.

파이썬에서는 외부 Library를 패키지라고 부릅니다. 먼저 PySide 패키지를 설치해봅시다. 설정에서 프로젝트 > 인터프리터 > 빈곳 더블클릭하면 됩니다. 여기서 pyside6 를 선택하고 “설치” 를 누르면 패키지 설치가 진행됩니다.

테스트

from PySide6.QtWidgets import *

app = QApplication()
btn = QPushButton("Test Button")
btn.show()
app.exec()

GUI 에디터 셋팅

PySide를 사용하여 GUI 개발을 하는데, 매번 venv > lib > site-package > pyside > designer.exe 를 수행하기에는 번거롭습니다.

바로가기 제작

따라서, 바로가기를 만들어 편리하게 pyside를 수행합시다.

설정 > 도구 > 외부도구에 + 버튼을 누릅니다.

이름, 프로그램(경로: 생성된 프로젝트 명 > venv > Lib > site-packages > PySide6 > desinger.exe) > 고급옵션(도구 출력용 콘솔 열기 끄기) > 확인

설정 완료 후 좌측 탭 빈곳에서 마우스 오른쪽 버튼 후 외부 도구에서 실행시키기

DB 패키지 설치

MySQL 공식 Connection 방법을 이용하여 DB와 Pyside 연결하기! 설정에서 프로젝트 > 인터프리터 > 빈곳 더블클릭하면 됩니다. 여기서 mysql-connector와 mysql-connector-python를 선택하고 “설치” 를 누르면 패키지 설치가 진행됩니다.

테스트

from PySide6.QtWidgets import *
import mysql.connector

db = mysql.connector.connect(host='AWS IPv4 주소', user='관리자 계정 아이디', password='관리자 계정 비밀번호', database='생성한 스키마명')
cur = db.cursor() # query의 결과를 저장하는 공간을 나타내는 Database 명령어

#query
cur.execute("select * from command")

#print : 생성한 행 이름에 맞게 설정
for (id, time, cmd_string, arg_string, is_finish) in cur:
    print(id, time, cmd_string, arg_string, is_finish)

cur.close()
db.close()

UI 제작

아까 만들어둔 desginer 바로가기를 통해 designer을 실행시킵니다. Main Window에서 PlainTextEdit과 Push Button 위젯을 생성해줍니다. PlainTextEdit의 객체명은 logText로 Push Button의 객체명은 startButton으로 설정해줍니다. 버튼 클릭시 start()라는 함수가 실행되도록 Signal & Slot을 연결해줍니다.

venv 폴더 밖 경로에 mainUI.ui 파일명으로 파일을 저장합니다.

바로가기 제작

ui 파일을 py로 convert 해줘야하는데, 이 또한 바로가기로 제작해봅니다!

설정 > 도구 > 외부도구에 + 버튼을 누릅니다.

이름, 프로그램(경로: 생성된 프로젝트 명 > venv > Scripts > pyside6-uic.exe),인수($FileDir$\mainUI.ui -o $FileDir$\mainUI.py) , 고급옵션(도구 출력용 콘솔 열기 끄기) > 확인

설정 완료 후 좌측 탭 빈곳에서 마우스 오른쪽 버튼 후 외부 도구에서 실행시키기

UI 테스트 코드

from PySide6.QtWidgets import *
from mainUI import Ui_MainWindow

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.init()

    def init(self):
        print("INIT")

    def start(self):
        print("START")

app = QApplication()
win = MyApp()
win.show()
app.exec()

Pyside6 - DB 연결 코드

from PySide6.QtWidgets import *
from mainUI import Ui_MainWindow
import mysql.connector

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.init()

    def init(self):
        self.db = mysql.connector.connect(host='AWS IPv4 주소', user='관리자 계정 아이디', password='관리자 계정 비밀번호', database='생성한 스키마명')
        self.cur = self.db.cursor()


    def start(self):
        self.cur.execute("select * from command")
        for (id, time, cmd_string, arg_string, is_finish) in self.cur:
            print(id, time, cmd_string, arg_string, is_finish)

    def closeEvent(self, event):
        self.cur.close()
        self.db.close()

app = QApplication()
win = MyApp()
win.show()
app.exec()

QTimer을 이용하여 반복적으로 Query하기

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from mainUI import Ui_MainWindow
import mysql.connector

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.init()

    def init(self):
        self.db = mysql.connector.connect(host='AWS IPv4 주소', user='관리자 계정 아이디', password='관리자 계정 비밀번호', database='생성한 스키마명')
        self.cur = self.db.cursor()

        #timer setting
        self.timer = QTimer()
        self.timer.setInterval(500) #500ms
        self.timer.timeout.connect(self.pollingQuery)

    def start(self):
        self.timer.start()

    def pollingQuery(self):
        self.cur.execute("select * from command")
        self.ui.logText.clear()
        for (id, time, cmd_string, arg_string, is_finish) in self.cur:
            str = "%d | %s | %6s | %6s | %4d" % (id, time.strftime("%Y%m%d %H:%M:%S"), cmd_string, arg_string, is_finish)
            self.ui.logText.appendPlainText(str)

    def closeEvent(self, event):
        self.cur.close()
        self.db.close()

app = QApplication()
win = MyApp()
win.show()
app.exec()

버튼 추가

logText의 font를 Consolas로 수정하기 Go(객체명: goButton, slot: go()), Back(객체명: backButton, slot: back()), Mid(객체명: midButton, slot: mid()), Left(객체명: leftButton, slot: left()), Right(객체명: rightButton, slot: right()), STOP(객체명: stopButton, slot: stop()) 추가하기

테스트

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from mainUI import Ui_MainWindow
import mysql.connector

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.init()

    def init(self):
        self.db = mysql.connector.connect(host='AWS IPv4 주소', user='관리자 계정 아이디', password='관리자 계정 비밀번호', database='생성한 스키마명')
        self.cur = self.db.cursor()

        #timer setting
        self.timer = QTimer()
        self.timer.setInterval(500) #500ms
        self.timer.timeout.connect(self.pollingQuery)

    def start(self):
        self.timer.start()

    def pollingQuery(self):
        self.cur.execute("select * from command")
        self.ui.logText.clear()
        for (id, time, cmd_string, arg_string, is_finish) in self.cur:
            str = "%d | %s | %6s | %6s | %4d" % (id, time.strftime("%Y%m%d %H:%M:%S"), cmd_string, arg_string, is_finish)
            self.ui.logText.appendPlainText(str)

    def closeEvent(self, event):
        self.cur.close()
        self.db.close()

    def insertCommand(self, cmd_string, arg_string):
        time = QDateTime().currentDateTime().toPython()
        is_finish = 0

        query = "insert into command(time, cmd_string, arg_string, is_finish) values (%s, %s, %s, %s)"
        value = (time, cmd_string, arg_string, is_finish)

        self.cur.execute(query, value)
        self.db.commit()

    def go(self):
        self.insertCommand("go", "5")

    def stop(self):
        self.insertCommand("stop", "0")

    def back(self):
        self.insertCommand("back", "0")

    def left(self):
        self.insertCommand("left", "0")

    def mid(self):
        self.insertCommand("mid", "0")

    def right(self):
        self.insertCommand("right", "0")

app = QApplication()
win = MyApp()
win.show()
app.exec()

Sensing Table 추가하기

logText를 객체명: sensingText, Font: Consolas로 추가합니다.

테스트

from PySide6.QtWidgets import *
from PySide6.QtCore import *
from mainUI import Ui_MainWindow
import mysql.connector

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.init()

    def init(self):
        self.db = mysql.connector.connect(host='AWS IPv4 주소', user='관리자 계정 아이디', password='관리자 계정 비밀번호', database='생성한 스키마명')
        self.cur = self.db.cursor()

        #timer setting
        self.timer = QTimer()
        self.timer.setInterval(500) #500ms
        self.timer.timeout.connect(self.pollingQuery)

    def start(self):
        self.timer.start()

    def pollingQuery(self):
        self.cur.execute("select * from command order by time desc limit 15")
        self.ui.logText.clear()
        for (id, time, cmd_string, arg_string, is_finish) in self.cur:
            str = "%d | %s | %6s | %6s | %4d" % (id, time.strftime("%Y%m%d %H:%M:%S"), cmd_string, arg_string, is_finish)
            self.ui.logText.appendPlainText(str)

        self.cur.execute("select * from sensing order by time desc limit 15")
        self.ui.sensingText.clear()
        for (id, time, num1, num2, num3, meta_string, is_finish) in self.cur:
            str = "%d | %s | %6s | %6s | %6s | %10s | %4d" % (id, time.strftime("%Y%m%d %H:%M:%S"), num1, num2, num3, meta_string, is_finish)
            self.ui.sensingText.appendPlainText(str)

    def closeEvent(self, event):
        self.cur.close()
        self.db.close()

    def insertCommand(self, cmd_string, arg_string):
        time = QDateTime().currentDateTime().toPython()
        is_finish = 0

        query = "insert into command(time, cmd_string, arg_string, is_finish) values (%s, %s, %s, %s)"
        value = (time, cmd_string, arg_string, is_finish)

        self.cur.execute(query, value)
        self.db.commit()

    def go(self):
        self.insertCommand("go", "0")

    def stop(self):
        self.insertCommand("stop", "0")

    def back(self):
        self.insertCommand("back", "0")

    def left(self):
        self.insertCommand("left", "0")

    def mid(self):
        self.insertCommand("mid", "0")

    def right(self):
        self.insertCommand("right", "0")

app = QApplication()
win = MyApp()
win.show()
app.exec()

셋팅

구글 클라우드 사이트에서 로그인 후 콘솔로 이동으로 이동하기

상단에서 프로젝트를 새로 생성하고, API 및 서비스에서 Cloud Speech-to-Text API를 사용하기

사용자 인증정보 탭 > 사용자인증 정보 만들기 - 서비스 계정 > 계정명 및 권한(소유자)로 설정 후 생성하기 > 생성된 계정 클릭 > 상단 탭 키 > 키 추가 > 새 키 만들기(JSON)를 통해 다운받기

다운 받은 키를 마이크가 달린 AR Class 보드 홈 디렉토리에 옮기기

export GOOGLE_APPLICATION_CREDENTIALS="/home/pi/xxxxxxx-xxxxxxxxx.json"를 통해 환경 변수 만들기

구글 클라우드 스피치 API 설치

우선 오류 발생을 방지하여 pip3 install --upgrade pip로 pip를 업그레이드 시킨다. pip3 install --use-deprecated=backtrack-on-build-failures google-cloud-speech를 통해 구글 클라우드 스피치 API 설치 참고) --use-deprecated=backtrack-on-build-failures 는 오류 발생시 이전 버전을 다운받는다는 설정

구글 클라우드 예제

구글 클라우드 스피치가 음성 데이터를 텍스트로 변환하는 방법

1. 짧은 음성 파일을 보내 한번에 응답을 받는 방법
2. 긴 음성 예제를 한번에 보내면 조각조각 응답 받는 방식
3. 실시간으로 연속적으로 보내고 받는 방법

   1. 짧은 음성 파일을 보내 한번에 응답을 받는 방법

   오디오 신호의 개념

   오디오 신호 : 아주 빠르게 변경되는 아날로그 신호 PCM(Pulse Code Modulation) : Sampling rate(얼마의 주기로 데이터를 확인할지), Bit depth(데이터 값을 얼마만큼 쪼갤지)를 통해 아날로그 신호를 디지털로 변환한다. 잘게 쪼갤수록 더 정교한 데이터를 전송할 수 있다.

코드

from google.cloud import speech
import io
# 사용할 파일 위치
local_file_path = '/home/pi/test.wav'

client = speech.SpeechClient()

# PCM 구성 : 해당 음성 데이터가 다음과 같이 구성되어 있어야 정상 작동한다.
config = speech.RecognitionConfig(
    encoding = speech.RecognitionConfig.AudioEncoding.LINEAR16, # 세로축(데이터)을 2의 16승 만큼 쪼갬
    sample_rate_hertz = 48000, # 가로축(시간)을 48000만큼 쪼갬
    language_code = "ko-KR"
)
with io.open(local_file_path, 'rb') as f:
    content = f.read()
audio = speech.RecognitionAudio(content=content)

# 한번에 음성 데이터를 보내고 변환된 모든 텍스트 데이터를 한번에 받는 함수로 오디오 파일의 구성을 파라미터로 보낸다.
response = client.recognize(config=config, audio=audio)

# response는 여러개의 대안으로 전송되어 오는데, 그 중 confidence가 가장 높은 것을 체택한다.
for result in response.results:
    print(f'Transcript: {result.alternatives[0].transcript}')

arecord -r48000 -fS16_LE -d10 -vv -c1 test.wav를 통해 데이터를 2의 16승만큼 쪼개고, 시간은 48000만큼 쪼개며, 10초동안 정상작동 되는지 보이고 채널은 mono로 제목을 test.wav로 녹음하겠다는 명령어

3. 실시간으로 연속적으로 보내고 받는 방법

구글 스피치는 시간에 따라 Response를 계속 받아서 스스로 피드백을 내리게 되며, is_final : true이라는 문구와 함께 보내오는 데이터가 완성된 문장임을 의미한다.

# transcribe_streaming_mic.py

import re # 정규표현식 모듈
import sys

from google.cloud import speech
import pyaudio  # 파이썬에서 오디오 입력 사용
import queue

# Audio recording parameters
RATE = 16000
CHUNK = int(RATE / 10)  

class MicrophoneStream(object):
    def __init__(self, rate, chunk):
        self._rate = rate
        self._chunk = chunk

        # Create a thread-safe buffer of audio data
        self._buff = queue.Queue()  # pyaudio가 전달해주는 데이터를 담을 큐 
        self.closed = True

    # 파이썬 context manager사용. 여기에서는 실행중 문제가 발생해도 오디오장치를 제대로 닫도록 할 수 있기 위함.
    def __enter__(self):
        self._audio_interface = pyaudio.PyAudio()   # 시작할 때 pyaudio 데이터 스트림 열림
        self._audio_stream = self._audio_interface.open( # pyaudio.open()은 pyaudio.Stream object를 리턴.
            format=pyaudio.paInt16, # 16bit 다이나믹 레인지
            channels=1,
            rate=self._rate,
            input=True,     
            frames_per_buffer=self._chunk,
            stream_callback=self._fill_buffer,  # pyaudio에서 한 블록의 데이터가 들어올 때 호출되는 콜백
        )

        self.closed = False

        return self

    def __exit__(self, type, value, traceback):
        self._audio_stream.stop_stream()
        self._audio_stream.close()
        self.closed = True
        self._buff.put(None)
        self._audio_interface.terminate()   # 끝날 때 반드시 pyaudio 스트림 닫도록 한다.

    def _fill_buffer(self, in_data, frame_count, time_info, status_flags):  # pyaudio.Stream에서 호출되는 콜백은 4개 매개변수 갖고, 2개값 리턴한다. pyaudio문서 참고.
        self._buff.put(in_data) # 큐에 데이터 추가
        return None, pyaudio.paContinue

    # 한 라운드의 루프마다 현재 버퍼의 내용을 모아서 byte-stream을 yield함.
    def generator(self):
        while not self.closed:
            # Use a blocking get() to ensure there's at least one chunk of
            # data, and stop iteration if the chunk is None, indicating the
            # end of the audio stream.
            chunk = self._buff.get()
            if chunk is None:
                return
            data = [chunk]

            # Now consume whatever other data's still buffered.
            while True:
                try:
                    chunk = self._buff.get(block=False)  # 가장 오래된 데이터부터 순차적으로 data[]에 추가함.
                    if chunk is None:
                        return
                    data.append(chunk)
                except queue.Empty: # 큐에 더이상 데이터가 없을 때까지
                    break

            yield b''.join(data) # byte-stream

# response  화면에 출력
def listen_print_loop(responses):
    num_chars_printed = 0
    for response in responses:
        if not response.results:
            continue

        # The `results` list is consecutive. For streaming, we only care about
        # the first result being considered, since once it's `is_final`, it
        # moves on to considering the next utterance.
        # 최종적인 결과값은 언제나 results[0]에 반영되므로 result[0]만 고려.
        result = response.results[0]
        if not result.alternatives:
            continue

        # 확실성 가장 높은 alternative의 해석
        transcript = result.alternatives[0].transcript

        # 완성된 문장이 intrim 문장보다 짧다면, 나머지 부분은 ' '으로 overwrite해 가려준다.
        overwrite_chars = ' ' * (num_chars_printed - len(transcript))   

        if not result.is_final: # 확정된 transcript가 아니라면,
            sys.stdout.write(transcript + overwrite_chars + '\r')   # '\r'로 줄바꿈은 하지 않고 맨 앞으로 돌아가 이전 문장위에 덧쓰도록 한다.
            sys.stdout.flush()

            num_chars_printed = len(transcript)

        else:   # 확정된 transcript라면
            print(transcript + overwrite_chars)

            # 문장중에 '명령끝'이라는 단어가 있다면 종료한다.
            if re.search(r'\b(명령 끝)\b', transcript, re.I):
                print('Exiting..')
                break

            num_chars_printed = 0


def main():
    # 한국말 사용
    language_code = 'ko-KR'  # a BCP-47 language tag

    client = speech.SpeechClient()
    config = speech.RecognitionConfig(
        encoding='LINEAR16', # enums.RecognitionConfig.AudioEncoding.LINEAR16
        sample_rate_hertz=RATE,
        max_alternatives=1, # 가장 가능성 높은 1개 alternative만 받음.
        language_code=language_code)
    streaming_config = speech.StreamingRecognitionConfig(
        config=config,
        interim_results=True) # 해석완료되지 않은(is_final=false) 중도값도 사용.

    with MicrophoneStream(RATE, CHUNK) as stream:   # 사운드 스트림 오브젝트 생성. 
                                                    # pyaudio가 terminate()되는 것을 보장하기 위해 python
                                                    # context manager  사용.
        audio_generator = stream.generator()
        requests = (speech.StreamingRecognizeRequest(audio_content=content)
                    for content in audio_generator) # 요청 생성

        responses = client.streaming_recognize(streaming_config, requests)  # 요청 전달 & 응답 가져옴
        listen_print_loop(responses)    # 결과 출력. requests, responses 모두 iterable object


if __name__ == '__main__':
    main()

Therading vs Asyncio

Threading

동시실행을 목적으로 사용한다.

import threading
import time

def sub_thread(start, end):
    for var in range(start, end):
        print(f'we ar in SUB: {var}')
        var += 1
        time.sleep(0.6)

# 서브 thread가 동작되는 함수로 thread 오브젝트 생성
t = threading.Thread(target = sub_thread, args = (0,100)) 
t.daemon = True # 데몬 Therad : main Thread 종료시 sub Thread 자동 종료

t.start() # thread 실행, 이후 메인 쓰레드와 서브 쓰레드의 동시 실행

for i in range(20):
    print("메인 쓰레디 실행중 ...")
    time.sleep(1)

Asyncio

시간 효율성을 목적으로 사용한다.

Blocking vs Non-Blocking

Blocking : 메모리로부터 긴 시간동안 데이터를 가져와야하는 작업때 CPU는 쉬고 있는다. Non-Blocing : 긴 시간이 필요한 작업의 응답을 기다리지 않고 다음 작업을 진행한다. blocking 방식

import time

def request1() :   # 시간이 오래걸리는 함수
    time.sleep(10)
    return time.perf_counter() # 프로그램 실행 시간을 반환

def request2() :
    time.sleep(5)
    return time.perf_counter()

def main():
    print("start")
    start_time = time.perf_counter()

    req1_time = request1() # 10초 걸리는 작업
    req2_time = request2() # 5초 걸리는 작업

    # print는 15초에 실행된다.
    print(f'req1 takes {req1_time - start_time}')
    print(f'req2 takes {req2_time - start_time}')

main() 

Non-blocking 방식 잠깐 멈춰서 다른 작업을 할 수 있는 작업이 정해져있다.

import time
import asyncio

async def request1():  # await 구문을 포함하므로 함수를 async화 해줘야한다.
    await asyncio.sleep(10) # time은 잠시 정지 기능이 지원한되므로, asyncio를 사용한다.
    return time.perf_counter()  # 프로그램 실행 시간을 반환

async def request2():
    await asyncio.sleep(5)
    return time.perf_counter()

 main도 async로 만들어줌
async def main():
    print("start")
    start_time = time.perf_counter()

    # event loop라고 작업을 멈추지 않고 원할하게 관리해주는 곳에 task 형태로 등록한다.
    req1_time = asyncio.create_task(request1())
    req2_time = asyncio.create_task(request2())

    await req1_time
    await req2_time

    # task에서의 return 값을 사용하기 위한 result
    print(f'req1 takes {req1_time.result() - start_time}')
    print(f'req2 takes {req2_time.result() - start_time}')

asyncio.run(main())

WebSocket 통신

HTTP 통신 : 요청과 응답이 반복 Socket 통신 : 연결이 되었다면 양방향 실시간 통신

websocket 통신 : 웹상에서도 tcp socket과 같이 실시간 양방향의 데이터 교환이 가능, 확장성 및 http의 보안성도 겸비하고 있다.

동작

서버와 클라이언트 모두 웹소켓 라이브러리 설치 : pip3 install websockets sever 코드

import asyncio # non-blocking방식으로 네트웍 통신하기 위해 asyncio 모듈 필요.
import websockets # websockets 모듈 임포트

async def hello(websocket, path): # 아래의 websockets.serve()에 의해 호출되는 함수
    while True:
        name = await websocket.recv()  # 데이터 받기
        print(f"{name}을 받았습니다.")    # 받은 데이터 출력

        greeting = f"Hello {name}!"
        await websocket.send(greeting)  # 데이터 보내기
        print(f"{greeting}을 보냈습니다.")    # 보낸 데이터 출력

async def main():
    # 웹소켓 서버를 만들고, hello 함수를 실행시킨다.
    server = await websockets.serve(hello, host="xxx.xx", port=5678) # 본인 서버 IP 주소
    await server.wait_closed() # 서버를 명시적으로 종료할 때까지 대기

asyncio.run(main())

client 코드

import asyncio # non-blocking방식으로 네트웍 통신하기 위해 asyncio 모듈 필요.
import websockets # websockets 모듈 임포트

async def hello(websocket, path): # 아래의 websockets.serve()에 의해 호출되는 함수
    while True:
        name = await websocket.recv()  # 데이터 받기
        print(f"{name}을 받았습니다.")    # 받은 데이터 출력

        greeting = f"Hello {name}!"
        await websocket.send(greeting)  # 데이터 보내기
        print(f"{greeting}을 보냈습니다.")    # 보낸 데이터 출력

async def main():
    # 웹소켓 서버를 만들고, hello 함수를 실행시킨다.
    server = await websockets.serve(hello, host="xxx.xx", port=5678) # 본인 서버 IP 주소
    await server.wait_closed() # 서버를 명시적으로 종료할 때까지 대기

asyncio.run(main())

재부팅시 설정 고정

IP 및 환경변수 및 부팅시 실행될 파일을 고정시켜보자!

IP 고정

ifconfig를 통해 본인 보드의 연결형태와 ip주소를 기록해둔 후, sudo vi /etc/dhcpcd.conf 명령어를 통해 static IP configuration 부분을 수정하자!

부팅시 실행할 파일 설정

부팅시 자동으로 가장 늦게 되는 파일은 .bashrc라는 파일입니다. 해당 파일에서 마지막 줄에 실행할 파일을 추가해주자! 수정이 가능하도록 백그라운드 실행으로 파일을 실행시켜보자! python3 [실행할 파일명]& : & => 백그라운드 실행

환경변수 고정

실행 파일들을 오류없이 실행시키기 위한 환경변수는 파일 실행 명령어 이전에 선언되어야 합니다. 따라서, 부팅시 제일 첫번째로 실행되는 파일인 /etc/profile에 환경변수를 선언해줄 것입니다. sudo vi /etc/profile에서 마지막 줄에 export GOOGLE_APPLICATION_CREDENTIALS="/home/pi/xxxxxxx-xxxxxxxxx.json"를 포함시키자!

AWS : 클라우드에서 Node 디바이스들을 관리해준다. 다른 디바이스 끼리 통신 중간다리 역할

AWS IoT Core : Core 로 부터 받은 데이터를 처리해주는 서비스로 IoT 디바이스를 AWS 에서 관리해준다.

AWS 세팅

AWS 홈페이지에서 IAM 사용자로 로그인합니다. IoT Core 서비스 검색 후 실행 관리 > 사물 > 사물생성 > 단일 사물 생성 > 사물이름 입력 > 인증서 자동 생성 > 정책 생성 > 정책 이름, 정책 효과 : 허용, 정책 작업/정책 리소스 : * > 생성된 정책으로 사물 생성 > 인증서 및 키 다운로드

보안 > 인증서 > 인증서 클릭후 작업 > 정책연결 > 알맞은 정책과 연결하기 인증서 클릭후 작업 > 사물연결 > 알맞은 사물과 연결하기

설정 > 엔드포인트의 ARN 정보를 복사해두자!

ARN(Amazon Resource Name) : 리소스를 유일하게 식별하는 이름

AWS & Node-red 연동

mqtt-out을 더블클릭하여 설정해주자! 서버 새로 만들기 > 서버 : ARN 포트 : 8883, 사용 TLS 클릭 후 연필 > 인증서, 비밀기(private), CA인증서(CA1) 추가하고 변경 후 완료하기

IoT 연결을 시각화 도구로 연결가능한 개발 도구로 자바스크립트 언어를 지원, 플로 flow는 JSON 으로 저장한다. Node.js를 설치해두어야 한다.

Node-RED 설치

npm install -g node-red를 cmd창에 입력하여 설치한다. 그 후 node-red를 통해 실행시켜보자! 그 후 브라우저 창에 http://127.0.0.1:1880로 접속해보자!

Dash board

Dashboard 란?

Dashboard : 하나의 화면에 다양한 정보를 중앙 집중적으로 관리하고 찾을 수 있도록 하는 사용자 인터페이스 (UI) 기능을 포함하는 보드

설치

cmd 창에 npm install -g node-red-dashboard를 통해 dashboard 메뉴 추가합니다

MQTT(Message Queing Telemetry Transport) : 서버로 데이터를 보낼때 자주 사용하는 프로토콜이다. 임베디드에서의 저성능 환경에서 작은 기기들이 지연 및 손실을 방지하는 안정적인 통신이 가능토록 하는 프로토콜

특징

실시간, 최소 전력, 신뢰성 있는 비동기적 메시징 방식, 다중 접속을 지원한다. 발행 구독 패턴 : 발행(Publish), 구독(Subscribe) 패턴의 TCP/IP 기반 경량 메시지 프로토콜

• 발행자 : 센서노드 - 중개자로 데이터 전송한다.
• 구독자 : 중개자를 통해서 데이터를 받는다.
• 중개자 : 센서노드에서 주기적으로 데이터를 저장한다. ex) Mosquitto

QoS : Quality of Service로 메세지 전달 방식의 품질을 결정한다.

주제

주제는 무엇이든 가능하며, 계층적으로 나타낼수 있다. /를 이용하여 레벨별 표현 가능하다.

1. 단일 레벨 : +
2. 다중 레벨 : #

Mosquitto

중재자 서버 역할을 하는 프로그램 설치에서 윈도우 버전 다운받기!

고급 시스템 설정 > 고급 > 환경변수 > 시스템 변수에서 Path > 추가 후 C:\Program Files\mosquitto 붙여넣기

작업관리자 > 서비스 > mosquitto를 중지됨 -> 시작 으로 변경

실습

구독부터 하고 발행을 해야 구독한 사람이 받을 수 있다. 발행자 : mosquitto_pub -t "myhome/firstfloor/livingroom/temperature" -m 23.4 구독자 : mosquitto_sub -t "myhome/firstfloor/livingroom/temperature"

주제 구조를 변경하여 다른 구독자에게 데이터를 전송할 수 있다.

주제 작성 팁

선행 슬래시 사용 x 공백 사용 x 주제는 짧고 간결하게 ASCll 문자만 사용 한글 x

와일드 카드

+와 #을 활용해보자! #은 항상 끝에서만 사용가능하다.

와일드 카드는 구독자 입장에서 사용가능하다.

+ : 단일레벨 - 1개의 주제를 대체한다. 구독자 : mosquitto_sub -t "myhome/firstfloor/+/temperature" 발행자 : mosquitto_pub -t "myhome/firstfloor/livingroom/temperature" -m 23.4

가능 : mosquitto_pub -t "myhome/firstfloor/kitchen/temperature" -m 23.4 불가능

mosquitto_pub -t "myhome/firstfloor/livingroom/brightness" -m 23.4
mosquitto_pub -t "myhome/secondfloor/livingroom/temperature" -m 23.4
mosquitto_pub -t "myhome/firstfloor/kitchen/livingroom/temperature" -m 23.4

# : 다중레벨 - 하위의 모든 주제를 포함한다. 구독자 : mosquitto_sub -t "myhome/firstfloor/#" 발행자 : mosquitto_pub -t "myhome/firstfloor/livingroom/temperature" -m 23.4

가능 :

mosquitto_pub -t "myhome/firstfloor/kitchen/temperature" -m 23.4
mosquitto_pub -t "myhome/firstfloor/livingroom" -m 23.4

불가능 : mosquitto_pub -t "myhome/secondfloor/kitchen/temperature" -m 23.4

라즈베리파이 - Mosquitto

라즈베리파이 터미널 창에 sudo apt install mosquitto를 통해 모스키토를 설치하자! sudo apt install mosquitto-clients : 브로커 동작 테스트 프로그램 설치

데이터 구독 빛 발행 명령어가 윈도우와는 살짝 다르다.

명령어

구독 : mosquitto_sub -t "everland/animals/tiger" -h 127.0.0.1 발행 : mosquitto_pub -t everland/animals/tiger" -h 127.0.0.1 -m aaa

-h는 IP주소로 동일한 PC에서 테스트하는거면 생략 해도 정상 작동한다.

발행 입장에서 -m 옵션 대신 -l 옵션을 주면 채팅형식으로 계속 데이터를 전송할 수 있다.

윈도우를 브로커로 사용하기

1. 워드패드를 관리자 권환으로 실행 후 > mosquitto.conf 파일 열기 > 맨 하단에 다음 두줄 추가

   bind_address [본인 IP] => ip는 cmd > ipconfig를 통해 확인하기 
   allow_anonymous true

2. 윈도우 검색 > 고급 보안이 포함된 ~ > 인바운드 규칙 > 새규칙 > 포트 > 특정 포트 > 1883 > 이름 : mosquitto로 설정

3. cd / > cd "Program Files" /mosquitto > mosquitto -c mosquitto.conf -v로 mosquitto 서버 실행시키기

구독 발행 명령어

구독 : mosquitto_sub -h [설정한 브로커 IP] -t "test" -p 1883 발행 : mosquitto_pub -h [설정한 브로커 IP] -t "test" -m hello -p 1883

브로커 서버를 살펴보면, 데이터 용량도 끝에 같이 표시된다.

ESP를 발행자로 사용하기

아두이노 IDE의 라이브러리 관리자에서 espmqttclient 설치 , install all

아두이노 IDE에서 해당 코드에서 ssid, pw, ip등을 변경하여 업로드 해보기

#include "EspMQTTClient.h"

EspMQTTClient client(
  "본인 ssid",
  "본인 pw",
  "브로커 IP",   // MQTT Broker server ip
  "MQTTUsername",   // Can be omitted if not needed
  "MQTTPassword",   // Can be omitted if not needed
  "TestClient",     // Client name that uniquely identify your device
  1883              // The MQTT port, default to 1883. this line can be omitted
);

int abc = 10;

void setup() {
  Serial.begin(9600);
  client.enableDebuggingMessages(); // Enable debugging messages sent to serial output
  client.enableHTTPWebUpdater(); // Enable the web updater. User and password default to values of MQTTUsername and MQTTPassword. These can be overrited with enableHTTPWebUpdater("user", "password").
  client.enableLastWillMessage("TestClient/lastwill", "I am going offline");  // You can activate the retain flag by setting the third parameter to true
}

// This function is called once everything is connected (Wifi and MQTT)
// WARNING : YOU MUST IMPLEMENT IT IF YOU USE EspMQTTClient
void onConnectionEstablished() {
  // Subscribe to "mytopic/test" and display received message to Serial
  client.subscribe("mytopic/test", [](const String & payload) { Serial.println(payload); });

  // Subscribe to "mytopic/wildcardtest/#" and display received message to Serial
  client.subscribe("mytopic/wildcardtest/#", [](const String & topic, const String & payload) { Serial.println(topic + ": " + payload); });

  // Publish a message to "mytopic/test"
  client.publish("mytopic/test", "This is a message"); // You can activate the retain flag by setting the third parameter to true

  // Execute delayed instructions
  client.executeDelayed(5 * 1000, []() { client.publish("mytopic/test", "This is a message sent 5 seconds later"); });
}

void loop() {



  client.loop();

  // You can activate the retain flag by setting the third parameter to true  
  client.publish("mytopic/test", String(abc));

  abc++;

  delay(2000);
}

cmd 창에서 mosquitto_sub -h [브로커 IP] -t "mytopic/test" -p 1883로 구독하기

라즈베리파이를 중재자로 사용하기

sudo vi /etc/mosquitto/mosquitto.conf에서 하단에 다음 두줄 추가

port 1883
allow_anonymous true

ps -ef | grep mosquitto 에서 확인한 id(앞)을 기억하여 sudo kill [id] 후 sudo mosquitto -v를 통해 키자!

ThingSpeak는 클라우드 기반으로 동작되는 데이터 분석 솔류션이다. 채널생성 및 필드 생성하기 API Keys 탭에서 Write Key 복사하기 channel settings에서 channel ID도 복사하기

아두이노 IDE 라이브러리 매니저에서 thingspeak 설치 예제 > thingspeak > esp32 > writesinglefield 예제 띄우기

ssid, pw, channel ID, write API key를 헤더에 입력하여 esp32에 업로드 시켜보면, 웹사이트에서 그래프가 20초마다 생길 것이다.

delay(20000) - 20초보다 짧게 주면 돈을 더 줘야하기 때문에, delay(20000)으로 고정하자!

Firebase

Firebase : 구글에서 제공하는 플랫폼 서비스로 Cloud Database 구축 용도이다. 개발자가 OS 에 관계없이 앱을 만들수 있으며 앱에서 필요로 하는 기능을 API 형태로 제공한다.

프로젝트 생성 후 빌드 > Firestor Database로 이동후 데이터베이스 만들기 > 테스트 모드에서 시작 으로 데이터베이스 생성하기 빌드 > Realtime Database > DB 만들기 > 테스트 모드로 생성하기 생성한 Realtime Database의 주소 복사하기 프로젝트 설정 > 서비스 계정 > DB 비밀번호에서 비밀번호 복사하기

아두이노 IDE 라이브러리 매니저에서 Firebase ESP 32 Client 설치 예제 > Firebase ESP 32 Client > esp32 > writesinglefield 예제 띄우기

#include <WiFi.h>
#include <FirebaseESP32.h>

#define FIREBASE_HOST "haha"       // 데이터베이스 주소
#define FIREBASE_AUTH "hoho"    // 데이터베이스 키

FirebaseData firebaseData;
FirebaseJson json;

#define WIFI_SSID "huhu"
#define WIFI_PASSWORD "hehe"

void setup()
{
  Serial.begin(115200);

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  Serial.print("Connected with IP: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  Serial.printf("Firebase Client v%s\n\n", FIREBASE_CLIENT_VERSION);
  Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
}

void loop()
{
    String str= "hello world!";

    json.set("payload", str);
    Firebase.pushJSON(firebaseData, "/response", json); // 보내기, 송신
    Serial.println("PATH: " + firebaseData.dataPath());
    Serial.println("PUSH NAME: " + firebaseData.pushName());    

    delay(2000);
}

TCP/IP 테스트 프로그램 설치 해당 프로그램은 서버에 다중 클라이언트 접속이 안된다.

cmd > ipconfig > 이더넷의 IPv4 주소 확인

다운 받은 프로그램에는 서버와 클라이언트로 나누어지는데, 서버 킨 후 확인한 IP는 클라이언트 주소에 입력한다. 서버에서 설정한 포트를 클라이언트에서 동일시하게 맞춰줘야 연결이 된다. text등이 정상적으로 보내진다면, 연결성공이다!

아두이노 IDE에서 예제 > WIFI > WIFICLINET 에서 ssid, pw, host 주소, 포트 등을 수정하여 설치한 프로그램에서 작동시킨 서버와 연결시켜보자!

라즈베리파이를 서버로

다중 접속을 위해, 라즈베리파이에 웹서버를 열어서 접속한다. 기존에 제작한 웹소켓 코드를 이용하여 빌드해보자! gcc ./chat_serv.c -D_REENTRANT -o ./cserv -lpthread 후 ./cserv 6000을 통해 서버 열기

데이터 관리

임베디드에서 데이터 전송은 EOF, SOF 를 같이 보내면 데이터가 깨지지 않는다. 데이터의 특성에 따라 물리적 저장 장치를 선택하는것이 좋다.

고속용 : SRAM
고속동작 X, 대용량 : Nand Flash, SD CARD 소용량, 영구저장, 고속 x : 내부 EEPROM

IoT(Internet of Things) : 각종 사물에 센서와 무선 통신 기능을 내장하여 인터넷에 연결하는 기술

활용 사례 : 홈 IoT, 스마트 팜, 웨어러블 단점 : 인터넷 보안 위험, 정전시 동작 오류 해결책 : 안정적인 IoT 서버, 보안강화

ESP32 보드

사용할 보드 : ESP32 모든 보드가 센서 노드가 될수 있지만 , IoT 를 위해서라면 어찌됐든지 간에 통신 기능이 있어야 한는데 ESP32는 무선통신인 Wi-Fi 및 BLE를 지원한다.

보드 테스트

윈도우용 스케치 프로그램(아두이노) 다운

내부 LED 테스트 코드

void setup() {  // 1회성 호출 - init 함수 역할
  pinMode(LED_BUILTIN, OUTPUT); // 출력으로 설정
}

void loop() {  // while과 같은 무한 루프
  digitalWrite(LED_BUILTIN, HIGH); // LED 켜기
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW); // LED 끄기
  delay(1000);
}

ESP32는 아두이노에서 공식적으로 지원하는 보드가 아니기 때문에, 보드를 따로 지정해줘야한다.

보드 지정

파일 > 환경설정 > 추가적인 보드 매니저 URLS에 https://dl.espressif.com/dl/package_esp32_index.json추가하기

툴 > 보드 > 보드 매니저 > esp32 겁색 후 설치

툴> 보드 > ESP32 Arduino > Node32S 선택과 장치관리자에서 확인한 포트를 알맞게 설정 후 코드를 빌드 및 업로드를 해보면, 파란색 LED가 깜빡일 것입니다.

빌드 단축키 : Crtl + R , 업로드 단축키 : Crtl + U

예전 버전의 ESP32

다음 이미지와 동일한 ESP32 보드를 사용한다면, 업로드할때 오류가 발생한다. 해결책으로는 예전 버전의 ESP32에 업로드 할 때에는 로그 발생시 IO0버튼을 3초간 눌러줘야 한다.

외부 I/O 연결하기

PWM

모든 핀이 PWM을 지원하지 않는다. 데이터 시트를 확인해보자

웹서버 제작

ESP32로 웹서버도 제작할 수 있습니다. 파일 > 예제 > Webserver > HelloSever 코드에서 본인의 SSID와 PW를 입력하여 웹서버에 접속할 수 있습니다. 하단에 함수를 수정하여 API를 통해 추가적인 결과를 얻을 수 있습니다. 웹사이트 이미지 URL을 통해 이미지 삽입 또한 가능하다.

나사산의 크기는 직경의 크기와 비례된다. 나사산은 범용적으로 쓰이기 의해 직경의 크기에 비례하여 고정되었다. 같은 직경의 크기의 나사의 모든 나사산은 동일하다.

나사 머리 모양

체결하려는 장소에 따라 사용하는 머리 모양이 달라집니다. 접시머리 나사는 홈이 나있는 곳에 써서 체결 시 튀어나오지 않아 평평하게 체결하기 위해 쓴다.

큰기어

큰기어 -> 작은기어 : 속도를 높인다. 1바퀴 -> 3바퀴 : 힘이 1/3로 줄어들지만, 3배 만큼 속도가 높아진다.

키 : 축과 기어가 같이 돌어가게 고정시키는 나사 구멍

베어링

베어링 : 안쪽 원과 바깥 쪽 원 사이에 구슬같은 회전에 용이하게 하는 것이 포함되어 있다.

조향장치(핸들)

서보모터를 통해 조향장치를 구현할 것입니다. 포텐셜모터가 엔코더 역할을 한다. 180도 범위를 갖는다.

너클

바퀴의 방향을 바꾸는 역할

충전형 배터리

18650 : 직경 18mm 길이 650mm 3.6V 2600mAh 리튬 이온 배터리 3개를 연결해서 11.8v로 약 12v를 전원어탭터에 전원을 인가합니다. 전원 어댑터에 인가된 전압은 라즈베리파이와 모터 드라이버에 각각 5V씩 인가된다.

모터 드라이버

모터 드라이버 사용 이유

라즈베리파이에서 공급할 수 있는 전류는 너무 한정되어있다. 하지만, 차량용 모터를 동작시키기 위해서는 전류가 턱없이 부족합니다. 또한, DC모터를 역으로 회전시키기위해서 배선을 일일히 바꿔줘야하는 번거롭습니다.

I2C 통신 연결

모터 드라이버와 라즈베리파이를 I2C을 통해 연결합니다.

I2C란?

I2C는 여러 장치를 동시에 연결하여 제어할 수 있지만, 장치 구분 및 송수신 판별로 인해 속도 및 효율이 떨어진다. 클럭과 데이터 전송 선만으로 연결이 가능할만큼 단순하다. 장치 구분을 위해 각 Slave마다 주소를 갖는다. 데이터에 주소가 실린다.

sudo i2cdetect -y 1 명령어를 통해 사용할 모터드라이버의 주소는0x6f임을 확인할 수 있다.

I2C 설정 및 설치

sudo raspi-config 명령어를 통해 설정창을 열고, interface options > i2c >켜기로 I2C를 가능토록 설정합니다.

모터드라이버 라이브러리 설치 : wget http://wiki.geekworm.com/images/a/ac/Raspi-MotorHAT-python3.zip 압축해제 : unzip Raspi-MotorHAT-python3.zip

cd Raspi-MotorHAT-python3를 통해 확인해보자! test 예제를 제외한 필수적인 라이브러리를 홈 디렉토리로 옮겨준다. => cp Raspi_* ~/

파이썬에서 I2C를 사용하기 위한 툴 설치 : sudo apt-get install python-smbus i2c-tools

RC카 이동 코드

DC 모터 제어 : 이동 제어

# motor move
from Raspi_MotorHAT import Raspi_MotorHAT, Raspi_DCMotor

mh = Raspi_MotorHAT(addr = 0x6f)
motor = mh.getMotor(2)  # because of dc motor connected with M2

try:
    while True:
        motor.setSpeed(125) # speed limit : 0~255
        motor.run(Raspi_MotorHAT.FORWARD) # FORWARD
        # motor.run(Raspi_MotorHAT.BACKWARD) # BACKWARD

finally: 
    motor.run(Raspi_MotorHAT.RELEASE) # STOP

PWM 제어

디지털 신호를 강약으로 나타내는 방법

Servo 제어

Pulse의 폭에 따라 특정 각도로 움직인다.

코드

Servo 모터 제어 : 방향 제어

# servo motor control
from Raspi_MotorHAT import Raspi_MotorHAT

mh = Raspi_MotorHAT(0x6F) # motor-HAT i2c address
servo = mh._pwm

servo.setPWMFreq(60) # 사용할 서보모터의 주파수

# because of sevro motor is connected with #1
# 1주기 2^12 = 4096
# 0degree = 200, 90degree = 400, 180degree = 600 
servo.setPWM(1, 0, 400)  # 3개의 파라미터 : 장치번호, 시작, 끝

Bootloader 란

Bootloader: 부팅시 운영체제 사용되기 이전에 동작되는 프로그램으로 Disk 에 저장되어 있는 운영체제를 실행 시키는 역할 커널이 동작되기 전 준비를 마치고, 커널을 메모리에 적재 후 제어권을 넘기는 프로그램이므로, 메모리 직접 접근이 가능하다. 부트 스트랩 로더 ” 를 줄여 부트스트랩 or 부트로더 라고 한다. 라즈베리파이는 자체 부트로더 사용 중이다.

리눅스에서는 U-Boot이라는 부트로더를 사용한다.

수행 기능

1. 다중 OS 부팅 기능
2. 장치 제어 및 테스트 기능

Kernel Image

Image : 램에 그대로 올라가면 실행 가능해지도록 만들어진 Binary File Linux Kernel Image : 리눅스 소스코드를 빌드 후 , 즉시 램에 올라가면 동작되도록 만들어진 Binary File

리눅스 커널 이미지는 압축되어 관리된다. 부트로더가 압축을 풀어 메모리에 적재한다

커널 이미지 종류

1. zImage : gzip 으로 압축된 Kernel Image
2. bzImage : 빅 zImage, 파일 크기(약 1MB 이상)가 큰 Kernel Image 를 뜻함

Vim-bootstrap

설치 가이드 파일 다운 사이트 : 대표적인 vim 설정 파일 vim 설정 파일 vimrc에 복붙 후 vi를 통해 설치하자!

라즈베리파이에서 사용가능하기 위해서는 snippets 부분을 삭제해주면 에러없이 사용가능하다.

CMOS(하드웨어)

CMOS Chipset : 메모리 크기, 부팅순서, HW 구성 정보 등과 같은 CMOS Data(설정값)를 저장한다.

BIOS(프로그램)

BIOS : 기본적인 I/O 를 위한 Firmware (Basic I/O System), 컴퓨터 부팅시 바로 BIOS(Firmware) 가 동작을 시작한다. CMOS의 설정값들을 변경 가능하다

POST

POST(Power-on Self-Test) : BIOS에서 Power 를 켜자마자 주변장치들을 검사하는 과정으로 Log Message 가 출력된다.

UEFI

UEFI(유이파이) : Unified Extensible Firmware Interface로 BIOS 를 대체하는 그래픽 화려한 Firmware이다. 2.2TB 이상 디스크 사용을 위한 GPT 지원을 한다.

GPT : GUID 파티션 테이블로 2.2TB 이상 디스크 사용을 지원한다.

GRUB2

GRUB2 : 리눅스 배포판(우분투)에서 가장 자주 사용하는 GUI 부트로더

U-BOOT

U-Boot(Universal Boot Loader) : ARM(임베디드)에서 리눅스를 쓸 때 가장 자주 사용하는 부트로더로 USB, TCP/IP, Flash 제어 가능하다.

임베디드 부팅 순서

• 0, 1 단계 : 칩셋 사 제공, 제어권을 넘긴다.
• 2 단계 : Bootloader (u-boot) : 메모리 직접 접근하여 장치 테스트 가능, 리눅스 커널을 적재하여 리눅스 부팅
• Linux Kernel 실행

GRUB 다루기

cd /etc/default에서 grub을 sudo vi로 열고 내용 살짝 바꾸기 style = menu를 변경하여 메뉴창을 띄우고, 10초동안 키 입력 없을 시 넘어가는 설정 sudo update-grub을 통해 수정 사항 저장시키면 /boot/grup 경로에 grup.cfg라는 환경설정 파일이 생성된다.

추가 명령어

sudo reboot를 통해 GRUB을 실행시킬 수 있다. GRUB이 실행된 후 입력을 가하면 다음 스텝으로 넘어가지 않고 고정된다. e : grub.cnf 내용 확인 c : command모드로 진입

Command 모드

help : 내가 사용가능한 명령어 리스트 출력, Sroll 기능이 작동하지 않아 짤리는 부분은 확인하지 못한다. set pager=1을 입력후 help명령어를 입력해보면 짤리는 부분도 page down으로 확인가능하다.

해상도 변경하기

sudo vi /etc/default/grub에서 GRUB_GFXMODE=1024x768로 주석을 풀고 변경해준다. sudo update-grub 후 sudo reboot해준다.

파일 시스템 탐색

cat /boot/grub/grub.cfg을 통해 파일 열기 가능, ls 명령어도 사용가능

직접 메모리에 접근

부트로더이기 때문에, 직접 메모리 접근 가능하다. 쓰기 : write_byte 0x0000 1 읽기 : read_byte 0x0000 => 0x1

SSH(무선) vs UART(serial,유선)

SSH : 랜카드 없으면 접근 불가능, 부팅 이후에 접근 가능하기 때문에 부트로더 제어 불가능 UART : 개발하기 불편할 정도로 느림

U-Boot 실습

우선적으로, 라즈베리파이의 Serial Enable로 설정 후 해당 드라이버를 윈도우에 설치해줘야합니다. 전원을 끊고, 라즈베리파이와 : FT232BL 기기와 핀맵을 통해 연결합니다. 5V 연결 GND 연결 RX 는 TX 에 연결하기 TX 는 RX 에 연결하기

그 후, 전원을 가하고, PC와 FT232BL 기기와 연결합니다.

Mobaxterm에서 세션을 생성합니다. 그 후 아이디와 비밀번호는 모두 라즈베리파이 기본 ID : pi, pw : raspberry 로 입력합니다.

설치

1. U-boot 빌드를 위한 필수 도구 설치 sudo apt install git vim gcc bc bison flex libssl-dev make libc6-dev libncurses5-dev crossbuild-essential-armhf

2. u-boot 소스코드 다운로드 git clone https://github.com/u-boot/u-boot.git

3. config 파일 수정 cd u-boot/ 후 sudo vi config.mk파일에 CROSS_COMPILE := arm-linux-gnueabihf- 변수를 추가한다.

4. .config 파일 생성 sudo make rpi_4_32b_defconfig를 입력한다.

make menuconfig로 편리하기 수정할 수 있는 창을 띄울 수 있다.

5. make로 빌드하기 -> u-boot.bin 파일생성 sudo make -j4 : 라즈베리파이 코어가 4개이므로 j4 사용

6. 복사 sudo cp u-boot.bin /boot

cd /boot에서 u-boot.bin이 있음을 확인해보자!

7. /boot 경로 내에 config.txt 수정 sudo vi config.txt에서 마지막 줄에 kernel=u-boot.bin를 추가하고 저장!

8. 재부팅후 uart로 키기!

U-Boot Command

1. echo : 입력한 값이 그대로 출력된다. enter을 계속 입력하면, 최근에 실행한 명령어가 실행된다.

2. printenv : 환경변수들을 모두 출력한다. 변수 이름을 출력하려면 ${변수} 입력하면 된다. botcmd 변수 : 특정 시간까지 입력이 되지 않으면 수행할 명령어들의 모음

3. ls 장치이름 [device 번호 ]]: 파티션 ] 경로 명령어 : ls mmc 0:1 / 특정 장치의 파일 내용을 볼 수 있다.

4. mmc 명령어 : Disk 제어 , R/W/Erase 가능

• md 메모리 출력
• nm : 메모리 수정

dtb

보드에 대한 HW 정보들을 Linux 커널에 전달하는 방법으로 u-boot에 의해 메모리에 Load 되어 Linux 커널에 전달되므로 상세 사항을 Linux 커널에 하드코딩할 필요 없다.

app단에서 사용하는 헤더를 커널형으로 변환해서 사용할 수 있다.

#include <string.h> => #include <linux/string.h> 와 같이 변경해서 사용하면, app에서 사용한 라이버러리와 동일하게 사용가능하다.

모듈 파라미터

insmod를 통해 원하는 파라미터를 집어넣을 수 있다. kernel.c

static char *whom = "world";
static int num = 1;    
module_param(num, int, S_IRUGO);    // 숫자형 변수에 파라미터를 받을 수 있다.
module_param(whom, charp, S_IRUGO);   // 문자형 변수에 파라미터를 받을 수 있다.

insmod kernel c 100 0 num=10 whom = "Jaehoon"으로 파라미터 받기!

GPIO 핀을 사용할때 메모리맵에 쉽게 접근하는 API

커널에서 사용 가능하며, GPIO에 쉽게 접근 가능한 API 헤더파일 : #include <linux/gpio.h> 사용 API : gpio_direction_output(번호, 0) gpio_set_value(번호, 0 또는 1)

Interrupt

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <signal.h>

void go_alert(int signum)
{
    for(int i=0; i<5; i++)
    {
        printf("WARNING!!\n");
    }

}

int main()
{
    signal(SIGIO, go_alert);

    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDWR);
    if (fd == -1) {
        printf("FILE OPEN ERROR!!!\n");
        close(fd);
        return 0;
    }

    int pid = getpid();
    ioctl(fd, _IO(0,4), pid);

    while(1)
    {
        ioctl(fd, _IO(0,3), 0);
        usleep(300 * 1000);
    }


    // ioctl(fd, _IO(0, 3), 0);
    // ioctl(fd, _IO(0, 4), 0);

    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

kernel.c

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100

MODULE_LICENSE("GPL");

static uint32_t *BASE, *GPSEL2;
static uint32_t *GPIO_PUP_PDN_CNTRL_REG1;
static uint32_t *GPLEV0;

static int irq_num;
static int app_pid;

static struct kernel_siginfo sig_info;
static struct task_struct *task;

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

static long nobrand_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int lev;
    switch (cmd)
    {
        case _IO(0, 3) :
            printk(KERN_INFO "IO 3\n");
            lev = (*GPLEV0 >> 21) & 0x1;
            printk( KERN_INFO "GPIO21 LEV = %d\n", lev);
            break;
        case _IO(0, 4) :
            printk(KERN_INFO "IO 4\n");
            app_pid = (int)arg;
            break;
    }

    printk( KERN_ALERT "%d\n", cmd);
    return 0;
}
static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .unlocked_ioctl = nobrand_ioctl
};

static irqreturn_t lets_go(int irq, void *data)
{
    printk( KERN_ALERT "IT's ME\n");

    if(app_pid > 0)
    {
        sig_info.si_signo = SIGIO;
        task = pid_task(find_vpid(app_pid), PIDTYPE_PID); // task 변수에 pid 정보 집어넣기
        send_sig_info(SIGIO, &sig_info, task); // 신호를 app에 보낸다.
    }

    return IRQ_HANDLED;
}

static int nobrand_init(void) {

    int ret;

    BASE = (uint32_t *)ioremap(0xFE200000, 256);

    GPSEL2 = BASE + (0x08 / 4);
    *GPSEL2 = *GPSEL2 & ~(0x7 << 3);

    GPIO_PUP_PDN_CNTRL_REG1 = BASE + (0xe8 / 4);
    *GPIO_PUP_PDN_CNTRL_REG1 &= ~(0x3 << 10);
    *GPIO_PUP_PDN_CNTRL_REG1 |= (0x1 << 10);

    GPLEV0 = BASE + (0x34 / 4);

    irq_num = gpio_to_irq(21); // 21번의 interrupt 감시
    // 버튼을 땔 때 lets_go라는 함수 콜백한다.
    ret = request_irq(irq_num, lets_go, IRQF_TRIGGER_RISING, "interrupt", NULL);

    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    return 0;
}

static void nobrand_exit(void) {
    free_irq(irq_num, NULL);
    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}

module_init(nobrand_init);
module_exit(nobrand_exit);

ioctl : short for Input Output Control ioctl(fd, cmd, argument) : 3 개의 파라미터

1. File descriptor
2. cmd : 구분자
3. argument : 추가 정보

CMD

CMD 구성 : 약속된 cmd 변수의 비트 단위 Format 하지만, 비트 연산하기 번거로워 Kernel 이 제공하는 Macro 함수를 사용하자! Macro 함수 : _IO(type, number) => type : 매직넘버 , number : 구분번호

ex) ioctl(fd, 3, 0) => ioctl(fd, _IO(3,0), 0)

커널 로그 레벨

커널 로그에 나타나는 메세지 색상을 바꿔줄 수 있다.

값 송수신

유저 스페이스 주소 커널에서 쓰면 위험하다

app에서 데이터 전달

char buf[10] = "Hi Jaehoon";
ioctl(fd, _IO(0, 3), buf);

커널에서 데이터 수신

char *buf = (char *)arg;
printfk (KERN_INFO, "%s\n", buf);

커널 스페이스에서 유저 스페이스의 주소값을 건드리기 때문에 위험하다. 커널 패닉(=블루 스크린) 이 발생할 위험이 있다.

값 복사

따라서, 보내오는 데이터를 복사 하여, 주소를 건드리지 않는 방법으로 사용해야한다. copy_to_user와 copy_from_user을 사용한다.

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

int main()
{
    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDWR);
    if (fd == -1) {
        printf("FILE OPEN ERROR!!!\n");
        close(fd);
        return 0;
    }

    char buf[10] = "HI Jaehoon";

    ioctl(fd, _IO(0, 3), buf); // kernel에 데이터 전송
    ioctl(fd, _IO(0, 4), buf); // kernel로부터 데이터 받기
    printf("from kernel : %s\n", buf);

    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

kernel.c

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/io.h>
// 송수신 라이브러리
#include <linux/uaccess.h>
#include <linux/string.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100

MODULE_LICENSE("GPL");

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

static long nobrand_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    // 변수 선언
    char buf[10] = { 0 };
    unsigned long ret;

    switch (cmd)
    {
        case _IO(0, 3) :
            printk(KERN_INFO "IO 3\n");
            // app에서 보낸 문자열 10자리를 복사하여 수신한다.
            ret = copy_from_user((void*)buf, (void *)arg, 10);
            printk(KERN_INFO "%s\n", buf);
            break;
        case _IO(0, 4) :
            printk(KERN_INFO "IO 4\n");
            buf[0] = 'Z';
            // app 단에 'Z'를 전송한다.
            ret = copy_to_user((void *)arg, (void *)buf, 1); 
            printk(KERN_INFO "kernel will send %s\n", buf);
            break;
    }

    printk( KERN_ALERT "%d\n", cmd);
    return 0;
}
static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .unlocked_ioctl = nobrand_ioctl
};

static int nobrand_init(void) {

    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    return 0;
}

static void nobrand_exit(void) {
    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}

module_init(nobrand_init);
module_exit(nobrand_exit);

구조체 송수신

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

// 구조체 선언 : 계산하기 편하기 위해 모두 문자형으로 지정
struct Node{   
    char size;
    char buf[100];
};

int main()
{
    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDWR);
    if (fd == -1) {
        printf("FILE OPEN ERROR!!!\n");
        close(fd);
        return 0;
    }

    // 구조체 정의
    struct Node t = { 2, "HI" };    

    // 구조체 주소 전송
    ioctl(fd, _IO(0, 3), (void*)&t);

    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

kernel.c

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/io.h>
#include <linux/uaccess.h>
#include<linux/string.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100


MODULE_LICENSE("GPL");

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

// 구조체 선언
struct Node{
    char size;
    char buf[100];
};    

static long nobrand_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    int ret;
    struct Node t; // 구조체 정의
    switch (cmd)
    {
        case _IO(0, 3) :
            // 구조체 중 특정 변수에 복사
            ret = copy_from_user(&(t.size) ,(void*)arg,1);
            // 배열은 첫 주소값으로 반환하므로 & 안붙임
            // 널문자까지  받아 문자열임을 인식하기 위해 SIZE + 1
            // 또한 size을 문자형으로 선언했기 때문에 다음 구조체 변수의 주소가 +1이 된거지, 숫자형이였으면 +4를 해줘야함
            ret = copy_from_user(t.buf, (void*)(arg+1), t.size+1); 
            printk(KERN_INFO "t.size = %d\n", t.size);
            printk(KERN_INFO "t.buf = %s\n", t.buf);
            break;
    }

    printk( KERN_ALERT "%d\n", cmd);
    return 0;
}

static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .unlocked_ioctl = nobrand_ioctl
};

static int nobrand_init(void) {

    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    return 0;
}

static void nobrand_exit(void) {
    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}

module_init(nobrand_init);
module_exit(nobrand_exit);

bcm2711 칩 라즈베리파이 데이터시트

일반적인 Memory Address는 32bit를 사용한다. 0x0000 0000 ~ 0xFFFF FFFF 까지 각 1Byte 공간을 저장하여 총 4GByte 저장 공간 Address를 가짐

하지만, 라즈베리파이의 ARM에 LPAE 기능을 사용하여 35bit까지 표현하고 최대 메모리는 32GB까지 저장 가능

C언어에서 35bit까지 표기 불가능, Low Peripheral 메모리 주소를 사용하면 된다.

0x7C00 0000을 건드리고 싶다면, 0xFC00 0000을 건드리면 된다.

GPIO 연결

데이터시트를 살펴보면, Base 주소 : 0x7e20 0000이다. 따라서, 실제 라즈베리파이에서 건드려야 하는 주소는 0xFe20 0000이다.

참고) 임베디드에서 e는 에코라 읽는다. 2와 커뮤니케이션 혼동을 피하기 위해

offset : 얼마나 떨어져 있는지 표기

LED를 18번핀에 연결하여 출력한다고 하면

GPFSEL1 Register의 26:24에 001을 넣어야하고, 0xFE20 0004 주소 공간을 건드려야한다.

SET / CLEAR

18번핀 SET : 0xFE20 001C의 18번 bit에다가 1 세팅 => LED ON 18번핀 Clear : 0xFE20 0028의 18번 bit에다가 1 세팅 => LED OFF

커널 모듈 붙이고 뗄때 LED 키고 끄는 코드

static : 해당 파일 내에서만 사용가능한 전역변수 nobrand.c 에 추가

#include <asm/io.h>

static volatile uint32_t *BASE;
static volatile uint32_t *GPFSEL1;
static volatile uint32_t *GPSET0; 
static volatile uint32_t *GPCLR0; 

static int nobrand_init(void) {
    BASE = (uint32_t *)ioremap(0xFE200000, 256); // 해당 주소의 물리적 공간을 사용하기 위해 

    // offset을 해주는데, int의 자료형 크기가 4Byte이기 때문에 4를 나누어줘야 주소 공간 offset이 정상 작동된다.
    GPFSEL1 = BASE + (0x04 / 4); // `0xFE20 0004`
    GPSET0 = BASE + (0x1C / 4); // `0xFE20 001C`
    GPCLR0 = BASE + (0x28 / 4); // `0xFE20 0028`주소

    // GPFSEL1 Register의 26:24에 001을 넣는다.
    *GPFSEL1 &= ~(0x7 << 24);
    *GPFSEL1 |= (1 << 24);

    *GPSET0 = (1 << 18); // LED ON : `0xFE20 001C`의 18번 bit에다가 1 세팅

    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    printk(KERN_INFO "hi\n");
    return 0;
}

static void nobrand_exit(void) {
    *GPCLR0 = (1 << 18); // LED OFF : `0xFE20 0028`의 18번 bit에다가 1 세팅
    iounmap(BASE);

    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}

버튼으로 LED 제어하기

버튼을 제어하기 위해서는 데이터 시트에서 다음 부분을 참고해야합니다.

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

int main()
{
    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDWR);
    if (fd == -1) {
        printf("FILE OPEN ERROR!!!\n");
        return 0;
    }

    //read
    char buf[100];
    while(1) {
        read(fd, buf, 2);  // 커널에서 buf값 읽어오기
        if (buf[0] == 'P')  // 만약 buf[0]이 'P'이면 LED ON
        {
            ioctl(fd, 3, 0);
        }
        else  // 만약 buf[0]이 'P'가 아니면 LED OFF
        {
            ioctl(fd, 4, 0);
        }

        usleep(100*1000);
    }

    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

nobrand.c

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/io.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100

MODULE_LICENSE("GPL");

static volatile uint32_t *BASE;
static volatile uint32_t *GPFSEL1;
static volatile uint32_t *GPSET0;
static volatile uint32_t *GPCLR0;

static volatile uint32_t *GPLEV0;
static volatile uint32_t *GPIO_PUP_PDN_CNTRL_REG0;

static void led(int isTurnOn);
static int isButtonPush(void);

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

static ssize_t nobrand_read(struct file *filp, char *buf, size_t count, loff_t *ppos) {

    if (isButtonPush()) buf[0] = 'R';
    else buf[0] = 'P';
    buf[1] = '\0';

    return count;
}

static long nobrand_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{

    if (cmd == 3) {
        led(1);
    }

    if (cmd == 4) {
        led(0);
    }

    printk( KERN_ALERT "%d\n", cmd);
    return 0;
}

static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .read = nobrand_read,
    .unlocked_ioctl = nobrand_ioctl
};

static int nobrand_init(void) {

    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    BASE = (uint32_t *)ioremap(0xFE200000, 256);

    GPFSEL1 = BASE + (0x04 / 4);
    GPSET0 = BASE + (0x1C / 4);
    GPCLR0 = BASE + (0x28 / 4);
    GPLEV0 = BASE + (0x34 / 4);
    GPIO_PUP_PDN_CNTRL_REG0 = BASE + (0xE4 / 4);

    //24~26bit 001 output
    *GPFSEL1 &= ~(0x7 << 21); //000
    *GPFSEL1 |= (1 << 21); //001

    //using embedded pull up : 데이터 시트에서 초기값이 01이라 다음 코드 안해줘도 되긴 한다.
    *GPIO_PUP_PDN_CNTRL_REG0 &= ~(0x3 << 4);
    *GPIO_PUP_PDN_CNTRL_REG0 |= (0x1 << 4); 

    return 0;
}

static void nobrand_exit(void) {
    unregister_chrdev(NOD_MAJOR, NOD_NAME);

    led(OFF);
    iounmap(BASE);

    printk( KERN_INFO "BYE BYE\n\n");
}

static int isButtonPush(void) {
    int ret = 0;

    ret = (*GPLEV0 >> 2) & 0x1;  // 버튼 2번핀에 연결되어 있다.
    printk(KERN_INFO "BTN : %d\n", ret);
    return ret;
}

static void led(int isTurnOn) {

    if (isTurnOn)  // LED ON
    {
        *GPSET0 = (1 << 18);
    }
    else  // LED OFF
    {
        *GPCLR0 = (1 << 18);
    }
}


module_init(nobrand_init);
module_exit(nobrand_exit);

read : 커널 모듈로부터 장문의 데이터 받기 write : 커널 모듈로에 장문의 데이터 보내기

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDWR);  // 읽기 쓰기 둘가 가능 모드로 설정
    if (fd == -1) {
        printf("FILE OPEN ERROR!!!\n");
        return 0;
    }

    //write
    write(fd, "Let's go\n", 7);

    //read
    char buf[100];
    read(fd, buf, 100);
    printf("%s\n", buf);
    printf("%s\n", buf);

    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

nobrand.c

#include <linux/module.h>
#include <linux/fs.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100

MODULE_LICENSE("GPL");

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

static ssize_t nobrand_read(struct file *filp, char *buf, size_t count, loff_t *ppos) {

    buf[0] = 'H';
    buf[1] = 'I';
    buf[2] = '\0';

    return count;
}

static ssize_t nobrand_write(struct file *filp, const char *buf, size_t count, loff_t *ppos)
{
    printk( KERN_INFO "HIHI\n\n");
    printk( KERN_INFO "app message : %s\n", buf);
    return count;
}

static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .read = nobrand_read,
    .write = nobrand_write
};

static int nobrand_init(void) {
    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) {
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    return 0;
}

static void nobrand_exit(void) {
    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}



module_init(nobrand_init);
module_exit(nobrand_exit);

ioctl 추가

ioctl : 만능, read/write 둘다 가능, 대신 가독성 떨어짐 또한 ioctl은 값 하나의 데이터를 보내고 받을 수 있다. 장문의 데이터를 송수신하려면 copy_from_user()와 같은 커널함수를 추가 작성해줘야 한다.

app.c에 추가

#include <sys/ioctl.h>

ioctl(fd, 3, 0);  // 3 전송
ioctl(fd, 4, 0);  // 4 전송

nobrand.c에 추가

static long nobrand_ioctl(struct file *flip, unsigned int cmd, unsigned long arg)
{
    printk( KERN_ALERT "%d\n", cmd);  // 3과 4 커널 로그에 찍음
    return 0;
}

static struct file_operations fops = {
    .open = nobrand_open,
    .release = nobrand_release,
    .read = nobrand_read,
    .write = nobrand_write,
    .unlocked_ioctl = nobrand_ioctl
};

Build 환경

1. Native 환경 개발 : 개발할 장치 OS에서 코딩하는 것으로, Device Driver와 App을 개발할 때는 유용하다.
2. Cross Compile : 개발 PC 개발 후 Target 보드로 옮겨 테스트하며 개발하는 것으로, Kernel 혹은 규모가 큰 Device Driver와 App을 개발할 때 유용하다.

참고 : intel CPU 컴파일러를 통해 나온 실행파일은 ARM Core에서 작동되지 않는다. 따라서, ARM 컴파일러를 통해 실행파일을 만들면 된다.

#include <stdio.h>

int main()
{
    int vect[5] = 
    {
        [0] = 4,
        [3] = 1,
    };

    return 0;
}

특정 구조체 초기화

#include <stdio.h>

struct Node
{
    int a;
    int b;
    int c;
};

int main()
{
    struct Node t = 
    { 
        .a = 100, 
        .c = 200 
    };

    return 0;
}

구조체 콜백함수와 연결

#include <stdio.h>

void aaa()
{

}

void bbb()
{

}

void ccc()
{

}

struct MBC
{
    void(*one)();
    void(*two)();
    void(*three)();
};

struct TV {
    struct MBC go;
    struct MBC shoot;
};

int main()
{
    struct MBC mbc =
    {
        .one = aaa,
        .two = bbb,
        .three = ccc,
    };

    struct TV tv = {
        .go = {
            .one = aaa,
            .two = bbb,
        },
        .shoot = {
            .three = aaa,
        }
    };

    return 0;
}

디바이스 드라이버 종류

1. 캐릭터 디바이스(chrdev) : Byte 단위로 값 전달
2. 블록 디바이스(blkdev) : kb 이상의 블록단위로 값을 전달
3. 네트워크 디바이스(netdev) : socket 을 열고 ioctl 이라는 System Call 로 장치를 제어

Device Node란?

Device Node는 Device File로 HW 컨트롤을 한다. ./dev에서 장치들을 관리한다.

ls-al ./dev를 하게 되면, 다음 이미지와 같이 확인할 수 있다.

Major Number(주번호) : 디바이스 종류 Minor Number(부번호) : 구분하기 위한 용도

Device 파일 만들기

sudo mknod ./[파일명] c 100 200 : chardev로 주번호 100 보조번호 200인 device file 생성

App에서 커널 접근하기

커널 내부에서 디바이스 파일과 커널 모듈을 연결하여, app 단에서 디바이스 파일을 열어서 커널 모듈을 제어한다.

app에서 Device 파일에 접근하기

nobran.c 기본형태

#include <linux/module.h>

MODULE_LICENSE("GPL");

static int nobrand_init(void) {
    printk( KERN_INFO "OK HELLO NOBRAND!!\n");
    return 0;
}

static void nobrand_exit(void) {
    printk( KERN_INFO "BYE BYE\n\n");
}

module_init(nobrand_init);
module_exit(nobrand_exit);

Device File ./dev는 장치 파일을 제어해주는 디렉토리, 디바이스 파일은 ./dev에 저장되어 있어야 한다. sudo mknod /dev/nobrand c 100 0 sudo chmod 666 /dev/nobrand

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    printf("OPEN FILE!!\n");
    int fd = open("/dev/nobrand", O_RDONLY); // 디바이스 파일에 접근하기
    if (fd == -1)
    {
        printf("FILE OPEN ERROR\n");
        return 0;
    }


    printf("CLOSE FILE!!\n");
    close(fd);

    return 0;
}

커널 모듈형태의 Device Driver 제작

nobrand.c 완성본

#include <linux/module.h>
#include <linux/fs.h>

#define NOD_NAME "nobrand"
#define NOD_MAJOR 100  // Device File의 Major Number

MODULE_LICENSE("GPL");

static int nobrand_open(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "OPEN!!!\n");
    return 0;
}

static int nobrand_release(struct inode *inode, struct file *filp) {
    printk( KERN_INFO "CLOSE!!!\n");
    return 0;
}

static struct file_operations fops = {
    .open = nobrand_open,  // app.c에서 open 명령어 실행시 실행
    .release = nobrand_release // app.c에서 close 명령어 실행시 실행
};

static int nobrand_init(void) {  // insmod 명령어 입력시 실행
    printk( KERN_INFO "OK HELLO NOBRAND!!\n");  // KERN_INFO : log에 print하기 위해
    if (register_chrdev(NOD_MAJOR, NOD_NAME, &fops) < 0) { // device file에 접근 실패시 실행
        printk( KERN_INFO "ERROR!!! register error\n");
    }

    return 0;
}

static void nobrand_exit(void) { // rmmod 명령어 입력시 실행
    unregister_chrdev(NOD_MAJOR, NOD_NAME);
    printk( KERN_INFO "BYE BYE\n\n");
}



module_init(nobrand_init);
module_exit(nobrand_exit);

makefile

KERNEL_SRC=/lib/modules/$(shell uname -r)/build
obj-m := nobrand.o

go:
    make -C $(KERNEL_SRC) M=$(PWD) modules
clean:
    make -C $(KERNEL_SRC) M=$(PWD) clean

KERNEL_SRC 경로에 Makefile이 존재한다. 해당 Makefile에 선언해준 obj-m이 있다. PWD(현재 경로)의 모든 파일을 커널에 접근하여 make를 통해 나온 결과물을 다시 가져오게된다.

실행

make를 통해 커널 모듈 빌드 sudo insmod ./nobrand.ko를 통해 커널에 집어넣기 gcc ./app.c -o ./app을 통해 app 파일 빌드 ./app을 통해 app에서 커널 모듈에 접근 sudo rmmod nobrand를 통해 커널에서 빼기

참고 : ko 파일은 test용으로 app단에 존재하는거지, 원래는 커널에 있어야한다.

재부팅 시 실행 순서

재부팅시 필요한 파일들을 만들어주는데, 상단에서 만든 nobrand 파일은 필수가 아니므로 다시 만들어줘야한다. $ make clean $ rm app $ sudo mknod /dev/nobrand c 100 0 $ sudo chmod 666 /dev/nobrand $ make $ gcc app.c -o app 터미널 새로 키고 $ dmesg -w $ sudo insmod nobrand.ko $ ./app $ sudo rmmod nobrand $ make clean $ rm app

좀더 간편화

Makefile 수정

app gcc를 추가

KERNEL_SRC=/usr/src/linux
TARGET := app
obj-m := nobrand.o

all: driver app

driver:
        make -C $(KERNEL_SRC) M=$(PWD) modules

app:
     $(CC) -o $@ $@.c

clean:
     make -C $(KERNEL_SRC) M=$(PWD) clean
     rm -f *.o $(TARGET)

alias.sh 파일 만들기

source ./alias.sh로 실행가능 매크로 함수로, sd로 커널 진입 , sc로 커널 빠져나오기

alias sc='sudo insmod ./nobrand.ko'
alias sd='sudo rmmod nobrand'