[아두이노] 아두이노 간 I2C 통신 응용

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 사전학습 :
  [아두이노] 아두이노 간 I2C 통신
  [아두이노] 1:N 아두이노 간 I2C 통신
  [아두이노] n:m 아두이노 간 I2C 통신
• 실험 참고 자료 :
  [아두이노] 아두이노 마이크로 보드 제어
  [아두이노] 조도센서 제어
  [아두이노] LCD16x2 I2C(LiquidCrystal_I2C) 제어

지난 시간까지는 가상시뮬레이터로만 I2C 통신에 대해 실험했었는데 오늘은 몇가지 실제 부품을 가지고 아두이노 간 I2C 통신 실험을 할까 합니다. 상황 설정은 슬레이브 아두이노에 조도센서를 연결하여 조도센서 값을 측정하고 마스터 아두이노는 조도센서값을 슬레이브 아두이노에게 요청하고 응답 받은 조도센서값을 I2C 통신을 통해 16x2 LCD 모듈에 결과를 출력해보면 재밌을 것 같아서 한번 도전해봤습니다. 사실 부품이 몇개 없어서 좀 더 새로운 실험을 하고 싶었는데 있는 부품으로만 I2C 통신을 하다 보니깐 부품의 제약이 따라 기존의 실험했던 부품을 다시 사용하여 약간 복습 실험이 되고 말았네요.

이제 실험을 본격적으로 시작해 봅시다.

1. 회로도

• 준비물 : 조도센서 1개, 저항 1k옴 1개, 16x2 LCD 모듈 1개, 뻥판, 아두이노우노, 아두이노마이크로
• 내용 : 아두이노우노, 아두이노마이크로, 16x2 LCD SDA, SCL핀을 서로 공유한다.

아두이노우노가 2대 였다면 좋았을텐데 아두이노우노가 1대뿐이고 다행히 아두이노마이크로가 있어서 마스터/슬레이브 아두이노로 I2C 통신을 할 수 있었네요.

참고로 아두이노우노와 아두이노마이크로의 SDA, SCL핀 번호가 다릅니다.

아두이노우노 A4(SDA), A5(SCL) => 아두이노마이크로 D2(SDA), D3(SCL)

보드마다 핀번호가 다르니깐 꼭 확인하시고 연결하세요.

위 그림을 보시면 아두이노우노(마스터)와 아두이노마이크로(슬레이브)는 각각 다른 역할을 수행합니다.

• 아두이노우노 : 16x2 LCD 모듈에 결과 출력을 담당
• 아두이노마이크로 : 조도센서에 연결되어 조도센서값 읽기를 담당

아두이노우노는 아두이노마이크로에게 조도센서값을 요청하고 아두이노마이크로는 요청에 대해 응답하고 조도센서값을 아두이노우노에게 보내게 됩니다. 아두이노우노는 조도센서값을 읽은 후 16x2 LCD 모듈에 결과를 출력하게 됩니다.

2. 코딩

• 참고 출처 : https://www.arduino.cc/en/Reference/Wire

1) 마스터 아두이노 코딩

설계 :

• 슬레이브 아두이노에게 조도센서값 요청과 수신
• 16x2 LCD 모듈에 조도센서값 출력

슬레이브 아두이노에게 조도센서값을 요청

조도센서값은 0~1023사이의 아날로그 신호를 읽게 됩니다. 그러면 슬레이브 아두이노에서 조도센서값을 byte 단위로 보내면 총 4자리 숫자가 전송됩니다. 원래 다른방법이 있지만 왠지 4자리 숫자를 쪼개고 합치는 방식으로 처리하고 싶어지더군요.

우선, 요청을 하면 최대 4자리이기 때문에 아래와 같이 요청을 하게 했습니다.

 Wire.requestFrom(1,4); 

문제는 조도센서값이 0~1023이기 때문에 한자리~네자리로 숫자 데이터로 표현되니깐 최대 4자리 4byte형태를 유지해서 데이터를 수신하게 설정한다면 다음과 같습니다.

[합치기]

  while(Wire.available())
  {
    byte a=Wire.read(); //1의자리
    byte b=Wire.read(); //10의자리
    byte c=Wire.read(); //100의자리
    byte d=Wire.read(); //1000의자리
    m_cds = d*1000+c*100+b*10+a;     
  }

사실 int형의 데이터를 전송하고 int형이 2byte이니깐

int형 <= (앞byte<<8)|뒤byte)

예)

  int k = 1023;
  
  //쪼개기
  byte a = k>>8;
  byte b = k;
    
  //합치기
  int c = (a<<8)|b;

이렇게 하면 되겠지만 한번 색다르게 접근 했네요.

16x LCD모듈에 조도센서값을 출력

• 참고 : [아두이노] LCD16x2 I2C(LiquidCrystal_I2C) 제어

LiquidCrystal_I2C 라이브러리 함수를 이용합니다.

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F,16,2);  // 0x27 or 0x3F

출력은 슬레이브 아두이노에서 요청한 값이 m_cds변수에 저장되니깐 그 값을 lcd.print(m_cds)함수로 출력하면 됩니다.

void output(){
 lcd.print("                "); //지우기
 lcd.setCursor(0, 1); //2번째 줄의 0번째칸
 lcd.print("CDS : "); 
 lcd.setCursor(7, 1); //2번째 줄의 7번째칸
 lcd.print(m_cds);    
}

2) 슬레이브 아두이노 코딩

설계 :

• 조도센서값 읽기
• 마스터 아두이노 요청 시 응답처리

조도센서값 읽기

m_cds = analogRead(cdspin);

마스터 아두이노 요청 시 응답 처리

Wire.onRequest(requestEvent);

[쪼개기]

void requestEvent() {
  int val = m_cds; //조도센서값
  for(int i=0;i<4;i++){
    Wire.write(val%10);  //자리수 출력
    val=val/10;
  }  
}

3) 종합 코딩

[마스터 아두이노]

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
 
LiquidCrystal_I2C lcd(0x3F,16,2);  // 0x27 or 0x3F
int m_cds=0;
void setup()
{
  lcd.init(); //초기화
  lcd.backlight(); //배경불켜기
  lcd.setCursor(0, 0);
  lcd.print("Hello World");
  delay(1000);
  lcd.clear();  
}

