[아두이노] 아두이노 bit 계산

IOT/아두이노|2019. 8. 28. 09:00

[아두이노] 아두이노 bit 계산



지난시간에 int형을 byte로 쪼개고 다시 쪼개진 byte를 int형으로 합치는 코딩을 간단히 이야기 한 적이 있습니다.

  int x = 0B0000000100000001;//257
  
  //쪼개기
  byte a = x>>8;
  byte b = x;
    
  //합치기
  int c = (a<<8)|b;
  
  Serial.println(a);
  Serial.println(b);
  Serial.println(c);

[결과]

1 <=a
1 <=b
257 <=c

아두이노는 int형이 2byte형으로 구성되어 있으며 쪼개기/합치기 코딩을 하면 결과는 위와 같이 결과로 출력됩니다. 여기서 좀 더 깊게 자료형 변수의 값을 byte 단위로 쪼개지는 것에서 더 나아가 쪼개진 byte를 bit로 접근해보고 싶어지더군요. 그래서, 아두이노 홈페이지에 레퍼런스를 살펴보니 bit 관련 함수들이 제공되어서 bit 계산 함수를 정리하는 시간을 가져보고 싶어서 post를 쓰게 되었네요.

bit 관련 함수에 대해서 본격적으로 살펴 봅시다.

1. bit 함수



아두이노 함수는 총 7개를 제공해줍니다. 각 함수에 대해서 살펴 봅시다.

1) bit(n) 함수 : n번째 위치의 bit 값을 출력



예) 5이면 => bit(5) =>32

이렇게 n번째 위치의 bit 값을 반환합니다.

2) bitRead(x,n) : X 데이터 값에 n번째 위치의 bit 읽기


byte x = 0B00001111;  

byte x의 값은 아래 표로 나타냅니다.


여기서 bitRead(x,n)함수를 사용하여 특정 위치의 bit를 읽어 봅시다.

byte x = 0B00001111;  

Serial.println(bitRead(x, 1));

[결과]

1 <= 1번째위치 bit값

3) bitClear(x,n) : x 데이터 값에 n번째 위치의 bit 값을 지우기


byte x = 0B00001111;  

byte x의 값은 아래 표로 나타냅니다.


bitClear(x,1);

이렇게 x값을 1번째 위치의 bit를 지우게 됩니다.


byte x = 0B00001111; // 15
Serial.println(x); 
bitClear(x,1);
Serial.println(x); 

[결과]

15 <= x
13 <=bitClear(x,1)

대충 어떤 느낌인지 아시겠지요.

4) bitSet(x,n) : x 데이터 값에 n번째를 1로 세팅


위의 bitClear(x,n)함수는 0으로 초기화 한다면 bitSet(x,n) 반대로 1로 세팅하는 함수입니다.


위 표로 보시면 값이 어떻게 변하는지 쉽게 확인이 되시죠.

byte x = 0B00001111; // 15
bitClear(x,1);
Serial.println(x); 
bitSet(x,1);
Serial.println(x); 

[결과]

15 <=x
13 <=bitClear(x,1)
15 <=bitSet(x,1)

5) highByte(y)와 lowByte(y) 함수


  • highByte(y) : y 변수값의 최상위 byte 값을 반환합니다. 하지만 큰 자료형일 경우 두번째로 작은 byte를 반환하게 됩니다.
  • lowByte(y) : y 변수값의 최하위 byte 값을 반환합니다.

한번 어떤값이 나오는지 확인 해 볼까요.

예를 들면,

  int y= 0B0000111100000111;

int형은 2byte로 구성되어 있습니다. 각각 8bit로 나누어 상위 byte와 하위 byte루 구분 할 수 있습니다. 즉, 방금 이야기 한 highByte(y)와 lowByte(y) 함수로 상위 byte와 하위 byte가 반환되는지 확인하시면 되겟죠.

  int y= 0B0000111100000111;
    
  Serial.println(highByte(y));
  Serial.println(lowByte(y));

[결과]

15 <=00001111
7  <=00000111

대충 어떤 느낌으로 반환되는지 아시겠지요.

6) bitWrite(x, n, b) : x 데이터 값에서 n번째 위치값을 b(0 or 1)로 변경


byte x = 0B00001111;  

byte x의 값을 bitWrite(x, 1, 0) 함수를 사용하면 아래 표처럼 결과를 얻게 됩니다.


  byte x = 0B00001111;  

  bitWrite(x, 1, 0); 
  Serial.println(x);

[결과]

13 <=00001101

2. 실험



1) 코딩


위에서 설명한 함수들을 순서대로 출력해 보았습니다.

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

  byte x = 0B00001111;  
  int y = 0B0000111100000111;
  
  //x값 출력
  Serial.println(x); 
  
  //5번째 bit값 출력
  Serial.println(bit(5));
  
  //x 데이터의 1번째 bit를 출력
  Serial.println(bitRead(x, 1));
  
  //x 데이터의 1번째 bit를 0으로 초기화
  bitClear(x,1);  
  Serial.println(x);

  //x 데이터의 1번째 bit를 1로 세팅
  bitSet(x,1);  
  Serial.println(x);

  //y 데이터의 상위byte와 하위byte를 출력
  Serial.println(highByte(y));
  Serial.println(lowByte(y)); 
  
  //x 데이터 1번째 bit를 0로 변환
  bitWrite(x,1,0); 
  Serial.println(x);
}

void loop()
{

}

2) 결과


결과를 보시면 숫자만 쭉 나열 되어 있는데 위 코딩에 주석으로 단 글을 읽으면서 순서대로 어떻게 값이 바뀌는지 비교하면서 결과를 확인하시기 바랍니다.



마무리


오늘은 지난시간에 I2C 통신에서 int형 값을 byte로 쪼개고 다시 합치는 과정에서 문득 조금 더 bit단위까지 컨트롤 해보고 싶어져서 이렇게 정리를 하게 되었네요. 위 함수들은 막상 사용하려고 하면 어디에서 사용하지 잘 떠오르지 않을거에요. 그나마 위 함수중에서 가장 많이 사용했던 것은 bitRead()함수입니다. 아두이노를 할때 특정 패턴을 만들 때 0 or 1로 만드는 경우가 많고 특정 패턴을 저장한 변수의 크기를 줄이기 위해서 bit 패턴을 종종 만듭니다. 이렇게 만들어진 bit 패턴을 읽기 위해서 bitRead()함수를 자주 사용 했었습니다. 하지만 다른 함수들은 사용하는 사례가 그렇게 많지 않지만 오늘 배운 함수들 알아 두시면 나중에 도움이 될꺼에요. bit 단위로 컨트롤 할 수 있기 때문에 아두이노에서 접근하는 데이터를 가장 작은 bit 단위로 접근할 수 있고 변수 공간을 효율적으로 관리할 수 있어서 자원 낭비를 최소화 할 수 있습니다.

댓글()

[아두이노] 아두이노와 스마트폰의 만남

IOT/아두이노|2019. 8. 27. 09:00

[아두이노] 아두이노와 스마트폰의 만남



아두이노에 스마트폰을 연동하면 어떤 일이 벌어질까요. 지금까지 아두이노 실험에서는 아두이노와 스마트폰 간의 Bluetooth 통신이였습니다. 아두이노에서 측정한 센서값을 Bluetooth 통신을 통해 스마트폰에 그 결과를 출력하거나 스마트폰의 조정기 어플을 이용하여 아두이노를 컨트롤 하는 실험만 했었습니다. 단순히 아두이노와 스마트폰 사이에 무선 통신을 통해 데이터를 주고 받는 동작만이 전부였었죠. 사실 아두이노와 스마트폰의 사이에 딱 하나 Bluetooth 기능만 있는게 아닙니다. 스마트폰에 내장된 다양한 센서 부품들이 있는데 이 기능들을 잘만 아두이노와 연동하면 많은 것들을 만들어 낼 수 있습니다.

스마트폰에 내장된 고급 부품들이 많고 그 부품들의 데이터를 손쉽게 얻을 수 있습니다. 아두이노를 공부하시는 분들은 스마트폰에 내장된 부품의 기능을 사용할 때 해당 부품에 대한 오류 처리 코딩 부분을 생략 할 수 있습니다. 실제 아두이노에서 해당 부품을 구매해서 아두이노에 연결 할 경우 거기서 발생 할 수 있는 문제와 오류들을 해결하고 거기에 맞는 코딩을 수작업으로 일일히 체크하고 코딩해야 합니다. 하지만 스마트폰에 내장 되 부품을 이용하면 해당 부품의 데이터만 읽는 부분만 신경 쓰면 되기 때문에 코딩하기가 편해집니다. 참고로, 센서 읽기와 그 센서 데이터를 Bluetooth 통신을 통해 아두이노에게 명령만 내리면 되기 때문에 아두이노를 컨트롤 하기 쉽고 고퀄리티 작품을 제작하기에 효과적입니다.


스마트폰을 이용하려면 아두이노와 연동 할 스마트폰 센서는 어떻게 접근 할 수 있어야 합니다. 그 부분을 오늘 이야기 할까 합니다. 스마트폰 센서와 어플에 대해 간단히 소개하고 아두이노와 스마트폰이 연동을 하면 어떤 가능성이 있는지 살펴보도록 합시다.

1. 스마트폰 센서


스마트폰에는 어떤 센서가 내장되어 있을까요?


스마트폰에는 가속센서, 중력센서, 자이로센서, 온도센서, 압력센서, 조도센서, 근접센서, GPS센서, 지자기센서, 방향센서 ... 등이 탑재되어 있습니다. 스마트폰에 내장 된 센서들을 보면 아두이노에서 실험했던 일부 센서들이 있습니다. 그리고 특정 센서는 고가로 아두이노에서 실험을 한다면 부품 가격 때문에 저가의 부품을 사용하게 되고 그러면 만족할 만한 정확한 결과를 얻기 힘듭니다. 실험 제작 단가가 올라가겠죠.

아두이노에서 스마트폰과 연동을 하면 스마트폰에 탑재된 센서들을 다 사용할 수 있습니다. 스마트폰의 다양한 센서를 이용하여 아두이노를 동작시킬 수 있습니다.

예를 들면, 스마트폰으로 모바일 비행 시뮬레이터 게임 같은 것을 할 때 스마트폰 몸체를 좌/우 위/아래로 움직이면 모바일 게임 내 비행기 조정하는 게임을 한번 쯤 해보셨을 꺼에요. 바로 스마트폰 내에 내장된 자이로/가속 센서 값을 이용하여 조정을 하게 되는데 현실에서 이 조정값을 Bluetooth를 통해 아두이노로 보내면 그 값을 토대로 RC카 or 로보팔 같은 것을 실제 조정을 할 수 있게 됩니다.

다양한 센서를 읽을 수 있게 되면 Bluetooth를 통해 아두이노에 활용한다면 꽤 재밌는 것들을 만들 수 있겠죠.

2. 안드로이드 폰 센서 읽기



안드로이드 폰을 기준으로 이야기 하면 위 출처에 가시면 Sensor 부분을 읽으시면 됩니다.


안드로이든 폰에 내장된 센서를 어떻게 읽을 수 있는지 그 방법에 대해 자세히 나와 있습니다.

자바스크립트로 코딩부분까지 자세히 나와 있는데 어플로 센서 값을 읽고 어플 안에 Bluetooth 통신 코딩까지 합쳐진다면 이 어플을 통해서 아두이노를 제어 할 수 있게 되겠죠.

어플을 만들려면 아래 안드로이드 스튜디오와 같은 어플 개발 툴들을 사용 할 수 있어야 겠죠.



몇년 전에 봤던 강좌인데 나름 볼만 하네요. 최근판은 어떤지 모르겠네요.

직접 안드로이드 어플로 만들어 봐야 하는데 오래 전에 잠깐 재미로 봤던 거라서 다시 안드로이드 스튜디오를 사용 하려면 공부를 다시 해야하기 때문에 시간이 좀 소요되어 이 부분을 못 보여드리네요.

나중에 안드로이드 스튜디오를 다시 공부하게 된다면 한번 만들어 볼 날이 오겠죠.

스마트폰에 내장된 센서들을 사용하기 위해서는 어플 공부를 하셨으면 합니다.

스마트폰을 아두이노와 연동을 하면 뭘 할 수 있을까요?

간단히 사례와 상상을 이야기 해보겠습니다.

3. 아두이노와 스마트폰의 만남 후 가능성



위 그림을 폰드론 에토스 이미지 입니다. 보시면 아두이노 관점으로 해석하면 드론의 조정 핵심 부분을 스마트폰이 대신하게 됩니다 .스마트폰이 두뇌가 됩니다. 스마트폰에는 드론 컨트롤에 필요한 부품들이 내장되어 있기 때문에 어플로 로직만 잘 짜시면 나머지 아두이노는 폰이 명령한대로 드론모터만 제어하면 됩니다. 이렇게 스마트폰으로 드론을 컨트롤하면 다양한 것들을 할 수 있게 됩니다. 스마트폰에 카메라를 이용하여 고급 촬영이 가능하고 드론에 필요한 고급부품을 스마트폰이 대신하기 때문에 아두이노는 실질적으로 드론모터를 컨트롤하는 기능만 잘 표현하면 됩니다. 제작비를 대폭 줄이고 고급기능을 사용할 수 있게 됩니다.

미래의 전자기기는 이처럼 스마트폰과 연동한 제품들이 많이 만들어 질거라 생각됩니다.

한가지 가능성을 상상을 해보면 저번에 post한 [아두이노] 시각장애인을 위한 스마트 지팡이 원리 이해 내용에서 스마트 지팡이를 만약 스마트폰에 연동을 하게 된다면 어떤 것들을 할 수 있을까요.

위 그림처럼 스마트폰의 카메라를 이용 할 수 있게 되면 어떻게 될까요. 정면의 보행길과 사물을 인식할 수 있는 영상처리를 할 수 있겠죠. 이말은 실제 보행유도선이 깔림 보드블록이 없어도 영상으로 가상 보행유도선을 만들어 낼 수 있고 그 정보로 시각장애인을 안내할 수 있게 될거라 생각됩니다. 이걸로 자율보행스마트지팡이를 제작 하면 좋겠죠. 그리고 현재의 위치를 GPS 정보를 알 수 있는데 이 센서를 이용하여 주변의 건물이나 사물을 식별하고 그 정보를 스마트폰으로 제공받을 수도 있겠죠. 시각장애인은 이어폰으로 현재 상황 정보를 소리로 들을 수 있게 되겠죠. 간단히 상상을 해봤습니다. 아두이노 스마트지팡이에 스파트폰을 연결하면 다양한 결과물을 만들어 낼 수 있기 때문에 그 가능성은 엄청납니다.

참고로, 디지털 영상처리에 대해 관심을 가졌으면 합니다. 요즘 핫한 자율주행차에 핵심 기술입니다. 자율보행스마트지팡이로 주변 환경과 사물 인식에 대해 연구하시면 스마트지팡이에서 끝나지 않고 나중에 자율주행차에서도 그 기술을 활용할 수 있을 거라 생각됩니다. 프로그램을 배우는 학생분들은 서점에 가셔서 디지털 영상처리 책을 한번 읽어보시고 관심을 가졌으면 합니다. 저도 영상처리에 관심이 한때 많았고 3D Rendering 쪽으로 코딩 공부를 했었고 영상 인식부분은 자료가 부족하여 제대로 공부를 제대로 못해 봤습니다. 혹시 프로그램에 관심있으신 분이라면 자율주행차나 뭔가 영상인식에 관심을 가진 분들이라면 영상처리를 공부해 보셨으면 합니다. 이 기술은 나중에 아두이노와 같은 것들과 접목하면 고퀄리티 작품을 만들어 낼 수 있는 기반이 됩니다.

마무리


아두이노와 스마트폰을 연동하기 위해서는 어플을 필수로 배우셔야 합니다. 어플 공부가 쉽지는 않습니다. 코딩에 대해서 어느정도 능력이 탑재되어 있어야 합니다. 그럼에도 어플 공부를 추천하는 이유는 스마트폰의 다양한 센서 기능을 활용할 수 있고 그걸 활용하면 아두이노로 엄청난 걸 만들 수 있기 때문입니다. 뭔가 제대로 아두이노 작품을 만들어 보고 싶다면 스마트폰과의 연동에 관한 연구를 하셨으면 합니다. 그리고 영상인식에 관심이 있다면 디지털 영상처리 책을 구매하셔서 공부해보셨으면 합니다.

스마트폰을 활용하기 위해서는 스마트폰의 센서값을 읽을 수 있어야 합니다. 안드로이드폰이면 안드로이드 폰에서 센서값을 읽는 함수를 사용할 수 있어야 합니다. 읽은 센서값에 대한 동작 명령을 아두이노에 보내야 하기 때문에 Bluetooth 코딩도 알아야 합니다. 그러면 어플을 만들 수 있는 개발 툴을 사용 할 수 있어야 합니다. 앱 제작 공부를 해야 합니다. 어플을 만들 수 있는 능력이 있어야 아두이노와 스마트폰의 연동을 제대로 할 수 있게 됩니다. 스마트폰의 센서를 사용하기 위해서는 어플 공부를 해야 하는 어려움이 있지만 꼭 공부해보셨으면 해요.

어플을 공부하시면 나중에 스팀 블록체인과 관련한 어플도 제작 가능하기 때문에 꼭 이쪽 분야가 아니더라도 다른 분야에서도 많이 활용되니깐 공부해보셨으면 합니다.

댓글()

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

IOT/아두이노|2019. 8. 26. 09:00

