<div id="readability-page-1" class="page"><div> 

LCD일반

LCD는 Liquid Crystal Display의 약자로 액정표시장치를 말한다. Liquid Crystal이란 액체처럼 유체의 성질을 가지면서 고체처럼 광학적 성질을 가지는 물질로써 액정은 고체표면에 액정이 특정 방향으로 정렬할 수도 있어, 전기적 신호를 가해 원하는 방향으로 배열하여 빛을 투과시키거나 차단시킬 수 있다. 아래는 2줄 16 문자를 표시할 수 있는 LCD를 보여준다.

2x16 LCD

<figure data-origin-width="317" data-origin-height="141" data-ke-mobilestyle="alignCenter"><img src="https://blog.kakaocdn.net/dn/noeS3/btrKZ1VfxEl/YeGfU4Fk5aYvb2WK1GyFM1/img.png" data-filename="그림12-1.png" data-ke-mobilestyle="alignCenter"><figcaption>2줄, 16문자 표시기</figcaption></figure>
2*16&nbsp; LCD 구성과 핀 번호 기능을 살펴보면 다음과 같다. 이 핀 연결과 제어를 i2c 인터페이스를 사용하여 단순하게 만든 것을 i2c LCD 라고 생각하면 된다.

<figure data-origin-width="470" data-origin-height="238" data-ke-mobilestyle="alignCenter"><img src="https://blog.kakaocdn.net/dn/cV28tg/btrK4VTtptG/ugMI3IMj6ITz1WR6VNmyz0/img.png" data-filename="그림12-2.png" data-ke-mobilestyle="alignCenter"><figcaption>2x16 LCD</figcaption></figure>

<table data-ke-align="alignLeft">
<tbody>
<tr>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
<td>5</td>
<td>6</td>
<td>7</td>
<td>8</td>
</tr>
<tr>
<td>VSS</td>
<td>VCC</td>
<td>VEE</td>
<td>RS</td>
<td>R/W</td>
<td>E</td>
<td>DB0</td>
<td>DB1</td>
</tr>
<tr>
<td>GND핀</td>
<td>5V 전원 핀</td>
<td>LCD밝기 조절 핀</td>
<td>레지스터 선택 핀</td>
<td>읽기쓰기모드 선택 핀</td>
<td>레지스터에 쓰기위한 핀</td>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
</tr>
</tbody>
</table>
<table data-ke-align="alignLeft">
<tbody>
<tr>
<td>9</td>
<td>10</td>
<td>11</td>
<td>12</td>
<td>13</td>
<td>14</td>
<td>15</td>
<td>16</td>
</tr>
<tr>
<td>DB2</td>
<td>DB3</td>
<td>DB4</td>
<td>DB5</td>
<td>DB6</td>
<td>DB7</td>
<td>LED+</td>
<td>LED-</td>
</tr>
<tr>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
<td>데이터 입출력 핀</td>
<td>LED 5V 전원 핀</td>
<td>LED GND핀</td>
</tr>
</tbody>
</table>

I2C LCD는 16개의 핀이 있고 전원을 빼더라도 12개가 필요하다. 즉, GPIO의 핀을 많이 사용한다. I2C컨버터와 일반 LCD를 연결하여 사용하면 전원을 제외하더라도 2개의 GPIO핀만 있으면 된다. &nbsp;


<figure data-origin-width="1088" data-origin-height="770" data-ke-mobilestyle="alignCenter"><img src="https://blog.kakaocdn.net/dn/ATpeM/btrK5aiypRg/8MPU9EqMnK6ws3Kg1Tz1z0/img.png" data-filename="그림12-3.png" data-ke-mobilestyle="alignCenter"><figcaption>I2C LCD</figcaption></figure>

<table data-ke-align="alignLeft">
<tbody>
<tr>
<td>핀 구성</td>
<td>제품 명</td>
</tr>
<tr>
<td>GND</td>
<td rowspan="4">LCD 1602</td>
</tr>
<tr>
<td>VCC</td>
</tr>
<tr>
<td>SDA</td>
</tr>
<tr>
<td>SCK</td>
</tr>
</tbody>
</table>

