I2C Class
I2C Class의 생성자 파라미터
I2C Class의 생성자 파라미터를 정리하자면 아래와 같다.
I2C(
id,
*,
scl=None,
sda=None,
freq=400_000,
timeout=50_000
)
id 파라미터
id 파라미터는 I2C가 사용할 블록 번호를 지정한다. RP2040은 0번 블록이 하나밖에 없으므로 0을 입력한다. ESP32에서는 블록이 2개이므로 원하는 블록을 지정하면 된다.
scl 파라미터
해당 파라미터는 통신하고 싶은 장치의 SCL 핀이 연결되어 있는 GPIO 값을 Pin객체로 생성하여 넘기면 된다. 어렵지 않다. SCK에 대해서 I2C 통신 파트에서 설명했듯이, I2C에는 SCK가 아니라 SCL이고, 제조사에 따라서 SCK로 적혀져 있는 경우가 있다. 이는 SCL로 해석하고 핀을 연결하면 된다.
sda 파라미터
해당 파라미터는 통신하고 싶은 장치의 SDA 핀이 연결되어 있는 GPIO 값을 Pin객체로 생성하여 넘기면 된다. 이 또한 어렵지 않다.
freq 파라미터
freq는 SCL 클럭의 주파수를 설정할 수 있다. 장치가 지원하는 클럭의 최대 속도보다 높은 값을 설정하거나, 또한 너무 낮은 값을 설정하게 되면 통신 실패가 발생할 수 있다.
timeout 파라미터
timeout은 I2C통신에 오류가 생겼을 때 언제까지 기다려 줄 것인가에 대한 값이다. 만약 통신 시간이 timeout값을 넘어간다면 비정상적인 통신으로 인식하고 해당 통신을 중
참고, i2c 통신 시간 측정
필자는 time 모듈의 tick_us() 메서드를 사용하여 I2C 시간을 측정하였다. 통신 측정을 위한 반복 횟수는 100번으로 잡았고, 해당 데이터는 리스트에 저장하였다. 이때 리스트의 append로 인하여 gc가 실행될 가능성이 있기 때문에 미리 리스트를 반복 횟수만큼 할당해놓고 측정을 시작하였다. 측정 코드는 아래와 같다.
def get_i2c_timeout(func, repeat=100, warm_up=10):
times = [0] * repeat
for i in range(warm_up):
func() # warm-up
for i in range(repeat):
start = time.ticks_us()
func()
times[i] = ticks_diff(time.ticks_us(), start)
return [max(times), times]
위 코드는 i2c 통신을 하는 func() 함수의 실행을 repeat 만큼 반복하여 times 리스트에 저장한다. timeout 값을 설정할 때는 제일 오래 걸렸던 작업 시간을 기준으로 잡아야 하므로 max(times)를 times와 같이 리스트 형태로 같이 반환하였다. 이 때, func의 warm-up까지 고려하여 정확한 시간 측정을 하였다.
I2C Class 메서드
scan()
I2C와 통신하고 있는 주소를 반환받을 수 있다. 형식은 아래와 같다.
i2c.scan()
I2C 통신에서 8비트 중 7비트는 주소값, 1비트는 쓰기 또는 읽기의 여부를 보낸다고 하였다. 해당 반환값도 쓰기/읽기 여부가 포함된 비트열일 것 같지만, 실제로는 7비트 주소만 반환한다. 참고로 반환은 리스트로 한다.
readfrom()
readfrom()은 원하는 장치의 송신값을 읽어올 수 있는 메서드이다. 형식은 아래와 같다.
I2C.readfrom(addr, nbytes, stop=True, /)
반환은 bytes 객체로 한다.
addr 파라미터
addr은 원하는 장치의 주소값 입력하면 된다. 여기서 scan() 메서드를 사용하여 해당 주소 값을 가져와 넣을 수 있다.
nbytes 파라미터
nbytes는 해당 장치로부터 읽을 바이트 수를 지정한다.
stop 파라미터
stop은 i2c 통신 마지막에 해당 readfrom()를 마치고 STOP 신호를 보낼 것인지에 대한 여부를 결정할 수 있다.
만약, 다음 코드 줄에서 i2c 통신을 수행해야 한다면 stop의 값을 False로 설정하여 STOP 신호를 미룰 수 있다.
####
필자는 다음 i2c 통신이 있을 때 stop 파라미터를 False와 True로 설정하는 것이 어떤 차이가 있는지 궁금하였다.
그래서 위와 같이 time 모듈의 ticks_us() 메서드를 사용하여 비교하였다. 코드는 아래와 같다.
from machine import I2C, Pin
import time
i2c = I2C(
0,
sda=Pin(20),
scl=Pin(21),
)
addr = i2c.scan()[0]
warm_up = 10
for i in range(warm_up):
i2c.writeto(addr, b"\xAB")
repeat = 100
run = 100
# stop=False
stop_false_times = [0] * repeat
for i in range(repeat):
start = time.ticks_us()
for j in range(run):
i2c.writeto(addr, b"\xAB", False)
stop_false_times[i] = time.ticks_diff(time.ticks_us(), start)
# stop=True
stop_true_times = [0] * repeat
for i in range(repeat):
start = time.ticks_us()
for j in range(run):
i2c.writeto(addr, b"\xAB", True)
stop_true_times[i] = time.ticks_diff(time.ticks_us(), start)
mean_stop_false_time = sum(stop_false_times) / len(stop_false_times)
mean_stop_true_time = sum(stop_true_times) / len(stop_true_times)
print(f"stop=False일 때 : {mean_stop_false_time}ns")
print(f"stop=True일 때 : {mean_stop_true_time}ns")
출력 결과는 아래와 같았다.
>>>
stop=False일 때 : 7863.8ns
stop=True일 때 : 8177.06ns
stop을 False로 설정했을 때가 True보다 313.26024ns 더 빨랐다.
readfrom_into()
readfrom_into()는 bytes 객체로 반환하지 않고 파라미터로 넘긴 버퍼(<class ‘bytearray’>)에 저장하는 구조를 가진다. 위에서 말했던 바이트 객체(<class ‘bytes’>)와는 다르다. 참고로 바이트 객체는 수정이 불가능하지만, 바이트 배열은 수정이 가능하다. readfrom_into() 형식은 아래와 같다.
i2c.readfrom_into(addr, buf, stop)
buf 파라미터
buf 파라미터는 bytearray 객체를 넘긴다. byte 객체와 달리 재사용이 가능하다. buf 파라미터로 읽어오는 값을 덮어쓰기 때문에 readfrom() 메서드의 nbytes 파라미터 같은 읽어올 바이트 수가 필요하지 않다. bytearray를 생성할 때 배열 크기를 지정하기 때문에 해당 크기만큼 장치로부터 값을 읽어온다.
readfrom()과 readfrom_into()의 차이
readfrom_into()는 readfrom()보다 메모리 할당을 거의 하지 않기 때문에 센서 값을 반복적으로 읽게 된다면 readfrom_into()를 사용하는 것이 유리하다.
writeto()
writeto() 는 전달하는 주소에 해당하는 장치에 데이터를 전송하는 메서드이다. 형식은 아래와 같다.
i2c.writeto(addr, buf, stop)
해당 파라미터에 대한 설명은 위에서 설명했으므로 패스하겠다.
해당 메서드의 반환값은 ACK 신호의 횟수이다. ACK는 장치에서 1바이트를 잘 받았을 때 보내는 신호이다. 즉 통신을 잘 완료한 바이트 수라고 생각해도 괜찮다. 만약 중간에 NACK 신호가 오게 되면 바이트 전송을 중단하고 stop 파라미터에 따라서 STOP 신호가 출력된다. NACK신호는 통신에 문제가 발생하였을 때 장치에서 보낸다.
writevto()
writevto()는 write + v + to 이다. 여기서 v는 vector이다. 갑자기 벡터가 나와 ‘엥?’ 할 수도 있겠지만, writeto()와 차이점을 비교해보면 금방 해소 된다. writeto()같은 경우는 해당 장치에 하나의 버퍼를 보내지만, writevto()는 두 개의 버퍼를 합치지 않고 연속적으로 보낼 수 있다. 예시를 봐보자.
만약 아래와 같은 데이터를 보내야 한다고 해보자.
header = b"\x40"
payload = bytearray(512)
writeto() 방식을 사용하게 되면 해당 메서드를 두 번 사용해야 한다.
i2c.writeto(addr, header)
i2c.writeto(addr, payload)
추가로, writeto()는 연속적으로 데이터를 보내지 않기 때문에 stop=True로 설정되어 있으면, 중간에 i2c transaction도 두 번 발생하게 된다.
START
주소 + W
header
STOP
START
주소 + W
payload
STOP
하지만 이는 마지막 writeto()만 stop=True로 설정하면 해결할 수 있기 때문에 적절한 예시는 아니다. 그럼에도 불구하고, 중요하게 보아야 할 것은 버퍼를 두 개 보내고 싶다면, writeto()를 사용했을 때 무조건 두 번 써야만 한다는 것이다.
그럼 두 개의 버퍼를 하나의 객체로 합쳐 한 번에 보내면 되지 않냐는 생각이 드는 것은 자연스럽다. 아래의 코드를 봐보자.
i2c.writeto(addr, header + payload)
이는 writevto()와 매우 유사해보인다. 하지만, 저렇게 “+”로 합치게 되면 새로운 객체를 생성하는 비용이 발생한다. 임베디드 시스템에서는 제한된 자원을 항시 고려해야 하기 때문에 위와 같은 코드는 적절하지 않다.
writevto()는 객체를 새로 생성하지 않고 참조만 하여 연속적으로 데이터를 보낼 수 있다. 아래 코드를 봐보자.
i2c.writevto(addr, (header, payload))
writevto()는 실제로 해당 데이터를 복사하는 것이 아니라, 기존 객체들을 참조한다. 하지만 위 코드 또한 tuple 객체를 생성하게 되므로 반복문을 돌리기 전에 tuple 객체를 생성하여 안에 넣어 놓는 것이 적절하다. 반복문에서 여러 번 객체를 생성하게 되면 heap fragmentation의 문제가 발생할 수 있기 때문이다. 제한된 환경에선 해당 단편화가 과하게 발생하지 않게 조심해야 할 것이다.
header = b"\x40"
payload = bytearray(512)
vector = (header, payload)
while True:
i2c.writevto(addr, vector)
위와 같은 코드처럼 짜게 되면 반복문을 돌릴 때마다 tuple 객체를 매번 생성할 필요가 없다.
writevto() 가 writeto() 보다 비효율적일 수도 있다.
writevto()가 writeto()보다 비효율적일 수도 있다는 것은 writevto()를 사용할 때만 발생하는 작업이 존재한다는 것을 의미한다.
writevto()는 전달받은 tuple에서 각 객체를 하나씩 읽고 해당 객체의 주소와 길이를 기록한다. 즉 존재하는 객체를 순회하고 기록하는 비용이 발생하는 것이다. 그래서 연속적이지 않은 데이터를 굳이 writevto()를 사용하게 되면 순회, 기록 비용이 발생할 수 있으므로 writeto() 보다 비효율적인 상황이 발생한다.
참고로 순회한 결과를 descriptor라고 하고, 해당 데이터는 stack을 이용하여 저장한다.
readfrom_mem()
readfrom_mem()은 해당 장치의 레지스터 값을 읽어온다. 형식은 아래와 같다.
i2c.readfrom_mem(
addr,
memaddr,
nbytes,
*,
addrsize=8
)
예를 들어 BME280 이라는 온,습도 기압 센서가 있다고 해보자. BME280 안에는 수많은 레지스터가 존재한다. 실제 Bosch BME280 데이터시트의 메모리 맵을 살펴보면 아래와 같은 장치 안에 레지스터가 존재한다.
BME280 (I²C 주소 0x76)
│
├─ 0xD0 : 칩 ID
├─ 0xE0 : Reset
├─ 0xF2 : 습도 설정
├─ 0xF3 : 상태
├─ 0xF4 : 온도/기압 측정 설정
├─ 0xF5 : 필터/대기시간 설정
├─ 0xF7 : 기압 데이터 상위 바이트
├─ 0xF8 : 기압 데이터
├─ 0xF9 : 기압 데이터 하위 부분
├─ 0xFA : 온도 데이터 상위 바이트
├─ 0xFB : 온도 데이터
├─ 0xFC : 온도 데이터 하위 부분
├─ 0xFD : 습도 데이터 상위 바이트
└─ 0xFE : 습도 데이터 하위 바이트
즉, 0x76(addr) 안에 0xF3(memaddr) 안에 있는 값을 3(nbytes)바이트 만큼 읽어온다고 해석할 수 있다. addrsize 같은 경우는 장치에 따라 레지스터 주소가 8비트일 수도 있고, 16비트일 수도 있다. 해당 파라미터는 장치간의 호환성을 위해 레지스터 주소를 장치와 통신할 때 몇 비트로 통신할 것인지 정해주는 것이다.
여기서 중요하게 보아야 할 것은 nbytes 값이다. 만약 내가 0xF3 의 상태 레지스터 값을 3byte만큼 읽어온다고 해서 0xF3의 값이 1바이트인데 3바이트만큼 확장해서 값을 읽어오는 것이 아닐 수 있다. 장치마다 다르고 레지스터 설계마다 다르겠지만, BME280에서는 읽었을 때 레지스터 주소가 자동으로 증가한다. 즉, 원치 않는 값을 같이 읽어올 수 있다. 개발자는 무조건 해당 장치의 데이터시트의 메모리 맵을 확인하고, 공식 문서를 읽고 코드를 작성해야 한다.
반환값은 읽어온 데이터를 bytes 객체로 반환한다.
readfrom_mem_into()
readfrom_mem_into()는 개발자가 넘기는 버퍼에 덮어씌우는 것이다. 위에서 설명했듯이 bytes 객체가 아니라 bytearray이므로 재사용성이 높다. 반복적인 수행을 할 때에는 readfrom_mem_into()를 사용하는 것이 적절하다. 형식은 아래와 같다.
i2c.readfrom_mem_into(
addr,
memaddr,
buf,
*,
addrsize=8
)
반환값은 당연히 None이다.
writeto_mem()
writeto_mem()는 해당 장치의 특정 레지스터에 값을 쓸 수 있다. 형식은 아래와 같다.
i2c.writeto_mem(
addr,
memaddr,
buf,
*,
addrsize=8
)
이 때에도 해당 장치의 데이터시트를 무조건 확인해야 하고, 해당 메서드 같은 경우는 반환값이 없고 오류는 예외로 확인해야 함을 유의해야 한다.
init()
init() 메서드는 이미 생성된 객체의 파라미터 값들을 다시 재설정해줄 수 있다. 형식은 아래와 같다.
i2c.init(
scl,
sda,
freq=400_000
)
필자가 사용하고 있는 RP2040 같은 경우는 init() 메서드를 지원하지 않는다. 그래서 객체를 다시 생성하여 파라미터 값들을 수정해야 한다.
deinit() 같은 경우도 RP2040에서 지원하지 않는다. deinit()은 해당 자원을 해제하는 것이지만 RP2040에서는 객체를 다시 생성하여 해결한다.
start(), stop() - SoftI2C
start(), stop() 메서드는 각각 START, STOP 조건을 생성하는 것이다. SoftI2C 객체가 아닌 I2C 객체는 해당 메서드를 사용할 수 없다.
readinto() write() - SoftI2C
readinto() 은 I2C 통신의 주소 선택과 START을 만들지 않고 sda를 즉시 읽어온다. 형식은 아래와 같다.
i2c.readinto(buf, nack)
nack 파라미터
nack 파라미터는 마지막 바이트를 보낼 때 NACK 신호를 보낼 것인지에 대한 여부를 결정한다. True 인 경우에는 마지막에 NACK 신호를 보내고 False 인 경우에는 마지막에 ACK 신호를 보내 I2C 통신을 이어서 진행할 수 있게 해준다.
반환값은 None이다.
write() 은 I2C 통신의 주소 선택을 하지 않고 해당 바이트를 바로 버스에 올려 보낸다.
i2c.readinto(buf, nack)
SoftI2C 원시 코드 사용 - start(), stop(), readinto(), write()
해당 메서드들은 SoftI2C 객체의 메서드들이고, 원시 메서드이다. I2C 통신을 직접 이해하기 매우 좋다.
아래 코드는 장치 주소 0x68로부터 2바이트 데이터를 직접 읽어오는 구조이다.
from machine import SoftI2C, Pin
i2c = SoftI2C(
scl=Pin(21),
sda=Pin(20),
)
addr = 0x68
buf = bytearray(2)
i2c.start()
# 주소 7비트를 왼쪽으로 밀고 Read 비트 1을 결합
i2c.write(bytes([(addr << 1) | 1]))
i2c.readinto(buf, True)
i2c.stop()
print(buf)
하지만 I2C 객체를 사용하면 아래와 같이 한 줄로 처리가 가능하다.
data = i2c.readfrom(0x68, 2)
I2C와 SoftI2C의 차이
I2C는 하드웨어 I2C이기 때문에 CPU 사용량이 적고 속도/효율도 대체로 좋다. 하지만 SoftI2C는 CPU를 이용하여 신호들을 조작하기 때문에 CPU 사용량이 많고, 속도/효율 측면에서 상대적으로 느리다.
아래와 같은 구조도를 보면 더 자세히 이해가 될 것이다.
I2C
MicroPython
↓
RP2040 I2C0 하드웨어
↓
SCL / SDA
SoftI2C
MicroPython 코드
↓
CPU가 GPIO 직접 HIGH/LOW
↓
SCL / SDA