[아두이노] 아두이노 간 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. 코딩



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모듈에 조도센서값을 출력

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 통신을 이용하면 많은 부품을 아두이노 한대로 제어하는 것보다 여러대로 나누어 제어를 할 수 있습니다. 한곳에서 많은 부품을 제어하려면 각각의 부품의 소요되는 시간과 중간에 다른 동작의 개입할 때 까다로운 코딩을 설계해야 하는데 여러대로 분산 제어한다면 분산된 부품은 각각의 아두이노에서 해당 동작만 코딩하면 되기 때문에 코딩이 어느정도 쉬워질 거라 생각되네요.

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


댓글()

[아두이노] n:m 아두이노 간 I2C 통신

IOT/아두이노|2019. 8. 23. 09:00

[아두이노] n:m 아두이노 간 I2C 통신



지난 시간에 마스터 아두이노와 슬레이브 아두이노 간 통신을 기본적으로 다뤘습니다. post를 정리하다가 문득 슬레이브 간의 I2C 통신이 하고 싶어져서 한번 도전을 해보았습니다. 지난 시간의 코딩한 방법으로 반복 코딩하면 재미가 없기 때문에 print(), println()함수를 이용하여 데이터를 전송하고 수신할 때는 문자열로 읽는 방식으로 코딩을 해봤습니다.

그러면, 어떻게 처리했는지 살펴보도록 하죠.

1. 1:1 슬레이브 아두이노 I2C 통신 회로도


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


가정은 마스터 아두이노는 있다고 가정한 상태에서 슬레이브 간 통신을 실험으로 각 아두이노에 주소를 부여하고 주소 간의 통신을 하는 실험으로 1:1 통신을 실험합니다.


실험은 1:1 통신이지만 연결하는 갯수에 따라서 n:m 통신이 가능합니다. post를 읽은 후 2대 이상의 아두이노를 서로 데이터를 전송해 보세요.

2. 코딩



코딩은 슬레이브 아두이노 간의 데이터 전송을을 해보도록 하죠.

슬레이브 아두이노 간 데이터 전송


설계 :

  • A 슬레이브 아두이노에서 B 슬레이브 아두이노로 데이터 전송

[데이터 전송] : print(), println()함수로 이번에 실험을 했습니다.

  Wire.beginTransmission(2);                
  Wire.println("a1/test1!");           
  Wire.endTransmission(); 

데이터 전송은 슬레이브 간 보낼 수 있다고 했죠. 그래서 기존 데이터 전송 코딩은 동일 합니다.

[문자열 데이터 수신] : 문자열로 이번에 읽는 실험을 했습니다.

void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()) { 
    String inString = Wire.readStringUntil('\n'); 
    Serial.println(inString);         
  }      
}

데이터 전송과 수신은 지난 시간과 동일하게 표현하면 재미 없기 때문에 좀 색다르게 표현 했네요. 반대의 경우 방금했던 코딩을 동일하게 코딩하시면 됩니다.

슬레이브 아두이노 1,2 코딩을 해볼까요.

[슬레이브 아두이노 1]

#include <Wire.h>

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

void loop() {
  Wire.beginTransmission(2);                
  Wire.println("a1/test1!");           
  Wire.endTransmission();  
  delay(200);  
}
void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()) { 
    String inString = Wire.readStringUntil('\n');      
    Serial.println(inString);
  }      
}

[슬레이브 아두이노 2]

#include <Wire.h>

void setup() {
  Wire.begin(2); //슬레이브 주소                  
  Wire.onReceive(receiveEvent); //마스터 데이터 전송시 receiveEvent함수 호출
  Serial.begin(9600); 
}

void loop() {
  Wire.beginTransmission(1);                
  Wire.println("b2/test2!");           
  Wire.endTransmission();  
  delay(500);  
}

void receiveEvent(int howMany) { //전송 데이터 호출시 명령
  while (Wire.available()) { 
    String inString = Wire.readStringUntil('\n');      
    Serial.println(inString);
  }      
}

참고로 딜레이 시간이 동일하게 되면 같은 시간에 데이터를 보내고 같은 시간에 데이터를 읽게 됩니다. 그러면 좀 문제가 생기겠지요. 가상시뮬레이터에서 데이터를 정상적으로 읽지 못하더군요. 그래서 시간 차를 다르게 했습니다. 즉, 시분할 스케줄링 처리를 해줘야 할 듯 싶네요. 아니면 지난 시간에 했던 1:N 연결을 통해서 마스터 아두이노에서 컨트롤 타워 연결을 수행하여 각 슬레이 간의 데이터 통신을 제어하는 방법이 가장 쉬울 듯 싶네요.

추가로, delay()함수를 쓰기 싫으면 다음과 같이 코딩하면 됩니다.

unsigned long timeVal = 0;

void loop() {
  if(millis()-timeVal>200){
     Wire.beginTransmission(2);                
     Wire.println("a1/test1!");           
     Wire.endTransmission();  
     timeVal=millis();
  }
}

3. 결과


각 슬레이브 아두이노가 상대 슬레이브 아두이노에 데이터를 전송하고 그 결과를 문자열로 읽고 시리얼모니터로 결과를 출력합니다. 나중에 여기에 마스터 아두이노를 연결하여 마스터와 슬레이브 아두이노 간 통신을 하는 동시에 슬레이브 간의 통신을 별도로 수행할 때 오늘 배운 내용을 적용하면 되겠죠.


마무리


오늘은 print(), println()함수로 데이터를 보내봤습니다. 그리고 수신할 때는 한번에 문자열로 읽어 보았습니다. 문자열로 읽을 경우 문자열 안에 데이터를 보낸 슬레이브주소코드를 같이 넣어서 보내면 누가 어떤 데이터를 보냈는지 쉽게 확인 할 수 있습니다. 쉽게 말해서, 문자열 "식별코드주소/전송데이터" 형태로 데이터를 보내고 수신하는 아두이노는 식별코드주소와 전송데이터를 분리해 내면 다수의 아두이노를 식별하고 해당 명령을 적절하게 수행할 수 있습니다.

그리고, 식별코드주소 뿐 아니라 여기에 요청코드를 넣게 되면 요청코드를 확인 후 요청한 식별코드주소을 토대로 상대 아두이노로 응답 메시지를 보내면 쌍방 통신도 가능해 지겠죠. Wire 라이브러리 요청/응답 함수를 사용하지 않더라도 데이터 전송함수를 이용하면 그 전송 된 메시지를 가지고 응답 처리를 유사하게 표현이 가능합니다. 한번 연구해 보세요.

여러분들은 계속 I2C 통신을 이용하는데 여러대의 아두이노가 있을 때 여러가 상황을 만들고 각 상황에 대해서 어떤식으로 통신을 할 것인지 상상의 나래를 펼쳐 보셨으면 합니다.

댓글()

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

IOT/아두이노|2019. 8. 22. 09:00

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



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

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

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


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



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

2. 코딩



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

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 통신

IOT/아두이노|2019. 8. 21. 09:00

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



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

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

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



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

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

Boardpins
UnoA4 (SDA), A5 (SCL)
Mega256020 (SDA), 21 (SCL)
Leonardo, Micro2 (SDA), 3 (SCL)
Due20 (SDA), 21 (SCL), SDA1, SCL1

이제 아두이노홈페이지에 나와 있는 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. 코딩



사전 학습으로 위 아두이노공식 홈페이지에 가시면 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 통신이 가능합니다. 다수의 아두이노 통신을 할 수 있는데 한번 오늘 배운 내용을 기반으로 연장해서 실험을 해보세요.


댓글()

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

IOT/아두이노|2019. 8. 19. 09:00

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



시리얼통신으로 통해 전송되는 하나의 패턴 문자열에 대한 처리에 대해 다뤘습니다. 문득 아두이노에 연결 된 여러개의 부품을 통신을 통해 제어를 할 경우에 대해 어떻게 처리하면 좋을지 궁금해 지더군요. 하나의 패턴 문자열을 통해 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문을 통해서 분류하여 선택한다면 원하는 동작을 수행 할 수 있게 됩니다.

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


댓글()

[아두이노] 아두이노 피아노 만들기

IOT/아두이노|2019. 8. 16. 09:00

[아두이노] 아두이노 피아노 만들기



예전 post를 정리하면서 피에조부저의 응용 예제로 빼먹었던 아두이노 피아노 만들기를 이번에 post로 작성하게 되었습니다. 원리는 피에조부저 제어편에서 "도레미파솔라시도" 음을 순서대로 FOR문을 통해 멜로디를 출력했던 소스에서 이 멜로디 음을 스위치버턴을 이용하여 아두이노 피아노로 구현해 보았습니다. 실험은 가상시뮬레이터에서 이루어 집니다.

이제 어떻게 만들는지 살펴보도록 하죠.

1. 피아노 이해



피아노의 건반을 아두이노를 이용하여 표현을 해 볼까요. 피아노는 건반과 사운드로 나눌 수 있습니다. 건반을 누르면 해당 음으로 소리로 출력이 됩니다. 이 부분을 아두이노로 표현한다면 다음과 같습니다.

  • 건반 = 스위치 버턴
  • 사운드 = 피에조부조


스위치 버턴을 누르면 피에조부저로 해당 음을 출력하면 간단히 아두이노 피아노를 만들 수 있겠죠.

2. 아두이노 피아노 회로도


준비물 : 스위치버턴 8개, 피에조부저 1개, 아두이노우노
내용 : 스위치 버턴을 2,3,4,5,6,7,8,9번 핀에 연결하고 피에조부저는 12번에 연결하시오.



9번부터 2번까지 "도레미파솔라시도"의 건반핀으로 사용 할 예정입니다.

3. 코딩



피에조부저 제어편에 가시면 기본 멜로디 "도레미파솔라시도" 출력 예제가 있습니다. 그 소스를 기반으로 실험합니다.

  • 기본음계
#define NOTE_C5  523   //도 (5옥타브 음계 데이터)
#define NOTE_D5  587   //레
#define NOTE_E5  659   //미
#define NOTE_F5  698   //파
#define NOTE_G5  784   //솔
#define NOTE_A5  880   //라
#define NOTE_B5  988   //시
#define NOTE_C6  1047  //도
  • 스위치버턴 변수
const byte melodyPin[] = {9,8,7,6,5,4,3,2}; //스위치버턴
  • 멜로디 출력 변수
const byte tonepin = 12; //피에조부저
  • 음계 변수
const int melody[] = { NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6 }; //도레미파솔라시도
int noteDurations = 50; //톤길이
  • 스위치버턴 누름 동작
for(int i=0;i<8;i++){ //8개의 건반을 빠르게 체크
   if(digitalRead(melodyPin[i])==LOW){ //내부풀업스위치버턴 누르면
     tone(tonepin, melody[i],noteDurations); //해당 스위치 버턴 음 출력
     delay(noteDurations);  //음길이 최소
     noTone(tonepin); //음 중단
   }
 }

총 0~7까지의 배열위치의 스위치버턴 상태를 체크합니다. 8개의 스위치 버턴 상태를 체크하기 때문에 위에서 for문을 이용하여 순차적으로 체크를 하게 됩니다. 해당 스위치 버턴이 눌르게 되면 최소 누른 음과 길이를 50만큼 음이 울리게 지정했습니다. 이렇게 한 이유는 2개 이상의 스위치 버턴을 누를 때 2개이상의 음이 동시에 울리는 착시음 효과를 나타내기 위해 최소음길이로 지정했네요. 이 원리는 예전에 여러개의 LED를 하나의 제어선을 이용하여 시간차로 동시에 서로 다른 LED에 불이 들어오게 하는 원리와 비슷합니다.

종합해보면,

#define NOTE_C5  523   //도 (5옥타브 음계 데이터)
#define NOTE_D5  587   //레
#define NOTE_E5  659   //미
#define NOTE_F5  698   //파
#define NOTE_G5  784   //솔
#define NOTE_A5  880   //라
#define NOTE_B5  988   //시
#define NOTE_C6  1047  //도

const byte melodyPin[] = {9,8,7,6,5,4,3,2}; //스위치버턴
const byte tonepin = 12; //피에조부저
const int melody[] = { NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6 }; //도레미파솔라시도
int noteDurations = 50; //톤길이

void setup()
{
  for (int i = 0; i < 8; i++) {
    pinMode(melodyPin[i], INPUT_PULLUP); //내부풀업스위치 지정
  }    
}

void loop()
{
  for(int i=0;i<8;i++){ //8개의 건반을 빠르게 체크
    if(digitalRead(melodyPin[i])==LOW){ //내부풀업스위치버턴 누르면
      tone(tonepin, melody[i],noteDurations); //해당 스위치 버턴 음 출력
      delay(noteDurations); //음길이 최소
      noTone(tonepin); //음 중단
    }
  }
}

4. 결과


간단히 "학교종"을 연주해 보았습니다.


마무리


오늘은 예전에 피에조부저에 대해서 post하면서 빼먹은 피에조부저 응용 예제로 아두이노 피아노를 간단히 실험을 하였습니다.


댓글()

[아두이노] 아두이노 논문 검색

IOT/아두이노|2019. 8. 15. 09:00

[아두이노] 아두이노 논문 검색 



오늘은 아두이노 관련 논문을 검색하는 방법을 살펴보도록 하죠. 국내 아두이노를 이용한 연구 자료들을 쉽게 찾을 수 있고 깊게 공부하고 싶은 분들에게 이용 할 만한 사이트으로 RISS 통합 검색과 국회전자도서관을 소개합니다. 무료로 논문 자료들을 공개되어 있어서 온라인상에서 쉽게 자료를 다운 받을 수 있습니다. 구지 학교도서관이나 근처 지역도서관에 방문하셔서 논문을 찾을 필요 없이 인터넷에서 쉽게 논문 자료를 수집할 수 있습니다. 대학생들이라면 레포트 쓸 때 참고자료용으로 많이 이용하시고 계시겠죠. 그리고 꼭 아두이노가 아니더라도 다른 학문 분야에 관심 있는 분들도 한번쯤은 위 논문 사이트를 이용해 보셨을 거라 생각됩니다.

왜! 논문 검색을 소개 할까요. 논문은 좀 더 전문적인 지식을 습득하기에 많은 도움을 줍니다. 그 뿐 아니라 현재의 국내 아두이노의 흐름을 이해하기에 무척 좋은 자료가 되기 때문에 여러분들에게 상상과 응용의 필요한 지식을 제공해 줍니다.

그러면 간단히 어떻게 논문을 검색하는지 살펴보도록 하겠습니다.

1. RISS 통합 검색 사이트



위 링크된 사이트에 가시면 아래와 같은 창이 뜨고 검색어는 "아두이노"만 치시면 됩니다.


관련 자료는 단어 형태로 검색하시면 아두이노 뿐 아니라 다른 분야의 논문들을 쉽게 찾을 수 있습니다.

아두이노라는 단어로 현재 학위논문이 131편이고 국내학술지논문 521편이네요.


무료 or 유료 or 기관내 무료 형태로 논문을 제공하는데 무료로 많이 제공하니깐 한번씩 읽어보시는 것도 재미 있습니다. 현재 국내 학생과 연구자들이 어떤 창의적인 아이템으로 논문을 섰는지 한눈으로 확인할 수 있고 많은 참고 지식을 얻을 수 있기 때문에 읽어보시면 지식적 측면에서 꽤! 아두이노에 대한 시야가 넓어질거라 생각 됩니다.

실제로 특정 논문을 클릭하시면 기본 정보를 제공하고 원문보기를 누르시면 보시는 것처럼 확인이 가능합니다.


경우에 따라 로그인이 필요한 경우에는 구글ID로 로그인하시면 됩니다.

2. 국회전자도서관



위 링크된 사이트에 가시면 아래와 같은 창이 뜨고 검색어는 "아두이노"만 치시면 됩니다.


여기서 "아두이노" 검색어로 치면 아래와 같은 창이 뜹니다.


여기서, 학위논문과 학술지 자료가 있네요. 특정 논문 자료를 선택 해봤네요.


위 그림처럼 특정 논문 하나를 선택했네요. 아래 "원문보기"를 누르면 국회전자도서관은 논문을 볼 수 있게 프로그램을 설치해야 합니다. 이게 좀 불편하네요. 논문 내용은 보기 편하게 되어 있는데 그걸 하기 위해서는 프로그램을 설치해야 한다는 불편함이 있습니다.

마무리


자주 사용하는 사이트는 RISS 통합 검색 사이트를 이용 합니다. 여러분들도 시간이 날때 마다 한번 아두이노를 가지고 어떤 실험들을 국내에서 하고 있는지 읽어 보셨으면 합니다. 아두이노 시야가 한단계 더 업그레이드 될 거라 생각됩니다.

댓글()

[아두이노] 시각장애인을 위한 스마트 지팡이 원리 이해

IOT/아두이노|2019. 8. 14. 11:11

[아두이노] 시각장애인을 위한 스마트 지팡이 원리 이해



지난 시간에 진동모터에 대해 살펴보았습니다. 진동모터는 촉각을 느끼는 출력 부품입니다. 즉, 어떤 상황이 발생했을 때 그 상황에 대해 진동으로 인간에게 알릴 수 있습니다. 일상에서 진동모터는 어디에서 사용 할까요. 바로 스마트폰의 진동모드입니다. 스마트폰의 진동으로 전화나 문자가 왔을을 쉽게 알 수 있습니다. 또다른 응용사례가 뭐가 있을까요. 구글 검색을 통해 살펴보니 시각장애인을 위한 스마트 지팡이가 있더군요. 이 주제를 한번 가상시뮬레이터로 테스트 해보고 싶어지더군요. 참고로 제가 새로운 뭔가를 하루만에 창조하고 실험까지 하기는 시간적 여유가 없기 때문에 기존에 구현한 주제를 가지고 한번 가상시뮬레이터로 모방 실험을 통해 진동모터를 이해하는 시간을 갖고자 합니다.