void loop() {

  Wire.requestFrom(1,4); //슬레이브(1)에 4byte 요청   
  while(Wire.available())
  {
    byte a=Wire.read();
    byte b=Wire.read();
    byte c=Wire.read();
    byte d=Wire.read();
    m_cds = d*1000+c*100+b*10+a;     
  }
  output();  
  delay(500);
}

void output(){
 lcd.print("                ");
 lcd.setCursor(0, 1);
 lcd.print("CDS : ");
 lcd.setCursor(7, 1);
 lcd.print(m_cds);    
}

[슬레이브 아두이노]

#include <Wire.h>

const byte cdspin = A0;
int m_cds = 0;

void setup() {
  Wire.begin(1);
  Wire.onRequest(requestEvent);
}

void loop() {  
  m_cds = analogRead(cdspin);
  Serial.println(m_cds);   
  delay(500);   
}

void requestEvent() {
  int val = m_cds;
  for(int i=0;i<4;i++){
    Wire.write(val%10);  
    val=val/10;
  }  
}

3. 결과

영상을 보시면 좀 지져분하게 만들어 졌네요. 조도센서를 손으로 가리면 조도센서값이 작아지는데 이 조도센서값은 아두이노마이크로에서 측정이 됩니다. 그리고 아두이노우노, 아두이노마이크로, 16x2 LCD I2C 모듈은 SDA, SCL 핀은 공유되어 있고 아두이노우노에서 16x2 LCD I2C모듈을 제어합니다. 아두이노마이크로에서 조도센서측정 작업을 수행하고 아두이노우노는 조도센서값을 요청과 조도센서값을 출력 작업을 수행합니다. 그 결과가 아래 영상에서 확인 할 수 있습니다.

마무리

오늘 실험 내용은 예전 실험 했던 내용인데 하나의 아두이노우노에서 조도센서를 측정하고 16x2 LCD 모듈에 출력해도 됩니다. 이 작업을 구지 나누어 두 대의 아두이노에 역할을 분담 시켰습니다. 이렇게 I2C 통신을 이용하면 많은 부품을 아두이노 한대로 제어하는 것보다 여러대로 나누어 제어를 할 수 있습니다. 한곳에서 많은 부품을 제어하려면 각각의 부품의 소요되는 시간과 중간에 다른 동작의 개입할 때 까다로운 코딩을 설계해야 하는데 여러대로 분산 제어한다면 분산된 부품은 각각의 아두이노에서 해당 동작만 코딩하면 되기 때문에 코딩이 어느정도 쉬워질 거라 생각되네요.

조도센서로 실험했지만 여러분들은 다른 부품을 가지고 실험을 해보세요. 다양한 실험을 해야지 다양한 상상을 할 수 있으니깐요.

[아두이노] 1:N 아두이노 간 I2C 통신

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 사전학습 : [아두이노] 아두이노 간 I2C 통신
• 공개회로도 : https://www.tinkercad.com/things/dIcybQ2vHWd

지난시간에 아두이노간 I2C 통신 실험을을 하기 위해서 공유선을 A4(SDA), A5(SCL)핀에 연결하여 2대의 아두이노 간 통신을 했었습니다. 오늘은 마스터 아두이노와 2대의 슬레이브 아두이노 간의 통신을 연장해서 실험을 해보겠습니다. 지난 시간의 실험 내용에서 아두이노가 한 대 더 추가되었을 뿐 변동 사항은 거의 없습니다. 오늘 실험은 마스터 아두이노에 슬레이브 아두이노 2대를 연결하여 실험하지만 더 많은 아두이노로 통신 하시고 싶다면 2대 이상 연결하여 실험을 하셔도 됩니다. 슬레이브 아두이노의 갯수는 여러분들이 정해서 실험하시면 됩니다.

이제 1:N 아두이노들 간의 I2C 통신 실험을 해보도록 하죠.

1. 1:N 아두이노 I2C 통신 회로도

준비물 : 아두이노우노 3개
내용 : 아두이노우노의 A4(SDA), A5(SCL)핀을 서로 공유한다.

회로도의 선 연결은 지난 시간에 아두이노 간의 I2C 통신 회로도에서 아두이노 한대가 더 추가 된 회로도 입니다.

2. 코딩

• 참고 출처 : https://www.arduino.cc/en/Reference/Wire
• 사전학습 : [아두이노] 아두이노 간 I2C 통신

사전 학습에서 사용된 코딩을 약간만 수정하시면 됩니다.

1) 마스터 아두이노 코딩

설계 :

• 각 슬레이브 아두이노에 데이터 전송
• 각 슬레이브 아두이노에 데이터 요청과 수신

동작은 위 2가지 형태로 실험이 이루어 집니다. 아래 그림처럼 그림A와 그림B 동작을 마스터 아두이노는 각 슬레이브 아두이노 간의 순차적으로 동작하게 됩니다.

[지난소스]

  //데이터 전송
  Wire.beginTransmission(1);                 
  Wire.write("good ");       
  Wire.write(x);             
  Wire.endTransmission();    
     
  delay(500);
    
  //데이터 요청 & 수신
  Wire.requestFrom(1, 4); //슬레이브(1)에 4byte 요청
  while (Wire.available()) {
    char c = Wire.read(); 
    Serial.print(c);        
  }  

지난시간에 슬레이브 아두이노에 특정 데이터를 전송한 뒤에 다시 데이터를 요청 했었습니다. 1대가 아니고 2대의 슬레이브 아두이노에 데이터를 전송하고 데이터를 요청하도록 수정 한다면 어떻게 해야 할까요.

동작은 설계에서 딱 두개의 동작만을 수행 합니다. 데이터를 전송하고 데이터를 요청한다. 이 두가지 동작을 2대의 슬레이브 아두이노와 통신을 해야 한다면 지난 소스을 적용한다면 2번 반복 수행해야 겠죠. 그러면, 위 코딩을 복사해서 길게 두번 코딩해야 할까요. 그럴 필요는 없습니다. for문으로 두번만 위 코딩을 반복시키면 됩니다.

각 슬레이브 주소를 1, 2번으로 지정해 주고 아래와 같이 코딩하면 됩니다.

  for(int i=1;i<3;i++){
    Wire.beginTransmission(i);                
    Wire.write("test ");       
    Wire.write(i);             
    Wire.endTransmission();    
     
    delay(500);
    Wire.requestFrom(i, 4);   
    while (Wire.available()) {
        char c = Wire.read(); 
        Serial.print(c);        
    }
  }   

