티스토리 뷰

해당 포스팅은 2016.06.25 에 작성된 내용입니다.




지난번과 마찬가지로, 블로그는 체험단과 상관없기에 개인적으로 올려둡니다 :)



제품명 : Neuromeka BeagleBone Air Starter Kit




주어진 미션에 대한 활용기입니다.

"I2C 를 이용한 가속센서값 읽어오기"


공식홈페이지 제품 소개

Beaglebone Air Wiki


위 링크에 제품에 대한 소개가 잘 나와있습니다.

첫 번째, 공식홈페이지는 깔끔한 디자인으로 심플한 소개가 나와 있고,

아무래도 자세한 정보를 얻고 싶다면 두번째 링크인 Wiki를 참조하는 것이 좋겠습니다.




테스트환경 : Windows7 64bit, Debian(OS), Cloud9

언어 : Python



지금 올리는 내용은 매우 간단한 활용기입니다. data라는 것이 활용을 했을 때 그 가치가 나오는 것인데, 오늘은 단순히 미션대로 데이터값만 읽어오는 포스팅입니다. IoT에 있어서 IMU의 역할에 대해 생각을 많이 해보았습니다. 대표적으로는 드론이 있겠죠. 누군가는 드론이 어떻게 IoT냐! 라고 하실 수도 있겠습니다. IoT정의가 애매하긴 하지만 어쨌든 드론이라는 사물에 네트워크(그것이 어떤 방식이든)를 구축하여 원격조종이 가능하고 때로는 드론으로부터 다양한 정보를 받아 처리할 수 있으니, IoT라 한다면 할 수 있을 것 같습니다.


기본적으로 IMU값을 활용해서 특정한 명령을 자동으로 수행하게끔 하는 것이기 때문에, 드론뿐만 아니라 다양한 접근을 할 수 있을 것입니다. 물론 이것은 각자의 아이디어와 상황, 적용범위에 따라 달라질 것입니다. IMU가 전혀 필요없는 경우도 있을 것이고 유용하게 사용되는 경우도 있을 것입니다.


서론이 길었는데, 결국 IoT에서 IMU를 사용하는 이유는,

이 값들(움직임이라는 직관적인 행동)을 통해 무언가를 제어 혹은 (참조할)데이터화하기 위함이라는 것입니다.

일단 이것을 위해서는 IMU의 값들을 읽어들여와야 합니다.

따라서 미션 주제에 맞게 오늘은 값을 읽어들이는 부분에 주안을 두도록 하겠습니다.

나머지 활용부분은 각자의 몫이 되겠습니다. (물론 개인적으로 이것저것 더 시도해보면서 포스팅 할 예정입니다)


제 포스팅은 포커스를 초보자로 맞추기로 하겠습니다.







I2C란?


I²C (Inter-Integrated Circuit), pronounced I-squared-C, is a multi-master, multi-slave, single-ended, serial computer bus invented by Philips Semiconductor (now NXP Semiconductors). It is typically used for attaching lower-speed peripheral ICs to processors and microcontrollers in short-distance, intra-board communication. Alternatively I²C is spelled I2C (pronounced I-two-C) or IIC(pronounced I-I-C).


SMBus, defined by Intel in 1995, is a subset of I²C that defines the protocol use more strictly. One purpose of SMBus is to promote robustness and interoperability. Accordingly, modern I²C systems incorporate some policies and rules from SMBus, sometimes supporting both I²C and SMBus, requiring only minimal reconfiguration either by commanding or output pin use.


출처 : https://en.wikipedia.org/wiki/I%C2%B2C


이번 포스팅에서 말하고자 하는 것은 I2C 인터페이스입니다. IoT장치를 사용함에 있어서 I2C통신 기반의 수많은 모듈들이 존재합니다. 따라서 이 I2C가 어떠한 것인지, 사용법은 어떠한지를 아는 것이 이번 활용기의 핵심이 되겠습니다. IMU사용은 한 예시일뿐입니다. 그렇다고 해당 포스팅에서 I2C를 자세히 다루지는 않을 것입니다. 어디까지나 제품에 대한 활용기이기 때문에, 간략히 언급하고 넘어가겠습니다. 


 간단한 예를 들겠습니다. Email서비스를 사용하려 합니다. 누군가에게 편지를 쓰려고 하죠.

