Raspberry Pi Pico: python-i2c

Raspberry Pi Pico I2C - MicroPython

Raspberry Pi Pico I2C(Inter-Integrated Circuit) 통신 - MicroPython

Pi Pico I2C 통신

I2C object(class I2C)
I2C 통신을 이용한 측정 과 제어 시스템 구성 예
프로그램 예: DS1621을 사용한 온도 측정
프로그램 예: DS1621을 사용한 온도 측정(DS1621 Library 사용)
프로그램 예: Master(Pi Pico) - Slave(ATmega128) I2C 통신 예
프로그램 예: I2C 통신(Master(Pi Pico) - Slave(ATmega128))을 이용한 LED 제어
I2C 통신을 사용한 LCD 모듈 제어

Pi Pico I2C 관련 페이지 보기

Pi Pico I2C 통신

I2C object(class I2C)

I2C는 2개의 Bus line을 사용하여 장치 간 통신을 한다. SCL(클럭)과 SDA(데이터) 2개의 통신 선을 사용한다.

참고자료: ATmega128 I2C 통신

I2C object 생성자(Constructors): class machine.I2C(id=- 1, *, scl, sda, freq=400000)

id: I2C 장치의 식별자 이다. id 가 -1(기본값)인 경우 I2C는 소프트웨어로 구현된다. 이 경우 SCL 및 SDA에 핀을 활당하여야 한다. id에 허용되는 다른 값은 특정 보드에 따라 다르며 scl 및 sda 지정은 경우에 따라 필수 또는 허용되지 않을 수 있다. Pi Pico 모듈을 사용하는 경우에는 I2C 번호(Software I2C인 경우 생략할 수 있음)와 scl와 sda 핀을 지정하여야 한다.
scl: SCL 선의 Pin 객체이다.
sda: SDA 선의 Pin 객체이다.
freq: SCL clock rate

일반적인 Method

I2C.init(scl, sda, *, freq=400000): I2C 버스를 초기화한다.
I2C.deinit(): I2C bus를 Turn off 한다.
I2C.scan(): 0x08과 0x77(포함) 사이의 모든 I2C 주소를 스캔하고 응답하는 주소 목록을 반환한다. 장치는 주소(write bit 포함)가 버스로 전송된 후 SDA 라인을 로우로 하면 응답한다.

I2C 기본 동작

start(): 버스에 START 조건을 생성한다.(SCL이 높은 동안 SDA가 낮음으로 전환됨).
stop(): 버스에 STOP 조건을 생성한다.(SCL이 높은 동안 SDA가 높음으로 전환됨).
readinto(buf, nack=True): 버스에서 테이터(Byte)를 읽어 buf에 저장한다. 읽은 바이트 수는 buf의 길이 이다. ACK는 마지막 바이트를 수신 한 후에 버스로 전송된다. 마지막 바이트가 수신 된 후, nack가 참이면 NACK가 전송되고 그렇지 않으면 ACK가 전송된다.(이 경우 슬레이브는 연속되는 호출에서 더 많은 바이트를 읽을 것이라고 가정한다).
I2C.write(buf): buf에서 버스에 테이터(Byte)를 Write 한다. 각 테이터(Byte)를 Write한 다음 ACK가 수신되었는지 확인하고 NACK가 수신되면 나머지 테이터(Byte) 전송을 중지한다. 이 함수는 수신 된 ACK 수를 반환한다.

표준 Bus 동작

다음 Method는 슬레이브 장치를 대상으로 하는 표준 I2C 읽기 및 쓰기 Method 이다.

I2C.readfrom(addr, nbytes, stop=True): addr로 지정된 슬레이브에서 n 바이트를 읽는다. stop이 참이면 전송이 끝날 때 STOP 조건이 생성된다. 읽은 데이터가있는 바이트 열 객체를 반환한다.
I2C.readfrom_into(addr, buf, stop=True): addr에 의해 지정된 슬레이브에서 테이터(Byte)를 읽어 buf에 저장한다. 읽은 바이트 수는 buf의 길이 이다. stop이 참이면 전송이 끝날 때 STOP 조건이 생성한다. 이 메서드는 None을 반환한다.
I2C.writeto(addr, buf, stop=True): buf에 저장된 테이터(Byte)를 addr로 지정된 슬레이브에 write 한다. Bus에 데이터(Byte)를 write한 다음 NACK가 수신되면 나머지 테이터는 전송되지 않는다. stop이 True이면 전송이 끝날 때 STOP 조건이 생성된다. 이 함수는 수신 된 ACK 수를 반환한다.
I2C.writevto(addr, vector, stop=True): 벡터에 포함 된 테이터(Byte)를 addr로 지정된 슬레이브에 write 한다. 벡터는 Tuple 또는 Object 목록이어야 한다. addr가 한 번 전송 된 다음 벡터 내의 각 객체로 부터 테이터(Byte)가 순차적으로 Write 된다. 벡터의 객체는 길이가 0 바이트 일 수 있으며이 경우 데이터는 출력되지 않는다. 벡터의 객체 중 하나에서 테이터(Byte)를 쓴 다음 NACK가 수신되면 나머지 테이터(Byte)와 나머지 객체는 전송되지 않는다. stop이 참이면 NACK가 수신 되더라도 전송이 끝날 때 STOP 조건이 생성된다. 이 함수는 수신 된 ACK 수를 반환한다.

Memory 동작

일부 I2C 장치는 읽고 쓸 수있는 메모리 장치(or 레지스터 세트)역할을 한다. 이 경우 Slave address와 Memory address가 필요하다. 다음 Method는 이러한 장치와 통신하기 위한 기능이다.