회로 연결도는 아래 그림을 참고한다.

<figure data-origin-width="1116" data-origin-height="721" data-ke-mobilestyle="alignCenter"><img src="https://blog.kakaocdn.net/dn/qyxi7/btrK3YwqVv1/HBI5LXmjkNtup0mWVrdFOk/img.png" data-filename="그림12.png" data-ke-mobilestyle="alignCenter"></figure>


프로그램 소스 코드는 C언어와 Python 코드를 아래에 나타내었다. 우선 C 언어 소스코드를 살펴본다.

<pre id="code_1661932679858" data-ke-language="bash" data-ke-type="codeblock"><code>#include &lt;wiringPiI2C.h&gt;
#include &lt;wiringPi.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

// Define some device parameters
#define I2C_ADDR 0x27 // I2C device address

// Define some device constants
#define LCD_CHR 1 // Mode - Sending data
#define LCD_CMD 0 // Mode - Sending command

#define LINE1 0x80 // 1st line
#define LINE2 0xC0 // 2nd line

#define LCD_BACKLIGHT 0x08 // On
// LCD_BACKLIGHT = 0x00 # Off

#define ENABLE 0b00000100 // Enable bit

void lcd_init(void);
void lcd_byte(int bits, int mode);
void lcd_toggle_enable(int bits);

// added by Lewis
void typeInt(int i);
void typeFloat(float myFloat);
void lcdLoc(int line); //move cursor
void ClrLcd(void); // clr LCD return home
void typeln(const char *s);
void typeChar(char val);
int fd; // seen by all subroutines

int main() {

 if (wiringPiSetup () == -1) exit (1);

 fd = wiringPiI2CSetup(I2C_ADDR);

 //printf("fd = %d ", fd);

 lcd_init(); // setup LCD

 char array1[] = "Hello world!";
 char array2[] = "Smart Class!";
 
 while (1) {

 lcdLoc(LINE1);
 typeln("Using wiringPi");
 lcdLoc(LINE2);
 typeln("kjpark editor.");

 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln("I2c Programmed");
 lcdLoc(LINE2);
 typeln("in C not Python.");

 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln("Arduino like");
 lcdLoc(LINE2);
 typeln("fast and easy.");

 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln(array1);
 lcdLoc(LINE2);
 typeln(array2);


 delay(2000);
 ClrLcd(); // defaults LINE1
 typeln("Int ");
 int value = 201904;
 typeInt(value);

 delay(2000);
 lcdLoc(LINE2);
 typeln("Float ");
 float FloatVal = 10045.25989;
 typeFloat(FloatVal);
 delay(2000);
 }

 return 0;

}


// float to string
void typeFloat(float myFloat) {
 char buffer[20];
 sprintf(buffer, "%4.2f", myFloat);
 typeln(buffer);
}

// int to string
void typeInt(int i) {
 char array1[20];
 sprintf(array1, "%d", i);
 typeln(array1);
}

// clr lcd go home loc 0x80
void ClrLcd(void) {
 lcd_byte(0x01, LCD_CMD);
 lcd_byte(0x02, LCD_CMD);
}

// go to location on LCD
void lcdLoc(int line) {
 lcd_byte(line, LCD_CMD);
}

// out char to LCD at current position
void typeChar(char val) {

 lcd_byte(val, LCD_CHR);
}


// this allows use of any size string
void typeln(const char *s) {

 while ( *s ) lcd_byte(*(s++), LCD_CHR);

}

void lcd_byte(int bits, int mode) {

 //Send byte to data pins
 // bits = the data
 // mode = 1 for data, 0 for command
 int bits_high;
 int bits_low;
 // uses the two half byte writes to LCD
 bits_high = mode | (bits &amp; 0xF0) | LCD_BACKLIGHT ;
 bits_low = mode | ((bits &lt;&lt; 4) &amp; 0xF0) | LCD_BACKLIGHT ;

 // High bits
 wiringPiI2CReadReg8(fd, bits_high);
 lcd_toggle_enable(bits_high);

 // Low bits
 wiringPiI2CReadReg8(fd, bits_low);
 lcd_toggle_enable(bits_low);
}