1. 진동모터의 응용 사례 구글 검색



진동모터에 대한 응용 예제로 위 출처에 가시면 각 대학교 학생들이 만든 공모전 작품들에 대한 소개가 잘 나와 있습니다. 자세한 내용과 코딩은 읽지 않았습니다. 그 이유는 상상코딩에 방해가 되기 때문에 저만의 코딩을 할 수 없을 것 같아서 어떻게 스마트 지팡이를 구성했는지만 간단히 이미지를 참조하여 가상시뮬레이터에서 표현가능한 부품만을 이용하여 재구성해 보았습니다.

쉽게말해서, 이미지만 보고 한번 모방 표현을 해 보았는데 어떻게 했는지 본격적으로 살펴 볼까요. 참고로 스마트지팡이의 이미지는 출처에 가셔서 직접 보시기 바랍니다.

2. 스마트 지팡이 모방 재구성 이미지



  • 조도센서 : 보행 주변 조명 상태 확인
  • LED : 어두울 때 조명을 켜서 보행자을 알림등으로 활용
  • 초음파센서 : 3개의 초음파 센서로 벽감지 초음파센서는 전방에 벽을 확인하고 보행 초음파센서는 보행자의 보폭에 따른 장애- 물을 감지하고 바닥 초음파센서는 계단과 같은 하단의 장애물을 감지한다.
  • 진동모터 : 초음파센서를 통해 장애물이 감지되면 진동으로 장애물 감지를 알림

3. 스마트 지팡이 회로도


  • 준비물 : 초음파센서 3개, 조도센서 1개, 1k옴 2개, 220옴 1개, 진동모터 1개, 아두이노우노
  • 내용 : 진동모터는 3번핀, 초음파센서는 5,6,7번핀, LED은 13번핀, 조도센서 A0핀에 연결하시오.

구글 검색을 통해 재해석한 표현입니다. 실험에 사용한 주제는 원작은 위 링크 출처의 자료의 이미지를 모방한 실험으로 제작품은 아닙니다. 가상시뮬레이터에서 원리를 실험하는게 목적인 post 입니다.


상단 초음파센서는 벽(장애물) 감지이고 중앙 초음파센서는 보행(장애물) 감지이고 하단 초음파센서는 바닥(장애물) 감지합니다. 장애물이 감지되면 진동모터가 작동하여 진동으로 보행자에게 알린다. 조도센서는 스마트지팡이의 조명을 담당하면 주변이 어두울 때 지팡이에 조명이 켜지고 보행자을 식별할 수 있게 한다.

2. 코딩


설계 :

  • 조도센서를 통해서 LED 조명을 제어한다.
  • 3개의 초음파센서를 통해 3가지 장애물 진동 패턴을 다르게 한다.

먼저 조도센서를 통해 LED 조명을 제어해 볼까요.

조도센서를 읽기

int cds=analogRead(CDSPin);  

조도센서의 값이 100(임의값)미만이면 LED(조명)가 켜지고 100이상이면 LED(조명)가 꺼진다.

if(어두운지) 조명 켜기;
else 조명끄기;

위 if문을 코딩화 하면 다음과 같습니다.

if(cds<100) digitalWrite(LedPin,HIGH);   
else digitalWrite(LedPin,LOW);  

이제는 3개의 초음파센서를 통해 3가지 장애물 감지와 진동 패턴을 출력 해 볼까요.

가상시뮬레이터의 초음파센서는 3핀입니다. newPing 라이브러리를 이용하면 편한데 가상시뮬레이터에서 제공되지 않고 쓸려면 라이브러리 파일 안에 코딩을 전부 가상시뮬레이터로 복사해야 하기 때문에 수작업 코딩으로 실험했네요.

초음파 센서 읽기(사용자함수로 표현)

float UltrasonicDistance(int m_pin){
  pinMode(m_pin,OUTPUT); 
  digitalWrite(m_pin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(m_pin,HIGH); 
  delayMicroseconds(10); 
  digitalWrite(m_pin,LOW); 
  
  pinMode(m_pin,INPUT);    
  float duration = pulseIn(m_pin, HIGH);  
  return duration / 57.5;  
}

3개의 초음파센서이니깐 위 사용자정의함수로 표현하면 loop()함수 안에서는 다음과 같이 3줄로 초음파센서 값을 읽으면 됩니다.

float v1=UltrasonicDistance(5);
float v2=UltrasonicDistance(6);
float v3=UltrasonicDistance(7);

각 초음파센서의 값을 읽었으면 진동을 출력해야 겠죠. 출력하기 전에 출력한 진동 패턴은 다음과 같이 설정 해보았습니다.

  if(v3<20){
    if(state == false){ //처음 장애물 감지때만 진입
          하단 초음파 초기상태;
    }    
    timeState = 200;  //진동 간격
  }
  else if(v2<30){
    if(state == false){      
      중앙 초음파 초기상태;
    }
    timeState = 500; //진동 간격
  }                    
  else if(v1<50) {
    if(state == false){      
      상단 초음파 초기상태;
    }
    timeState = 1000; //진동간격
  }
  else { //장애물 감지 안되면 초기화 시킴
    state = false;  
    digitalWrite(VibrationPin,LOW); 
  } 

위에서 초기상태는 장애물 감지 된 후의 동작이니깐 state 출력 상태로 바꾸고 초기 진동상태값은 true로 하고 이전시간값을 진동 간격만큼 처음 빼줍니다. 그 이유는 처음에는 무조건 진동을 먼저 시작하고 반복되게 하기 위해서 입니다. 참고로, Setup()함수에서는 강제적으로 delay(1000)하면 음수에 대한 오류는 발생하지 않습니다.

    if(state == false){ //처음 장애물 감지때만 진입
      state = true; //진동 출력 상태
      VibrationState=true; //진동모터의 상태
      timeVal = millis()-200; //진동이전값(처음에 무조건 진동해야하기 때문 -200을 함)
    }    

위 내용을 합치면,

  if(v3<20){
    if(state == false){ //처음 장애물 감지때만 진입
      state = true; //진동 출력 상태
      VibrationState=true; //진동모터의 상태
      timeVal = millis()-200; //진동이전값
    }    
    timeState = 200;  //진동 간격
  }
  else if(v2<30){
    if(state == false){      
      state = true;   
      VibrationState=true;
      timeVal = millis()-500;
    }
    timeState = 500;
  }                    
  else if(v1<50) {
    if(state == false){      
      state = true;   
      VibrationState=true;
      timeVal = millis()-1000;
    }
    timeState = 1000;    
  }
  else { 
    state = false;  
    digitalWrite(VibrationPin,LOW); 
  } 

이제 출력 상태를 지정을 했으니 출력을 해볼까요.

  if(state == true){ //출력 상태 확인
    if(millis()-timeVal>=timeState){ //출력 간격 체크
      digitalWrite(VibrationPin,VibrationState); //진동 출력
      VibrationState=!VibrationState; //진동출력상태 반전
      timeVal=millis(); //이전시간값
    }   
  } 

위와 같이 코딩함으로 진동을 울린건지 state값을 통해서 진동을 울리게 됩니다. 진동 울리는 간격은 millis()함수를 이용하여 딜레이함수 없이 딜레이 효과를 주었습니다. 왜! 이 원리를 이용했냐면 스마트지팡이에는 진동모터만 있는게 아닙니다. 다른 부품들도 실시간으로 동작을 처리해야 합니다. 그렇기 때문에 millis()함수를 이용하여 delay()효과를 주었네요. 이렇게 표현하면 조도센서에 대한 LED(조명) 변화는 동시에 처리할 수 있습니다.

종합해보면,

int timeState = 0;
boolean state = false;
boolean VibrationState = true;
unsigned long timeVal = 0;


const byte LedPin = 13;
const byte VibrationPin = 3;
const byte CDSPin = A0;

void setup(){
  
  //Serial.begin(9600);  
  pinMode(LedPin,OUTPUT);
  pinMode(VibrationPin,OUTPUT);  
  
  delay(1000);
}
void loop(){
  int cds=analogRead(CDSPin);  
  
  if(cds<100) digitalWrite(LedPin,HIGH);   
  else digitalWrite(LedPin,LOW);  
  
  
  float v1=UltrasonicDistance(5);
  float v2=UltrasonicDistance(6);
  float v3=UltrasonicDistance(7);
  
  
  if(v3<20){
    if(state == false){      
      state = true;
      VibrationState=true;
      timeVal = millis()-200;
    }    
    timeState = 200;  
  }
  else if(v2<30){
    if(state == false){      
      state = true;   
      VibrationState=true;
      timeVal = millis()-500;
    }
    timeState = 500;
  }                    
  else if(v1<50) {
    if(state == false){      
      state = true;   
      VibrationState=true;
      timeVal = millis()-1000;
    }
    timeState = 1000;    
  }
  else { 
    state = false;  
    digitalWrite(VibrationPin,LOW); 
  } 
  
  if(state == true){
    if(millis()-timeVal>=timeState){
      digitalWrite(VibrationPin,VibrationState);      
      VibrationState=!VibrationState;
      timeVal=millis();
    }   
  } 
 }
float UltrasonicDistance(int m_pin){
  pinMode(m_pin,OUTPUT); 
  digitalWrite(m_pin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(m_pin,HIGH); 
  delayMicroseconds(10); 
  digitalWrite(m_pin,LOW); 
  
  pinMode(m_pin,INPUT);    
  float duration = pulseIn(m_pin, HIGH);  
  return duration / 57.5;  
}

4. 결과


아래 결과 영상만 보면 좀 이해가 안 될 수 있습니다. 위에 지팡이 이미지를 보고시고 사용된 부품의 위치와 가상시뮬레이터의 부품과 일치시켜서 어느정도 상상을 하면서 보셔야 이해가 될 듯 싶네요.


5. 문제점



문제점은 위 그림에서 보는 것 처럼 보행을 할 때 세부분으로 나눠서 3꼭지점을 지면 바닥에 닿고 나머지 부분은 h(높이)로 반원의 곡선을 그리면서 지팡이를 움직이게 됩니다. 지면에는 딱 세번의 위치를 찍을 뿐 지팡이는 대부분 공중에 떠있게 됩니다. 그래서 지면과의 거리를 측정하는 센서가 추가하여 지면에서 얼마만큼 높이이고 장애물과의 거리가 정확히 위치를 잡아야 하는데 이 부분은 가상시뮬레이터에서 생략했습니다. 그래서 실제 구현한다면 스마트 지팡이의 곡선 움직으로 인한 장애물 측정의 약간 문제가 생길 수 있습니다. 즉, 위 코딩대로 라면 하단 초음파 센서가 곡선을 그릴 때 중간 장애물을 하닥 근접 장애물로 인식한 진동음으로 울릴 수 있으며 지팡이가 포물선으로 움직이기 때문에 각도의 변화가 일어나기 때문에 그 각도에 대한 계산 부분이 코딩에 담겨져 있지 않습니다. 그래서 정확한 측정은 좀 더 코딩을 수학적 계산 부분이 필요합니다. 위 코딩은 단순한 가상시뮬레이터에서의 스마트 지팡이의 단순 원리를 테스트 하기 위한 내용이니 실제 구현시에는 여러가지를 고려하야 정확한 장애물 위치에 대한 진동을 만드셔야 합니다.

원래는 초음파센서로만 스마트지팡이를 구성하고 장애물을 감지하는데에는 한계가 있습니다. 사실 초음파센서보다는 진짜 제대로 된 스마트 지팡이를 구현한다면 차라리 영상처리를 이용한 장애물 감지 기술을 공부하여 구현해보는 것이 좋습니다. 자율주행차에 대해 요즘 관심이 많고 대학들이 그와 관련된 연구를 하는 곳들이 많습니다. 이런 연구하는 대학에서 영상처리를 공부하는 학생들이 자율주행차보다 자율보행지팡이 쪽으로 연구가 이루어진다면 진짜 제대로 된 스마트 지팡이가 만들어 질거라 생각됩니다.

주변사물을 영상인식으로 통해 그 정보를 소리와 진동으로 알려준다면 제대로 된 보행을 할 수 있을 거라 생각됩니다. 자율주행차와 같은 원리를 자율보행안내 지팡이 연구를 한다면 그 기술은 자율주행차에도 응용 가능하기 때문에 연구의 가치가 있습니다.

마무리


오늘은 진동모터의 응용 사례를 구글 검색으로 통해서 장애인을 위한 스마트 지팡이이라는 아이템을 찾아 가상시뮬레이터에서 간단히 테스트를 해보았습니다. 이미지를 보고 바로 코딩을 하다보니깐 코딩이 별로 마음에 안들고 좀 길어서 보기 안좋습니다. 이미지를 응용하고 코딩을 만드는데 2시간정도 시간이 걸렸네요. 저녁에 실험하다보니 이번 post를 좀 연기할 까 했는데 그래도 완성은 시켰네요. 완성해놓고 보면 별거 없는데 몇가지 상상했던 코딩들 중에 하나를 선택해서 제가 의도한 방향으로 코딩을 하다보니 좀 시간이 길어져 버렸습니다. 하루만에 완성하려고 하니 볼품없는 post가 되었네요. 실제 제작을 해도 원하는 결과는 좀 얻기 힘들거라 생각됩니다. 대충 어떤 의미로 동작하는지 그 의미만 가상시뮬레이터로 실험한 post라고 이해 하셨으면 합니다.

다른 응용사례를 찾지 못했는데 혹시 찾으신다면 여러분들도 저처럼 이렇게 모방 실험을 한번 해보세요. 모방이라도 코딩을 보지 않고 이미지만 보고 응용하여 의미를 이해하고 자신의 상상으로 재해석해서 회로도를 만들어 보세요. 그리고 재해석된 회로도의 표현들을 자신의 상상력을 동원하여 코딩해 보세요. 위 코딩은 초벌 코딩으로 간단히 원리를 실험한 코딩이지만 위 코딩에서 좀 더 개선하면 좋은 코딩이 될거라 생각됩니다. 여러분들은 위 코딩을 그대로 하지 말고 원리만 이해하시고 여러분들 스스로가 여러분만의 코딩으로 재해석하여 코딩을 만들어 보셨으면 합니다.


댓글()

[아두이노] 진동센서(Vibration Sensor) 제어

IOT/아두이노|2019. 8. 13. 09:00

[아두이노] 진동센서(Vibration Sensor) 제어



지난시간에 다룬 진동모터는 진동을 외부로 출력하는 부품인데 반대로 진동을 감지하여 내부로 입력을 받는 진동센서 부품이 있습니다. 진동에 대한 전기 신호를 만들어 내는데 디지털 신호와 아날로그 신호로 만들어 냅니다. 아무튼 진동을 감지 할수 있는 이 센서는 참 재밌는 부품입니다. 만약에 이 진동센서를 특정위치에 부착하면 그 대상물에 진동이 발생했을 때 진동센서로 진동을 감지하여 전기 신호로 만들어 낼 수 있습니다. 가령 대상물에 누가 건들거나 또는 대상물 주변에 진동이 발생하는 상황에서 아두이노에서 그에 대한 특정한 명령을 내릴 수 있습니다. 즉, 진동 감지 원리를 이용하여 도난방지나 침입 방지를 위한 경보기와 같은 곳에서 응용할 수 있습니다. 예를 들면은 차량에 누가 터지하거나 충격을 주게 되면 차량에서 경보음이이 울리는 것으 많이 보셨을 꺼에요. 그런 것들을 연상하시면 될 듯 싶네요.

이제 진동센서를 알아봅시다.

1. 진동센서(Vibration Sensor)


진동센서는 진동을 감지하는 센서로 진동에 대해 디지털 신호 or 아날로그 신호를 만들어 냅니다. 진동센서는 3핀으로 VCC, GND, D0핀으로 구성된 모듈이 있는가 하면 아래 그림처럼 VCC, GND, D0, A0핀으로 구성된 모듈이 있습니다. 아래 그림을 보시면 진동에 대한 값을 십자모양의 가변저항으로 조절 할 수 있습니다.


진동센서는 2가지 형태로 출력 신호를 만들어 냅니다. 첫번째로 디지털 출력으로 0 or 1의 값을 만들어 내는데 진동센서에 대해 조사하니 초기상태값이 HIGH 상태이고 진동이 발생하면 LOW 상태가 된다고 나와 있습니다. 즉, 진동이 발생하면 진동센서는 LOW가 되고 아두이노우노에서 진동(LOW)에 대한 처리 동작을 설계하면 됩니다. 두가지 상태만 존재하기 때문에 스위치 역할을 수행하는 주제에 알맞습니다. 두번째로 아날로그 출력으로 0~1023의 값을 만들어 내겠죠. 디지털 출력는 진동에 대한 두가지 상태만 존재하기 때문이 때문에 두가지 상황만 만들어 낼 수 있지만 아날로그 출력은 진동의 강도값으로 진동의 신호를 만들어 내기 때문에 이 신호의 범위값을 나누면 여러 상황을 만들어 낼 수 있고 처리동작도 여러개의 형태로 처리동작을 만들어 낼 수 있습니다. 두가지 방식 중 여러분들이 설계하는 목적에 맞게 디지털로 읽을지 아날로그를 읽을지만 잘 정하고 알맞게 사용하시면 도비니다.

진동센서의 값을 읽는 방법은 다음과 같습니다.

  • 디지털 입력 : digitalRead(D0)
  • 아날로그 입력 : analogRead(A0)

위 함수를 통해서 읽은 값에 대한 처리 동작만 간단히 코딩하면 되기 때문에 진동센서는 어려운 부품이 아닙니다.

2. 진동센서 회로도


준비물 : 진동센서, LED 1개, 저항 220옴 1개, 아두이노우노
내용 : 진동센서의 D0핀을 7번에 연결하고 LED 핀은 12번에 연결하시오.



위 그림은 진동의 상태를 LED로 출력하기 위한 회로도 입니다.

3. 코딩


설계 : 진동이 발생하면 LED에 불이 들어오게 한다.

if(진동감지) LED 켜기;
else LED 끄기;

딱 두줄이면 됩니다. 실험에서는 디지털 입력을 받기 때문에 아래와 같습니다.

if(digitalRead(디지털핀)==LOW) digitalWrite(LED핀, HIGH);
else digitalWrite(LED핀, LOW);

종합해 보면,

const byte StatePin = 12;
const byte VibrationPin = 7;

void setup(){
 pinMode(StatePin, OUTPUT);
 pinMode(VibrationPin, INPUT); 
}

void loop(){
 if(digitalRead(VibrationPin)==LOW) digitalWrite(state, HIGH);
 else digitalWrite(state, LOW);
}

진동감지에 대한 간단히 코딩입니다. 실제 부품이 없어서 결과는 알 수 없지만 유사한 실험을 한다면 기울기센서로 대신 가상시뮬레이터에서 실험하시면 됩니다.



기울기 센서에서 기울기가 발생하면 LED에 불이 들어오는 실험이 있으닊나 진동센서를 기울기 센서로 감안하여 대신 실험을 할 수 있습니다.

4. 경보기 응용


진동센서와 피에조부저 같은 사운드 출력 센서를 이용하면 진동이 발생하면 소리로 결과를 출력 할 수 있습니다. 경보장치로 활용하면 좋습니다. 보안이 필요한 대상에 대해서 진동이 발생하면 경보음이 울리게 설정 할 수 있습니다.

1) 진동센서 경보기 회로도


준비물 : 진동센서, LED 1개, 저항 220옴 1개, 아두이노우노
내용 : 진동센서의 D0핀을 7번에 연결하고 LED 핀은 12번에 연결하시오.



피에조부저만 6번에 추가로 연결하시면 됩니다.

2) 코딩