I2C.readfrom_mem(addr, memaddr, nbytes, *, addrsize=8)

addr로 지정한 슬레이브의 메모리 주소(memaddr)에서 시작하여 n 바이트를 읽는다. 인수 addrsize는 주소 크기를 비트 단위로 지정한다. 읽은 데이터가 저장된 바이트 열 객체를 반환한다.

I2C.readfrom_mem_into(addr, memaddr, buf, *, addrsize=8)

addr로 지정한 슬레이브의 메모리 주소(memaddr)에서 데이터(Byte)를 읽어 buf에 저장한다. 읽은 바이트 수는 buf의 길이 이다. 인수 addrsize는 주소 크기를 비트 단위로 지정한다(ESP8266에서 이 인수는 인식되지 않으며 주소 크기는 항상 8 비트이다). 이 메서드는 None을 반환한다.

I2C.writeto_mem(addr, memaddr, buf, *, addrsize=8)

addr로 지정한 슬레이브의 메모리 주소(memaddr)에 buf에 저장된 데이터(Byte)를 순차적으로 Write 한다. 인수 addrsize는 주소 크기를 비트 단위로 지정한다(ESP8266에서 이 인수는 인식되지 않으며 주소 크기는 항상 8 비트이다). 이 메서드는 None을 반환한다.

I2C 통신을 이용한 측정 과 제어 시스템 구성 예

I2C 통신을 이용한 측정 과 제어 시스템 구성도

주: I2C Pull-Up 저항은 Pi Pico 모듈에 내장되어 있기 때문에 이 구성도에는 생략되었음.

프로그램 예: DS1621을 사용한 온도 측정

윗 I2C 통신을 이용한 측정 과 제어 시스템 구성 예에서 Pi Pico 개발보드를 Master로 디지털 온도 센서(DS1621)를 Slave device로 사용 한다. 이 예에서는 이해를 쉽게하기 위하여 온도측정에 필요한 최소한의 기능만 구현한다. 확장된 기능은 DS1621 Library를 사용하는 예를 참고 바람.

DS1621을 사용한 온도 측정 프로그램 예: python_i2c_ds1621_basic.py

# Raspberry Pi Pico I2C
# i2c_addr(7 bits) : 1 0 0 1 A2 A1 A0
# DS1621는 3개의 Address Pin(A2, A1, A0)을 갖는다.
# A2A1A0 = 000(모든 Address Pin이 GND) 일때 DS1621의 I2C bus address는 0x48 번지가 된다.

from machine import Timer, I2C, Pin
import ustruct
import time

# DS1621의 Command set
ACCESS_CONFIG = const(0xAC)     # 1 byte, read/write
READ_TEMPERATURE = const(0xAA)  # 2 bytes, read only
START_CONVERT = const(0xEE)
STOP_CONVERT = const(0x22)

# DS1621의 Address를 0x48로 설정
i2c_addr = const(0x48)
# 0번 I2C 장치의 Object를 생성한다.
i2c = I2C(0, scl=Pin(21), sda=Pin(20), freq=100000)

# 온도 측정 주기: 0.75Sec(750mSec)
measurePeriod = 750

# Config_register 값을 저장할 bytearray
config_register = bytearray(1)
# 2 Byte data를 저장할 bytearray
wordData = bytearray(2)

def convert_word_to_temperature(word):
    # bytearray data(2 byte)를 Word data(Big endian format으로 저장)로 변환하면,
    # Bit15 - Bit8에 온도의 정수 값이 저장되고 Bit7는 0.5도를 표시한다. Bit6 - Bot0는 무시함.
	# 이 값을 256으로 나누면 Bit15 - Bit8은 실수의 소숫점 수가가 되고 Bit7는 0.5도를 표시한다. 
    return ustruct.unpack('>h', word)[0]/256

def get_config_register(i2c, i2c_addr, config_register):
    # Configuration register(1 Byte)를 읽어 Return 한다.
    config_register = i2c.readfrom_mem(i2c_addr, ACCESS_CONFIG, 1)
    #print("configRg: 0x{0:02x}".format(config_register[0]))
    return config_register[0]

def set_config_register(i2c, i2c_addr, config_register):
    # Configuration register에 설정 값(1 Byte)을 쓴다.
    # Configuration register의 설정은 변환 동작이 정지된 상태에서 만 가능하다.
	# Continuous mode로 동작중인 경우 Stop Convert 명령을 먼저 실행하여야 한다.
    i2c.writeto_mem(i2c_addr, ACCESS_CONFIG, bytes([config_register]))

# 동작모드("One-shot" or "Continuous")를 설정한다.
def set_conversion_mode(i2c, i2c_addr, mode, config_register):
    # Configuration register 갖어 온다.
    config_register = get_config_register(i2c, i2c_addr, config_register)
    # Conversion mode: Configuration Rg LSB(Bit0)의 상태에 따라 결정된다.
    if mode == "One-shot":
        # One-shot mode (LSB = 1)
        set_config_register(i2c, i2c_addr, config_register | 0x01)
    elif mode == "Continuous":
        # Continuous mode (LSB = 0)
        set_config_register(i2c, i2c_addr, config_register & 0xFE)
    else:
        raise NameError("Invalid conversion mode name")

def get_temperature(i2c, i2c_addr, wordData):
    # Temperature register 값(2 Byte)을 읽어 온다.
    wordData = i2c.readfrom_mem(i2c_addr, READ_TEMPERATURE, 2)
    # wordData에 저장된 온도 값을 대응하는 실수로 변환하여 Return 한다.
    return convert_word_to_temperature(wordData)