void lcd_toggle_enable(int bits) {
 // Toggle enable pin on LCD display
 delayMicroseconds(500);
 wiringPiI2CReadReg8(fd, (bits | ENABLE));
 delayMicroseconds(500);
 wiringPiI2CReadReg8(fd, (bits &amp; ~ENABLE));
 delayMicroseconds(500);
}


void lcd_init() {
 // Initialise display
 lcd_byte(0x33, LCD_CMD); // Initialise
 lcd_byte(0x32, LCD_CMD); // Initialise
 lcd_byte(0x06, LCD_CMD); // Cursor move direction
 lcd_byte(0x0C, LCD_CMD); // 0x0F On, Blink Off
 lcd_byte(0x28, LCD_CMD); // Data length, number of lines, font size
 lcd_byte(0x01, LCD_CMD); // Clear display
 delayMicroseconds(500);
}</code></pre>

파이선 코드는 아래를 참고한다.

<pre id="code_1661932719976" data-ke-language="bash" data-ke-type="codeblock"><code>#!/usr/bin/python
#--------------------------------------
# ___ ___ _ ____
# / _ \/ _ \(_) __/__ __ __
# / , _/ ___/ /\ \/ _ \/ // /
# /_/|_/_/ /_/___/ .__/\_, /
# /_/ /___/
#
# lcd_i2c.py
# LCD test script using I2C backpack.
# Supports 16x2 and 20x4 screens.
#
# Author : Matt Hawkins
# Date : 20/09/2015
#
# http://www.raspberrypi-spy.co.uk/
#
# Copyright 2015 Matt Hawkins
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see &lt;http://www.gnu.org/licenses/&gt;.
#
#--------------------------------------
import smbus
import time

# Define some device parameters
I2C_ADDR = 0x27 # I2C device address
LCD_WIDTH = 16 # Maximum characters per line

# Define some device constants
LCD_CHR = 1 # Mode - Sending data
LCD_CMD = 0 # Mode - Sending command

LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94 # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4 # LCD RAM address for the 4th line

LCD_BACKLIGHT = 0x08 # On
#LCD_BACKLIGHT = 0x00 # Off

ENABLE = 0b00000100 # Enable bit

# Timing constants
E_PULSE = 0.0005
E_DELAY = 0.0005

#Open I2C interface
#bus = smbus.SMBus(0) # Rev 1 Pi uses 0
bus = smbus.SMBus(1) # Rev 2 Pi uses 1

def lcd_init():
 # Initialise display
 lcd_byte(0x33,LCD_CMD) # 110011 Initialise
 lcd_byte(0x32,LCD_CMD) # 110010 Initialise
 lcd_byte(0x06,LCD_CMD) # 000110 Cursor move direction
 lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off 
 lcd_byte(0x28,LCD_CMD) # 101000 Data length, number of lines, font size
 lcd_byte(0x01,LCD_CMD) # 000001 Clear display
 time.sleep(E_DELAY)

def lcd_byte(bits, mode):
 # Send byte to data pins
 # bits = the data
 # mode = 1 for data
 # 0 for command

 bits_high = mode | (bits &amp; 0xF0) | LCD_BACKLIGHT
 bits_low = mode | ((bits&lt;&lt;4) &amp; 0xF0) | LCD_BACKLIGHT

 # High bits
 bus.write_byte(I2C_ADDR, bits_high)
 lcd_toggle_enable(bits_high)

 # Low bits
 bus.write_byte(I2C_ADDR, bits_low)
 lcd_toggle_enable(bits_low)

def lcd_toggle_enable(bits):
 # Toggle enable
 time.sleep(E_DELAY)
 bus.write_byte(I2C_ADDR, (bits | ENABLE))
 time.sleep(E_PULSE)
 bus.write_byte(I2C_ADDR,(bits &amp; ~ENABLE))
 time.sleep(E_DELAY)