간단하죠. 여기서, 아두이노가 N대를 연결한다면 for문의 i값의 N 횟수 만큼 반복되도록 숫자만 변경해주면 여러대의 슬레이브 아두이노와 통신을 할 수 있게 됩니다.

2) 슬레이브 아두이노 코딩

설계 :

• 데이터 수신 처리
• 데이터 요청 응답

지난 시간의 코딩과 동일합니다. 식별 번호만 바꿨네요. "ok1"으로 해당 슬레이브 아두이노의 요청 메시지만 수정했네요.

  Wire.onRequest(requestEvent); //요청시 requestEvent함수 호출
  Wire.onReceive(receiveEvent); //데이터 전송 받을 때 receiveEvent함수 호출

void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()>1) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }
  int x = Wire.read();    
  Serial.println(x);      
}
void requestEvent() { //마스터 요청 시 수행 함수
  Wire.write("ok1\n");   
}

여기서, 두 대의 슬레이브 아두이노로 실험하니깐 요청이 들어오면 "ok1", "ok2"로 메시지가 출력되게 코딩하면 됩니다.

종합해보면,

[마스터 아두이노]

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600); 
}

void loop() {  
  for(int i=1;i<3;i++){
    Wire.beginTransmission(i);                
    Wire.write("test ");       
    Wire.write(i);             
    Wire.endTransmission();    
     
    delay(500);
    Wire.requestFrom(i, 4);   
    while (Wire.available()) {
        char c = Wire.read(); 
        Serial.print(c);        
    }
  }   
}

[슬레이브 아두이노 1]

#include <Wire.h>

void setup() {
  Wire.begin(1); //슬레이브 주소                
  Wire.onRequest(requestEvent); //마스터 요청시 requestEvent함수 호출
  Wire.onReceive(receiveEvent); //마스터 데이터 전송시 receiveEvent함수 호출

  Serial.begin(9600);           
}

void loop() {
  delay(500);
}

void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()>1) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }
  int x = Wire.read();    
  Serial.println(x);      
}
void requestEvent() { //마스터 요청 시 수행 함수
  Wire.write("ok1\n"); 
  
}

[슬레이브 아두이노 2]

#include <Wire.h>

void setup() {
  Wire.begin(2);                
  Wire.onRequest(requestEvent); //마스터 요청시 requestEvent함수 호출
  Wire.onReceive(receiveEvent); //마스터 데이터 전송시 receiveEvent함수 호출
  Serial.begin(9600); 
}

void loop() {
  delay(500);
}

void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()>1) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }
  int x = Wire.read();    
  Serial.println(x);      
}
void requestEvent() { //마스터 요청 시 수행 함수
  Wire.write("ok2\n");   
}

3. 결과

위 코딩으로 1:N 아두이노 간의 I2C 통신을 할 수 있게 되었습니다. 가상시뮬레이터에서 결과가 어떻게 나오는지 영상으로 살펴보세요.

마무리

오늘은 1:1 I2C 통신하는 방식에서 1:N I2C 통신을 실험 했습니다. 오늘 내용은 지난 시간에 했던 내용을 for문 하나가 추가 되었을 뿐 따로 추가된 부분은 없습니다. 여러대를 연결하면 각 슬레이브 아두이노로 데이터를 보내고 각 슬레이브 아두이노에 데이터를 요청하면 거기에 맞게 각 슬레이브 아두이노는 데이터 수신과 데이터 요청에 대한 응답 처리 코딩만 하면 됩니다.

오늘은 그냥 복습차원으로 반복 학습 post입니다. 1:1 통신을 할 수 있으면 1:N 통신을 잘 생각하면 쉽게 떠올릴 수 있는데 혹시 1:N이 잘 연상이 안되는 분들이 있을 것 같아서 지난시간에 마무리 글로 1:N 통신으로 연장해서 상상을 해보시라고 했는데 못하시는 분들을 위해 이렇게 post로 다시 이야기를 하게 되었습니다.

[아두이노] 아두이노 간 I2C 통신

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 공개회로도 : https://www.tinkercad.com/things/bPDpkJ3K8K6

오늘은 아두이노 간 통신을 I2C 방식을 이용하여 실험을 할까 합니다. 예전에 시리얼통신을 할 때 한꺼번에 소개 했어야 했는데 미뤄졌네요. 지난 시간에 시리얼 통신으로 다수 명령 처리 방법에 대한 post를 하다 보니 다수 아두이노 통신을 통해 명령을 처리해보고 싶어져서 다수 통신 실험을 위해 I2C 방식을 소개하면서 다뤄보고 싶어 이렇게 post를 쓰게 되었습니다. 통신에 대한 복습차원으로 좋을 것 같아서 겸사겸사 이야기를 이여 갑니다.

이제부터, I2C 방식으로 어떻게 통신이 이루어지는지 살펴 보겠습니다.

1. I2C 통신을 위한 Wire 라이브러리

• 참고 출처 : https://www.arduino.cc/en/Reference/Wire

위 참고 출처에 가시면 아두이노 공식 홈페이지에 Wire 라이브러리에 대해 자세히 나와 있습니다. 그리고, Master Reader/Slave Writer, Master Writer/Slave receiver 예제가 있는데 이 예제를 통해서 아두이노 간 통신을 배우시면 되겠습니다.

아두이노 간 통신을 하기 위해서 Wire 라이브러리를 이용하여 I2C 통신을 할 수 있는데 아두이노우노의 A4(SDA), A5(SCL)핀에 아두이노들 간의 공유선을 이용하여 통신이 이루어 집니다. 만약, 다른 보드를 이용할 경우 해당 보드의 SDA, SCL핀이 몇번 핀인지 확인하시고 해당핀을 공유선에 연결하시면 됩니다.

이제 아두이노홈페이지에 나와 있는 Master Reader/Slave Writer, Master Writer/Slave receiver 예제로 기반으로 간단히 설명을 드리겠습니다.

1) 아두이노 주소 지정

아두이노 간의 식별은 주소로 구별합니다. 주소를 지정하는 방식은 다음과 같습니다.

Master : Wire.begin()
Slave : Wire.begin(address)