위 진동센서 회로도에서 피에조부저만 추가로 부착되었기 때문에 소리에 대한 부분만 표현하시면 됩니다.

  • 피에조부저 : tone(핀번호, 주파수, 출력시간), noTone(핀번호), delay(시간값)

간단히 한음의 소리를 울리게 표현을 하면 아래와 같습니다.

   tone(SoundPin,523,1000/8);     // 도음으로 8분음표(음길이)
   delay(1000/4*1.30);             
   noTone(SoundPin);         

이 코딩을 어디에 넣어야 할까요? 바로 진동이 발생하는 시점에 경보음이 울리게 하면 됩니다.

종합해보면,

const byte StatePin = 12;
const byte VibrationPin = 7;
const byte SoundPin = 6;

void setup(){
 pinMode(StatePin, OUTPUT);
 pinMode(VibrationPin, INPUT); 
}

void loop(){
 if(digitalRead(VibrationPin)==LOW) {
   digitalWrite(state, HIGH);
   tone(SoundPin,523,1000/8);     // 도음으로 8분음표(음길이)
   delay(1000/4*1.30);             
   noTone(SoundPin);         
 }
 else digitalWrite(state, LOW);
}

유사한 예제로는 아래 거리경보장치 실험을 참조하시면 됩니다. 초음파센서로 거리값으로 경보음이 울리는 예제인데 여기서 진동센서의 역할을 초음파센서가 대신한 걸로 상상하시면 됩니다.



마무리


진동센서에 대해서 간단히 살펴보고 응용 예제로 진동센서로 경보장치를 상상해 보았습니다. 이것 말고도 다양한 것을 상상 할 수 있습니다. 위에서는 디지털 입력을 다뤘지만 진동에 대한 아날로그 입력을 받을 수 있다면 진동의 강도에 따라서 다양한 명령을 내릴 수 있습니다. 디지털 입력의 경우는 진동 하냐/안하냐 두가지 상태지만 아날로그는 진동의 범위에 따라 내리는 명령을 다양하게 내릴 수 있어 진동의 강도에 따른 섬세한 제어가 가능하다는 걸 알아 두세요.

아두이노는 재밌는 부품이 많습니다. 진동을 발생하는 진동모터가 있는가 하면 진동을 감지하는 진동센서가 있습니다. 여러분들도 특정 부품에 대해 조사하고 실험을 할 때 어떤 A동작을 수행하는 부품이 있다면 반대의 B동작의 부품이 없는지 같이 찾아서 공부하시면 아두이노 공부에 많은 도움이 됩니다. 공부하실 때 같은 동작을 하는 부품을 찾거나 반대 동작하는 부품을 같이 찾아서 공부를 꼭 해주세요. 못찾으면 어쩔 수 없지만 찾으시면 따블로 공부 효과를 얻을 수 있기 때문에 꼭 제가 말한 방식으로 아두이노를 공부해 주세요. 그래야 나중에 뭔가를 표현하고 싶을 때 도움이 많이 됩니다.

댓글()

[아두이노] 진동모터(Vibration Motor) 제어

IOT/아두이노|2019. 8. 12. 09:00

[아두이노] 진동모터(Vibration Motor) 제어



오늘은 가상시뮬레이터에 제공되는 부품 중 한가지 진동모터 부분을 빼먹은 것 같아서 진동모터에 대해서 이야기를 하고자 합니다. 진동모터는 모터에서 진동을 일으키는 모터입니다. DC모터는 모터가 회전하는 반면에 진동모터는 회전이 아닌 진동입니다. 제어하는 방식은 DC모터와 동일하며 전류가 공급되면 진동이 발생하고 전류의 세기에 따라서 진동의 세기가 달라집니다. 따로 알아야 할 부분은 없으면 가볍게 진동모터에 대해서 이야기 하고자 합니다.

1. 진동모터(Vibration Motor)


진동모터는 모터의 진동을 발생하는 부품입니다. 진동을 발생은 인간에게 촉감으로 느끼게 하는는 부품이라고 할 수 있습니다. 대표적인 예로 스마트폰은 전화나 문자가 올 때 사운드(음악소리)로 기본적으로 알립니다. 여기서 진동모드로 바꾸면 사운드가 아닌 스마트폰의 진동으로 전화나 문자가 온 걸 알려주게 됩니다. 이처럼 소리가 아닌 진동으로 인간에게 특정한 상황을 알릴 수 있습니다. 즉, 진동응 인간이 촉감으로 느낄 수 있는 출력부품으로 어떤 상황을 진동으로 감지할 수 있게 하는 출력부품이라고 생각하시면 됩니다.

그리고 진동모터는 상상하실 때 이렇게 생각하시면 됩니다. LED, 스피커 등과 같은 다양한 출력 부품들의 표현들을 진동모터로 대신하여 표현 할 수 있기 때문에 진동모터로 순순하게 상상하실 필요 없이 기존의 다양한 출력 부품들을 진동모터로 대체하고 응용상상을 하시면 됩니다.

가상시뮬레이터에서 제공되는 진동모터는 5V 입니다. 일반적인 DC모터를 제어하던 방식과 비슷합니다.


실제 실험에 사용하는 진동모터는 소형진동모터로 모터의 종류에 따라서 필요 전압이 다릅니다. 아두이노우노는 3.3V와 5V를 공급해줍니다. 아두이노우노 핀에서 출력 전압이 5V인데 만약 3V대 진동모터라면 아래와 같이 저항을 붙여 줘야 겠지요.


여러분들이 구매하신 진동모터가 몇V인지를 꼭 확인하시고 회로도를 구성하시면 됩니다.

참고로 아두이노우노는 PWM 핀은 아날로그 출력을 0~255(0~5V)을 출력 제어할 수 있습니다. 즉, 아날로그 출력값에 따라서 진동의 세기를 조절 할 수 있습니다. 위 두개의 의 그림을 보시면 5V일 때 진동모터는 진동 이미지로 3개의 띠를 보여주지만 저항이 붙은 진동모터는 2개의 띠가 희미하게 보이실 꺼에요. 이처럼 V값에 따라서 진동의 세기가 달라집니다.

진동모터를 구매하실 때 진동모터 사양을 꼭 확인하시기 바랍니다. 소형진동모터는 대개 약3V정도 인 것 같더군요.


참고로 가상시뮬레이터에 있는 위 그림 형태의 진동모터를 제공합니다. 이것을 가지고 회로도를 구성한다면 아래와 같겠죠.


void setup(){
  pinMode(3, OUTPUT);
}
void loop(){
  analogWrite(3, 255); //진동세기 임의의 값
  delay(1000);
  analogWrite(3, 0);
  delay(1000);
}

이렇게 가상시뮬레이터에서 돌리면 전압이 너무 낮아서 진동하지 않네요. 뭔가 잘못된 건가 하고 실제 구현하신분들의 영상을 보면 정상적으로 동작하더군요. 가상시뮬레이터에서는 진동모터가 5V라서 아두이노 핀에서 출력되는 전압이 낮고 해서 진동이 발생하지 않았습니다. 잘못되었다기 보다는 진동 전압이 낮기 때문에 진동을 가상시뮬레이터에서 발생시키지 못하더군요. 저항을 제거하고 실험하셔도 전압이 낮더군요. 디지털핀에서 제공되는 전압에서는 모터가 가상시뮬레이터에서 반응이 없습니다. 아래 3.3V와 5V에서는 진동이 전상적으로 발생하지만 디지털 핀에서의 전원공급에는 좀 문제가 있습니다. 사실 디지털핀으로 전원을 공급한다는 설계 자체가 좀 문제가 있습니다. 진동모터도 모터의 일정인데 디지털핀에서 모터의 전원을 공급한다는 설정은 좀 그렇죠. 아무리 낮은 전압이라도 모터는 모터이기 때문에 될 수 있으면 디지털 핀같은 곳에서 모터의 전원을 공급하는 설정은 추천하지 않습니다. 제가 post에서 실험한 내용은 단지 예를 든 실험입니다.

아무튼 아래 그림처럼 가상시뮬레이터에서 이렇게 결과가 나오네요.


전압이 낮은 진동모터였다면 동작을 했겠죠. 위 그림처럼 실험 할 시에 저항은 진동모터 전압에 맞는 저항을 붙여줘야 합니다. 최대 진동을 기본으로 맞추고

analogWrite(3, 255); //진동세기 임의의 값

이렇게 255가 되었을 때 최대 진동이고 0~255사이의 값을 줌으로서 진동의 세기를 조절 할 수 있게 됩니다. 최소 전압도 필요하기 때문에 너무 낮은 값으로 출력하면 진동모터가 동작 안할 수 있습니다. 가상 시뮬레이터는 전압이 5V 진동모터라 아두이노에서 출력되는 전압이 약4.7V에다가 저항에 따라서 1.92V정도 나왔네요. 그래서 진동을 가상시뮬에터에서 발생하지 않지만 실제는 다릅니다.

참고로, 저항없이 바로 PWM(3번)핀에 연결하시면 됩니다. 그럴 경우는

analogWrite(3, 100); //진동세기 임의의 값

진동 세기값으로 실험하는 진동모터의 최대값 수치가 예를 들어 100이라고 가정하면 100이상만 안넘기게만 하면 됩니다. 위 진동모터는 고려해야 부분이 몇가지 있네요.

아래 사진처럼 모듈형태의 진동모터도 제공되고 고려할 부분은 모듈 전압만 확인 하시면 됩니다. 회로도 연결은 간단합니다.

그림 출처 : https://www.aliexpress.com

모듈형태의 진동모터는 제어가 훨씬 편합니다. SIG, VCC, GND 핀으로 구성되어 있고 SIG핀은 아두이노 PWM핀에 연결하여 값만 넣으시면 됩니다.

예) SIG (3번핀) 연결 되었을 경우


void setup(){
  pinMode(3, OUTPUT);
}
void loop(){
  analogWrite(3, 200); //진동세기 임의의 값
  delay(1000);
  analogWrite(3, 0);
  delay(1000);
}

대충 이런식으로 제어를 할 수 있겠죠.

이제는 가상시뮬레이터에서 동작하게끔 변형 시켜서 실험을 해보도록 하겠습니다.

2. 진동모터 회로도


준비물 : NPN트렌지스터, 저항 1k옴 1개, 진동모터 1개, 아두이노우노
내용 : 3번핀을 진동모터 핀으로 이용해 봤네요.



위 그림에서 다이오드와 캐피시터를 달아야 하는데 생략 했네요.

실제는 아래 그림처럼 해도 동작할 꺼에요.


위 처럼 가상시뮬레이터에서 실험하면 움직이지 않습니다. 문제가 있는가 하고 인터넷 실험 영상을 찾아보니깐 동작에는 문제가 없어 보이더군요. 전류를 살펴보니 너무 낮은 전압이라서 동작을 안한 것이더군요. 아무튼 실제로 하실 때는 .트렌지스터 사용하지 않고 간단히 표현하셔도 아마 될 듯 싶네요.

3. 코딩


PWM핀을 이용하는데 analogWirte()함수를 이용하셔도 되지만 그냥 기본 digitalWrite()함수를 이용하셔도 됩니다. 가상시뮬레이터에서는 digitalWrite()함수를 이용했습니다.

void setup()
{  
  pinMode(3, OUTPUT);
}

void loop()
{
  digitalWrite(3, HIGH);
  delay(1000); 
  digitalWrite(3, LOW);
  delay(1000); 
}

4. 결과



위 회로도를 보시면 어디서 많이 본 듯한 회로도이지 않나요. 예전에 DC Motor에서 다뤘던 회로도 입니다.



참고 post의 회로도에 약간 다른 방식으로 디자인 해 봤네요. DC MOTOR편을 보시고 참고하셔서 회로도를 디자인을 하셔도 됩니다.

마무리


위에서 표현한 방식으로 표현하실 필요는 없습니다. 실제로 실험 하실 때는 진동모터의 사양을 보시고 필요 전압이 몇인지에 따라서 아두이노에 직접 연결하실 때 저항을 붙여서 연결하시든지 아니면 그냥 연결하시고 나서 PWM핀에 analogWirte()함수를 이용하여 진동 모터의 세기 전압만 맞추셔도 됩니다.

간단한 진동모터를 좀 복잡하게 설명한 것 같네요. 아무튼 진동모터로 할 수 있는 것들이 뭐가 있는지 한번 여러분들이 찾아보시고 뭘 할 수 있을지 상상해 보세요.

댓글()

[아두이노] 시리얼 플로터 사용

IOT/아두이노|2019. 8. 9. 09:00

[아두이노] 시리얼 플로터 사용



아두이노를 실험 할 때 지금까지는 시리얼 모니터로 디지털 값으로만 확인 해 봤습니다. 사실 지금까지 시리얼 플로터를 사용하지 않는 이유는 시이얼 플로터로 결과를 확인이 필요한 경우가 없었는데 지난 시간에 Color Sensor를 사용하면서 시리얼 플로터로 결과를 확인할 필요성이 느껴져서 이번에 post 주제로 선정했네요. 시리얼 플로터는 아날로그 파형으로 그래프 형태로 결과를 시각적으로 보여주는 출력 장치입니다. 그럼 이제 시리얼 플로터가 어떤 느낌인지 자세히 살펴보도록 하죠.

1. 시리얼 플로터


시리얼 모니터는 출력값을 디지털 형태의 숫자로 결과를 출력을 하고 시리얼 플로터는 아날로그 형태의 그래프 형태로 시각화 출력을 합니다.

그러면 시리얼 모니터와 시리얼 플로터의 출력 형태를 비교해 볼까요.

[실험 소스]

int output = 1;
unsigned long timeVal = 0;

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

void loop()
{   
   if(millis()-timeVal>=100){ //0.1초 단위로 1 or -1의 결과를 출력합니다.
    output=-output;
    timeVal=millis();    
   }
   Serial.println(output); //시리얼 출력
}

[시리얼모니터 결과]


[시리얼플로터 결과]


둘의 출력 형태가 어떤 느낌인지 아시겠지요.

2. 시리얼 플로터에 여러개의 데이터 출력


위에서는 한개의 데이터만 출력했습니다. 지난 시간에 실험한 Color Sensor은 3개의 RGB 데이터를 출력하는데 그러면 그 데이터는 한번에 같이 어떻게 출력 할까요.

아래와 같은 방식으로 코딩하시면 됩니다. 즉, 데이터와 데이터 사이를 공백으로 띄워서 데이터를 출력하면 나눠서 출력하게 됩니다.

int output = 1;
unsigned long timeVal = 0;

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

void loop()
{   
   if(millis()-timeVal>=100){ //0.1초 단위로 1 or -1의 결과를 출력합니다.
    output=-output;
    timeVal=millis();    
   }
     
     //시리얼 출력
   Serial.print(output); //데이터 1번
   Serial.print(" "); 
   Serial.println(output*2); //데이터 2번
}

즉, output와 output*2의 값 사이에 공백을 넣어주면 두개의 데이터를 동시에 아래 결과처럼 출력하게 됩니다.

[결과]


3. Color Sensor 값을 시리얼 플로터로 출력



지난 시간의 회로도를 그대로 적용 합니다.

1) Color Sensor 회로도


위 회로도는 지난시간에 만들 회로도이고 코딩도 그래도 적용합니다.

2) 코딩


시리얼 출력 부문만 약간 수정합니다.

const byte s0_pin = 3;
const byte s1_pin = 4;
const byte s2_pin = 5;
const byte s3_pin = 6;
const byte out_pin = 7;

const byte r_pin = 9;
const byte g_pin = 10;
const byte b_pin = 11;