이때, 우리는 몇가지 조건을 갖추어야합니다. 발신자는 자신의 계정이 필요하고, 수신자 이메일 주소를 입력해야합니다. 또한, 편지의 제목을 입력해야 하고 내용을 입력해야 합니다. 그리고 전송 버튼을 통해 전송을 하죠.


 우리가 단순히 메일을 보내기 위해서도 이러한 조건 혹은 정보들이 필요합니다. 사실 사용자 측면을 넘어서 그 원리까지 들어가면 수많은 정보와 절차가 필요합니다. 즉, 통신을 위해 우리는 어떠한 약속이 필요합니다. 이러한 것을 우리는 프로토콜이라 부릅니다. 우리가 인터넷 주소창에 입력하거나 볼수있는 http도 프로토콜의 한 종류입니다. 마지막의 p가 프로토콜을 의미하거든요.

 지금 우리가 사용해야할 I2C 역시 프로토콜의 일종입니다. I2C는 클럭과 어드레스주를 활용하여 통신을 하는반이중(Half-Duplex) 방식이며, 따라서 클럭과 주소가 필요합니다. 그래서 I2C인터페이스를 보게 되면 VCC와 GND를 제외한 두가지가 필요한데, SCL과 SDA가 그 주인공입니다. SCL은 동기화, SDA는 데이터 및 주소를 주고 받는 기능을 합니다. 반이중은 쉽게말해, 서로 데이터를 주고받을 수는 있으나 한쪽이 송신을 하면 다른쪽은 수신만해야한다는 특성을 말합니다. 이와 관련된 자세한 내용은 검색만 하면 쉽게 정보를 얻으실 수 있으십니다.

 I2C의 장점은 주소가 겹치지 않는 한 연결 가능한 장치의 수에 제한이 없다는 것이고, 필요한 선이 적다는 것입니다. 단점으로는 속도가 SPI 등 다른 통신에 비해서는 느리고 반이중 통신이라는 것인데, 따라서 단순히 값을 받아오거나 상호간 복잡한 연산이 필요없는 경우에 많이 사용됩니다. 그리고 사실 속도가 느리다고는 하지만 단순히 값만 읽어들이는데 있어서는 충분하고도 남는 속도입니다. 홈네트워크 등 복잡하지 않은 IoT 시스템에서는 가장 쉽게 많이 쓰이는 인터페이스라고 생각하시면 되겠습니다.


 지나치게 단순화하다보니 정확한 설명이 안되었을 수도 있습니다. 세부적인 내용은 별도의 검색을 통해 학습하시길 바라며, 괜찮은 정보를 링크하고 넘어가도록 하겠습니다. I2C설명








IMU란?


An inertial measurement unit (IMU) is an electronic device that measures and reports a body's specific force, angular rate, and sometimes the magnetic field surrounding the body, using a combination of accelerometers and gyroscopes, sometimes also magnetometers.


출처 : https://en.wikipedia.org/wiki/Inertial_measurement_unit

Inertial Measurement Unit . 이것이 IMU의 Full name입니다. 즉 관성 측정 장치입니다.

흔히 이야기 되는 가속도(accelerometers), 각속도(gyroscopes)를 측정하는 장치인 것입니다.
위 설명처럼 때로는 지자계(magnetometers)를 포함하는데, 아무튼 이러한 변화량을 측정하는 장치를 IMU라고 통칭합니다. 이 값들을 활용하면 자세제어 부분에 있어서 매우 용이하고, 스마트폰에서도 사용되어 사용자에 맞게 적절한 인터페이스를 제공해 줄 수 있습니다. (자동 화면 전환 등)
자세한 내용은 Wiki를 참조하시면 되겠으나... 언어가 힘드시다면, 검색을 추천합니다.
쉽게 접근하시라고 간단한 설명이 되어있는 곳을 링크합니다.








IMU 연결하기