위 함수를 보면 아무것도 안적혀 있으면 Master가 되고 address를 지정해 주면 그 address가 해당 아두이노의 슬레이브 주소(7bit)가 됩니다. 이렇게 주소를 지정하면 상대 아두이노에서 해당 주소을 통해서 데이터를 보낼 수 있고 받을 수 있습니다.

2) 데이터 전송

Wire.beginTransmission(1); // 슬레이브주소 1번 전송시작
Wire.write("good\n");        // 문자열 전송
Wire.endTransmission();    // 전송 중단

데이터를 보낼 때 beginTransmission(address)와 endTransmission()함수가 쌍을 이루고 write()함수로 데이터를 해당 주소지로 보내게 됩니다. write()함수가 쓰기 불편하시면 print() println()함수로 쓰셔도 됩니다. 참고로 Wire.send()함수와 같이 봐주시기 바랍니다.

3) 데이터 수신

setup()함수에 한번만 표현하고 데이터가 수신이 되면 receiveEvent 함수가 호출이 됩니다.

Wire.onReceive(receiveEvent); //데이터 수신 시  receiveEvent()함수 호출

호출된 함수 내부의 코딩은 시리얼통신 때 배웠던 코딩과 동일합니다.

void receiveEvent(int howMany) { //전송 데이터 처리 명령
  while (Wire.available()) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }  
}

4) 요청/응답

위에서는 단순히 일방적으로 데이터를 보내고 받는 방식이라면 여기에서는 데이터를 특정 슬레이브 아두이노에게 데이터를 요청하고 해당 슬레이브 아두이노는 요청을 확인 한 후 데이터를 보내게 됩니다.

마스터 아두이노에서 요청은 다음과 같습니다.

Wire.requestFrom(1, 4); //슬레이브(1)에 6byte 요청

while (Wire.available()) { //보내온 데이터가 있을 시 데이터 읽기
  char c = Wire.read(); 
  Serial.print(c);        
}  

슬레이브 아두이노에서 응답은 다음과 같습니다.

Wire.onRequest(requestEvent); //요청할 때마다 호출

위 함수는 setup()함수에 한번만 표현하고 데이터 요청이 올 때 requestEvent()함수가 호출되게 됩니다.

호출된 함수 내부의 코딩은 간단한 메세지 전송만 보내게 표현해 보겠습니다.

void requestEvent() { //요청 시 수행 함수
  Wire.write("ok!\n");   
}

정리를 하면, Wire.requestFrom(1, 4) 함수은 마스터 아두이노에서 슬레이브(1) 아두이노에게 요청을 하고 4byte을 읽겠다는 의미이고, Wire.onRequest(requestEvent) 함수는: 슬레이브(1) 아두이노는 요청을 받게 되면 requestEvent()함수를 호출하고 그 안에 있는 write()함수를 통해 마스터 아두이노에 데이터를 보내게 됩니다.

2. I2C 아두이노 간 통신 회로도

준비물 : 아두이노우노 2개
내용 : 아두이노우노의 A4(SDA), A5(SCL)핀을 서로 공유한다.

회로도의 선 연결은 어렵지 않죠. A4, A5 선만 잘 연결하시면 됩니다. 참고로 실제로 실험하실 때는 여러분들이 사용하시는 보드에 따라 선 연결이 다릅니다. 여러분들이 사용하는 보드의 SDA, SCL 핀이 몇번인지 확인하시고 연결하셔야 합니다. 아두이노우노의 경우는 A4, A5로 연결하면 됩니다.

3. 코딩

• 참고 출처 : https://www.arduino.cc/en/Reference/Wire

사전 학습으로 위 아두이노공식 홈페이지에 가시면 Master Reader/Slave Writer, Master Writer/Slave receiver 예제가 있는데 있는데 위 회로도에다가 코딩만 복사하셔어 가상시뮬레이터에서 돌려 보세요.

Master Reader/Slave Writer, Master Writer/Slave receiver 예제를 합쳐진 코딩으로 실험을 해보겠습니다.

위 공식홀페이지의 예제에서는 마스터 아두이노에서 x값을 순차적으로 슬레이브 아두이노에 보내는 동작과 마스터 아두이노에서 데이터 요청하고 슬레이브 아두이노에서 응답하는 동작을 하는 예제입니다.

실험은 마스터에서 x값을 순차적으로 슬레이브로 보내면서 슬레이브 아두이노에게 데이터 요청을 동시에 수행하고 슬레이브 아두이노는 데이터는 수신하면서 요청이 들어오면 응답을 수행하도록 해보겠습니다.

1) 마스터 아두이노 코딩

설계 :

• 데이터 전송
• 슬레이브 아두이노에 데이터 요청과 수신

먼저, Wire 라이브러를 함수를 사용하기 때문에 아래와 같인 선언 해주셔야 합니다.

#include <Wire.h>

그리고, 마스터 아두이노이기 때문에 주소지정은 다음과 같습니다.

void setup() {
  Wire.begin();
    
    Serial.begin(9600);           
}

한번만 수행되면 되니깐 Setup()함수 내에서 표현합니다.

데이터 전송하기

int x = 0;

Wire.beginTransmission(1);                
Wire.write("good\n");       
Wire.write(x);             
Wire.endTransmission();
x++;
if(x==6)x=0;  

데이터 요청과 수신

Wire.requestFrom(1, 4); //슬레이브(1)에 4byte 요청
while (Wire.available()) {
    char c = Wire.read(); 
    Serial.print(c);        
}    

2) 슬레이브 아두이노 코딩

설계 :

• 데이터 수신 처리
• 데이터 요청 응답

슬레이브 아두이노는 다음과 같이 코딩합니다.

#include <Wire.h>

void setup() {
  Wire.begin(1); //슬레이브 주소                
  Wire.onRequest(requestEvent); //요청시 requestEvent함수 호출
  Wire.onReceive(receiveEvent); //데이터 전송 받을 때 receiveEvent함수 호출
    
  Serial.begin(9600);           
}

마스터 아두이노와 다른 접은 Wire.begin(address) 함수의 주소를 지정해 줘야 합니다. 데이터 수신과 요청에 대한 onReceive()함수와 onRequest()함수를 setup()함수에 한번만 표현합니다.

이제 데이터 수신과 요청에 대한 이벤트 호출함수에 대한 동작만 코딩하면 됩니다.