def lcd_string(message,line):
 # Send string to display

 message = message.ljust(LCD_WIDTH," ")

 lcd_byte(line, LCD_CMD)

 for i in range(LCD_WIDTH):
 lcd_byte(ord(message[i]),LCD_CHR)

def main():
 # Main program block

 # Initialise display
 lcd_init()

 while True:

 # Send some test
 lcd_string("RPiSpy &lt;",LCD_LINE_1)
 lcd_string("I2C LCD &lt;",LCD_LINE_2)

 time.sleep(3)
 
 # Send some more text
 lcd_string("&gt; RPiSpy",LCD_LINE_1)
 lcd_string("&gt; I2C LCD",LCD_LINE_2)

 time.sleep(3)

if __name__ == '__main__':

 try:
 main()
 except KeyboardInterrupt:
 pass
 finally:
 lcd_byte(0x01, LCD_CMD)</code></pre>

C언어 코드를 컴파일하고 실행하는 방법은 아래 명령어를 사용한다.

<table data-ke-align="alignLeft">
<tbody>
<tr>
<td>컴파일 명령어</td>
<td>gcc –o I2C LCD I2C LCD.c -lwiringPi</td>
<td>실행파일명을 I2C LCD로 설정하여 컴파일한다.</td>
</tr>
<tr>
<td>실행</td>
<td>sudo ./I2C LCD</td>
<td>프로그램을 실행한다.</td>
</tr>
</tbody>
</table>

 
</div></div>

기린

LCD일반
 
LCD는 Liquid Crystal Display의 약자로 액정표시장치를 말한다. Liquid Crystal이란 액체처럼 유체의 성질을 가지면서 고체처럼 광학적 성질을 가지는 물질로써 액정은 고체표면에 액정이 특정 방향으로 정렬할 수도 있어, 전기적 신호를 가해 원하는 방향으로 배열하여 빛을 투과시키거나 차단시킬 수 있다. 아래는 2줄 16 문자를 표시할 수 있는 LCD를 보여준다.
 
2x16 LCD
 
2*16  LCD 구성과 핀 번호 기능을 살펴보면 다음과 같다. 이 핀 연결과 제어를 i2c 인터페이스를 사용하여 단순하게 만든 것을 i2c LCD 라고 생각하면 된다.
 
 
1
2
3
4
5
6
7
8
VSS
VCC
VEE
RS
R/W
E
DB0
DB1
GND핀
5V 전원 핀
LCD밝기 조절 핀
레지스터 선택 핀
읽기쓰기모드 선택 핀
레지스터에 쓰기위한 핀
데이터 입출력 핀
데이터 입출력 핀
9
10
11
12
13
14
15
16
DB2
DB3
DB4
DB5
DB6
DB7
LED+
LED-
데이터 입출력 핀
데이터 입출력 핀
데이터 입출력 핀
데이터 입출력 핀
데이터 입출력 핀
데이터 입출력 핀
LED 5V 전원 핀
LED GND핀
 
I2C LCD는 16개의 핀이 있고 전원을 빼더라도 12개가 필요하다. 즉, GPIO의 핀을 많이 사용한다. I2C컨버터와 일반 LCD를 연결하여 사용하면 전원을 제외하더라도 2개의 GPIO핀만 있으면 된다.  
 
 
 
핀 구성
제품 명
GND
LCD 1602
VCC
SDA
SCK
 
회로 연결도는 아래 그림을 참고한다.
 
 
 
프로그램 소스 코드는 C언어와 Python 코드를 아래에 나타내었다. 우선 C 언어 소스코드를 살펴본다.
 