이번 포스팅에서 사용할 IMU는 MPU6050 (GY-521) 입니다. 가속도와 각속도를 측정할 수 있는 6축 IMU가 되겠습니다.

PIN은 일단 4개만 사용합니다. VCC, GND, SCL, SDA 입니다.
이 핀들은 Air Cape 오른쪽에 위치한 I2C 커넥터에 연결하면 사용할 수 있습니다.
저같은 경우는 4핀 커넥터도 없고 만들어서 사용하기도 번거로워서 잠깐 들어내서 4개 핀을 추가로 납땜해서 사용했습니다.

결선은 아래와 같이 하시면 됩니다.
VCC    ----     3.3V
GND    ----     GND
SDA    ----     SDA
SCL    ----     SCL

혹시나 Cape가 없으신 분들을 위해 (비글본블랙, 비글본그린, Air 모두 해당) 핀번호를 남깁니다.
VCC    ----     P9_3 (3.3V)
GND    ----     P9_1 (GND)
SDA    ----     P9_20 (I2C2_SDA)
SCL    ----     P9_19 (I2C2_SCL)

PINMAP에 관해서는 비글본 홈페이지에서 확인할 수 있습니다.
또한, 앞서 사용기에서 설명한 Bone101 (비글본 IP주소로 브라우저 접속)에서 바로 확인하실 수 있으십니다.
이 경우는 인터넷연결이 필요 없겠죠 :) 


위 사진처럼 자신의 방법에 맞게 연결을 하고 나면, 비글본에 접속을 합니다.
PC와 결선으로부터 독립하고 싶은 마음에 WIFI IP주소로 접속합니다.
저같은 경우는 192.168.0.11이 되겠군요. 우선 CLI(Command line interface)를 사용하기 위해 PuTTY로 접속합니다. 

접속을 하였다면 아래와 같이 명령을 합니다.

1
$ i2cdetect --1
cs

I2C 장치를 찾는 명령입니다. 위에서 정상적으로 연결을 하였다면, 아래와 같이 나열된 모습을 보실 수 있습니다.
저기 말하는 68이 MPU6050의 주소가되겠습니다. 0x68.
I2C에 대해 간략히 설명하며 필요하다고 했던 주소가 이것입니다. MPU6050의 주소인 것이죠.
실제로 MPU6050의 Datasheet를 찾아보면 0x68을 Device Address로 알려주고 있습니다.


자, IMU가 제대로 연결이 되었음을 확인하였습니다.
이제 기본기능인 Cloud9로 넘어가도록 하겠습니다. 저의 경우는 192.168.0.11:3000 이 되겠군요.
지난번에 사용을 해보았으니 조금은 인터페이스가 익숙해지셨을 겁니다.
소스 창 탭에 있는 + 버튼을 눌러서 파일을 생성합니다. 그리고 저장 (Ctrl + s)을 합니다.
저장 시에는 아래와 같이 파일명과 확장자, 그리고 디렉토리를 지정 후 저장하면 되겠습니다.
이 포스팅의 경우 파이썬 기반의 소스를 사용할 것이므로 확장자를 .py라고 입력하였습니다.
또한, 단순한 예제로 사용할 것이기때문에 디렉토리는 example로 하였습니다.
파이썬의 경우는 이런 소스파일을 모듈이라고 부르는데, 자세한 것은 파이썬에 대한 공부를 해보시면 되겠습니다
접근이 어렵지 않은 언어이고 상당히 매력적인 언어이기 때문에, 이번 기회에 공부해보시는걸 추천드립니다 :)


자 파일을 생성한 뒤,
코딩을 시작하겠습니다.는.. 이번 포스팅에 어울리지 않습니다.
오픈되어 있는 소스를 가져오도록 하겠습니다.
( 소스에 대한 설명은 하지 않습니다 )

위의 링크로 들어가시면 MIT IMU 라이브러리를 기반으로 두 사람이 만든 파이썬 모듈이 존재합니다.
파이썬의 경우 모듈을 설치하고, import를 통해 쉽게 사용할 수 있습니다.
하지만, 간단한 테스트인 관계로 MPU6050.py 와 example.py 를 하나로 합치겠습니다.
(그래봐야 단순히 붙여넣는 수준입니다)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 """This program handles the communication over I2C
between a Raspberry Pi and a MPU-6050 Gyroscope / Accelerometer combo.
Made by: MrTijn/Tijndagamer
Released under the MIT License
Copyright 2015
"""
 