데이터 수신하기

void receiveEvent(int howMany) { //전송 데이터 읽기
  while (Wire.available()>1) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }
  int x = Wire.read();    
  Serial.println(x);      
}

데이터 요청 응답하기

void requestEvent() { //요청 시 수행 함수
  Wire.write("ok!\n");   
}

종합해보면,

[마스터 아두이노 소스]

#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600); 
}

byte x = 0;

void loop() {
  Wire.beginTransmission(1);                
  Wire.write("good ");       
  Wire.write(x);             
  Wire.endTransmission();    
     
  delay(500);
  
  Wire.requestFrom(1, 4); //슬레이브(1)에 4byte 요청
  while (Wire.available()) {
    char c = Wire.read(); 
    Serial.print(c);        
  }    
  x++;
  if(x==6)x=0;  
}

위 코딩을 보면 데이터 전송과 데이터 요청 사이의 delay()함수를 주었습니다. 그 이유는 서로 충돌이 일어나지 않게 일정시간 딜레이 주었는데 한번 딜레이 함수없이 가상시뮬레이터에서 실행 시켜보세요. 어떤 결과가 나오는지 확인을 하시기 바랍니다.

[슬레이브 아두이노 소스]

>#include <Wire.h>

void setup() {
  Wire.begin(1); //슬레이브 주소                
  Wire.onRequest(requestEvent); //요청시 requestEvent함수 호출
  Wire.onReceive(receiveEvent); //데이터 전송 받을 때 receiveEvent함수 호출

  Serial.begin(9600);           
}

void loop() {
  delay(500);
}

void receiveEvent(int howMany) { //전송 데이터 읽기
  while (Wire.available()>1) { 
    char ch = Wire.read(); 
    Serial.print(ch);         
  }
  int x = Wire.read();    
  Serial.println(x);      
}
void requestEvent() { //요청 시 수행 함수
  Wire.write("ok!\n");   
}

여기서 available()함수에서 왜 1보다 커야 하는지 한번 0보다 크다일 때와 1보다 크다 일때는 비교해보세요. 그 차이점을 구별하시기 바랍니다.

4. 결과

결과는 마스터 아두이노는 "good " 문자열과 x값을 0~5까지의 값을 슬레이브 아두이노에 보내고 슬레이브 아두이노는 전송 된 "good 숫자"의 값을 읽고 시리얼모티너로 출력합니다. 그리고 슬레이브 아두이노는 데이터 요청이 오면 "ok!\n"문자열 값을 마스터 아두이노에 보내고 마스터 아두이노는 "ok!\n"문자열을 읽고 시리얼모니터로 요청/응답이 정상적으로 처리 되었는지 해당 메시지로 확인 할 수 있습니다.

마무리

오늘은 아두이노 간 I2C 통신을 실험 해 보았습니다. 2대의 아두이노 간 통신이였지만 여러 대의 슬레이브 아두이노에 주소 지정을 하시게 되면 1:N 통신이 가능합니다. 다수의 아두이노 통신을 할 수 있는데 한번 오늘 배운 내용을 기반으로 연장해서 실험을 해보세요.

[아두이노] 시리얼 통신으로 다수 명령 처리 방법

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 사전학습 : [아두이노] Serial 통신 때 String 사용
• 공개회로도 : https://www.tinkercad.com/things/0JjrP4gnbKU

시리얼통신으로 통해 전송되는 하나의 패턴 문자열에 대한 처리에 대해 다뤘습니다. 문득 아두이노에 연결 된 여러개의 부품을 통신을 통해 제어를 할 경우에 대해 어떻게 처리하면 좋을지 궁금해 지더군요. 하나의 패턴 문자열을 통해 A부품을 제어했다면 또다른 패턴문자열로 B부품을 제어할 일이 생길 경우가 있습니다. 여러개의 서로 다른 패턴 문자열을 아두이노우노에서 동시에 처리하고자 할 때 기초적인 방법으로 처리하는 상상코딩을 해보도록 하겠습니다.

1. 부품 패턴 문자열

LED와 Servo Motor를 통신을 통해 제어를 한다면 어떻게 할까요.

LED(A부품)패턴 문자열 : LED 핀이 13번일 경우를 가정해 봅시다.

String inString = "a13,1" or "a13,0";

• "a13,1" => a부품이고 13번 pin에 상태는 1이다.

digitalWrite(13,1);

• "a13,0" => a부품이고 13번 pin에 상태는 0이다.

digitalWrite(13,0);

위 A 패턴문자열을 통해서 13번 핀을 HIGH(1) or LOW(0) 상태를 지정할 수 있게 됩니다.

Servo Motor(B부품)패턴 문자열" : Servo pin이 7번일 경우를 가정해 봅시다.

String inString = "b90";

• "b90" => b부품이고 회전각 90도이다.

servo.write(90);

위 B 패턴문자열을 통해서 고정 Servo Motor 핀을 특정각으로 회전 시킬 수 있게 됩니다.

예를들어, 2개의 패턴 문자열을 통신을 통해 전송되고 아두이노는 서로 다른 문자열이 입력되면 해당 문자열에 맞은 동작을 처리하도록 하기 위해서는 어떻게 할까요. 바로, 문자열을 분해하여 부품 패턴형태를 선택문(switch)문으로 분리해 내면 됩니다.

2. 다수 패턴 문자열을 선택

패턴 형태를 앞글자 첫번째 알파벳으로 지정하게 했습니다. 즉, a,b로 2개의 부품의 패턴부품으로 분류가 됩니다.

a,b의 부품 패턴을 선택문을 통해서 해당 부품을 지정할 수 있습니다.

• 문자열 읽기 :

String inString = Serial.readStringUntil('\n');   

• 첫번째 문자(부품패턴) 읽기 : 문자열에서 특정 위치의 알파벳은 charAt(위치)함수로 해당 문자를 읽어옴

char ch = inString.charAt(0); //문자열에서 첫문자 읽기

• 패턴 선택

switch(ch){
  case 'a':  
           A부품 문자열 읽기;
           A부품 LED동작;
           break;
  case 'b':
           B부품 문자열 읽기;
           B부품 Servo Motor동작;
           break;
}

예를 들어, 두개의 부품 a,b 부품를 제어하는 명령인데 실제로 뭔가를 만들 때는 여러개 부품을 통신에을 통해 제어 할때는 여러개의 case를 만들면 되겠죠.