def start_convert(i2c, i2c_addr):
    # Temperature conversions(측정)을 시작한다.
    # One-shot mode인 경우 한번만 변환한다.
    # Continuous mode인 경우에는 Stop Convert command 가 실행될 때 까지 계속 변환한다.
    # Continuous mode인 경우에도 변환 동작 시작을 위하여 Start Convert command 가 한번 필요하다. 
    i2c.writeto(i2c_addr, bytes([START_CONVERT]))

def stop_convert(i2c, i2c_addr):
    # Continuous conversion mode에서 변환 동작을 정지한다.
    i2c.writeto(i2c_addr, bytes([STOP_CONVERT]))

def is_conver_progress(i2c, i2c_addr, config_register=None):
    # Temperature conversion 진행 상태를 Return 한다.
	# 만약 현재 변환이 진행중인 경우 True를, 변환이 종료된 경우 False를 Return 한다.
    if config_register is None:
        # Config register의 상태를 읽는다.
        config_register = self.get_config_register(i2c, i2c_addr, config_register)

# Config register의 Bit 7(DONE)이 0 이면 현재 변환이 진행중인 상태이다.
    if config_register & 0x80 == 0x00:
        return True
    # Config register의 Bit 7(DONE)이 1 이면 현재 변환이 완료된 상태이다.
    else:
        return False

# Conversion mode를 설정한다. mode = "One-shot" or "Continuous"
set_conversion_mode(i2c, i2c_addr, "One-shot", config_register)
time.sleep_ms(measurePeriod)

# 변환(측정) 결과를 갖어와 출력한다.
while True:
    # Conversion을 시작한다.
    start_convert(i2c, i2c_addr)
    time.sleep_ms(measurePeriod)
    temperature = get_temperature(i2c, i2c_addr, wordData)
    print("Temperature  : {} °C".format(temperature))

실험을 위한 준비

Pi Pico 개발보드와 온도 센서(DS1621)의 I2C 통신선 연결

Pi Pico 개발보드 SDA(GP20) <-> DS1621 SDA(Pin1) : 2-wire serial 통신을 위한 Data input/output pin.
Pi Pico 개발보드 SCL(GP21) <-> DS1621 SCL(Pin2) : 2-wire serial 통신을 위한 Clock input/output pin.
Pi Pico 개발보드 Pin 36 3.3V <-> DS1621 VDD(Pin8) : VDD pin.
Pi Pico 개발보드 Pin 38 GND <-> DS1621 GND(Pin4) : Ground pin.

온도센서 번호(번지) 설정 하기

DS1621의 Pin7(A0), Pin6(A1), Pin5(A2)를 사용하여 온도 센서의 번호(번지)를 설정 한다.
온도 센서의 번호(번지)를 설정 예

0번(이 예에서는 0번 장치를 0x48 번지로 설정 하였다.): A0 <- GND, A1 <- GND, A2 <- GND

실험 방법

위 프로그램(python_i2c_ds1621_basic.py)을 Download 하여 저장한다.
Thonny IDE를 실행하고 Thonny IDE의 사용 환경(Thonny 실행에 사용할 장치와 COM Port 선택)이 바르게 되어 있는지 확인한다.
Thonny IDE의 Python shell 창에 prompt( >>> )가 출력되었는 확인한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 python_i2c_ds1621_basic.py 파일을 Open 한다.
실험

"실행 -> 현재 스크립트 실행"을 실행하거나 Toolbar의 "실행" Icon을 클릭하면 스크립트가 개발보드에 전송되고 프로그램이 실행된다.
프로그램이 실행되면 750mSec 주기로 온도가 측정되어 콘솔창에 출력된다. DS1621 칩 위애 손을 대고 있으면 체온에 의하여 변동된 온도(보통 상승)가 출력된다.

프로그램 예: DS1621을 사용한 온도 측정(DS1621 Library 사용)

이 예에서는 DS1621 기능을 대부분 사용하기 위하여 DS1621 Library를 사용한다.

DS1621 Library를 사용한 프로그램 예

DS1621 Library를 사용하는 메인 프로그램: python_i2c_ds1621_lib_main.py
DS1621 Library: DS1621.py

실험을 위한 준비는 위 "DS1621을 사용한 온도 측정"을 참고 할 것.
실험 방법

"python_i2c_ds1621_lib_main.py" 프로그램 파일을 Download하여 저장한다.
"DS1621.py" Library 파일을 Download하여 저장한다.
Thonny IDE를 실행하고 Thonny IDE의 사용 환경(Thonny 실행에 사용할 장치와 COM Port 선택)이 바르게 되어 있는지 확인한다.
Thonny IDE의 Python shell 창에 prompt( >>> )가 출력되었는 확인한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 DS1621.py 파일을 Open 한다.
Thonny IDE의 "...(으)로 저장" 기능을 사용하여 DS1621.py 파일을 "MicroPython 장치"에 저장(Upload)한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 python_i2c_ds1621_lib_main.py 파일을 Open 한다.
실험

"실행 -> 현재 스크립트 실행"을 실행하거나 Toolbar의 "실행" Icon을 클릭하면 스크립트가 개발보드에 전송되고 프로그램이 실행된다.
프로그램이 실행되면 750mSec 주기로 온도가 측정되어 콘솔창에 출력된다. DS1621 칩 위애 손을 대고 있으면 체온에 의하여 변동된 온도(보통 상승)가 출력된다.

주: 프로그램 개발이 완료되면 python_i2c_ds1621_lib_main.py을 main.py로 Rename하여 Pi Pico에 Upload 하면 Pi Pico에 전원이 인가되는 즉시 자동으로 실행할 수 있다.

프로그램 예: Master(Pi Pico) - Slave(ATmega128) I2C 통신 예