void setup() {
  Serial.begin(9600);
  
  pinMode(r_pin, OUTPUT);
  pinMode(g_pin, OUTPUT);
  pinMode(b_pin, OUTPUT);
  
  pinMode(s0_pin, OUTPUT);
  pinMode(s1_pin, OUTPUT);
  pinMode(s2_pin, OUTPUT);
  pinMode(s3_pin, OUTPUT);
  
  pinMode(out_pin, INPUT);
  
  digitalWrite(s0_pin,HIGH);
  digitalWrite(s1_pin,LOW);
}


void loop() {
  digitalWrite(s2_pin,LOW);
  digitalWrite(s3_pin,LOW);
  int red_color = pulseIn(out_pin, LOW);
  red_color = map(red_color, 25,72,255,0);
  red_color = constrain(red_color, 0, 255);
  delay(50);
  
  digitalWrite(s2_pin,HIGH);
  digitalWrite(s3_pin,HIGH);
  int green_color = pulseIn(out_pin, LOW);
  green_color = map(green_color, 30,90,255,0);
  green_color = constrain(green_color, 0, 255);
  delay(50);
  
  digitalWrite(s2_pin,LOW);
  digitalWrite(s3_pin,HIGH);
  int blue_color = pulseIn(out_pin, LOW);
  blue_color = map(blue_color, 25,70,255,0);
  blue_color = constrain(blue_color, 0, 255);
  delay(50);

  analogWrite(r_pin, red_color);
  analogWrite(g_pin, green_color);
  analogWrite(b_pin, blue_color);

  //시리얼 플로터 출력
  Serial.print(blue_color);
  Serial.print("  ");  
  Serial.print(red_color);
  Serial.print("  ");      
  Serial.println(green_color);
  
  delay(100);
}

시리얼 출력 부분에서 시리얼 플로터 출력으로 약간 수정 했네요. 시리얼 플로터에 색상에 맞추다 보니깐 B, R, G 순으로 했네요. 혹시 여러분들이 출력을 했는데 아래 결과의 색상이 다르면 위 코딩의 색상 출력 순서를 변경하시면 됩니다.

3) 결과



Color의 변화를 시각적으로 확인 할 수 있습니다. 자세히 보시면 노이즈로 인해 색값이 변화가 중간에 심하게 발생하는 보실 수 있을꺼에요. 센서 자체가 납땜이 안되어 있고 전선꼽아서 하기 때문에 손으로 만지면 전선과 센서 사이에 잡음이 발생 할 수 밖에 없네요.

아래는 색상이 측정되고 출력되는 결과를 기록해 놓았습니다.


마무리


시리얼 플로터는 특정한 값의 변화를 시각적으로 확인하기에 편합니다. Color Sensor와 같은 부품을 제어 할 때에 값의 변화가 수치보다는 시각적 챠트로 보는게 더 효과적이겠죠. 이 챠트를 보면 색의 주파수 범위를 나중에 색종이를 가지고 지정할 때 활용하면 좋겠죠.

오늘은 간단히 시리얼 플로터를 사용하는 방법을 살펴 보았네요.


댓글()

[아두이노] Color Sensor 제어

IOT/아두이노|2019. 8. 1. 09:00

[아두이노] Color Sensor 제어



Color Sensor(TCS3200)은 색을 감지할 수 있는 센서입니다. 빛에서 색을 주파수값으로 읽는 센서인데 이 주파수 값을 가지고 RGB색을 만들어 내게 됩니다. 참고로 주파수 값을 읽을 수 있다고 해서 색값으로 바로 만들어 지지 않습니다. 각 RGB색의 값에 대한 주파수 영역을 잡아 색값 0~255사이의 값으로 변환 시켜야 합니다. 그 색 주파수 영역을 통해서 진짜 RGB색을 만들어 내는데 최근에 구매한 부품이여서 정확히 RGB 주파수 영역을 직접 만들어 내지 못했네요. 색종이로 RGB색을 측정하여 주파수 영역을 잡고 조정 작업을 해야 하는데 이미 만들놓은 분의 RGB 주파수 영역을 인용하여 간단히 실험을 하였습니다. 시간적 여유가 되시는 분들은 꼭 직접 RGB 주파수 영역을 본인이 가지고 있는 Color Sensor의 값을 측정하면서 원시값을 토대로 직접 그 영역을 만들어 보세요. 영유가 안된다면 저처럼 인용을 통해 간단히 실험하시면 됩니다.


1. Color Sensor




위 그림처럼 해당 핀에 대해서 살펴봅시다.

S0, S1 핀을 통해서 출력되는 주파수 크기값을 지정 합니다.


퍼센트 수치가 클수록 출력되는 숫자의 값은 작아 집니다. (L, H)은 숫자의 크기가 너무 큰 수가 나오고 (H,H)은 너무 작은 숫자값이 나오기 때문에 RGB색을 추출하기에는 좀 불편합니다. 그나마 색(0~255)을 만들기 위해서는 적당한 출력 수치값으로 (H,L)로 출력하면 적당한 주파수 크기로 출력됩니다. 실험에서는 (H,L)로 20% 크기로 출력됩니다.

RGB 각 색의 주파수 값을 얻기 위해서는 S2, S3의 상태로 해당 색상의 주파수 값을 얻을 수 있습니다.


위 표를 통해 RGB 색의 주파수 값을 얻게 됩니다.

결론은 S0, S1은 출력되는 주파수 크기를 지정하고 S2,S3은 해당 색을 지정해 줍니다.

2. Color Sensor 회로도




Color 센서에서 측정된 RGB 값을 3색 LED로 출력하는 회로도 입니다.

3. 코딩


위 데이터시트에의 나온 표를 기반으로 Color Sensor의 색을 읽기

Red 색 읽기

digitalWrite(s0_pin,HIGH); //출력 크기
digitalWrite(s1_pin,LOW);

digitalWrite(s2_pin,LOW); //Red 색
digitalWrite(s3_pin,LOW);
int Red = pulseIn(out_pin, LOW); //Red 주파수 값

Green 색 읽기

digitalWrite(s0_pin,HIGH);
digitalWrite(s1_pin,LOW);
digitalWrite(s2_pin,HIGH); //Green 색
digitalWrite(s3_pin,HIGH);
int Green = pulseIn(out_pin, LOW);

Blue 색 읽기

digitalWrite(s0_pin,HIGH);
digitalWrite(s1_pin,LOW);
digitalWrite(s2_pin,LOW); //Blue 색
digitalWrite(s3_pin,HIGH);
int Blue = pulseIn(out_pin, LOW);

3가지 색을 이렇게 읽게 됩니다.

스케일 20%로 고정이니깐 출력 크기는 setup()함수로 빼내고 나머지 각 색은 Loop함수에서 지정해 주면 되겠죠.

R,G,B 색값을 읽으면 그 색값이 색으로 보여지지 않습니다. 데이터시트에 가시면 주파수 챠트가 있는데 그걸 보고 색의 추출 범위를 지정해야 합니다.

색종이 같은 걸로 Red, Green, Blue 색의 주파수 최소 최대 범위를 지정하면 좋은데 색종이가 없어서 색의 범위 지정하기 어려워서 색의 범위를 만든 post를 겨우 찾아서 색의 범위를 지정할 수 있게 되었네요.



위 post 출처에서 Red, green, blue의 범위를 인용하여 실험했네요.

red_color = map(red_color, 25,72,255,0);
green_color = map(green_color, 30,90,255,0);
blue_color = map(blue_color, 25,70,255,0);

제가 보유한 Color Sensor는 깔금하게 색을 만들어 내지 못하더군요. 그리고 색 값이 0~255 범위를 벗어나는 값이 나오기 때문에 constrain()함수로 0~255사이로 묶어 두었습니다. 0보다 작은 값은 0에 고정되게 하고 255값을 벗어나면 255에 고정되게 만들었네요.

Red을 기준으로 표현하면

int Red = pulseIn(out_pin, LOW);
red_color = map(red_color, 25,72,255,0);
red_color = constrain(red_color, 0, 255);

나머지 색도 위 코딩과 같이 코딩하시면 됩니다.

Color 값을 만들었다면 그 값을 3색 LED로 핀은 PWM 핀으로 아날로그값을 출력하기 때문에 아래와 같이 코딩하면 됩니다.

RGB LED 출력

analogWrite(r_pin, red_color);
analogWrite(g_pin, green_color);
analogWrite(b_pin, blue_color);

종합해 보면,

const byte s0_pin = 3;
const byte s1_pin = 4;
const byte s2_pin = 5;
const byte s3_pin = 6;
const byte out_pin = 7;

const byte r_pin = 9;
const byte g_pin = 10;
const byte b_pin = 11;


void setup() {
  Serial.begin(9600);
  
  pinMode(r_pin, OUTPUT);
  pinMode(g_pin, OUTPUT);
  pinMode(b_pin, OUTPUT);
  
  pinMode(s0_pin, OUTPUT);
  pinMode(s1_pin, OUTPUT);
  pinMode(s2_pin, OUTPUT);
  pinMode(s3_pin, OUTPUT);
  
  pinMode(out_pin, INPUT);
  
  digitalWrite(s0_pin,HIGH);
  digitalWrite(s1_pin,LOW);
}

void loop() {

  //Red Color Read
  digitalWrite(s2_pin,LOW);
  digitalWrite(s3_pin,LOW);
  int red_color = pulseIn(out_pin, LOW);
  red_color = map(red_color, 25,72,255,0);
  red_color = constrain(red_color, 0, 255);
  delay(50);
  
  //Green Color Read
  digitalWrite(s2_pin,HIGH);
  digitalWrite(s3_pin,HIGH);
  int green_color = pulseIn(out_pin, LOW);
  green_color = map(green_color, 30,90,255,0);
  green_color = constrain(green_color, 0, 255);
  delay(50);
  
  //Blue Color Read
  digitalWrite(s2_pin,LOW);
  digitalWrite(s3_pin,HIGH);
  int blue_color = pulseIn(out_pin, LOW);
  blue_color = map(blue_color, 25,70,255,0);
  blue_color = constrain(blue_color, 0, 255);
  delay(50);

  //3색 LED에 RGB 출력
  analogWrite(r_pin, red_color);
  analogWrite(g_pin, green_color);
  analogWrite(b_pin, blue_color);
  
  Serial.print("RED: ");
  Serial.print(red_color);
  Serial.print("  ");
  
  Serial.print("GREEN: ");
  Serial.print(green_color);
  Serial.print("  ");

  Serial.print("BLUE: ");
  Serial.print(blue_color);
  Serial.println("  ");
  
  delay(1000);
}

4. 결과


시리얼 모니터에 색값을 출력해 보았습니다.


스케일을 2%로 지정했다면 위 값은 천단위로 출력되고 스케일을 100% 했다면 일단위로 값이 출력됩니다. 위 결과처럼 20%가 가장 적당합니다. 참고로 위 결과는 20% 스케일의 map()함수를 이용하여 주파수 값을 색값으로 변환하고 다시 constrain()함수로 0~255사이로 고정시켜 나온 결과입니다.

아래 3색 LED에 Color Sensor로 측정한 값이 출력한 영상인데 깔끔하게 출력되지 않네요. Color Sensor를 딱 붙이지 않고 좀 높이를 어느정도 띄워서 측정하면 색이 좀 더 측정하는 색에 가깝게 출력되더군요. 한손으로 측정하고 한손으로 스마트폰 촬영을 하다 보니깐 높이를 제대로 맞추지 못해서 결과는 마음에 들지 않게 나왔네요.


마무리


Color Sensor부품은 처음에는 좀 쉽게 생각했는데 다루기가 좀 까다로운 부품이네요. 동작 코딩은 어렵지 않지만 정확하게 색의 값을 만들어 내는게 쉽지 않네요. 센서의 연결 부분에 노이즈가 발생하면 값의 변화가 크고 정확하게 RGB값으로 분리해 내기도 어렵습니다. 직접 사용하는 센서의 측정되는 RGB값의 범위를 일일히 잡아야 하는게 쉬운 부품이 아니네요. RGB 색값의 범위를 지정 할 수 있다면 나머지 부분은 간단하기 때문에 컨트롤 하기는 어렵지는 않는데 색 주파수 영역이 문제네요.


댓글()

[아두이노] 마그네틱도어센서+멜로디 트렌지스터 응용

IOT/아두이노|2019. 7. 31. 09:00

[아두이노] 마그네틱도어센서+멜로디 트렌지스터 응용



오늘은 지난시간에 다룬 멜로디 트렌지스터를 가지고 마그네틱도어센서에 연동하여 출입문 알림이를 상상해보는 시간을 가져 보았습니다. 일상에서 사용되는 여러가지 응용들을 중에 이 주제를 선택한 이유는 아주 간단한 원리로 동작하기 때문입니다. 실제 부품이 없는 상태에서도 충분히 상상코딩이 가능하기 때문입니다. 편의점 같은 장소에서 출입문을 열고 들어가면 멜로디가 나오는 상점들을 한번쯤은 들어보셨을 꺼에요. 그러면 어떻게 멜로디가 나오는 것일까요. 아주 간단합니다 .출입문 쪽에 마그네틱도어센서가 부착되어 출입문이 닫혀있을 때와 열렸을 때 마그네틱도어센서의 값은 1 or 0 의 상태값이 발생하고 그 값을 통해서 멜로디 IC를 작동시켜 출입문이 열렸을 때 멜로디가 연주 되게 회로도를 구성하면 됩니다.

그러면 마그네틱도어센서로 어떻게 멜로디 IC를 동작시키는지 아두이노로 간단히 상상 테스트를 해보도록 하죠.

1. 마그네틱도어센서



마그네틱도어센서는 일반 스위치와 같은 용도로 사용합니다. 위 그림에서 보는 것처럼 두개의 물체로 구성되어 있고 한쪽 물체에 두개의 전선 가닥이 연결되어 있습니다. 한쪽 전선에 전류를 Input(입력) 되면 다른 전선은 Output(출력) 역할을 합니다. 전선이 연결되어 있는 물체 몸체와 반대면 물체 몸체가 가까워지거나 멀어질 때 Output(출력) 상태는 1 or 0의 상태가 됩니다. 즉, 두 물체가 가까워지거나 멀어질 때 전선이 연결된 위치에 자력에 의해가 연결되거나 끊어지게 되는데 전류의 상태는 1 or 0 됩니다.

2. 마그네틱도어센서+Melody IC 회로도(도어상태알람)



마그네틱도어센서를 실제 가지고 있지 않아서 대충 상상력을 동원하여 회로도를 만들어 보았네요. 사전학습 post의 아두이노에 연결한 멜로디 IC를 간단히 표현했는데 거기에 마그네틱도어센서만 추가로 부착해 봤네요.


3. 코딩


실제로 실험을 못하기 때문에 코딩은 최대한 오류가 없는 방향으로 상상코딩을 해보도록 하겠습니다.

편의점 같은 장소에서 출입문을 열고 들어가면 잠깐 멜로디가 나오는 것을 들으신 적이 있을 꺼에요. 그걸 상상코딩을 해보도록 하겠습니다.

우선 마크네틱도어센서가 가까울 때(닫힘)는 "1" 상태이고 멀어질 때(열림) "0"상태라고 가정하겠습니다.

회로도의 센서값 읽기는 디지털 상태가 0 or 1을 읽는 digitalRead()함수를 사용하니깐 아래와 같이 코딩합니다.

int senserValue = digitalRead(마그네틱도어센서핀);

0 or 1상태에서 멀어질 때(열림) 멜로디 연주가 시작이 되어야 하기 때문에 다음과 같이 코딩 합니다. senserValue값에 따라서 해당 2번핀에 digitalWrite()함수로 전류를 출력하면 멜로디가 연주되고 전류를 차단하면 멜로디가 중단 되게 코딩을 하면 됩니다.

if(senserValue==LOW) digitalWrite(멜로디핀,HIGH);
else digitalWrite(멜로디핀,LOW);

종합해보면,

const byte melodyPin = 2;
const byte swPin = 3;

void setup(){
  pinMode(swPin,INPUT);
  pinMode(melodyPin,OUTPUT);
}
void loop(){
  int senserValue = digitalRead(swPin);
    
  if(senserValue==LOW) digitalWrite(melodyPin,HIGH);
  else digitalWrite(melodyPin,LOW);
    
  delay(50);
}

대충 위와 같은 코딩으로 표현 하면 될거라 생각 되네요. 따로 문제가 되는 부분은 없고 간단한 실험을 했기 때문에 회로도나 코딩에는 문제가 없을거라 생각됩니다.

마무리


마그네틱도어센서는 서로 전선이 연결되어 있지 않는 상태에서 자력의 원리를 이용하여 전류의 흐름을 제어할 수 있는 부품이라 참 재밌는 부품입니다. 이 부품으로 도어상태알람을 상상 실험을 했지만 이것 말고도 다양한 응용 분야에 사용되고 있습니다. 가령 창문에 연결하면 방범알람이로 디자인 할 수 있습니다. 여기에 추가로 Bluetooth or Wifi 같은 무선 모듈을 연결하면 스마트폰으로 방범 정보를 전송할 수 있게 됩니다. 집 같은 장소에다가 방범장치로 활용하면 원격으로 정보를 스마트폰으로 수신할 수 있어 꽤 유용하겠죠. 이걸 계속 업그레이드 하면 더 재밌는 것을 만들어 내실 수 있을 꺼에요.

그리고 마그네틱도어센서 대신에 근접센서나 인간감지센서와 같은 부품을 접목한 다양한 표현들이 현실에 존재합니다. 한번 어떤 것들이 있는지 찾아 보세요. 그리고 아두이노시각으로 그걸 한번 구현해 보세요.

댓글()

[아두이노] 멜로디 트렌지스터

IOT/아두이노|2019. 7. 30. 09:00

[아두이노] 멜로디 트렌지스터