2개 부품을 읽을 때는 아래와 같이 2개의 case를 살펴봅시다.

• "a13,1" or "a13,0" 읽기(A부품)

index_pin = inString.indexOf(',');     
index_state = inString.length(); 
pin = inString.substring(1, index_pin).toInt();     
state = inString.substring(index_pin+1,index_state).toInt(); 

• "b90" 읽기(B부품)

index_servo = inString.length();   
angle = inString.substring(1, index_servo).toInt(); 

• "a13,1" or "a13,0" 동작(A부품)

void LedOutput(int pin, int state){
  digitalWrite(pin, state);
}

• "b90" 동작(B부품)

void ServoOutput(int angle){
  servo.write(angle);  
}

처리 동작을 보면 단순합니다. 실제는 좀 복잡한 제어 명령으로 출력함수를 코딩하겠죠.

종합해보면,

#include <Servo.h>

Servo servo;
const byte servoPin = 7;
const byte redPin = 13;
const byte greenPin = 11;
const byte bluePin = 9;

int index_pin, index_state;
int pin, state;
int index_servo, angle;


void setup()
{
  Serial.begin(9600); 
  pinMode(redPin,OUTPUT);
  pinMode(greenPin,OUTPUT);
  pinMode(bluePin,OUTPUT);
  
  servo.attach(servoPin); 
  servo.write(0);
  delay(1000);
}

void loop()
{  
  if(Serial.available()){
    String inString = Serial.readStringUntil('\n');    
    
    char ch = inString.charAt(0);
    
    switch(ch){
      case 'a':                 
                index_pin = inString.indexOf(',');     
                index_state = inString.length(); 
                pin = inString.substring(1, index_pin).toInt();     
                state = inString.substring(index_pin+1,index_state).toInt(); 
                LedOutput(pin,state);
                break;
      case 'b':
                index_servo = inString.length();   
                angle = inString.substring(1, index_servo).toInt();       
                ServoOutput(angle);
                break;                                
    }      
  } 
}

void LedOutput(int pin, int state){
  digitalWrite(pin, state);
}

void ServoOutput(int angle){
  servo.write(angle);  
} 

부품 2개를 시리얼통신을 통해서 제어해 보는 간단한 코딩입니다. 여러 부품을 제어할 때는 switch문을 이용하여 여러개의 패턴 문자열에 대한 처리 동작을 코딩을 표현하시면 다수의 부품을 제어할 수 있습니다.

위 코딩이 실제로 동작하는지 가상시뮬레이터로 돌려 볼까요.

3. 회로도

준비물 : LED 3개, 저항 220옴 3개, Servo Motor 1개, 아두이노우노
내용 : LED은 13, 11, 9번 핀에 연결하고 Servo Motor은 7번핀에 연결하시오.

LED핀은 12,11,10이렇게 하셔도 됩니다. 사실 회로도의 배선을 가상시뮬레이터에서 디자인할 때 최소화 하기 위해서 한칸씩 띄워서 연결햇네요.

4. 결과

LED와 Servo Motor에 대한 명령을 시리얼 통신을 통해 패턴 문자열을 아두이노에 보내고 그 명령들을 아두이노가 처리하는 과정을 간단히 테스트 했습니다.

마무리

오늘은 다수의 패턴 문자열을 만들고 각 문자열에 맞는 동작처리를 하는 방법을 살펴 보았습니다. 이 방법은 어디에다가 쓸까요. 가령, 다양한 부품들을 통신을 통해 한꺼번에 제어할 할때 유용합니다. 즉, 다양한 명령을 문자열로 아두이노로 전송을 하게 되면 각 문자열의 명령들을 아두이노가 식별하고 해당 부품의 동작 명령을 내릴 수 있습니다.

예를 들어, 아두이노가 웹서버에 연결되어 있다고 상상해 봅시다. 웹서버에서는 아두이노로 "A 모터를 돌려라!", "B 부품의 전원을 공급하라", "C 부품으로 온도를 측정하여 온도를 알려달라!" 등 다양한 명령을 내린다고 상상해 봅시다. 아두이노는 이런 다양한 명령을 어떻게 처리해야 할까요. 바로 오늘 소개한 방식으로 다양한 명령 패턴문자열로 보내오고 그 문자열을 위에서 코딩했던 방식으로 switch문을 통해서 분류하여 선택한다면 원하는 동작을 수행 할 수 있게 됩니다.

간단한 원리지만 활용도 면에서 꽤 유용하니깐 참고해 주세요.

[아두이노] Bluetooth 통신 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com/
• 참고자료 출처 :
  [아두이노] Serial 통신 제어
  [아두이노] 아두이노 끼리 통신하기

오늘은 Bluetooth 통신을 주제로 이야기를 할가 합니다. 원래는 나중에 할 예정이였는데 Servo Motor를 조이스틱으로 제어하고 스위치 버턴으로 제어하는 포스프를 쓰다 보니깐 나중에 Bluetooth를 포스트하고 응용 예제로 LED나 Servo Motor를 복습차원을 포스팅을 할 것 같아서 이참에 한번에 해버리는게 좋을 것 같아서 오늘의 포스트 주제로 선정했네요. 이제 본격적으로 Bluetooth 통신으로 들어 가겠습니다.

1. Bluetooth HC-06 모듈

• Rx - 데이터 읽기
• Tx - 데이터 보내기

두 개의 Rx, Tx만 무슨 핀인지만 아시면 됩니다. 두 핀만 잘 아두이노에 연결하면 무선 통신을 할 수 있게 됩니다.

하지만 이 Bluetooth HC-06 모듈을 아두이노에 연결할 때 잘 생각하고 연결하셔야 합니다. 물론 아무 핀에다 연결해도 상관은 없습니다만 아두이노에 연결 했을 때 해당 핀이 어떤 핀인지에 대한 정의를 머리속에서 내리셔야 합니다.

다음 회로도에서 설명하겠지만 Bluetooth Rx핀은 아두이노에서 사용 할 Tx핀에 연결해야 하고 Bluetooth Tx핀은 아두이노에서 사용 할 Rx핀에 연결해야 합니다. 이 부분만 주의하시면 됩니다. 즉, 아두이노가 보내는 데이터 핀은 아두이노 자체니깐 Tx핀이겠죠. 그게 Bluetooth가 읽으니간 Rx에 연결하는 것이고 Bluetooth가 보내는 데이터는 Bluetooth의 Tx핀에서 나와서 아두이노가 그 데이터를 읽기 위해서는 아두이노의 Rx핀에서 읽어들이겠죠. 이렇게 생각하시면 될 듯 싶네요.