#include <wiringPiI2C.h>
#include <wiringPi.h>
#include <stdlib.h>
#include <stdio.h>
// Define some device parameters
#define I2C_ADDR 0x27 // I2C device address
// Define some device constants
#define LCD_CHR 1 // Mode - Sending data
#define LCD_CMD 0 // Mode - Sending command
#define LINE1 0x80 // 1st line
#define LINE2 0xC0 // 2nd line
#define LCD_BACKLIGHT 0x08 // On
// LCD_BACKLIGHT = 0x00 # Off
#define ENABLE 0b00000100 // Enable bit
void lcd_init(void);
void lcd_byte(int bits, int mode);
void lcd_toggle_enable(int bits);
// added by Lewis
void typeInt(int i);
void typeFloat(float myFloat);
void lcdLoc(int line); //move cursor
void ClrLcd(void); // clr LCD return home
void typeln(const char *s);
void typeChar(char val);
int fd; // seen by all subroutines
int main() {
 if (wiringPiSetup () == -1) exit (1);
 fd = wiringPiI2CSetup(I2C_ADDR);
 //printf("fd = %d ", fd);
 lcd_init(); // setup LCD
 char array1[] = "Hello world!";
 char array2[] = "Smart Class!";
 
 while (1) {
 lcdLoc(LINE1);
 typeln("Using wiringPi");
 lcdLoc(LINE2);
 typeln("kjpark editor.");
 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln("I2c Programmed");
 lcdLoc(LINE2);
 typeln("in C not Python.");
 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln("Arduino like");
 lcdLoc(LINE2);
 typeln("fast and easy.");
 delay(2000);
 ClrLcd();
 lcdLoc(LINE1);
 typeln(array1);
 lcdLoc(LINE2);
 typeln(array2);
 delay(2000);
 ClrLcd(); // defaults LINE1
 typeln("Int ");
 int value = 201904;
 typeInt(value);
 delay(2000);
 lcdLoc(LINE2);
 typeln("Float ");
 float FloatVal = 10045.25989;
 typeFloat(FloatVal);
 delay(2000);
 }
 return 0;
}
// float to string
void typeFloat(float myFloat) {
 char buffer[20];
 sprintf(buffer, "%4.2f", myFloat);
 typeln(buffer);
}
// int to string
void typeInt(int i) {
 char array1[20];
 sprintf(array1, "%d", i);
 typeln(array1);
}
// clr lcd go home loc 0x80
void ClrLcd(void) {
 lcd_byte(0x01, LCD_CMD);
 lcd_byte(0x02, LCD_CMD);
}
// go to location on LCD
void lcdLoc(int line) {
 lcd_byte(line, LCD_CMD);
}
// out char to LCD at current position
void typeChar(char val) {
 lcd_byte(val, LCD_CHR);
}
// this allows use of any size string
void typeln(const char *s) {
 while ( *s ) lcd_byte(*(s++), LCD_CHR);
}
void lcd_byte(int bits, int mode) {
 //Send byte to data pins
 // bits = the data
 // mode = 1 for data, 0 for command
 int bits_high;
 int bits_low;
 // uses the two half byte writes to LCD
 bits_high = mode | (bits & 0xF0) | LCD_BACKLIGHT ;
 bits_low = mode | ((bits << 4) & 0xF0) | LCD_BACKLIGHT ;
 // High bits
 wiringPiI2CReadReg8(fd, bits_high);
 lcd_toggle_enable(bits_high);
 // Low bits
 wiringPiI2CReadReg8(fd, bits_low);
 lcd_toggle_enable(bits_low);
}
void lcd_toggle_enable(int bits) {
 // Toggle enable pin on LCD display
 delayMicroseconds(500);
 wiringPiI2CReadReg8(fd, (bits | ENABLE));
 delayMicroseconds(500);
 wiringPiI2CReadReg8(fd, (bits & ~ENABLE));
 delayMicroseconds(500);
}
void lcd_init() {
 // Initialise display
 lcd_byte(0x33, LCD_CMD); // Initialise
 lcd_byte(0x32, LCD_CMD); // Initialise
 lcd_byte(0x06, LCD_CMD); // Cursor move direction
 lcd_byte(0x0C, LCD_CMD); // 0x0F On, Blink Off
 lcd_byte(0x28, LCD_CMD); // Data length, number of lines, font size
 lcd_byte(0x01, LCD_CMD); // Clear display
 delayMicroseconds(500);
}
 
파이선 코드는 아래를 참고한다.
 