오늘은 특정 멜로디 트렌지스터(UTC UM66TXXL) 부품에 대해 이야기를 하고자 합니다. 참 재밌는 부품으로 이 부품에 스피커를 연결하고 전류를 공급하면 멜로디가 흘러 나옵니다. 멜로디가 나오는 부품은 활용 분야가 엄청 많습니다. 여러분들도 일상에서 한번쯤은 접해 봤을 꺼에요. 편의점 문을 열때 멜로디가 나오거나 자동차 후진음으로 멜로디를 들어 보신분들이 많을꺼에요. 그리고 경보장치, 알람장치, 장난감 등에서 한번쯤은 들어 보셨을 거라 생각합니다. 이렇게 열거한 곳에서 멜로디 트렌지스터가 사용 됩니다.

이제 멜로디 트렌지스터를 어떻게 사용하는지 간단히 살펴보도록 하죠.

1. 멜로디 트렌지스터(데이터시트 내용을 간단히 정리)



링크 걸어 놓은 UTC UM66TXXL데이터시트에 가시면 자세히 이 부품에 대한 설명이 나와 있습니다. 데이터시트에 나온 내용 중 최소 알아야 할 부분만 발췌해서 아래와 같이 정리 했습니다. 자세히 보고 싶으시다면 위 출처에 가셔서 확인하시면 되겠습니다.


부품은 간단합니다. 그리고 데이터시트에 가셔서 보시면 2개의 형태의 회로도가 아래와 같습니다.

출처 : 데이터시트 (p4)



위 회로도는 데이터시트에 나와 있는 기본 회로도 입니다. 스위치 버턴을 이용하여 피에조부저와 스피커로 멜로디를 출력하는 회로도 이더군요. 그림2은 전자부품 쇼핑몰에 가시면 키트로 판매하더군요 약2천 얼마였던 것 같은데 잘 기억이 안나네요.

여기서 아두이노에 연결하여 실험한다면 스위치 부분만 아두이노우노의 핀에 연결하시면 아두이노 우노에서 제어가 가능해 집니다.

참고로, 이 부품은 한곡의 멜로디가 담겨져 있지만 부품 번호에 따라서 멜로디가 다릅니다. 데이터시트에 나온 멜로디 리스트는 다음과 같습니다.


"XX" 위치에 Number를 통해 곡이름을 알 수 있습니다.

참고로, 해당 부품의 가격은 개당 400~500원 사이의 가격정도 되더군요. 사실 실험을 하기 위해서 약 500원짜리 부품을 구매하기 위해서 택배로 주문 하는 것 자체가 너무 낭비인 것 같아서 실제 구매해서 실험을 해보고 싶었지만 아쉽게 못해봤네요.

2. 멜로디 트렌지스터 회로도


데이터시트에서 그림1번 회로도는 아래 그림과 같습니다.


위 그림의 회로도를 아두이노우노와 연결하면 다음과 같습니다.


이렇게 3번핀을 스위치버턴의 역활을 수행하면 됩니다. 참고로 아두이노우노의 출력값은 0~5V입니다. 그래서 5V로 전류를 보내기 보다는 멜로디 IC은 "1.5V~4.5V" 전류를 맞춰야 하기 때문에 저항을 붙여주셔야 겠죠.

3. 코딩


void setup() {  
  pinMode(3, OUTPUT);  
}
void loop(){
 digitalWrite(3, HIGH);  //3초 멜로디 연주 시작
 delay(3000);
 digitalWrite(3, LOW);  //2초 멜로디 중단
 delay(2000);
}

3번핀이 스위치 버턴 역활을 하기 때문에 결과는 3초동안 멜로디 IC의 곡이 연주되고 2초동안 멜로디 연주가 중단됩니다. 간단히 동작 테스트입니다. 실제 부품으로 실험 할 때는 한곡의 시간을 측정하시고 그 시간만큼 delay를 주고 멜로디를 연주해 보세요.

결과는 사실 멜로디 IC가 없기 때문에 확인 할 수 없습니다. 하지만 대충 동작 느낌은 아시겠지요.

4. 비슷한 예제(과제)



거리경보장치 응용 post에 가시면 초음파센서를 이용하여 장애물 감지가 되면 경보음이 울리는 예제입니다. 이 예제에서 수정하는 부분은 피에조부저 부분에 멜로디 IC을 연결하시면 됩니다.


위 회로도에서 화살표가 가리키는 녹색선에다가 멜로디 IC를 연결하시면 됩니다. 코딩은 post에서 거리에 따른 멜로디가 연주가 되어야 하는데 이 경우는 특정 거리일 때 연주가 되어야 합니다.

그러면 연주시작/중지는 특정 거리를 기준으로

  if(distance < 50)  digitalWrite(11, HIGH);  
  else  digitalWrite(11, LOW);  

이렇게 11번이 스위치 연할을 담당하여 초음파센서로 측정한 거리를 기준으로 전류를 공급과 차단을 통해서 제어를 하면 됩니다.

간단히 설명했지만 실제로 멜로디 IC가 있으시면 직접 제작해 보세요. 위 회로도와 똑같이 만들 필요가 없습니다. 대충 거리경보장치의 동작 원리와 비슷한 실생활의 유사한 장치를 찾으시고 그 모습을 아두이노로 표현하시면 됩니다.

마무리


간단히 멜로디 IC를 통해 특정곡이 연주하는 방법을 살펴 보았습니다. 원리를 간단합니다. 2번핀에 전류를 공급하고 3번핀에 멜로디 신호가 나오고 3번핀에 스피커를 연결하면 멜로디 IC에 담겨진 곡이 연주가 됩니다.

오늘 내용은 별거 없습니다. 사실 실생활의 멜로디 IC는 아두이노와 같은 곳에다 프로그램을 이식해서 사용하기 보다는 하드웨어적 전류의 상태를 이용하여 동작하게 합니다. 즉, 스위치 부분의 특정 센서나 제어 부품을 부착하고 타이머관련 부품을 연동하여 전류를 일정시간동안 유지하게 해서 멜로디가 흘러나오게 하는 경우가 많습니다. 구지 아두이노에 연결하여 동작하는 실험을 한 이유는 확장성 때문입니다. 사실 하드웨어적으로만 제어하면 여러가지의 부품을 연동 할 때 회로도를 구성하기가 복잡합니다. 비전문가분들은 사실 회로도를 만드는 자체가 어렵습니다. 하지만 이 부품을 아두이노에 연결하면 아두이노의 핀값을 프로그램을 통해 제어하기 때문에 오늘 배운 멜로디 IC 뿐아니라 다른 부품과의 연동에서 쉽게 회로도를 만들 수 있습니다. 오늘 내용는 아두이노 3번핀을 멜로디 IC의 스위치 버턴 역할을 수행할 수 있다는 것은 별거 아닌 내용이지만 무척 중요한 내용입니다. 예로 감지센서값을 아두이노에서 읽고 그 값을 기준으로 멜로디 IC를 작동 시킨다고 생각해보세요. 경보기, 알람기 등을 아두이노로 만들 수 있겠죠. 회로도도 사실 각 부품을 아두이노 핀에 연결만 하면 쉽게 만들 수 있습니다.

제가 지금까지 post한 것 중에 한번 이 멜로디 IC를 결합하여 만들 만 한 것이 있는지 한번 찾아보세요. 순간 떠오른 것은 아두이노 RC카에다가 후진할 때 멜로디가 연주되게 하면 자동차 후진음과 같과 같은 형태로 재밌게 만들 수 있을 것 같네요. 하지만 부품이 없어서 실제로 실험을 못하는게 아쉽습니다. 나중에 기회가 되면 한번 구매해서 실험해 보고 싶네요.

댓글()

[아두이노] 뽑기기계 횟수 락 원리

IOT/아두이노|2019. 7. 29. 09:00

[아두이노] 뽑기기계 횟수 락 원리



오늘은 횟수 락이 걸린 뽑기기계에 대한 아두이노시각으로 그 원리를 이해하는 시간을 가져보도록 하죠. 꼭 이렇게 뽑기 기계가 만들어진게 아니고 비슷한 느낌으로 아두이노에서 표현하여 살펴보도록 하죠.

1. 뽑기기계의 가상 설정



대충 위그림과 같은 뽑기 기계가 있다고 가정해 봅시다. 화살 막대기가 좌에서 우로 이동하면서 사각구멍 위치에 정확히 멈출 때 상품을 꺼낼 수 있게 됩니다. 이런류 게임을 해보신 분들은 뽑기기계가 락이 걸려서 일정 횟수 이상 돈을 넣고 도전을 해야 뽑을 수 있게 되어 있다는 것을 유튜버들의 뽑기영상을 보시면 간접 체험을 여러분들은 해보신 분들이 많을 꺼에요.

유튜버가 하는 말이 정확히 멈췄는데 약간 락이 풀릴 때까지 계속 멈춘 위치에서 좀더 이동해서 멈춘다고 이야기를 하는 소리를 많이 들었을 꺼에요. 계속 정확히 멈추는데 밀린다고 락이 걸려서 일정 횟수 이상 계속 해야지 뽑을 수 있다고 뽑기 락에 이야기를 많이 들었을 꺼에요.

여기서 횟수 락은 도대체 어떻게 하는 것일까 아두이노 시각으로 관찰하고 유사한 실험을 해볼까 합니다.

[특징]

  • 일정 횟수가 안되면 못 뽑는다.
  • 부정확한 위치에서는 그상태로 멈추지만 뽑는 위치에 멈추면 약간 밀리는 느낌으로 좀 더 이동한다.

이 특징을 가지고 이제 실험을 해 보겠습니다.

2. 횟수 락 회로도


  • 준비물 : Servo모터 1개, 스위치 버턴 2개, 아두이노 우노
  • 내용 : 스위치버턴은 인터럽트함수를 이용하기 위해 2,3번에 연결하고 Servo모터는 7번에 연결하시오.

실제 뽑기 기계에는 Stepper Motor로 움직이지만 가상시뮬레이터에서 실험을 간단히 하기 위해서 Servo모터로 대신 실험을 합니다.


횟수 락을 실험하기 때문에 스위치 버턴 2개로 Servo Motor를 제어하하면서 회전을 하는데 특정 각도에 범위에 대한 횟수 락 실험을 하게 됩니다. 그래서 복잡한 회로도 설계를 할 필요가 없고 이 회로도만으로 충분히 횟수 락 실험이 가능합니다.

3. 코딩


[설계]

  • 3번 스위치 버턴은 게임 시작
  • 2번 스위치 버턴은 멈춤(정지)
  • 2번 스위치 버턴을 눌러 멈춘 위치가 상품 범위에 들 때 횟수 카운트 하기
  • 횟수 카운트 할 때 상품 뽑기 횟수가 부족하면 멈춤 위치를 좀더 이동 시킴
  • 상품 뽑기 횟수에 도달하면 멈춤 위치가 상품을 뽑는 위치면 성공

스위치 버턴 동작
3번 스위치 버턴은 뽑기 시작버턴이고 2번 버턴은 뽑기 멈춤 버턴입니다. 인터럽트 함수를 이용하기 때문에 코딩은 다음과 같습니다.

const byte interruptPin1 = 3;
const byte interruptPin2 = 2;
boolean stateStart = false;
boolean stateStop = false;

void setup()
{
  pinMode(interruptPin1, INPUT_PULLUP);
  pinMode(interruptPin2, INPUT_PULLUP);  
  attachInterrupt(digitalPinToInterrupt(interruptPin1), exchange1, FALLING);  //인터럽트 발생 시 호출
  attachInterrupt(digitalPinToInterrupt(interruptPin2), exchange2, FALLING);  //인터럽트 발생 시 호출
}
void loop(){

  if(stateStart==true){
    뽑기시작;   
  }
 if(stateStop==true){ //뽑기정지
    뽑기정지;
 }
}
void exchange1() { //인터럽트스위치버턴  이벤트1
  stateStart=true;  
  stateStop=false;
}

void exchange2() { //인터럽트스위치버턴  이벤트2
  stateStart=false;
  stateStop=true; 
}

위 코딩을 보시면 stateStart, stateStop 변수의 상태 값으로 두가지 뽑기시작과 뽑기정지 버턴의 동작을 수행하게 됩니다.

뽑기시작 코딩은
Servo모터의 회전을 시작하도록 코딩이 이뤄집니다.

Servo servo;
const byte servoPin = 7; 

void setup(){
  servo.attach(servoPin);   
  servo.write(0);
  delay(1000);
}

위의 코딩은 Servo모터 초기상태입니다. 회전이 시작되기전 0도의 위치가 시작지점입니다.

0~180도로 왔다 갔다 회전을 하도록 뽑기시작 명령을 코딩하면 다음과 같습니다.

  if(stateStart==true){ //뽑기시작
    val+=stateNum;
    Serial.println(val);

    if(val==180)stateNum = -1;
    if(val==0)stateNum = 1;    
    
    servo.write(val);
    delay(50);
  }

val은 회전각입니다. stateNum은 180도가 되면 -1로 바뀌고 0도가 되면 1로 바뀌게 if문으로 제어해서 0~180도 회전이 1도씩 움직이게 됩니다. 이렇게 해서 뽑기가 시작되는 걸로 간주하시면 됩니다.

뽑기정지 코딩은
뽑기가 시작되면 이제 Servo모터를 정지시켜야 합니다. 뽑을 각도에 멈춰야 상품을 뽑을 수 있겠죠. 여기에 뽑기 횟수 락을 코딩을 하게 됩니다.

횟수 락은

    if(val>95 && val<105){ //뽑기 성공각도
      if(cnt<2){ //cnt 횟수 락
        cnt++;
        val=106;      
      }
      else cnt++;
    }
    else if(val>80 && val<120){ //상품 A의 횟수 증가 범위
      cnt++;
    } 
        servo.write(val);
    delay(100);

뽑기 성공하는 각도 범위는 95~105도 사이가 되면 뽑기가 성공됩니다. 하지만 횟수 락으로 cnt변수값이 3회이상이여야지만 뽑을 수 있게 락이 걸리게 됩니다. 즉, 아무리 95~105도 사이에 멈추더라도 cnt(횟수) 3회 미만이 되면 강제적으로 106도 각도로 움직이게 하여 약간 밀리는 느낌으로 뽑기 실패가 됩니다.

여기서 여러개의 상품이 있는데 A상품을 뽑는다고 가정한다면 A상품에 대한 뽑기 횟수가 증가해야 겠죠. B상품은 B상품에 대한 카운터를 해야 됩니다. 그렇기 때문에 A상품에 대한 횟수 락을 카운트 할 범위를 지정해 줘야 합니다. 위 코딩은 cnt는 A상품으로 여기면 됩니다.

만약, 여러개의 상품을 한다면 cntA, cntB, cntC 이런식으로 횟수 증가 범위를 개별적으로 증가시켜서 코딩하시면 됩니다.

아무튼 위 코딩으로 횟수락을 완성했네요. 3회 이상이 되지 않는 다면 아무리 완벽하게 성공 범위 지점에 정지시켜도 회적각이 밀리게 됩니다. 뽑기가 어떤 느낌인지 아시겠지요.

종합해보면,

#include <Servo.h>

Servo servo;
const byte servoPin = 7; 
const byte interruptPin1 = 3;
const byte interruptPin2 = 2;

boolean stateStart = false;
boolean stateStop = false;

int val = 0;
int cnt = 0;
int stateNum = 1;

void setup()
{
  Serial.begin(9600);
    
  pinMode(interruptPin1, INPUT_PULLUP);
  pinMode(interruptPin2, INPUT_PULLUP);  
  attachInterrupt(digitalPinToInterrupt(interruptPin1), exchange1, FALLING);  //인터럽트 발생 시 호출
  attachInterrupt(digitalPinToInterrupt(interruptPin2), exchange2, FALLING);  //인터럽트 발생 시 호출
  
  servo.attach(servoPin);   
  servo.write(0);
  delay(1000);
}

void loop()
{
  if(stateStart==true){ //뽑기시작
    val+=stateNum;
    Serial.println(val);

    if(val==180)stateNum = -1;
    if(val==0)stateNum = 1;    
    
    servo.write(val);
    delay(50);
  }
  
  if(stateStop==true){ //뽑기정지
    if(val>95 && val<105){ //뽑기 성공각도
      if(cnt<2){ //횟수 락
        cnt++;
        val=106;      
      }
      else cnt++;
    }
    else if(val>80 && val<120){ //상품 A의 횟수 증가 범위
      cnt++;
    }    
    servo.write(val);
    delay(100);
    
        //결과
    Serial.print("End Val : ");
    Serial.println(val);
    Serial.print("Count : ");
    Serial.println(cnt);
    if(cnt>2 && val>95 && val<105){ //성공 메시지와 cnt 초기화
      Serial.println("success!");
      cnt=0;
    }
    else Serial.println("failure!"); //실패 메시지
    
    //초기화
    val=0;
    servo.write(val);
    delay(200);    
    stateStop=false;    
  }  
}

void exchange1() { //인터럽트스위치버턴  이벤트1
  stateStart=true;  
  stateStop=false;
}

void exchange2() { //인터럽트스위치버턴  이벤트2
  stateStart=false;
  stateStop=true; 
}

4. 결과


원래 뽑기 성공범위는 좀 더 좁은 범위로 해야 하는데 녹화를 딱 맞게 하기 위해서 성공 범위를 좀 넓게 지정했네요. 횟수 락의 카운트 값은 2입니다. 3회부터서 성공 범위에 들면 뽑기 성공이 됩니다. 성공 범위가 아닌 뽑기 범위면 카운트만 세고 성공 범위인데 횟수가 부족하면 강제적으로 성공 범위를 벗어나게 하는 동작 소스입니다.

횟수 락에 의해서 성공 범위인 103각도에 멈췄지만 106도 강제적으로 이동시켜 실패하게 만들었네요.