이 예는 Master와 Slave(Pi Pico 개발보드를 Master로 ATmega128 보드를 Slave로 사용) 사이에 Data 통신을 하는 예 이다.

프로그램 예

ATmega128 보드 프로그램(c 언어): cho_avr_i2c_slave_basic.zip
Pi Pico 개발보드 프로그램(MicroPython 언어): pico-i2c-avr-sw-basic.py

# Raspberry Pi Pico to ATmega128 I2C Communication 
# MicroPython Code 
 
from machine import Pin, Timer, I2C
import time 
 
# Slave Addresses for AVR
SLAVE_ADDRESS = 0x014 # I2C Address of AVR 
 
# 0번 I2C 장치의 Object를 생성한다.
i2c = I2C(0, scl=Pin(21), sda=Pin(20), freq=100000)

byteData = bytearray(1)

# Debouncing timer callback function
# 이 callback function는 External interrupt 발생 후 20mSec 후에 실행된다.
def on_pressed(timer1):
  # Button을 누른 상태가 계속(20mSec 이상)되고 있으면 버튼을 누른 것으로 판단한다.
  if button.value() == 0:
    # 문자(Byte)를 Slave에 전송 한다.
	# cmd = 0xa0 : 이 코드를 Slave에서 문자 수신 명령으로 해석 한다.
    # 그 결과 byteData(문자 'Y')가 명령으로 전송되어 AVR의 모니터에 출력된다.
    byteData[0] = ord('Y')
    i2c.writeto_mem(SLAVE_ADDRESS, 0xa0, byteData)

# AVR로 부터 수신한 문자열을 저장할 변수
    out_str = ''
    # 최대 32자의 문자를 CR Code(13) 가 수신될 때 까지 수신 한다.
    for i in range(32):
      # 문자(Byte)를 Slave에서 수신 한다.
	  # cmd = 0x20 : 이 코드를 Slave에서 문자 전송 명령으로 해석 한다.
      in_data = i2c.readfrom_mem(SLAVE_ADDRESS, 0x20, 1)
      out_str += in_data.decode('utf-8')
      time.sleep(0.01)
      # CR Code(13) 가 수신되면 문자 수신을 종료 한다.
      if in_data[0] == 13:
        break
    # 수신된 문자열을 putty 창(모니터)에 출력 한다.
    print('Received data: ' + out_str)

# Button를 누르면 발생하는  external interrupt handler
def debounce(button):
  # 20ms 후에 Timer interrupt(One_shot)이 발생한다. 
  timer1.init(mode=Timer.ONE_SHOT, period=20, callback=on_pressed)

# Software timer object를 생성한다.
timer1 = Timer(-1)

# GPIO22을 Button 입력 핀으로 설정한다.
button = Pin(22, Pin.IN, Pin.PULL_UP)

# 버튼을 누룰 때 External interrupt(Falling edge)이 발생하도록 설정
button.irq(handler=debounce, trigger=Pin.IRQ_FALLING)

print('Command: Push button switch(Pin22)')

실험을 위한 준비

Pi Pico 개발보드와 ATmega128 보드의 I2C 통신선 연결

Pi Pico 개발보드 SDA(GP20) <-> ATmega128 보드 SDA(PD1) : 2-wire serial 통신을 위한 Data input/output pin.
Pi Pico 개발보드 SCL(GP21) <-> ATmega128 보드 SCL(PD0) : 2-wire serial 통신을 위한 Clock input/output pin.
Pi Pico 개발보드 GND <-> ATmega128 보드 GND : Ground pin.
전원 연결: Pi Pico 개발보드는 3.3V, ATmega128 보드는 5V를 사용하는 경우가 많기 때문에 주의가 필요함. 이 경우는 각각 전원을 연결하고 GND 선만 공통으로 연결한다.
Pin22에 Push button switch를 설치한다.

참고자료: Switch Interfacing

실험 방법

"pico-i2c-avr-sw-basic.py" 프로그램 파일을 Download하여 저장한다.
cho_avr_i2c_slave_basic.zip 파일을 Download 하여 압축을 풀고 여기에 포함된 cho_avr_i2c_slave_basic.hex을 ATmega128 보드에 설치한다.
ATmega128 보드의 UART0를 PC에 연결(USB - UART 변환 모듈 사용)하고 프로그램을 실행한다. PC에서 터미널 프로그램을 실행(ATmega128 보드의 COM 포트 번호 확인이 필요함. Baud rate: 19200)하고 ATmega128 보드의 Reset 버튼을 누르면 "I2C testing." 메세지가 출력된다.
Thonny IDE를 실행하고 Thonny IDE의 사용 환경(Thonny 실행에 사용할 장치와 COM Port 선택)이 바르게 되어 있는지 확인한다.
Thonny IDE의 Python shell 창에 prompt( >>> )가 출력되었는 확인한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 pico-i2c-avr-sw-basic.py 파일을 Open 한다.
실험

"실행 -> 현재 스크립트 실행"을 실행하거나 Toolbar의 "실행" Icon을 클릭하면 스크립트가 개발보드에 전송되고 프로그램이 실행된다.
프로그램이 실행되면 Thonny IDE의 Python shell 창에 "Command: Push button switch(Pin22)" 메세지가 출력 된다.
Push button switch(Pin22) 버튼을 누르면 문자 'Y'가 ATmega128 보드에 전송되어 ATmega128 보드 터미널 창에 출력되고,
ATmega128 보드에서 Pi Pico 개발보드로 "AVR i2c testing" 메세지가 자동으로 전송된다.
그 결과 Thonny IDE의 Python shell의 Console 창에 "AVR i2c testing" 메세지가 출력된다.