2. 회로도 구성

• 준비물 : - Bluetoooth HC-06 1개, 아두이노우노
• 내용 : 0,1핀을 제외한 아무핀에다 연결하시오.

0,1 은 아두이노 자체 시리얼통신 핀입니다. 이곳에 Bluetooth를 연결해도 되긴 하는데 처음에 따로 연결해 주세요.

Bluetooth Tx 핀은 아두이노의 Rx 2번핀에 연결하고 Bluetooth Rx 은 아두이노의 Tx 3번핀에 연결합니다. 왜 이렇게 복잡하게 말하냐면 나중에 SoftwareSerial 라이브러리를 통해서 통신을 할 때 통신 함수의 인자 변수명을 일치시키기 위해서 입니다.

SoftwareSerial::SoftwareSerial(uint8_t rxPin, uint8_t txPin, bool inverse_logic)

• SoftwareSerial(rxPin, txPin) : 시리얼통신 핀을 세팅합니다.

여기서 인자값은 bluetooth의 Tx=rxPin, Rx=txPin으로 넘겨지기 때문입니다.

const int rxPin = 2;
const int txPin = 3;

SoftwareSerial mySerial(rxPin, txPin);

• Bluetooth Rx -> Arduino txPin
• Bluetooth TX -> Arduino rxPin

대충 변수명은 SoftwareSerial 생성자 함수의 인자 명하고 일치 시켜 유사한 이름을 써주세요.

간혹 Bluetooth 이름으로 짓는 경우가 많은데 그러면 혼동이 생길 수 있습니다.

int BT_TX = 2;
int BT_RX = 3;

이럴때

SoftwareSerial mySerial(BT_TX, BT_RX);

이렇게 이름을 짓는 경우가 많습니다. Bluetooth 관점으로 핀이름을 만들다 보니 이렇게 되죠. 엄밀히 말하면 생성자 함수의 인자 네임음 (rx, tx)입니다. 그런데 들어가는 값이 블루투스의 (tx, rx)다고 해서 이렇게 이름 만들면 혼동할 수 있습니다. 될 수 있으면 함수 인자의 네임을 일치시켜 주세요.

3. 코딩

• 내용 : 스마트폰 연결 Bluetooth를 연결하여 간단히 스마트폰에서 입력한 값을 아두이노에서 읽고 아두이노 IDE 시리얼모니터로 읽은 값을 출력을 해보자.

함수

• Serial.begin(9600) : 시리얼통신 시작
• Serial.write(출력값) : 시리얼모니터로 출력

SoftwareSerial 통신

#include <SoftwareSerial.h>

• SoftwareSerial mySerial (rx, tx) : 소프트시리얼 객체선언(rx(수신), tx(전송))
• mySerial.begin(9600) : 시리얼 통신 시작(예로 9600 통식속도를 사용해 봤네요.)
• mySerial.write(값) : 데이터 전송
• mySerial.available() : 데이터 들어왔는 확인
• mySerial.read() : 전송된 데이터 1byte 읽기

SoftwareSerial 라이브러리에서 제공되는 기본 예제로 테스트

• 출처 : https://www.arduino.cc/en/Tutorial/SoftwareSerialExample

해당 소스에서 2,3핀을 시리얼통신 핀으로 사용 했습니다. 그리고 전송속도는 9600으로 둘 다 해버렸네요.

• 전송 속도 : 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600, 115200
  다른 속도로 하셔도 됩니다.

[기본 소스] : 이 코딩은 위 아두이노공식홈페이지에 있는 기본 예제를 기반으로 약간만 수정한 소스입니다. 제가 만든게 아니라 위 아두이노 공식홈페이지에서 제공되는 오픈 예제 소스입니다.

#include <SoftwareSerial.h>

const int rxPin = 2;
const int txPin = 3;

SoftwareSerial mySerial(rxPin, txPin); // RX, TX

void setup()  
{
  Serial.begin(9600);
  while (!Serial) {
    ; 
  }
  Serial.println("Bluetooth Start!");
  mySerial.begin(9600);  
}

void loop() 
{
  if (mySerial.available()) Serial.write(mySerial.read()); 
  if (Serial.available()) mySerial.write(Serial.read()); 
}

딱히, 어려운 건 없습니다. 링크 예제를 안하더라도 대부분 Bluetooth 샘풀 테스트를 하면 위 소스와 비슷한 방식으로 다들 실험을 합니다.

(1) SoftwareSerial 헤더파일 연결
(2) SoftwareSerial 객체변수 선언
(3) 객체변수.begin(전송속도)
(4) if(객체변수.available()) { byte ch = 객체변수.read(); }
(5) Serial.write(ch);

누가 실험을 하든 이게 젤 처음 다들 하는 Bluetooth 실험 소스입니다. 그냥 자연스럽게 이렇게 코딩하게 됩니다.

여기서 loop()문은 통신을 수행하는 문장입니다.

예전에 시리얼 통신을 할 때 시리얼모니터에서 데이터를 입력하면
if (Serial.available()) {
byte ch = Serial.read();
}

이렇게 읽었습니다. 시리얼 모티터로 출력 한다면

Serial.write(출력값); 

이렇게 사용했습니다. 블루투스 통신에서도 이와 같습니다. 

if (mySerial.available()){
    Serial.write(mySerial.read()); 
}

블루투스를 통해 들어온 데이터를 시리얼모니터로 출력하는 문장입니다. 이것과 반대로 시리얼모니터로 입력한 데이터를 블루투스로 반대로 보내는 동작은 다음과 같습니다.

  if (Serial.available()) {
        mySerial.write(Serial.read()); 
    }

이전에 시리얼 통신을 해왔던 방식 그대로 표현 하시면 됩니다. 단지 블루투스를 SoftwareSerial 라이브러리를 이용하기 때문에 따로 SoftwareSerial 의 객체 변수를 선언해주고 그 객체명으로 시리얼통신함수를 사용하시면 됩니다.