횟수 락이 풀리고 성공 범위인 97각도에 멈춰고 97각도로 최종적으로 완료 되어 3회만에 성공이 되었네요.


만약에 3회 이후에 성공 범위에서 멈추지 못했다면 계속 성공할 때까지 도전해야 합니다.

아래 도전 영상을 올려 놓았습니다.


마무리


원래는 다른 post를 준비 중이였는데 문득 뽑기 횟수 락이 떠올라서 작성 중인 post를 멈추고 뽑기 횟수 락 실험을 하게 되었네요. 실제 뽑기가 이렇게 코딩이 되어졌다는 의미는 아니고요 관찰을 통해서 대충 이런 느낌이 아닐까 하고 그 느낌을 코딩화 했을 뿐입니다.
아두이노는 재밌는 것은 주변 환경을 관찰하고 그 관찰된 현상을 코딩화를 쉽게 할 수 있다는 점입니다. 최근 post들이 주변에 접할 수 있는 한번쯤은 경험했던 상황들을 아두이노적 시각으로 실험하고 있는데 여러분들도 이런 감각을 배우셨으면 합니다.


댓글()

[아두이노] 구부림(flex) 센서와 관절 제어

IOT/아두이노|2019. 7. 26. 09:00

[아두이노] 구부림(flex) 센서와 관절 제어



지난 시간까지 주변 사물을 관찰하는 실험을 하였는데 문득 손을 보고 손의 움직임을 관찰하다가 한번 아두이노 시각으로 표현하고 싶은더군요. 그래서 손가락 관절을 제어하는 실험에 대해 상상하다가 예전에 공부했던 손가락의 움직임을 감지 할 수 있는 센서가 떠올랐네요. 실제 구부림 센서가 없어 실제로 실험은 못하지만 구부림 센서을 대해 간단히 이야기만 하고 가상시뮬레이터로 구부림 센서를 대신 할 부품으로 가변저항을 이용하여 가상시뮬레이터에서 손가락 관절 제어 실험을 해 보겠습니다.

1. 구부림(flex) 센서


구부림 센서는 구부림의 정도에 따라서 저항값이 달라집니다. 이 값을 통해서 구부림의 각도를 계산해 낼 수 있습니다.

int val = analogRead(A0);
int angle = map(val,입력최소값,출력최대값,0,90);

위와 같이 설정하면 구부림 값에 따라 0~90도의 각도를 만들어 낼 수 있습니다. 이 값을 통해서 Servo모터의 회전 시킬 수 있습니다.

2. 손가락 관절 제어


관철의 관찰 대상은 인간의 손으로 하겠습니다.


위 사진을 보시면 집게손가락을 보시면 세개의 관절이 있습니다. 이 부분의 동작을 관찰해 볼까요.

이제 주먹을 쥐어 볼까요.



자세히 보시면 각 마디의 관절이 약 90도 각도로 회전되어 있는 걸 보실 꺼에요.

이 관찰을 통해서 여러분들은 아두이노시각으로 표현한다면 뭐가 있을까요. 각도를 제어할 수 있는 Servo모터가 떠오르지 않나요.

집게손가락의 관절의 각도를 손이 쫙 펴진 상태에서 0도라면 주먹이 쥐어지는 과정은 서서히 3개의 관절의 각도를 증가시켜 90도 회전을 하게되면 주먹이 쥐어지는 형태가 됩니다. 이 원리를 잘 이용하게 손가락의 관절 제어를 할 수 있게 되겠죠.

오늘 다루게 되는 구부림센서를 이용하여 구부림의 각도값을 통해 3개의 관절(Servo모터)을 이용하면 손가락을 움직이게 할 수 잇겠죠.

이제 좀 더 자세히 알아보도록 하죠.

3. 구부림센서를 이용한 손가락 관절 제어


  • 준비물 : Servo모터 3개, 구부림센서, 저항 1m옴, 아두이노 우노
  • 내용 : A0는 구부림센서값을 읽기 위한 핀이고, Servo모터는 5,6,7핀을 이용한다.

실제 구부림 센서가 없기 때문에 회로도만 간단히 소개합니다.


위 회로도로 만들게 된다면 구부림의 정도에 따라서 3개의 Servo모터를 회전시키면 손가락 관절을 회전시키는 결과를 얻게 됩니다.

4. 가상시뮬레이터에서 손가락 관절 제어 실험


  • 준비물 : Servo모터 3개, 가변저항 1개, 아두이노 우노
  • 내용 : A0는 구부림센서값을 읽기 위한 핀이고, Servo모터는 5,6,7핀을 이용한다.

가상시뮬레이터에서는 구부림 센서는 없습니다. 예전에 post로 이야기 했듯이 없는 부품은 유사한 같은 느낌의 부품을 이용해서 실험을 하라고 했죠. 이번에는 가변저항을 이용하여 구부림 센서의 값을 대신하면 유사한 실험을 할 수 있게 됩니다.

위 회로도에서 보는 것처럼 가변저항의 Vcc, Gnd 핀을 연결하면 가변저항을 회전시키면 1023~0의 아날로그 신호의 변화가 일어나고가 발생합니다. 반대로 연결하면 0~1023의 아날로그 신호 변화가 일어납니다. 이 부분을 주위해주세요.

5. 코딩


손가락 과절 제어는 가상시뮬레이터에서 가변저항의 값을 각도로 바꾸기 위해서는 1023~0의 아날로그 신호값을 0~90도의 각도값을 만들고 그 각도만큼 회전시키면 됩니다.

int angle = map(analogRead(A0),0,1023,0,90);  

map()함수로 0~1023의 아날로그값을 0~90의 각도값으로 변환시킵니다. angle값으로 Servo모터를 회전시키면 됩니다.

servo1.write(angle);     
servo2.write(angle);     
servo3.write(angle);     

이렇게 가변저항을 통해 얻은 회전각을 3개의 Servomotor의 회전값으로 실행시켜면 자연스럽게 손가락 관절을 움직이게 됩니다.

종합해보면,

#include <Servo.h>

Servo servo[3];
const byte servoPin[3] = {5,6,7};

void setup()
{ 
  for(int i=0;i<3;i++){
    servo[i].attach(servoPin[i]); 
    servo[i].write(0);
  }  
  delay(1000);
}

void loop()
{  
  int angle = map(analogRead(A0),0,1023,0,90);  
  for(int i=0;i<3;i++){
    servo[i].write(angle);     
  }
  delay(50);
}

손가락 관절 제어라고 했는데 거창한 코딩을 기대하고 post를 보셨다면 크게 실망하셨을 거라 생각됩니다. 이걸로 손가락 관절이 제어가 되는지 의구심을 갖을 수 있겠죠.

시뮬레이터 결과로 간단히 설명 드리겠습니다.

6. 결과





위 결과를 보면 저게 손가락 관절이야 하실 꺼에요. 손가락 위치로 한번 재 배치 해 볼까요.


위 그림이 어느정도 회전에 대한 손가락 관절을 이해하셨나요.


7. 구부림 센서의 한계


구부림 센서는 손가락 한개의 구부림 각도 한개만 만들어 냅니다. 즉, 3개의 관절을 같은 각도로 제어하기 때문에 단순한 움직임만 만들어 냅니다. 정교한 손가락 움직임을 만들어 낼 수 없습니다. 손가락 3개의 관절 중 2개의 관절만 구부려도 구부림 센서는 이 값을 가지고 3개의 관절을 동일한 각도로 회전시키는 문제가 발생합니다.

처음에는 구부림 센서와 같은 부품으로 간단히 손가락을 움직이게 하고 나중에 능력이 된다면 근육센서로 신경값을 분석하여 손가락을 움직이는 실험을 해보세요. 나중에 기회가 된다면 꼭 해보고 싶은 실험입니다. 문제는 근육센서가 비싸고 단순히 Servo모터로 손가락을 제어하는것도 좀 부자연 스럽고 어느정도 로봇손에 관련된 고급 모터 부품을 쓴다면 재미로 실험하기에는 가격 부담이 크네요.

마무리


구부림 센서를 이용한 손가락 관절 제어는 구글검색을 하시면 쉽게 post들을 찾아 볼 수 있습니다. 대개 장갑에 구부림 센서를 부착하여 장갑을 낀 상태로 주먹을 쥐면 주먹을 쥔 각도만큼 구부림 센서는 구부러지고 그 구부림 각도만큼 아두이노에서 센서값을 읽고 회전각을 만들어서 구부린 각도만큼 회전을 시키면 실제 센서가 부착된 장갑에서 손동작과 유사하게 로봇손을 움직이게 할 수 있게 됩니다.

실제로 Servo모터가 16개가 있고 다수 Servo모터를 컨트롤 할 수 있는 모터쉴드랑 다섯개의 구부림 센서가 있다면 로봇손 전부를 움직이게 하는 실험을 할 수 있을 꺼에요. 하지만 제가 가지고 있는 부품이 Servo모터 1개뿐이라 실제 관절 실험을 못해 봤네요. 하지만 가상시뮬레이터로 어느정도 유사한 실험을 할 수 있는 것에 만족합니다.

댓글()

[아두이노] 아두이노 주차장 출입구 차량차단장치

IOT/아두이노|2019. 7. 25. 09:00

[아두이노] 아두이노 주차장 출입구 차량차단장치



일상을 주제로 주변에 상황을 아두이노로 표현하는 실험을 계속 진행 중입니다. 오늘은 아파트나 일반 주차장 또는 특정 건물에 차량을 진입하는 입구 쪽에 차량 차단장치가 설치되어 있는 곳들이 많습니다. 이 차량 차단장치를 아두이노적 시각으로 한번 실험을 해보도록 하겠습니다.

1. 주차장 출입구 차량차단장치 설정



위와 같이 상황은 근접감지센서를 다른 것을 이용해야 하는데 실험에서는 초음파센서를 이용하여 근접감지를 하도록 상황을 만들고 차량이 출입구 쪽으로 다가오면 근접감지가 되고 그 감지되었을 때 차량차단막기 올라가게 됩니다. 차량차단막이 내려져 있을 때는 Red LED에 불이 들어와 있는 상태이고 차단막이 올라가면 Green LED에 불이 들어오고 차량이 통과된다는 설정입니다.

2. 아두이노 주차장 출입구 차량차단장치 회로도


  • 준비물 : 적색 LED 1개, 녹색 LED 1개, 저항 220옴 2개, 초음파센서, Servo모터, 아두이노우노
  • 내용 : 8,9번핀은 LED에 연결하고 초음파센서핀은 7번, Servo모터은 6번 핀에 연결하시오.

실제 초음파센서는 4핀이지만 가상시뮬레이터에서는 3핀 초음파센서로 7번핀으로 Trig, Echo 역활을 수행합니다.


회로도는 복잡하지 않죠. 위 회로도는 각 역활은 아래 그림으로 이해하시면 되겠습니다.


3. 코딩



사전학습으로 Servo모터와 초음파센서에 대해서 한번 읽고 오세요. 사용하실 수 있는 분들은 그냥 넘어가셔도 됩니다.

[설계]

  • 초기신호등은 적색LED에 불이 들어온 상태가 되면 차량 정지를 의미한다.
  • 초음파센서로 근접거리가 일정거리이하가 되면 차량감지로 간주한다.
  • 차량감지가 되면 차량차단막이 올라간다는 느낌으로 Servo모터를 90도 회전한다.
  • Servo모터가 90도 회전이 되었다가 간주한 시점에 "적색->녹색" 등으로 변환시킨다.
  • 차량은 통과하는데 통과가 완료되었다고 생각되는 감지 시간을 기준으로 차단만은 일정시간 유지한다.
  • 마지막 차량 감지된 시간을 기준으로 일정시간 차단막이 올라가 있다가 차량이 통과했다고 생각 되는 시간에 차단막이 내려온다는 느낌으로 Servo모터를 0도로 회전시킨다.
  • 0도 회전을 할 때 "녹색->적색"등으로 변환시킨다.(정지)

차량감지

거리를 측정은 위 초음파센서 post의 거리 계산를 함수로 거리값을 구하게 됩니다.

int CalDistance (int Pin){  //초음파센서(3핀) 예제를 그대로 외부함수로 빼냄
  pinMode(Pin,OUTPUT); //출력모드로  사용
  digitalWrite(Pin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(Pin,HIGH); 
  delayMicroseconds(10); 
  digitalWrite(Pin,LOW);   
  
  pinMode(Pin,INPUT);    //입력모드로 사용
  int duration = pulseIn(Pin, HIGH);  
  int distance = duration / 57.5;  //가상시뮬레이션의 오차율을 줄이기 위해 이걸로 테스트 함.
  return distance; //거리값 리턴
}

거리를 구하게 되면 차량이 감지판정은 if문으로 만든다.

if(m_distance<50){ //50cm미터 미만일 때 차량 감지로 간주             
  차량감지 후 동작;
}

차량이 감지 후 동작은

  if(m_distance<50){   //50cm미만일 때 차단막 올리기 동작       
    if(state==false){  //초기값은 state=false상태로 처음에는 이 if조건문이 무조건 참이 된다.
      servo.write(90); //감지 되었기 때문에 Servo모터 90도 회전
      delay(2000);   //2초 동안 강제로 Servo모터가 회전하도록 설정
      state=true;     //다시 이 if조건문을 수행할 필요가 없기 때문에 state=true 설정     
      digitalWrite(rPin, LOW); //차단막이 올라갔으니 적색등 끄기
      digitalWrite(gPin, HIGH); //차량 통행하도록 녹색등 켜기
    }
    timeVal=millis(); //마지막 차량 감지된 시간을 저장함
  }  
  if(state==true){ //차단막 내리기 동작
    if(millis()-timeVal>=2000){ //마지막 차량 감지된 시간을 기준으로 차단막 유지시간이 지났는가 체크
      servo.write(0); //차단막 내리기
      state=false; //차단막이 내려졌으니 이 if조건문을 수행할 필요가 없기 때문에 state=fasle 설정
      digitalWrite(gPin, LOW); //차단막이 내려오니깐 녹색등은 끄기
      digitalWrite(rPin, HIGH); //차량 정지하도록 적색등 켜기
    }    
  } 

주석을 일일히 다 달아놓았으니깐 주석을 살펴보시기 바랍니다. 왜! if문을 state의 상태값으로 두가진 차단막 올리기/내리기 동작을 구분하였을 까요. 두 동작을 구분을 지어서 동작하게 하기 위해서요. 자세히 보시면 만약 차단막이 올라간 상태에서 계속 현재 차량이 감지되거나 계속 새로운 차량이 들어올 경우는 계속 차단막 올리는 명령을 내려야 합니다. 이미 올라갔는데 구지 반복 명령을 내릴 필요는 없이 현상태만 유지하면 됩니다. 그래서 if문으로 올라갔으면 내려가는 상황만 체크하면 되지 올라가는 상황을 동작할 필요없는 없습니다. 여기서, timeVal은 올라가는 상황 코딩 안에 다 넣지 않고 밖에다 빼낸 이유는 계속 초음파센서로 감지했을 때 마지막으로 감지된 시간을 기준으로 차단막의 유지시간을 결정하게 하기 위해서 입니다.

종합해보면,

#include <Servo.h>

Servo servo;
const byte servoPin = 6;
const byte pingPin = 7;
const byte gPin = 8;
const byte rPin = 9;
int m_distance=0;
boolean state = false;
unsigned long timeVal=0;

void setup()
{
  pinMode(gPin, OUTPUT);
  pinMode(rPin, OUTPUT);  

  servo.attach(servoPin); 
  servo.write(0);
  delay(1000);
  
  digitalWrite(rPin, HIGH);
}

void loop()
{
  m_distance=CalDistance(7);  //초음파센서로 거리계산함수  
  if(m_distance<50){            
    if(state==false){
      servo.write(90);
      delay(2000); 
      state=true;          
      digitalWrite(rPin, LOW);
      digitalWrite(gPin, HIGH);
    }
    timeVal=millis();
  }  
  if(state==true){
    if(millis()-timeVal>=2000){
      servo.write(0);
      state=false;
      digitalWrite(gPin, LOW);
      digitalWrite(rPin, HIGH);
    }    
  }  
}

int CalDistance (int Pin){  //초음파센서(3핀) 예제를 그대로 외부함수로 빼냄
  pinMode(Pin,OUTPUT); //출력모드로  사용
  digitalWrite(Pin, LOW); 
  delayMicroseconds(2); 
  digitalWrite(Pin,HIGH); 
  delayMicroseconds(10); 
  digitalWrite(Pin,LOW);   
  
  pinMode(Pin,INPUT);    //입력모드로 사용
  int duration = pulseIn(Pin, HIGH);  
  int distance = duration / 57.5;  //가상시뮬레이션의 오차율을 줄이기 위해 이걸로 테스트 함.
  return distance; //거리값 리턴
}

loop()함수 내 로직만 설계에 맞게 코딩만 하면 오늘 코딩의 전부입니다. loop()함수 내 코딩은 몇줄 안되지만 설계의 내용을 다 포함되어 있네요. 글보다 코딩이 더 짧은 케이스네요.

4. 결과


가상시뮬레이터에서 결과입니다.


5. 실제 테스트


정상적으로 동작하는지 실제로 구현해 봤네요.

1) 아두이노 주차장 출입구 차량차단장치 회로도


4핀짜리 초음파센서로 대충 실제 제작 모습과 동일하게 디자인 했네요.


위 회로도를 실제 배치하고 선을 연결하니깐 아래와 같은 모습으로 좀 지져분하게 되었습니다.


2) 코딩



위의 가상시뮬레이터 코딩에서 newPing 라이브러리를 사용해서 그부분만 수정했습니다. 그리고 초음파센서가 4핀이니 trig, echo 핀을 정확하게 지정해 줘야 합니다.