프로그램 예: I2C 통신(Master(Pi Pico) - Slave(ATmega128))을 이용한 LED 제어

이 예는 Pi Pico 개발보드(Master)에서 I2C 통신을 이용하여 ATmega128 보드(Slave)의 LED를 제어하는 예 이다.

I2C 통신을 이용하여 ATmega128 보드(Slave)의 LED를 제어하는 프로그램 예: pico-i2c-avr-keypad-led.zip

I2C 통신을 이용하여 ATmega128 보드(Slave)의 LED를 제어하는 프로그램은 아래와 같이 3개의 프로그램으로 구성된다.

ATmega128 보드 LED를 제어하는 프로그램(c 언어): cho_avr_i2c_slave_led.zip
Pi Pico 개발보드 프로그램(Keyoad 제어를 위한 library 프로그램): keypadSoft.py
Pi Pico 개발보드 프로그램(LED 제어를 위한 프로그램): pico-i2c-avr-keypad-led.py

# I2C LED control(Pi Pico - ATmega128) - MicroPython

# LED control command format
# cmd = 0xa1: Left shift command
# cmd = 0xa2: Right shift command
# cmd = 0xa3: Blinking command
# cmd = 0xa4 , val = LED Value: Set LED command
# cmd = 0x20: Get LED status command
 
from machine import I2C, Pin
from time import sleep_ms
from keypadSoft import KeyPadSoft
 
# Slave Addresses for AVR
SLAVE_ADDRESS = 0x014
# 0번 I2C 장치의 Object를 생성한다.
i2c = I2C(0, scl=Pin(21), sda=Pin(20), freq=100000)

# Keypad input pin을 설정한다.
key_inputs = [Pin(2, Pin.IN, Pin.PULL_UP), Pin(3, Pin.IN, Pin.PULL_UP), Pin(4, Pin.IN, Pin.PULL_UP)]
# Keypad scan pin을 설정한다.
key_scans = [Pin(6, Pin.OUT), Pin(7, Pin.OUT), Pin(8, Pin.OUT), Pin(9, Pin.OUT)]
# Key code를 설정한다.
key_codes = [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['*', '0', '#']]
# KeyPad object를 생성한다.
myKeypad = KeyPadSoft(3, 4, key_inputs, key_scans, key_codes)

# Byte data 저장을 위한 bytearray
byteData = bytearray(1)
ledLength = 8
while 1:
  # commandFlag=1 : writeto_mem(), commandFlag=2 : readfrom_mem()
  commandFlag = 0
  # cmd: LED control command
  cmd = 0x00
  ledBits = 0x00
  ledValue = ""
  print('Command: Left:1, Right:3, Blinking:2, Set LED:*, Get LED:#')
  command = myKeypad.getKey()
  # Left shift
  if (command == '1'):
    cmd = 0xa1
    commandFlag = 1
  # Right shift
  if (command == '3'):
    cmd = 0xa2
    commandFlag = 1
  # Blinking
  if (command == '2'):
    cmd = 0xa3
    commandFlag = 1
  # Set LED data
  if (command == '*'):
    cmd = 0xa4
    print('LED Value(ex: 01011011): ')
    # Input LED Value(8 bits)
    for i in range(ledLength):
      ledValue += str(myKeypad.getKey())
      print("ledValue: " + ledValue)
    # String to bits conversion
    ledValueList = list(ledValue)
    for i in range(ledLength):
      if ledValueList[i] == '1':
        ledBits = ledBits | (0x80 >> i)
    commandFlag = 1

if commandFlag == 1: 
    byteData[0] = ledBits
    i2c.writeto_mem(SLAVE_ADDRESS, cmd, byteData)

# Get LED status
  if (command == '#'):
    cmd = 0x20
    commandFlag = 2
    in_data = i2c.readfrom_mem(SLAVE_ADDRESS, cmd, 1)
    # Bits to string conversion
    ledStatus = ''
    for i in range(8):
      if (in_data[0] & (1 << (7-i))) == 0:
        ledStatus += '0'
      else:
        ledStatus += '1'        
    print('ledStatus: ' + ledStatus)
  if commandFlag == 0:
    print('Command error')

실험을 위한 준비는 위 "Master(Pi Pico) - Slave(ATmega128) I2C 통신 예"를 참고 바람.
실험 방법

"pico-i2c-avr-keypad-led.zip"을 다운로드하여 압축을 해제 한다.
ATmega128 보드의 LED를 제어하는 cho_avr_i2c_slave_led.hex(위치: cho_avr_i2c_slave_led\cho_avr_i2c_slave_led\Debug)을 ATmega128 보드에 설치한다.
ATmega128 보드의 UART0를 PC에 연결(USB - UART 변환 모듈 사용)하고 프로그램을 실행한다. PC에서 터미널 프로그램을 실행(ATmega128 보드의 COM 포트 번호 확인이 필요함. Baud rate: 19200)하고 ATmega128 보드의 Reset 버튼을 누르면 "I2C LED control" 메세지가 출력된다.
Thonny IDE를 실행하고 Thonny IDE의 사용 환경(Thonny 실행에 사용할 장치와 COM Port 선택)이 바르게 되어 있는지 확인한다.
Thonny IDE의 Python shell 창에 prompt( >>> )가 출력되었는 확인한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 keypadSoft.py 파일을 Open 한다.
Thonny IDE의 "...(으)로 저장" 기능을 사용하여 keypadSoft.py 파일을 "MicroPython 장치"에 저장(Upload)한다.
Thonny IDE에서 "파일 -> 열기... -> 이 컴퓨터"를 실행하여 pico-i2c-avr-keypad-led.py를 Open 한다.
실험