import smbus
from time import sleep
 
class MPU6050:
 
    # Global Variables
    GRAVITIY_MS2 = 9.80665
    address = None
    bus = smbus.SMBus(1)
 
    # Scale Modifiers
    ACCEL_SCALE_MODIFIER_2G = 16384.0
    ACCEL_SCALE_MODIFIER_4G = 8192.0
    ACCEL_SCALE_MODIFIER_8G = 4096.0
    ACCEL_SCALE_MODIFIER_16G = 2048.0
 
    GYRO_SCALE_MODIFIER_250DEG = 131.0
    GYRO_SCALE_MODIFIER_500DEG = 65.5
    GYRO_SCALE_MODIFIER_1000DEG = 32.8
    GYRO_SCALE_MODIFIER_2000DEG = 16.4
 
    # Pre-defined ranges
    ACCEL_RANGE_2G = 0x00
    ACCEL_RANGE_4G = 0x08
    ACCEL_RANGE_8G = 0x10
    ACCEL_RANGE_16G = 0x18
 
    GYRO_RANGE_250DEG = 0x00
    GYRO_RANGE_500DEG = 0x08
    GYRO_RANGE_1000DEG = 0x10
    GYRO_RANGE_2000DEG = 0x18
 
    # MPU-6050 Registers
    PWR_MGMT_1 = 0x6B
    PWR_MGMT_2 = 0x6C
 
    SELF_TEST_X = 0x0D
    SELF_TEST_Y = 0x0E
    SELF_TEST_Z = 0x0F
    SELF_TEST_A = 0x10
 
    ACCEL_XOUT0 = 0x3B
    ACCEL_XOUT1 = 0x3C
    ACCEL_YOUT0 = 0x3D
    ACCEL_YOUT1 = 0x3E
    ACCEL_ZOUT0 = 0x3F
    ACCEL_ZOUT1 = 0x40
 
    TEMP_OUT0 = 0x41
    TEMP_OUT1 = 0x42
 
    GYRO_XOUT0 = 0x43
    GYRO_XOUT1 = 0x44
    GYRO_YOUT0 = 0x45
    GYRO_YOUT1 = 0x46
    GYRO_ZOUT0 = 0x47
    GYRO_ZOUT1 = 0x48
 
    ACCEL_CONFIG = 0x1C
    GYRO_CONFIG = 0x1B
 
    def __init__(self, address):
        self.address = address
 
        # Wake up the MPU-6050 since it starts in sleep mode
        self.bus.write_byte_data(self.address, self.PWR_MGMT_1, 0x00)
 
    # I2C communication methods
 
    def read_i2c_word(self, register):
        """Read two i2c registers and combine them.
        register -- the first register to read from.
        Returns the combined read results.
        """
        # Read the data from the registers
        high = self.bus.read_byte_data(self.address, register)
        low = self.bus.read_byte_data(self.address, register + 1)
 
        value = (high << 8+ low
 
        if (value >= 0x8000):
            return -((65535 - value) + 1)
        else:
            return value
 
    # MPU-6050 Methods
 
    def get_temp(self):
        """Reads the temperature from the onboard temperature sensor of the MPU-6050.
        Returns the temperature in degrees Celcius.
        """
        # Get the raw data
        raw_temp = self.read_i2c_word(self.TEMP_OUT0)
 
        # Get the actual temperature using the formule given in the
        # MPU-6050 Register Map and Descriptions revision 4.2, page 30
        actual_temp = (raw_temp / 340+ 36.53
 
        # Return the temperature
        return actual_temp
 
    def set_accel_range(self, accel_range):
        """Sets the range of the accelerometer to range.
        accel_range -- the range to set the accelerometer to. Using a
        pre-defined range is advised.
        """
        # First change it to 0x00 to make sure we write the correct value later
        self.bus.write_byte_data(self.address, self.ACCEL_CONFIG, 0x00)
 
        # Write the new range to the ACCEL_CONFIG register
        self.bus.write_byte_data(self.address, self.ACCEL_CONFIG, accel_range)
 
    def read_accel_range(self, raw = False):
        """Reads the range the accelerometer is set to.
        If raw is True, it will return the raw value from the ACCEL_CONFIG
        register
        If raw is False, it will return an integer: -1, 2, 4, 8 or 16. When it
        returns -1 something went wrong.
        """
        # Get the raw value
        raw_data = self.bus.read_byte_data(self.address, self.ACCEL_CONFIG)
 
        if raw is True:
            return raw_data
        elif raw is False:
            if raw_data == self.ACCEL_RANGE_2G:
                return 2
            elif raw_data == self.ACCEL_RANGE_4G:
                return 4
            elif raw_data == self.ACCEL_RANGE_8G:
                return 8
            elif raw_data == self.ACCEL_RANGE_16G:
                return 16
            else:
                return -1
 
    def get_accel_data(self, g = False):
        """Gets and returns the X, Y and Z values from the accelerometer.
        If g is True, it will return the data in g
        If g is False, it will return the data in m/s^2
        Returns a dictionary with the measurement results.
        """
        # Read the data from the MPU-6050
        x = self.read_i2c_word(self.ACCEL_XOUT0)
        y = self.read_i2c_word(self.ACCEL_YOUT0)
        z = self.read_i2c_word(self.ACCEL_ZOUT0)
 
        accel_scale_modifier = None
        accel_range = self.read_accel_range(True)
 
        if accel_range == self.ACCEL_RANGE_2G:
            accel_scale_modifier = self.ACCEL_SCALE_MODIFIER_2G
        elif accel_range == self.ACCEL_RANGE_4G:
            accel_scale_modifier = self.ACCEL_SCALE_MODIFIER_4G
        elif accel_range == self.ACCEL_RANGE_8G:
            accel_scale_modifier = self.ACCEL_SCALE_MODIFIER_8G
        elif accel_range == self.ACCEL_RANGE_16G:
            accel_scale_modifier = self.ACCEL_SCALE_MODIFIER_16G
        else:
            print("Unkown range - accel_scale_modifier set to self.ACCEL_SCALE_MODIFIER_2G")
            accel_scale_modifier = self.ACCEL_SCALE_MODIFIER_2G
 
        x = x / accel_scale_modifier
        y = y / accel_scale_modifier
        z = z / accel_scale_modifier
 
        if g is True:
            return {'x': x, 'y': y, 'z': z}
        elif g is False:
            x = x * self.GRAVITIY_MS2
            y = y * self.GRAVITIY_MS2
            z = z * self.GRAVITIY_MS2
            return {'x': x, 'y': y, 'z': z}
 
    def set_gyro_range(self, gyro_range):
        """Sets the range of the gyroscope to range.
        gyro_range -- the range to set the gyroscope to. Using a pre-defined
        range is advised.
        """
        # First change it to 0x00 to make sure we write the correct value later
        self.bus.write_byte_data(self.address, self.GYRO_CONFIG, 0x00)
 
        # Write the new range to the ACCEL_CONFIG register
        self.bus.write_byte_data(self.address, self.GYRO_CONFIG, gyro_range)
 
    def read_gyro_range(self, raw = False):
        """Reads the range the gyroscope is set to.
        If raw is True, it will return the raw value from the GYRO_CONFIG
        register.
        If raw is False, it will return 250, 500, 1000, 2000 or -1. If the
        returned value is equal to -1 something went wrong.
        """
        # Get the raw value
        raw_data = self.bus.read_byte_data(self.address, self.GYRO_CONFIG)
 
        if raw is True:
            return raw_data
        elif raw is False:
            if raw_data == self.GYRO_RANGE_250DEG:
                return 250
            elif raw_data == self.GYRO_RANGE_500DEG:
                return 500
            elif raw_data == self.GYRO_RANGE_1000DEG:
                return 1000
            elif raw_data == self.GYRO_RANGE_2000DEG:
                return 2000
            else:
                return -1
 
    def get_gyro_data(self):
        """Gets and returns the X, Y and Z values from the gyroscope.
        Returns the read values in a dictionary.
        """
        # Read the raw data from the MPU-6050
        x = self.read_i2c_word(self.GYRO_XOUT0)
        y = self.read_i2c_word(self.GYRO_YOUT0)
        z = self.read_i2c_word(self.GYRO_ZOUT0)
 
        gyro_scale_modifier = None
        gyro_range = self.read_gyro_range(True)
 
        if gyro_range == self.GYRO_RANGE_250DEG:
            gyro_scale_modifier = self.GYRO_SCALE_MODIFIER_250DEG
        elif gyro_range == self.GYRO_RANGE_500DEG:
            gyro_scale_modifier = self.GYRO_SCALE_MODIFIER_500DEG
        elif gyro_range == self.GYRO_RANGE_1000DEG:
            gyro_scale_modifier = self.GYRO_SCALE_MODIFIER_1000DEG
        elif gyro_range == self.GYRO_RANGE_2000DEG:
            gyro_scale_modifier = self.GYRO_SCALE_MODIFIER_2000DEG
        else:
            print("Unkown range - gyro_scale_modifier set to self.GYRO_SCALE_MODIFIER_250DEG")
            gyro_scale_modifier = self.GYRO_SCALE_MODIFIER_250DEG
 
        x = x / gyro_scale_modifier
        y = y / gyro_scale_modifier
        z = z / gyro_scale_modifier
 
        return {'x': x, 'y': y, 'z': z}
 
    def get_all_data(self):
        """Reads and returns all the available data."""
        temp = get_temp()
        accel = get_accel_data()
        gyro = get_gyro_data()
 
        return [accel, gyro, temp]
 
# Create a new instance of the MPU6050 class
sensor = MPU6050(0x68)
 
while True:
    accel_data = sensor.get_accel_data()
    gyro_data = sensor.get_gyro_data()
    temp = sensor.get_temp()
 
    print("Accelerometer data")
    print("x: " + str(accel_data['x']))
    print("y: " + str(accel_data['y']))
    print("z: " + str(accel_data['z']))
 
    print("Gyroscope data")
    print("x: " + str(gyro_data['x']))
    print("y: " + str(gyro_data['y']))
    print("z: " + str(gyro_data['z']))
    print("")
 
    sleep(1)
cs

자 이렇게 대충 소스를 조합해 보았습니다.
작동모습은 1초마다 IMU의 가속도값(3개)과 각속도값(3개)을 출력하는 것입니다.
한번 Run버튼을 클릭해서 값이 나오는지 확인해보도록 하겠습니다.


네, 위의 붉은색 박스 처럼 값이 출력되는 것을 확인하실 수 있으십니다.
생각보다 간단합니다. 그도 그럴것이 단순한 값만 읽어온 것이고 값에 대한 가공을 통해 특정 Task 코드를 구현하는 것이 아니기 때문입니다. 대부분 이러한 Raw데이터 수준의 값을 받아오는 것은 라이브러리나 이러한 오픈소스들이 존재하고 있습니다. 따라서 조금만 검색을 하면 누구나 쉽게 시도해 볼 수 있는 것이지요.

아래는 간단한 테스트 동영상입니다.













Beaglebone Air Spec



◈ H/W Spec

      • Dim: 86.36 X 54.61 (mm)
      • CPU: Sitara AM3358BZCZ100 (1GHz, 2000MIPS)
      • Memory: 512 MB (8 bit embedded MMC DDR3L 800MHz)
      • FlashROM: 4GB (8 bit eMMC on-board)
      • SD/MMC: microSD (3.3V)
      • Debugger: optional onboard 20-pin JTAG (serial header)
      • LAN: Ethernet 10/100M RJ45
      • Button: Power, Reset, Boot
      • Two expansion headers for 3rd-party CAPEs
      • Power input: 2mm 2 pin connector

◈ S/W Spec

      • OS: Linux (debian with kernel v.3.8.13 or higher)
      • All device drivers supported
      • BLE: GATT protocol
      • IoT SW platform

        • Sensor Domain Manager
        • IGoT micro webserver
        • Thing+ (optional)
      • Cross-compile Development Environment based on Eclipse (running on MS Windows)
      • IGoT Smart apps for Easy Connection (Android)

◈ Connection
      • Putty (Serial 통신) : Wiki에서 설명하고 있는 가장 기본적인 연결방법은 Putty를 사용한 Serial 통신
 
◈ Network
      • IP Address : BBAir의 IP주소는 DHCP로 자동으로 설정
 



지금까지 전체 체험기를 간단히 요약 및 추가하자면,
( 이번엔 Air 만의 장/단점 )

[장점]
1. 기존 비글본 보드들과 100% 호환으로 기본 보드들의 장점을 가지고 있다.
2. 무선칩들의 내장으로 인해 별도의 모듈구비 및 추가회로 구성 혹은 USB인터페이스 사용이 필요없어졌다. 즉, 거추장스러운 추가회로가 필요없고 다른 인터페이스를 보다 효율적으로 사용할 수 있다.
3. CAPE로 인해 통신에 주로 사용되는 핀을 쉽게 사용할 수 있다.
4. 기존 비글본의 브라우저 및 클라우드 서비스의 강력함과 유무선 통신에 용이한 인터페이스를 갖춤으로써 IoT의 네트워크 중심으로써의 그 가치가 높다.
 
[단점]
1. CAPE Schmetic이나 Manual이 필요하다.
   - PCB에 프린트된 내용으로도 충분히 할 수 있긴 하지만, 모든걸 보여줄 수는 없고 착오가 있을 수도 있으니 필요하다.
   물론 이부분은 CAPE를 본격적으로 판매할때는 제대로 구비가 될 것으로 판단된다.
2. CASE로 인해 CAPE등 실드 분리가 어렵고, 확장핀 사용시 불편한 점이 있다.
   - CAPE 혹은 실드를 고려한 재디자인이 필요하다
3. CAPE 스위치가 너무 튀어나와 있고 민감(덜렁거리기까지..)해서 순간 실수로 인한 접촉으로도 리셋이 된다.
   - 스위치를 누르기 쉽게 하려는 의도는 좋았으나 가벼운 접촉으로도 스위치가 작동해버리는 부분은 개선해야한다.
 
[확인이 필요한 사항]
1. Bluetooth의 경우, AT명령이 잘먹히지 않는 경우가 있다. 심할때는 20번 시도하여 1번 응답이 오는 경우가 있는데, 블루투스를 통한 데이터 송수신 테스트를 해보아야 실질적인 문제제기를 할 수 있을 것 같다.
 

 




일단 미션의무는 끝냈습니다. 하지만 더 다양한 테스트를 해보고 싶어 개인적으로 진행할 예정입니다.

간단한 평을 남기자면, 지금까지 체험한바로는 IoT로써의 그 기능이 매우 탁월하다고 생각합니다.

일반 다른 보드에 무선통신 동글을 별매/구성하여 발생하는 비효율을 생각하면, 이 보드를 추천하고 싶습니다.
물론 이번 무상체험단을 통해 필요한 내용들이 충분히 적용되어 개선이 된다면 말이죠.

특히, IoT 홈네트워크를 구축하려고 하시는 분들에게 좋은 제품이 되리라고 생각합니다. 일반적으로 설정하기도 까다롭고 접근하기 어려운 다른 보드들로 고생하는 것보다는 비글본의 강력함과 Air의 유무선통신에 대한 인터페이스를 활용하여 쉽게 접근하는 것이 더 낫다고 개인적으로 판단이 됩니다.
파이썬이나 자바스크립트가 기존 프로그래밍 언어들에 비해 복잡하지 않기에, 초보메이커나 일반인 대상으로 충분한 라이브러리와 예제, 적용가능한 오픈소스를 제공하는 포럼을 형성한다면 홈네트워크 분야에서만큼은 독보적이지 않을까 생각해봅니다. 어디까지나 전제조건이 성립해서 접근이 용이해졌을 때의 경우지만요 :)

어쨌든 부족한 글 끝까지 읽어주셔서 감사합니다 :)






댓글
댓글쓰기 폼