코딩은 가상시뮬레이터 소스에서 newPing 라이브러리를 이용한 방식과 4핀 초음파센서 부분만 수정하면 됩니다.
그리고 주의할 점은 실제 초음파센서에서는 거리 측정값이 오류가 발생합니다. 이 오류를 해결하기 위해서 초음파센서값에 대한 평균값을 구해서 오류값을 막을 수 도 있지만 간단하게 오류값을 무시하는 방식을 취했습니다.

  if(m_distance>오류값 && m_distance<감지거리){       
      동작;
  }

제가 쓰는 초음파센서는 가끔 0과 10이하의 값들이 찍히네요. 그래서 실험에서는 10이상의 값들만 거리 판정을 내렸네요. 만약 결과가 정상적으로 나오지 않는다면 거리측정값을 시리얼통신을 통해 시리얼모니터로 그 결과를 찍어보시고 여러분들이 원하는 값으로 수정해 주시면 됩니다.

수정해보면,

#include <NewPing.h>
#include <Servo.h>

Servo servo;
const byte servoPin = 7; 
const byte gPin = 8;
const byte rPin = 9;
int m_distance=0; //거리
boolean state = false; //차단막 제어를 위한 상태값
unsigned long timeVal=0;

NewPing sonar(6, 5, 200); // (Trig, Echo. 거리제한)

void setup() {
  
  Serial.begin(9600);
  pinMode(gPin, OUTPUT);
  pinMode(rPin, OUTPUT);  

  servo.attach(servoPin); 
  servo.write(0);
  delay(1000);
  
  digitalWrite(rPin, HIGH);
}

void loop() {  
  delay(50);            
  m_distance=sonar.ping_cm();  //초음파센서로 거리계산함수  
  Serial.println(m_distance);
  if(m_distance>10 && m_distance<20){  //20cm는 의미가 있는 것은 아닙니다.
    if(state==false){
      servo.write(90);
      delay(2000); 
      state=true;          
      digitalWrite(rPin, LOW);
      digitalWrite(gPin, HIGH);      
    }
    timeVal=millis();
  }  
  if(state==true){
    if(millis()-timeVal>=3000){
      servo.write(0);
      state=false;
      digitalWrite(gPin, LOW);
      digitalWrite(rPin, HIGH);
    }    
  } 
}

3) 결과


10cm이하는 차량감지로 판정을 하지 않습니다. 그리고 20cm미만일 때 차량감지 파전을 내렸네요. 스마트폰으로 촬영하기 위해서 거리값을 최대한 줄여서 실험 했네요.


마무리


최근에 계속 아두이노적 시각으로 주변환경을 관찰하면서 하나씩 post 주제를 선정하고 있네요. 지하주차장에 차량차단막이 되어 있는 곳을 들어 갈 때 차량을 감지하고 차단막이 올라가면서 옆에 신호등이 "적색->녹색" 등으로 바뀌는 상황을 보면서 "아! 이걸 주제로 표현해봐야지!"하고 이렇게 실험하게 되었네요.

여러분들도 한번 주변환경을 관찰하고 저처럼 실험을 해보세요.


댓글()

[아두이노] 아두이노 신호등과 횡단보도신호등

IOT/아두이노|2019. 7. 24. 09:00

[아두이노] 아두이노 신호등과 횡단보도신호등



지난 시간에 간단히 아두이노 신호등을 만들어 실험했는데 여기에 횡단보도신호등을 추가하여 같이 제어하는 실험을 해볼까 합니다. 특정 도로 상황을 만들고 그 상황에서 차량신호등과 횡단보도신호등의 동작을 설정하고 그 부분만 회로도로 구성하고 상황에 맞게 동작하도록 코딩을 해보았습니다.

1. 도로의 신호등과 횡단보도신호등의 상황 설정


우선 아래와 같은 도로의 상황을 설정해 보았습니다.


위 그림에서 A, B 지점의 신호등과 횡단보드신호등을 아두이노로 표현하여 실험을 하겠습니다.

상황은 차량신호등은 4차선 도로의 주행이 우선 시 하겠죠. 그러면 2차선에서 바라보는 신호등은 "녹->황->적" 순서에서 적색등이 다른 등보다 더 긴 시간을 유지합니다. 도로의 신호등의 시간은 도로의 상태에 따라 시간이 다르기 때문에 삼거리 도로에서는 4차선 도로쪽 녹색등 시간이 적색등보다 길고 2차선의 적색등이 녹색등보다 더 긴 시간을 유지하게 됩니다. 즉, 2차선 적색등일 때 4차선은 녹색등이니깐 두 신호등의 관계를 잘 이해해 주세요.

횡당보도신호등은 2차선에서 바라 봤을 때 적색등일 때 횡단보도신호등이 작동하게 코딩을 할까 합니다. 대충 2차선으로 바라봤을 때 "녹->황->적"순으로 바뀌는데 적색등으로 바뀔 때 횡단보드신호등의 적색등이 녹색등으로 바뀌고 횡단보드의 7-Segment Display가 카운트를 하게 됩니다. 그리고 0이 되면은 다시 적색등으로 바뀌는 형태로 코딩했습니다.

좀 상황을 설정하고 코딩을 완성하고 보니 상황이 약간 이상하게 설정했더군요. 다시 코딩을 수정하기 귀찮아서 이상태로 실험을 마무리했는데 이부분을 감안하시고 실험 내용을 보시기 바랍니다.

2. 아두이노 신호등+횡단보도신호등 회로도


  • 준비물 : 적색 LED 2개, 오렌지색 LED 1개, 녹색 LED 2개, 저항 220옴 6개, 7-Segment Display 1개, 74HC595칩 1개, 아두이노우노
  • 내용 : 신호등 5,6,7번 핀을 LED 출력핀으로 연결하고 횡단보도신호등 11,12번 핀을 LED 출력핀으로 연결한다. 그리고 74HC595칩은 9,10,11번을 이용하고 7-Segment Display의 Vcc핀을 8번핀으로 사용합니다.

아래 회로도는 지난시간의 신호등 회로도에서 횡단보도신호등을 추가한 회로도 입니다. 두개의 횡단보드신호등을 만들 수 있었지만 너무 복잡하게 그려질 것 같아서 한쪽 횡단보드신호등만 표현했네요. 만약 두개를 만드신다면 횡단보드신호등의 연결된 선을 공유선으로 연결하시면 됩니다.


좀 복잡한 회로도인데 해당 표현은 아래 그림으로 대충 구분하시면 됩니다.


3. 코딩



7-Segment Display 부품을 사용하는데 그냥 아두이노우노 핀에 적접 연결해도 되지만 복습차원으로 74HC595칩을 이용하여 제어하도록 하겠습니다.

74HC595칩 제어 :

  • latchPin, clockPin, dataPin을 pinMode( )로 선언
  • digitalWrite(결쇠핀, 열림/잠금)으로 74HC595칩에 입력할때 열림/잠금을 제어
  • shiftOut(데이터입력핀, 클럭핀, MSBFIRST, 전송값)으로 이걸 통해서 역순으로 데이터가 배치
const byte latchPin = 10; //ST_CP Pin
const byte clockPin = 11; //SH_CP Pin
const byte dataPin = 9; //DS Pin

byte data[]={
0B01000000, //0
0B01111001, //1
0B00100100, //2
0B00110000, //3
0B00011001, //4,
0B00010010, //5
0B00000010, //6
0B01111000, //7
0B00000000, //8
0B00010000  //9
};

위의 74HC595칩을 제어하는 3개의 ST_CP, SH_CP, DS Pin과 숫자는 1byte값안에 각 bit가 7-Segment Display의 각 핀에 해당됩니다. data[]배열변수에 숫자 패턴을 정의해 놓습니다. 0~9까지의 숫자 패턴을 만들어 놓았는데 실제로 0~3까지의 숫자만 사용됩니다.

그 값을 아래 3줄로 해서 출력하면 7-Segment Display의 숫자가 출력합니다.

digitalWrite(latchPin, LOW); //열림
shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]); //출력
digitalWrite(latchPin, HIGH); //닫힘

위 내용은 쉬프트레지스터(74HC595) 제어(아두이노) post에 가셔서 복습하시고 오셔야 이해가 되실 꺼에요. 이해가 안되시는 분들은 읽고 오시면 되겠습니다.

횡단보도신호등 동작 : 7-Segment Display가 "3-2-1-0"순서로 카운트하게 하려면 다음과 같습니다

if(cnt>0 && millis()-timeSeg>=1000){
    cnt--; 
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]);
    digitalWrite(latchPin, HIGH);                       
    timeSeg=millis();      
 }

timeSeg변수는 7-Segment Display에 출력에 대한 이전시간값을 가지고 있습니다. ">=1000"으로 체크하면 1초 단위로 if문이 참이 됩니다. 여기서 cnt는 숫자패턴의 위치값이 됩니다. 즉, 1초 단위로 체크하는데 숫자패턴이 0보다 커야한다고 락을 걸어놓은 if문입니다. "cnt--"으로 현재 숫자패턴위치값을 하나 감소 하면서 출력된다고 생각하시면 됩니다.

횡단보도신호등의 "적색->녹색" 변환

 digitalWrite(TransversboardLight[1], LOW); //적색 LOW
 digitalWrite(TransversboardLight[0], HIGH); //녹색 HIGH

횡단보도신호등의 "녹색->적색" 변환

 digitalWrite(TransversboardLight[0], LOW); //녹색 LOW
 digitalWrite(TransversboardLight[1], HIGH); //적색 HIGH

위 두가지 횡단보도신호등 변환은 차량신호등이 적색이 되는 순간의 코딩 부분에 "적색->녹색"변환 코딩을 하고 7-Segment Display가 카운트 0이 되는 순간의 코딩 부분에 "녹색->적색"변환 코딩을 삽입하면 됩니다.

이제 위에서 이야기한 횡단보드신호등 코딩 부분을 지난시간에 만든 차량신호등에 합쳐 봅시다.

[신호등 기본소스]

const byte trafficLight[3] = {5,6,7}; //신호등 핀
int lightTime[3] = {5,2,3}; //신호등 유지시간
unsigned long timeVal = 0; //이전시간
int indexVal = 0; //신호등 위치

void setup()
{
  for(int i=0;i<3;i++){
    pinMode(trafficLight[i], OUTPUT);
  }  
    //초기상태
  digitalWrite(trafficLight[indexVal], HIGH); //녹색등
}

void loop()
{  
  if(millis()-timeVal>=lightTime[indexVal]*1000){ //신호등 동작 trafficLight[3]순서대로
    digitalWrite(trafficLight[indexVal], LOW);  //이전등 끄기
    indexVal++; //신호등위치 증가
    if(indexVal==3)indexVal=0; // 신호등위치가 3이 되면 다시 0으로 처음위치로 돌아감
    digitalWrite(trafficLight[indexVal], HIGH); //새로운등 켜기
    timeVal=millis();
  }
}

어디서 부터 접근해야 할까요. 위 loop()함수는 신호등 "녹색->오렌지색->적색"순서로 깜박입니다. 여기서 적색등이 되는 순간에 횡단보도신호등이 바뀐다고 했죠. 그러면 적색등일 때 "indexVal==2"일때의 횡단보도신호등의 조건문을 만들어 주면 됩니다.

if(millis()-timeVal>=lightTime[indexVal]*1000){ //신호등 동작 trafficLight[3]순서대로
  신호등명령문;
    if(indexVal==2){ //적색등일때
      횡단보도신호등 초기상태;
    }
}

횡단보도신호등 초기상태는

 state=true;
 timeSeg=millis(); //7-Segment Display 이전시간값
 digitalWrite(TransversboardLight[1], LOW); //적색 LOW
 digitalWrite(TransversboardLight[0], HIGH); //녹색 HIGH

 digitalWrite(SegPower, HIGH);  //7-Segment Display 전원 공급
 //3 숫자 패턴 출력
 digitalWrite(latchPin, LOW);
 shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]);
 digitalWrite(latchPin, HIGH);   

대충 indexVal이 2일 때 적색으로 바뀌는 순간으로 그 때 횡단보도신호등의 초기상태를 위와 같이 코딩하게 됩니다. state은 다음 코딩의 체크문으로 사용하는 변수값입니다.

if(state==true){
  횡단보도신호등동작;
}

위와 같이 state문으로 횡단보도신호등을 동작시킬지 결정하는 if문입니다.

횡단보도신호등 동작은

 if(cnt>0 && millis()-timeSeg>=1000){ //"2-1-0"출력함 3은 초기상태에서 출력했기 때문에 나머지 숫자 출력함
    cnt--; 
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]); //숫자 출력
    digitalWrite(latchPin, HIGH);                       
    timeSeg=millis();  //이전시간변수에 현재시간 저장    
 }
 if(cnt==0 && millis()-timeSeg>=1000){ //0을 출력하고 1초동안은 0인 상태를 유지하기 위함
    cnt=3; //숫자패턴 3으로 초기화
    state = false; //횡단보도신호등 동작 중단      
        
    digitalWrite(SegPower, LOW); //7-Segment Display 전원 공급 중단
    digitalWrite(TransversboardLight[0], LOW); //녹색 LOW
    digitalWrite(TransversboardLight[1], HIGH); //적색 HIGH
 }

횡단보도신호등의 7-Segment Display의 숫자를 카운트하고 카운트가 끝나면 다시 "녹색->적색" 등으로 바뀌게 됩니다. 횡단보도신호등이 끝나면 다시 처음 원위치 상태로 돌아가야 합니다.

종합해보면,

byte data[]={
0B01000000, //0
0B01111001, //1
0B00100100, //2
0B00110000, //3
0B00011001, //4,
0B00010010, //5
0B00000010, //6
0B01111000, //7
0B00000000, //8
0B00010000  //9
};

const byte latchPin = 10; //ST_CP Pin
const byte clockPin = 11; //SH_CP Pin
const byte dataPin = 9; //DS Pin
const byte SegPower = 8;
const byte TransversboardLight[2] = {12,13};
int cnt = 3;
boolean state = false;

const byte trafficLight[3] = {5,6,7};
const byte lightTime[3] = {5,2,7};
unsigned long timeVal = 0;
unsigned long timeSeg = 0;
int indexVal = 0;


void setup()
{
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(SegPower, OUTPUT);
  
  pinMode(TransversboardLight[0], OUTPUT);
  pinMode(TransversboardLight[1], OUTPUT);
  
  for(int i=0;i<3;i++){
    pinMode(trafficLight[i], OUTPUT);
  }  
  digitalWrite(trafficLight[indexVal], HIGH);
  digitalWrite(TransversboardLight[1], HIGH);
}

void loop()
{  
  if(millis()-timeVal>=lightTime[indexVal]*1000){
    digitalWrite(trafficLight[indexVal], LOW);  
    indexVal++;
    if(indexVal==3)indexVal=0;
    digitalWrite(trafficLight[indexVal], HIGH);
    timeVal=millis();    
    
    if(indexVal==2){
      state=true;
      timeSeg=millis();
      digitalWrite(TransversboardLight[1], LOW);
      digitalWrite(TransversboardLight[0], HIGH);
      
      digitalWrite(SegPower, HIGH);      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]);
      digitalWrite(latchPin, HIGH);   
    }
  }
  if(state==true){
    if(cnt>0 && millis()-timeSeg>=1000){
      cnt--; 
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, data[cnt]);
      digitalWrite(latchPin, HIGH);                       
      timeSeg=millis();      
    }
    if(cnt==0 && millis()-timeSeg>=1000){
      cnt=3;
      state = false;      
      digitalWrite(SegPower, LOW);
      digitalWrite(TransversboardLight[0], LOW);
      digitalWrite(TransversboardLight[1], HIGH);
    }
  }  
}

4. 결과



실제로 제작해 해봤는데 배선이 좀 지져분하게 만들어 졌네요.


결과는 가상시뮬레이터에서 실험한 결과와 같은 동작으로 결과가 출력 되었네요.


마무리


기존의 신호등 코딩에서 횡단보도신호등을 추가했을 때 기존의 코딩에 대해서 신경 쓸 필요 없고 횡단보도신호등에 대한 코딩만 신경쓰면 됩니다. millis()함수를 이용하여 시간을 제어하면 차량신호등의 동작과 횡단보도신호등의 동작을 동시에 수행 할 수 있게 됩니다.

오늘 실험은 신호등과 횡단보드신호등에 상황을 만들고 두 상황을 동시에 처리를 하였습니다. 오늘 코딩한 스타일을 잘 기억해 주세요. 여러 상황을 동시에 처리하거나 또는 여러 부품을 동시에 제어할 때 millis()함수를 이용하여 시간을 제어하면 각 상황을 코딩하고 나서 다른 상황을 코딩할 때 시간에 대한 어려움을 쉽게 해결 합니다.

그리고, 오늘 post에서 2가지 상황을 설정하고 그 상황에 맞게 아두이노에서 동시에 처리하는 코딩을 하였습니다. 여러분들도 꼭 신호등이 아니더라도 여러가지 상황을 만들고 그 상황을 동시에 처리하는 코딩 연습을 많이 하셨으면 합니다. 하나의 부품을 제어하는 것은 무척 싶습니다. 하지만 둘 이상의 부품을 제어하는 것과 둘 이상의 상황을 제어하는 방법은 쉽지 않습니다. 둘 이상의 조건을 만족하기 위해서는 서로 충돌이 발생하지 않게 상상 코딩을 해야 하기 때문에 이 능력은 꾸준히 반복 학습을 통해서 터득 할 수 있습니다. 그렇기 때문에 오늘 제가 했던 방식으로 일상의 상황들을 하나씩 찾아서 적용하여 아두이노로 표현해 보세요.


댓글()