"실행 -> 현재 스크립트 실행"을 실행하거나 Toolbar의 "실행" Icon을 클릭하면 스크립트가 개발보드에 전송되고 프로그램이 실행된다.
프로그램이 실행되면 ESPlorer 콘솔창에 "Command: Left:1, Right:3, Blinking:2, Set LED:*, Get LED:#" 메세지가 출력 된다.
Keypad에서 LED 제어 명령(예: Keypad에서 1을 입력하면 ATmega128 보드의 LED Array가 좌측으로 순차적으로 점멸한다.)을 입력하면 입력한 명령이 ATmega128 보드에 전송되어 실행된다.

주: 이 실험을 위하여는 ATmega128 보드의 PORTF에 LED Array가 연결되어 있어야 함.

참고자료: Bit 정보를 보기 위한 8 Bits LED Bar 만들기

주: 프로그램 개발이 완료되면 pico-i2c-avr-keypad-led.py을 main.py로 Rename하여 Pi Pico에 Upload 하면 Pi Pico에 전원이 인가되는 즉시 자동으로 실행할 수 있다.

I2C 통신을 사용한 LCD 모듈 제어

장치 제어에 사용하는 Microcontroller는 I/O Port의 수가 제한되어 있기 때문에 LCD 모듈 제어(보통 8 Bits 가 필요)와 같이 많은 I/O Ports를 필요로 하는 장치의 제어를 위하여 I2C 통신을 사용한 I/O Port 확장(8 Bits) 모듈을 사용 한다. 이 예는 I2C 통신을 사용한 I/O Port 확장(8 Bits) 모듈을 이용하여 LCD 모듈을 제어하는 기술에 대하여 설명 한다.

I2C 통신을 사용한 LCD 모듈

I2C 통신을 사용한 I/O Port 확장(8 Bits) 모듈

SCL, SDA Pin은 I2C 통신에 사용 된다.
P0 - P7은 8 Bit Input/Output Port로 I/O Port 확장에 사용 한다.
A0 - A2는 Address를 설정하기 위하여 사용 한다.

I2C 통신을 이용한 I/O Port 확장 Chip(PCF8574)의 Block diagram

I2C 통신을 사용한 LCD 모듈

I2C - LCD Module은 I2C - I/O Expander(PCF8574)와 LCD의 Contrast를 조정하는 회로(가변저항 포함), Backlight Control 회로로 구성 되어 LCD 모듈을 제어 한다.
I2C - LCD Module은 Microcontroller로 부터 I2C 통신을 이용하여 Data를 수신하고, 이 Data를 이용하여 LCD Module을 제어 한다.
I2C - LCD Module과 LCD Module은 함께 조립되어 판매 하기 때문에 이용자는 Microcontroller(AVR)과 I2C - LCD Module 사이의 4선(SCL, SDA, VCC, GND) 만 연결하면 된다.

I2C 통신을 사용한 LCD 제어 시스템 구성도

I2C - LCD Module 과 LCD Module(1602)을 통합한 제품 예

I2C - LCD Library를 사용한 프로그램 예: i2c-lcd.zip

이 예는 I2C - LCD Library를 사용하여 PCF8574를 통해 연결된(I2C) HD44780 문자 LCD를 제어한다.

I2C - LCD Library를 사용하는 메인 프로그램: I2cLcd-main.py

PCF8574를 통해 연결된(I2C) HD44780 문자 LCD를 제어하는 Class Library: I2cLcd.py

#I2cLcd.py
import utime
import gc
from LcdApi import LcdApi

# PCF8574 pin definitions
MASK_RS = 0x01       # P0
MASK_RW = 0x02       # P1
MASK_E  = 0x04       # P2

SHIFT_BACKLIGHT = 3  # P3
SHIFT_DATA      = 4  # P4-P7

# PCF8574를 통해 연결된(I2C) HD44780 문자 LCD를 구현하는 Class
class I2cLcd(LcdApi):
    def __init__(self, i2c, i2c_addr, num_lines, num_columns):
        self.i2c = i2c
        self.i2c_addr = i2c_addr
        self.i2c.writeto(self.i2c_addr, bytes([0]))
        utime.sleep_ms(20)   # Allow LCD time to powerup
        # Send reset 3 times
        self.write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(5)    # Need to delay at least 4.1 msec
        self.write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(1)
        self.write_init_nibble(self.LCD_FUNCTION_RESET)
        utime.sleep_ms(1)
        # Put LCD into 4-bit mode
        self.write_init_nibble(self.LCD_FUNCTION)
        utime.sleep_ms(1)
        LcdApi.__init__(self, num_lines, num_columns)
        cmd = self.LCD_FUNCTION
        if num_lines > 1:
            cmd |= self.LCD_FUNCTION_2LINES
        self.write_command(cmd)
        gc.collect()