간단히 정리하자면 평소 Serial 통신에서 시리얼모니터에 아두이노의 결과물을 출력했던 방식으로 동일하게 Bluetooth도 동일한 방식으로 푠현한다고 생각하시면 됩니다.

4. Bluetooth 통신을 하기 위한 세팅

1) 스마트폰에서 Bluetooth 등록

위 그림 처럼 HC-06의 이름을 가진 Blutooth가 잡힙니다. 등록하기 위해서는 비번을 쳐야 하는데 초기 비번은 "0000", "1234" 둘 중 하나로 초기 비번으로 설정 되어 있습니다. 둘 중 하나니깐 두 개 다 입력해서 잡히면 그걸로 등록하시면 됩니다. 참고로 AT 명령어로 비번을 변경할 수 있습니다.

2) 스마트 폰 Bluetooth 통신 앱 설치

전 느낌 오는 걸로 구글스토어에서 블루투스 컨트롤을 쳐서 아래 그림의 어플을 설치했네요. 결과만 보기 위해서 대충 선택했네요. 다른 것들도 많으니간 편한 걸로 설치 하시면 됩니다.

혹시, 직접 만드시고자 하시는 분들은 웹인벤터에서 앱을 만들 수 있습니다. 스크래치 방식으로 블록으로 배치하여 직접 만들 수 있는데 구글 검색 키워드로 "bluetooth 앱인벤터"로 치시면 동영상하고 블로그 게시물이 엄청 많습니다. 유튜브에서 검색하셔도 됩니다. 동영상을 보고 따라 만드시면 나중에 자신이 원하는 스타일로 개조 할 수 있습니다.

3)실행

Bluetooth를 잡아놓은 상태어서 HC-06으로 제가 현재 쓰는 Bluetooth 모듈 명이 검색 되어 있네요. 초기 이름울 AT명령으로 Bluetooth 이름을 변경 할 수 있습니다. 그냥 초기 이름을 그대로 사용합니다. 클릭을 하면 옆 그림처럼 선택 목록이 있는데 젤 위의 Controller mode를 누르면 다음과 같이 조종기가 나옵니다.

간단히 방향버턴을 1,2,3,4 로 세팅했네요.

이제 아두이노 IDE를 열고 결과를 테스트 하면 됩니다.

5. 결과

스마트폰에서 방향 스위치를 누르면 아두이노에 연결된 Bluetooth가 방향 스위치 값을 읽고 그 값을 아두이노에서 PC에 연결된 아두이노 IDE 시리얼모니터로 결과가 출력된다.

아래 실험 영상 녹화는 데스크탑 PC에서 녹화한 영상입니다. PC에서 스마트폰을 원격접속하여 스마트폰을 PC에서 볼 수 있게 하였고, 아두이노는 라즈베리파이에 연결되어 작동하고 라즈베리파이에 설치된 아두이노 IDE 의 시리얼모니터로 Bluetooth에서 들어온 데이터를 출력하도록 해놓았습니다. 참고로 라즈베리파이도 데스크탑 PC에서 원격 접속을 하였습니다. 결론은 녹화를 하기 위해서 PC가 스마트폰과 라즈베리파이를 동시에 원격접속하여 PC 모니터에 띄워서 둘을 동시에 조정하여 그 결과를 녹화한 영상물입니다.

위 그림처럼 스마트폰과 라즈베리파이를 원격 접속하여 창을 띄운 화면입니다. 참 번거롭게 녹화을 했네요. 스마트폰으로 찍자니 그러면 Bluetooth 어플 조정을 못하니깐 어쩔 수 없이 원격 접속하여 PC로 녹화를 하게 되었습니다.

아 'Start' 단어에 오타가 다시 녹화 하기 귀찮아서 그냥 올립니다. 참고로 영상에서 처음 실행이 되면 "AT"라는 단어를 쳐보세요 그리고 보내면 "OK"라는 단어로 리턴된 값이 시리얼모니터로 출력됩니다. 이 말은 Bluetooth가 정상적으로 동작한다는 의미가 되겠습니다.

6. AT 명령어

• 출처 : http://www.electrodragon.com/w/AT_Commands

구글 검색하시면 레퍼런스가 많습니다. 제가 봤던 사이트 레퍼런스인데 명령어들을 잘 살펴보시면 됩니다.

Bluetooth 설정된 값을 변경할 수 있는 명령어입니다. 현재 Bluetooth 버전, 이름, 비번, 전속속도, Master와 Slave 설정 등을 할 수 있습니다. 참고로 버전이 낮을 경우 Master와 Slave은 고정되어 있는데 구매하실 때 자신이 쓰는 모델이 고정인지 겸용인지를 꼭 확인하세요.

• AT : "OK" 메세지가 나오면 Bluetooth 정상
• AT+VERSION : 현재 Bluetooth 사양 정보
• AT+NAMEaaa 이름(aaa)
• AT+PIN1234 비번(1234)
• AT+BAUE1 전송속도(1200) 1~9,A,B,C(레퍼런스참조)

이름과 비번만 바꿔주시고 사용하시면 돼요. 추가적으로 레퍼런스를 읽어보시기 바랍니다.

마무리

if (mySerial.available()) Serial.write(mySerial.read()); 

이 한줄의 명령을 수행하기 위해서 엄청 글을 썼네요. 이 한줄이 오늘 동작하는 명령의 전부입니다. 이걸 하기 위해서 세팅하는 과정이 꽤 길었네요.

지금까지 Serial 통신으로 시리얼모니터로 결과를 출력했던 방식으로 Serial 대신에 여러분들이 작명한 이름으로 변경만 하면 통신을 할 수 있게 됩니다.

마지막으로 방향 버턴을 1,2,3,4 로 값을 세팅했잖아요. 그 값을 기준으로 Servo 머턴을 제어를 코딩해 보세요. 어제 스위치 버턴으로 Servo Motor를 제어 했는데 그 소스랑 오늘 통신 소스를 합쳐서 코딩해보시면 아마도 쉽게 코딩을 할 수 있을 거라 생각됩니다.

이걸 또 내일 포스팅하기 그러니깐요 이 부분은 여러분들이 Servo Motor를 제어하는 하는 걸로 마무리 할까 합니다.

나중에 다른 주제에 오늘 사용한 Bluetooth를 활용하는 것을 포스트 하겠습니다.