#!/usr/bin/python
#--------------------------------------
# ___ ___ _ ____
# / _ \/ _ \(_) __/__ __ __
# / , _/ ___/ /\ \/ _ \/ // /
# /_/|_/_/ /_/___/ .__/\_, /
# /_/ /___/
#
# lcd_i2c.py
# LCD test script using I2C backpack.
# Supports 16x2 and 20x4 screens.
#
# Author : Matt Hawkins
# Date : 20/09/2015
#
# http://www.raspberrypi-spy.co.uk/
#
# Copyright 2015 Matt Hawkins
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#--------------------------------------
import smbus
import time
# Define some device parameters
I2C_ADDR = 0x27 # I2C device address
LCD_WIDTH = 16 # Maximum characters per line
# Define some device constants
LCD_CHR = 1 # Mode - Sending data
LCD_CMD = 0 # Mode - Sending command
LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
LCD_LINE_3 = 0x94 # LCD RAM address for the 3rd line
LCD_LINE_4 = 0xD4 # LCD RAM address for the 4th line
LCD_BACKLIGHT = 0x08 # On
#LCD_BACKLIGHT = 0x00 # Off
ENABLE = 0b00000100 # Enable bit
# Timing constants
E_PULSE = 0.0005
E_DELAY = 0.0005
#Open I2C interface
#bus = smbus.SMBus(0) # Rev 1 Pi uses 0
bus = smbus.SMBus(1) # Rev 2 Pi uses 1
def lcd_init():
 # Initialise display
 lcd_byte(0x33,LCD_CMD) # 110011 Initialise
 lcd_byte(0x32,LCD_CMD) # 110010 Initialise
 lcd_byte(0x06,LCD_CMD) # 000110 Cursor move direction
 lcd_byte(0x0C,LCD_CMD) # 001100 Display On,Cursor Off, Blink Off 
 lcd_byte(0x28,LCD_CMD) # 101000 Data length, number of lines, font size
 lcd_byte(0x01,LCD_CMD) # 000001 Clear display
 time.sleep(E_DELAY)
def lcd_byte(bits, mode):
 # Send byte to data pins
 # bits = the data
 # mode = 1 for data
 # 0 for command
 bits_high = mode | (bits & 0xF0) | LCD_BACKLIGHT
 bits_low = mode | ((bits<<4) & 0xF0) | LCD_BACKLIGHT
 # High bits
 bus.write_byte(I2C_ADDR, bits_high)
 lcd_toggle_enable(bits_high)
 # Low bits
 bus.write_byte(I2C_ADDR, bits_low)
 lcd_toggle_enable(bits_low)
def lcd_toggle_enable(bits):
 # Toggle enable
 time.sleep(E_DELAY)
 bus.write_byte(I2C_ADDR, (bits | ENABLE))
 time.sleep(E_PULSE)
 bus.write_byte(I2C_ADDR,(bits & ~ENABLE))
 time.sleep(E_DELAY)
def lcd_string(message,line):
 # Send string to display
 message = message.ljust(LCD_WIDTH," ")
 lcd_byte(line, LCD_CMD)
 for i in range(LCD_WIDTH):
 lcd_byte(ord(message[i]),LCD_CHR)
def main():
 # Main program block
 # Initialise display
 lcd_init()
 while True:
 # Send some test
 lcd_string("RPiSpy <",LCD_LINE_1)
 lcd_string("I2C LCD <",LCD_LINE_2)
 time.sleep(3)
 
 # Send some more text
 lcd_string("> RPiSpy",LCD_LINE_1)
 lcd_string("> I2C LCD",LCD_LINE_2)
 time.sleep(3)
if __name__ == '__main__':
 try:
 main()
 except KeyboardInterrupt:
 pass
 finally:
 lcd_byte(0x01, LCD_CMD)
 
C언어 코드를 컴파일하고 실행하는 방법은 아래 명령어를 사용한다.
 
컴파일 명령어
gcc –o I2C LCD I2C LCD.c -lwiringPi
실행파일명을 I2C LCD로 설정하여 컴파일한다.
실행
sudo ./I2C LCD
프로그램을 실행한다.

라즈베리파이 i2c lcd display 제어

댓글