# LCD를 초기화 하는데 사용하는 nibble 데이터를 write 한다.
    # 이 함수는 LCD를 초기화 하는데 사용된다.
    def write_init_nibble(self, nibble):
        byte = ((nibble >> 4) & 0x0f) << SHIFT_DATA
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        gc.collect()
        
    # Backlight를 Turn on 한다.
    def backlight_on(self):
        self.i2c.writeto(self.i2c_addr, bytes([1 << SHIFT_BACKLIGHT]))
        gc.collect()
        
    # Backlight를 Turn off 한다.
    def backlight_off(self):
        self.i2c.writeto(self.i2c_addr, bytes([0]))
        gc.collect()
        
    # LCD에 command를 write 한다.
    def write_command(self, cmd):
        # Data는 Enable 신호의 falling edge에서 latched 된다.
        byte = ((self.backlight << SHIFT_BACKLIGHT) |
                (((cmd >> 4) & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        byte = ((self.backlight << SHIFT_BACKLIGHT) |
                ((cmd & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        if cmd <= 3:
            # Home과 Clear commands는 실행에 4.1 msec가 필요하다.
            utime.sleep_ms(5)
        gc.collect()

# LCD에 data를 write 한다.
    def write_data(self, data):
        # Data는 Enable 신호의 falling edge에서 latched 된다.
        byte = (MASK_RS |
                (self.backlight << SHIFT_BACKLIGHT) |
                (((data >> 4) & 0x0f) << SHIFT_DATA))
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        byte = (MASK_RS |
                (self.backlight << SHIFT_BACKLIGHT) |
                ((data & 0x0f) << SHIFT_DATA))      
        self.i2c.writeto(self.i2c_addr, bytes([byte | MASK_E]))
        self.i2c.writeto(self.i2c_addr, bytes([byte]))
        gc.collect()

HD44780와 호환되는 Character LCD와 통신하기 위한 API(Application Programming Interface) Class Library: LcdApi.py

#LcdApi.py
# HD44780와 호환되는 Character LCD와 통신하기 위한 API(Application Programming Interface)
from time import sleep_us

class LcdApi:
    # HD44780 LCD controller command set
    LCD_CLR = 0x01              # DB0: clear display
    LCD_HOME = 0x02             # DB1: return to home position

LCD_ENTRY_MODE = 0x04       # DB2: set entry mode
    LCD_ENTRY_INC = 0x02        # --DB1: increment
    LCD_ENTRY_SHIFT = 0x01      # --DB0: shift

LCD_ON_CTRL = 0x08          # DB3: turn lcd/cursor on
    LCD_ON_DISPLAY = 0x04       # --DB2: turn display on
    LCD_ON_CURSOR = 0x02        # --DB1: turn cursor on
    LCD_ON_BLINK = 0x01         # --DB0: blinking cursor

LCD_MOVE = 0x10             # DB4: move cursor/display
    LCD_MOVE_DISP = 0x08        # --DB3: move display (0-> move cursor)
    LCD_MOVE_RIGHT = 0x04       # --DB2: move right (0-> left)

LCD_FUNCTION = 0x20         # DB5: function set
    LCD_FUNCTION_8BIT = 0x10    # --DB4: set 8BIT mode (0->4BIT mode)
    LCD_FUNCTION_2LINES = 0x08  # --DB3: two lines (0->one line)
    LCD_FUNCTION_10DOTS = 0x04  # --DB2: 5x10 font (0->5x7 font)
    LCD_FUNCTION_RESET = 0x30   # See "Initializing by Instruction" section

LCD_CGRAM = 0x40            # DB6: set CG RAM address
    LCD_DDRAM = 0x80            # DB7: set DD RAM address

LCD_RS_CMD = 0
    LCD_RS_DATA = 1

LCD_RW_WRITE = 0
    LCD_RW_READ = 1

def __init__(self, num_lines, num_columns):
        self.num_lines = num_lines
        # HD44780와 호환되는 LCD controller의 최대 Line 수는 4(보통 2) 이다.
        if self.num_lines > 4:
            self.num_lines = 4
        self.num_columns = num_columns
        # HD44780와 호환되는 LCD controller의 최대 Columns 수는 40(보통 16) 이다.
        if self.num_columns > 40:
            self.num_columns = 40
        self.cursor_x = 0
        self.cursor_y = 0
        self.implied_newline = False
        self.backlight = True
        self.display_off()
        self.backlight_on()
        self.clear()
        self.write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC)
        self.hide_cursor()
        self.display_on()

# LCD display를 Clears 하고 Cursor를 왼쪽 상단으로 이동한다.
    def clear(self):
        self.write_command(self.LCD_CLR)
        self.write_command(self.LCD_HOME)
        self.cursor_x = 0
        self.cursor_y = 0

# Cursor 가 보이도록 한다.
    def show_cursor(self):
        self.write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
                               self.LCD_ON_CURSOR)

# Cursor 가 보이지 않도록 한다.
    def hide_cursor(self):
        self.write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

# Cursor를 Turn on 하고, Blinking 하도록 한다.
    def blink_cursor_on(self):
        self.write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
                               self.LCD_ON_CURSOR | self.LCD_ON_BLINK)

# Cursor를 Turn on 하고, Blinking 하지 않도록 한다.
    def blink_cursor_off(self):
        self.write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY |
                               self.LCD_ON_CURSOR)

# LCD를 Turn on 한다.
    def display_on(self):
        self.write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY)

# LCD를 Turn off 한다.
    def display_off(self):
        self.write_command(self.LCD_ON_CTRL)

# Backlight를 Turn on 한다.
    # Backlight 기능은 HD44780의 기능이 아니고 LCD 모듈에서 주어지는 기능이기 때문에
    # LCD 모듈에 따라 이 기능이 없을 수도 있다.
    def backlight_on(self):
        self.backlight = True
        self.backlight_on()

# Backlight를 Turn off 한다.
    # Backlight 기능은 HD44780의 기능이 아니고 LCD 모듈에서 주어지는 기능이기 때문에
    # LCD 모듈에 따라 이 기능이 없을 수도 있다.
    def backlight_off(self):
        self.backlight = False
        self.backlight_off()

# Cursor 위치를 설정한다. 첫번째 column은 cursor_x = 0 이다.
    def move_to(self, cursor_x, cursor_y):
        self.cursor_x = cursor_x
        self.cursor_y = cursor_y
        addr = cursor_x & 0x3f
        if cursor_y & 1:
            addr += 0x40    # Lines 1 & 3 add 0x40
        if cursor_y & 2:    # Lines 2 & 3 add number of columns
            addr += self.num_columns
        self.write_command(self.LCD_DDRAM | addr)

# 현재 커서 위치에 문자를 출력하고 커서를 한 위치 이동한다.
    def putchar(self, char):
        if char == '\n':
            if self.implied_newline:
                # self.implied_newline이 True인 경우 Line의 끝에 도달하여
                # 자동으로 줄바꿈이 실행되었기 때문에 '\n' 코드를 무시한다.
                pass
            else:
                self.cursor_x = self.num_columns
        else:
            self.write_data(ord(char))
            self.cursor_x += 1
        # Cursor가 column 끝에 도달하면 cursor의 위치를 다음 line 첫 column에 위치하게 한다.
        if self.cursor_x >= self.num_columns:
            self.cursor_x = 0
            self.cursor_y += 1
            # char 가 '\n' 이 아는 경우 self.implied_newline는 True 가 된다. 
            self.implied_newline = (char != '\n')
        # Cursor가 Line의 끝에 도달하면 Cursor의 위치를 첫 Line에 위치하게 한다.
        if self.cursor_y >= self.num_lines:
            self.cursor_y = 0
        # 변경된 cursor의 위치를 설정 한다.
        self.move_to(self.cursor_x, self.cursor_y)

# 현재 커서 위치로 부터 문자열을 출력한다.
    def putstr(self, string):
         for char in string:
            self.putchar(char)

# Custom char을 CGRAM에 저장한다.
    # location: chr(0) - chr(7) 까지 8 CGRAM locations 이 가능하다.
    # charmap: Custom char를 정의하는 bytearray.
    def custom_char(self, location, charmap):
        location &= 0x7
        self.write_command(self.LCD_CGRAM | (location << 3))
        self.sleep_us(40)
        for i in range(8):
            self.write_data(charmap[i])
            self.sleep_us(40)
        self.move_to(self.cursor_x, self.cursor_y)

# Backlight를 Turn on 한다.
    # 필요한 경우 파생된 HAL(Hardware Abstraction Layer) 클래스에서 이 기능을 구현한다.
    def backlight_on(self):
        pass

# Backlight를 Turn off 한다.
    # 필요한 경우 파생된 HAL(Hardware Abstraction Layer) 클래스에서 이 기능을 구현한다.
    def backlight_off(self):
        pass

# LCD에 command를 write 한다.
    # 필요한 경우 파생된 HAL(Hardware Abstraction Layer) 클래스에서 이 기능을 구현한다.
    def write_command(self, cmd):
        raise NotImplementedError

# LCD에 data를 write 한다.
    # 필요한 경우 파생된 HAL(Hardware Abstraction Layer) 클래스에서 이 기능을 구현한다.
    def write_data(self, data):
        """Write data to the LCD.

It is expected that a derived HAL class will implement this
        function.
        """
        raise NotImplementedError

# 설정된(usecs) microseconds 동안 sleep 한다.
    def sleep_us(self, usecs):
        """Sleep for some time (given in microseconds)."""
        sleep_us(usecs)

실험을 위한 준비

Pi Pico 개발보드 SDA(GP20) <-> LCD 모듈의 SDA : 2-wire serial 통신을 위한 Data input/output pin.
Pi Pico 개발보드 SCL(GP21) <-> LCD 모듈의 SCL : 2-wire serial 통신을 위한 Clock input/output pin.
Pi Pico 개발보드 GND <-> LCD 모듈의 GND : Ground pin.
전원 연결: Pi Pico 개발보드의 5V pin과 LCD 모듈의 5V pin. LCD 모듈이 3.3V를 사용하는 경우에는 Pi Pico 개발보드의 3.3V 출력 pin과 연결하여야 한다.

실험 방법

i2c-lcd.zip(I2cLcd-main.py, I2cLcd.py, LcdApi.py)를 파일을 Download하여 압축을 해제한다.
Thonny IDE를 실행하고 Thonny IDE의 사용 환경(Thonny 실행에 사용할 장치와 COM Port 선택)이 바르게 되어 있는지 확인한다.
Thonny IDE의 Python shell 창에 prompt( >>> )가 출력되었는 확인한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 I2cLcd.py 파일을 Open 한다.
Thonny IDE의 "...(으)로 저장" 기능을 사용하여 I2cLcd.py 파일을 "MicroPython 장치"에 저장(Upload)한다.
Thonny IDE의 "파일 -> 열기"를 실행하여 LcdApi.py 파일을 Open 한다.
Thonny IDE의 "...(으)로 저장" 기능을 사용하여 LcdApi.py 파일을 "MicroPython 장치"에 저장(Upload)한다.
Thonny IDE에서 "파일 -> 열기... -> 이 컴퓨터"를 실행하여 I2cLcd-main.py를 Open 한다.
자신이 사용하는 LCD 모듈의 Slave 주소를 확인하여 설정(I2C_ADDR 값을 변경)한다. 보통 PCF8574를 사용한 경우에는 0x27 번지이고, PCF8574A를 사용한 경우에는 0x3f 번지이다.
실험

"실행 -> 현재 스크립트 실행"을 실행하거나 Toolbar의 "실행" Icon을 클릭하면 스크립트가 개발보드에 전송되고 프로그램이 실행된다.
프로그램이 실행되면 첫 줄에 "Hello LCD", 둘째 줄에 "하트와 I2C LCD"가 출력된다.

주: 프로그램 개발이 완료되면 I2cLcd-main.py을 main.py로 Rename하여 Pi Pico에 Upload 하면 Pi Pico에 전원이 인가되는 즉시 자동으로 실행할 수 있다.

Pi Pico I2C 관련 페이지 보기