ICS-Microprocessor-2020/Display_Avr_3
5
0
Fork 0
Code Issues 6 Pull Requests Projects Releases Wiki Activity

final version, gg

Browse Source
This commit is contained in:
Qukich 2024-02-09 12:36:55 +03:00
parent ca36c67ba2
commit 80cd73c3d6
30 changed files with 1579 additions and 1057 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

315
LiquidCrystal_I2C/LiquidCrystal_I2C.cpp Normal file
View File

@ -0,0 +1,315 @@
// Based on the work by DFRobot
#include "LiquidCrystal_I2C.h"
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#define printIIC(args) Wire.write(args)
inline size_t LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
return 1;
}
#else
#include "WProgram.h"
#define printIIC(args) Wire.send(args)
inline void LiquidCrystal_I2C::write(uint8_t value) {
send(value, Rs);
}
#endif
#include "Wire.h"
// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
// DL = 1; 8-bit interface data
// N = 0; 1-line display
// F = 0; 5x8 dot character font
// 3. Display on/off control:
// D = 0; Display off
// C = 0; Cursor off
// B = 0; Blinking off
// 4. Entry mode set:
// I/D = 1; Increment by 1
// S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that its in that state when a sketch starts (and the
// LiquidCrystal constructor is called).
LiquidCrystal_I2C::LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows)
{
_Addr = lcd_Addr;
_cols = lcd_cols;
_rows = lcd_rows;
_backlightval = LCD_NOBACKLIGHT;
}
void LiquidCrystal_I2C::init(){
init_priv();
}
void LiquidCrystal_I2C::init_priv()
{
Wire.begin();
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(_cols, _rows);
}
void LiquidCrystal_I2C::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
if (lines > 1) {
_displayfunction |= LCD_2LINE;
}
_numlines = lines;
// for some 1 line displays you can select a 10 pixel high font
if ((dotsize != 0) && (lines == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
delay(50);
// Now we pull both RS and R/W low to begin commands
expanderWrite(_backlightval); // reset expanderand turn backlight off (Bit 8 =1)
delay(1000);
//put the LCD into 4 bit mode
// this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode
write4bits(0x03 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// second try
write4bits(0x03 << 4);
delayMicroseconds(4500); // wait min 4.1ms
// third go!
write4bits(0x03 << 4);
delayMicroseconds(150);
// finally, set to 4-bit interface
write4bits(0x02 << 4);
// set # lines, font size, etc.
command(LCD_FUNCTIONSET | _displayfunction);
// turn the display on with no cursor or blinking default
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display();
// clear it off
clear();
// Initialize to default text direction (for roman languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
home();
}
/********** high level commands, for the user! */
void LiquidCrystal_I2C::clear(){
command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::home(){
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystal_I2C::setCursor(uint8_t col, uint8_t row){
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if ( row > _numlines ) {
row = _numlines-1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}
// Turn the display on/off (quickly)
void LiquidCrystal_I2C::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void LiquidCrystal_I2C::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void LiquidCrystal_I2C::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystal_I2C::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void LiquidCrystal_I2C::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystal_I2C::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void LiquidCrystal_I2C::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void LiquidCrystal_I2C::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void LiquidCrystal_I2C::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void LiquidCrystal_I2C::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystal_I2C::createChar(uint8_t location, uint8_t charmap[]) {
location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) {
write(charmap[i]);
}
}
// Turn the (optional) backlight off/on
void LiquidCrystal_I2C::noBacklight(void) {
_backlightval=LCD_NOBACKLIGHT;
expanderWrite(0);
}
void LiquidCrystal_I2C::backlight(void) {
_backlightval=LCD_BACKLIGHT;
expanderWrite(0);
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystal_I2C::command(uint8_t value) {
send(value, 0);
}
/************ low level data pushing commands **********/
// write either command or data
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
uint8_t highnib=value&0xf0;
uint8_t lownib=(value<<4)&0xf0;
write4bits((highnib)|mode);
write4bits((lownib)|mode);
}
void LiquidCrystal_I2C::write4bits(uint8_t value) {
expanderWrite(value);
pulseEnable(value);
}
void LiquidCrystal_I2C::expanderWrite(uint8_t _data){
Wire.beginTransmission(_Addr);
printIIC((int)(_data) | _backlightval);
Wire.endTransmission();
}
void LiquidCrystal_I2C::pulseEnable(uint8_t _data){
expanderWrite(_data | En); // En high
delayMicroseconds(1); // enable pulse must be >450ns
expanderWrite(_data & ~En); // En low
delayMicroseconds(50); // commands need > 37us to settle
}
// Alias functions
void LiquidCrystal_I2C::cursor_on(){
cursor();
}
void LiquidCrystal_I2C::cursor_off(){
noCursor();
}
void LiquidCrystal_I2C::blink_on(){
blink();
}
void LiquidCrystal_I2C::blink_off(){
noBlink();
}
void LiquidCrystal_I2C::load_custom_character(uint8_t char_num, uint8_t *rows){
createChar(char_num, rows);
}
void LiquidCrystal_I2C::setBacklight(uint8_t new_val){
if(new_val){
backlight(); // turn backlight on
}else{
noBacklight(); // turn backlight off
}
}
void LiquidCrystal_I2C::printstr(const char c[]){
//This function is not identical to the function used for "real" I2C displays
//it's here so the user sketch doesn't have to be changed
print(c);
}
// unsupported API functions
void LiquidCrystal_I2C::off(){}
void LiquidCrystal_I2C::on(){}
void LiquidCrystal_I2C::setDelay (int cmdDelay,int charDelay) {}
uint8_t LiquidCrystal_I2C::status(){return 0;}
uint8_t LiquidCrystal_I2C::keypad (){return 0;}
uint8_t LiquidCrystal_I2C::init_bargraph(uint8_t graphtype){return 0;}
void LiquidCrystal_I2C::draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end){}
void LiquidCrystal_I2C::draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_row_end){}
void LiquidCrystal_I2C::setContrast(uint8_t new_val){}

126
LiquidCrystal_I2C/LiquidCrystal_I2C.h Normal file
View File

@ -0,0 +1,126 @@
//YWROBOT
#ifndef LiquidCrystal_I2C_h
#define LiquidCrystal_I2C_h
#include <inttypes.h>
#include "Print.h"
#include <Wire.h>
// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80
// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00
// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00
// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00
// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00
// flags for backlight control
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00
#define En B00000100 // Enable bit
#define Rw B00000010 // Read/Write bit
#define Rs B00000001 // Register select bit
class LiquidCrystal_I2C : public Print {
public:
LiquidCrystal_I2C(uint8_t lcd_Addr,uint8_t lcd_cols,uint8_t lcd_rows);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS );
void clear();
void home();
void noDisplay();
void display();
void noBlink();
void blink();
void noCursor();
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void printLeft();
void printRight();
void leftToRight();
void rightToLeft();
void shiftIncrement();
void shiftDecrement();
void noBacklight();
void backlight();
void autoscroll();
void noAutoscroll();
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
#if defined(ARDUINO) && ARDUINO >= 100
virtual size_t write(uint8_t);
#else
virtual void write(uint8_t);
#endif
void command(uint8_t);
void init();
////compatibility API function aliases
void blink_on(); // alias for blink()
void blink_off(); // alias for noBlink()
void cursor_on(); // alias for cursor()
void cursor_off(); // alias for noCursor()
void setBacklight(uint8_t new_val); // alias for backlight() and nobacklight()
void load_custom_character(uint8_t char_num, uint8_t *rows); // alias for createChar()
void printstr(const char[]);
////Unsupported API functions (not implemented in this library)
uint8_t status();
void setContrast(uint8_t new_val);
uint8_t keypad();
void setDelay(int,int);
void on();
void off();
uint8_t init_bargraph(uint8_t graphtype);
void draw_horizontal_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);
void draw_vertical_graph(uint8_t row, uint8_t column, uint8_t len, uint8_t pixel_col_end);
private:
void init_priv();
void send(uint8_t, uint8_t);
void write4bits(uint8_t);
void expanderWrite(uint8_t);
void pulseEnable(uint8_t);
uint8_t _Addr;
uint8_t _displayfunction;
uint8_t _displaycontrol;
uint8_t _displaymode;
uint8_t _numlines;
uint8_t _cols;
uint8_t _rows;
uint8_t _backlightval;
};
#endif

BIN
LiquidCrystal_I2C/LiquidCrystal_I2C.o Normal file
View File

Binary file not shown.

2
LiquidCrystal_I2C/README.md Normal file
View File

@ -0,0 +1,2 @@
# LiquidCrystal_I2C
LiquidCrystal Arduino library for the DFRobot I2C LCD displays

70
LiquidCrystal_I2C/examples/CustomChars/CustomChars.pde Normal file
View File

@ -0,0 +1,70 @@
//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args) write(args);
#else
#define printByte(args) print(args,BYTE);
#endif
uint8_t bell[8] = {0x4,0xe,0xe,0xe,0x1f,0x0,0x4};
uint8_t note[8] = {0x2,0x3,0x2,0xe,0x1e,0xc,0x0};
uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};
uint8_t heart[8] = {0x0,0xa,0x1f,0x1f,0xe,0x4,0x0};
uint8_t duck[8] = {0x0,0xc,0x1d,0xf,0xf,0x6,0x0};
uint8_t check[8] = {0x0,0x1,0x3,0x16,0x1c,0x8,0x0};
uint8_t cross[8] = {0x0,0x1b,0xe,0x4,0xe,0x1b,0x0};
uint8_t retarrow[8] = { 0x1,0x1,0x5,0x9,0x1f,0x8,0x4};
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x27 for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
lcd.backlight();
lcd.createChar(0, bell);
lcd.createChar(1, note);
lcd.createChar(2, clock);
lcd.createChar(3, heart);
lcd.createChar(4, duck);
lcd.createChar(5, check);
lcd.createChar(6, cross);
lcd.createChar(7, retarrow);
lcd.home();
lcd.print("Hello world...");
lcd.setCursor(0, 1);
lcd.print(" i ");
lcd.printByte(3);
lcd.print(" arduinos!");
delay(5000);
displayKeyCodes();
}
// display all keycodes
void displayKeyCodes(void) {
uint8_t i = 0;
while (1) {
lcd.clear();
lcd.print("Codes 0x"); lcd.print(i, HEX);
lcd.print("-0x"); lcd.print(i+16, HEX);
lcd.setCursor(0, 1);
for (int j=0; j<16; j++) {
lcd.printByte(i+j);
}
i+=16;
delay(4000);
}
}
void loop()
{
}

28
LiquidCrystal_I2C/examples/HelloWorld/HelloWorld.pde Normal file
View File

@ -0,0 +1,28 @@
//YWROBOT
//Compatible with the Arduino IDE 1.0
//Library version:1.1
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x27 for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
lcd.init();
// Print a message to the LCD.
lcd.backlight();
lcd.setCursor(3,0);
lcd.print("Hello, world!");
lcd.setCursor(2,1);
lcd.print("Ywrobot Arduino!");
lcd.setCursor(0,2);
lcd.print("Arduino LCM IIC 2004");
lcd.setCursor(2,3);
lcd.print("Power By Ec-yuan!");
}
void loop()
{
}

34
LiquidCrystal_I2C/examples/SerialDisplay/SerialDisplay.pde Normal file
View File

@ -0,0 +1,34 @@
/*
* Displays text sent over the serial port (e.g. from the Serial Monitor) on
* an attached LCD.
* YWROBOT
*Compatible with the Arduino IDE 1.0
*Library version:1.1
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x27 for a 16 chars and 2 line display
void setup()
{
lcd.init(); // initialize the lcd
lcd.backlight();
Serial.begin(9600);
}
void loop()
{
// when characters arrive over the serial port...
if (Serial.available()) {
// wait a bit for the entire message to arrive
delay(100);
// clear the screen
lcd.clear();
// read all the available characters
while (Serial.available() > 0) {
// display each character to the LCD
lcd.write(Serial.read());
}
}
}

46
LiquidCrystal_I2C/keywords.txt Normal file
View File

@ -0,0 +1,46 @@
###########################################
# Syntax Coloring Map For LiquidCrystal_I2C
###########################################
###########################################
# Datatypes (KEYWORD1)
###########################################
LiquidCrystal_I2C KEYWORD1
###########################################
# Methods and Functions (KEYWORD2)
###########################################
init KEYWORD2
begin KEYWORD2
clear KEYWORD2
home KEYWORD2
noDisplay KEYWORD2
display KEYWORD2
noBlink KEYWORD2
blink KEYWORD2
noCursor KEYWORD2
cursor KEYWORD2
scrollDisplayLeft KEYWORD2
scrollDisplayRight KEYWORD2
leftToRight KEYWORD2
rightToLeft KEYWORD2
shiftIncrement KEYWORD2
shiftDecrement KEYWORD2
noBacklight KEYWORD2
backlight KEYWORD2
autoscroll KEYWORD2
noAutoscroll KEYWORD2
createChar KEYWORD2
setCursor KEYWORD2
print KEYWORD2
blink_on KEYWORD2
blink_off KEYWORD2
cursor_on KEYWORD2
cursor_off KEYWORD2
setBacklight KEYWORD2
load_custom_character KEYWORD2
printstr KEYWORD2
###########################################
# Constants (LITERAL1)
###########################################

15
LiquidCrystal_I2C/library.json Normal file
View File

@ -0,0 +1,15 @@
{
"name": "LiquidCrystal_I2C",
"keywords": "LCD, liquidcrystal, I2C",
"description": "A library for DFRobot I2C LCD displays",
"repository":
{
"type": "git",
"url": "https://github.com/marcoschwartz/LiquidCrystal_I2C.git"
},
"frameworks": "arduino",
"platforms":
[
"atmelavr"
]
}

9
LiquidCrystal_I2C/library.properties Normal file
View File

@ -0,0 +1,9 @@
name=LiquidCrystal I2C
version=1.1.2
author=Frank de Brabander
maintainer=Marco Schwartz <marcolivier.schwartz@gmail.com>
sentence=A library for I2C LCD displays.
paragraph= The library allows to control I2C displays with functions extremely similar to LiquidCrystal library. THIS LIBRARY MIGHT NOT BE COMPATIBLE WITH EXISTING SKETCHES.
category=Display
url=https://github.com/marcoschwartz/LiquidCrystal_I2C
architectures=avr

187
Disp1602.cpp → Lsd_print/Lsd_print.cpp
View File

@ -1,87 +1,100 @@
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
struct DisplayData {
char topLine[64];
int value1;
int value2;
int value3;
};
struct TextCounter {
unsigned long startTime;
int incrementValue;
};
TextCounter textCounter;
void setup() {
lcd.begin(16, 2);
textCounter.startTime = millis(); // Запоминаем время запуска программы
}
void loop() {
unsigned long currentTime = millis(); // Текущее время
// Проверяем, прошло ли 500 мс с момента последнего увеличения incrementValue
if (currentTime - textCounter.startTime >= 500) {
textCounter.incrementValue++; // Увеличиваем incrementValue на 1
textCounter.startTime = currentTime; // Обновляем время
}
DisplayData displayData;
strncpy(displayData.topLine, "we are responsible for those who have been tame ", sizeof(displayData.topLine) - 1);
displayData.topLine[sizeof(displayData.topLine) - 1] = '\0';
displayData.value1 = 500;
displayData.value2 = 800;
displayData.value3 = 855;
// Буферы для заполнения данных
char buffer1[17];
char buffer2[17];
// Заполнение буфера 1
fillBuffer1(displayData.topLine, buffer1, sizeof(buffer1), textCounter.incrementValue);
// Заполнение буфера 2
fillBuffer2(displayData.value1, displayData.value2, displayData.value3, buffer2, sizeof(buffer2));
// Создание массива для вывода на дисплей
char displayArray[32];
strncpy(displayArray, buffer1, 16); // Копирование первых 16 символов из buffer1 в displayArray
strncpy(displayArray + 16, buffer2, 16); // Копирование первых 16 символов из buffer2 в displayArray, начиная с позиции 16
// Вывод данных на экран
lcd.setCursor(0, 0);
lcd.print(displayArray);
lcd.setCursor(0, 1);
lcd.print(displayArray + 16); // Вывод второй половины displayArray
}
void fillBuffer1(const char * source, char * buffer, size_t bufferSize, int incrementValue) {
int startIndex = incrementValue % strlen(source); // Определяем начальный индекс на основе incrementValue
int endIndex = startIndex + 16;
if (endIndex > strlen(source)) {
// Если endIndex превышает длину строки source, переносим его на начало строки
endIndex = endIndex - strlen(source);
// Копируем символы с конца строки source
strncpy(buffer, source + startIndex, strlen(source) - startIndex);
// Копируем оставшиеся символы с начала строки source
strncat(buffer, source, endIndex);
} else {
strncpy(buffer, source + startIndex, endIndex - startIndex);
}
buffer[endIndex - startIndex] = '\0'; // Установка нулевого символа в конце буфера
}
void fillBuffer2(int value1, int value2, int value3, char * buffer, size_t bufferSize) {
snprintf(buffer, bufferSize, "%d.%d.%d", value1, value2, value3);
}
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <compat/twi.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include "lcdpcf8574.h"
#include "pcf8574.h"
#include "i2cmaster.h"
#include "lsd.h"
#include <Arduino.h>
struct DisplayData {
char topLine[64];
int value1;
int value2;
int value3;
};
struct TextCounter {
unsigned long startTime;
int incrementValue;
};
TextCounter textCounter;
void Lsd_inciliation() {
lcd_init(LCD_DISP_ON_BLINK); // инициализация дисплея
lcd_home(); // домой курсор
lcd_led(0); // вкл подсветки
textCounter.startTime = millis(); // Запоминаем время запуска программы
}
void fillBuffer1(const char * source, char * buffer, size_t bufferSize, int incrementValue) {
int startIndex = incrementValue % strlen(source); // Определяем начальный индекс на основе incrementValue
int endIndex = startIndex + 16;
if (endIndex > strlen(source)) {
// Если endIndex превышает длину строки source, переносим его на начало строки
endIndex = endIndex - strlen(source);
// Копируем символы с конца строки source
strncpy(buffer, source + startIndex, strlen(source) - startIndex);
// Копируем оставшиеся символы с начала строки source
strncat(buffer, source, endIndex);
} else {
strncpy(buffer, source + startIndex, endIndex - startIndex);
}
buffer[endIndex - startIndex] = '\0'; // Установка нулевого символа в конце буфера
}
void fillBuffer2(int value1, int value2, int value3, char * buffer, size_t bufferSize) {
snprintf(buffer, bufferSize, "%d.%d.%d", value1, value2, value3);
}
void printLsd(const char * inputText)
{
unsigned long currentTime = millis(); // Текущее время
// Проверяем, прошло ли 500 мс с момента последнего увеличения incrementValue
if (currentTime - textCounter.startTime >= 500) {
textCounter.incrementValue++; // Увеличиваем incrementValue на 1
textCounter.startTime = currentTime; // Обновляем время
}
DisplayData displayData;
strncpy(displayData.topLine, inputText, sizeof(displayData.topLine) - 1);
displayData.topLine[sizeof(displayData.topLine) - 1] = '\0';
displayData.value1 = 500;
displayData.value2 = 800;
displayData.value3 = 855;
// Буферы для заполнения данных
char buffer1[17];
char buffer2[17];
// Заполнение буфера 1
fillBuffer1(displayData.topLine, buffer1, sizeof(buffer1), textCounter.incrementValue);
// Заполнение буфера 2
fillBuffer2(displayData.value1, displayData.value2, displayData.value3, buffer2, sizeof(buffer2));
// Создание массива для вывода на дисплей
char displayArray[32];
strncpy(displayArray, buffer1, 16); // Копирование первых 16 символов из buffer1 в displayArray
strncpy(displayArray + 16, buffer2, 16); // Копирование первых 16 символов из buffer2 в displayArray, начиная с позиции 16
// Вывод данных на экран
lcd_gotoxy(0, 0);
lcd_puts(displayArray);
lcd_gotoxy(0, 1);
lcd_puts(displayArray + 16); // Вывод второй половины displayArray
}

8
Lsd_print/lsd.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef Lsd_print_h
#define Lsd_print_h
#include <Arduino.h>
void Lsd_inciliation();
void printLsd(const char* inputText);
#endif

22
MyLCD/MyLCD.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef MYLCD_H_
#define MYLCD_H_
// ïîäêëþ÷àåì âñå ëèáû
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <compat/twi.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include "lcdpcf8574.h"
#include "pcf8574.h"
#include "i2cmaster.h"
#endif

42
MyLCD/i2cmaster.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef _I2CMASTER_H
#define _I2CMASTER_H
// флаг, отвечающий за чтение данных по i2c
#define I2C_READ 1
// флаг, отвечающий за отправку данных по i2c
#define I2C_WRITE 0
// частота тактирования линии в Герцах
#define SCL_CLOCK 100000L
// инициализация интерфейса
void i2c_init(void);
// передача условия СТОП на шину
void i2c_stop(void);
// передача условия СТАРТ на шину
unsigned char i2c_start(unsigned char addr);
// повторный старт(перезапуск)
unsigned char i2c_rep_start(unsigned char addr);
// ждем, если устрой-во занято, а потом передаем условие СТАРТ на шину
void i2c_start_wait(unsigned char addr);
// отправка данных
unsigned char i2c_write(unsigned char data);
// читаем данные и продолжаем вещание
unsigned char i2c_readAck(void);
// читаем данные и после их получения передаем услови СТОП
unsigned char i2c_readNak(void);
// читаем данные с шины
unsigned char i2c_read(unsigned char ack);
// выбираем какой варинт чтения данных будет
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
#endif

10
MyLCD/keywords.txt Normal file
View File

@ -0,0 +1,10 @@
lcd_init KEYWORD2
lcd_clrscr KEYWORD2
lcd_home KEYWORD2
lcd_gotoxy KEYWORD2
lcd_led KEYWORD2
lcd_putc KEYWORD2
lcd_puts KEYWORD2
lcd_puts_p KEYWORD2
lcd_command KEYWORD2
lcd_data KEYWORD2

632
lcdpcf8574.cpp → MyLCD/lcdpcf8574.cpp
View File

@ -1,316 +1,316 @@
#include "MyLCD.h"
// задержеки через асемблер
#define lcd_e_delay() __asm__ __volatile__( "rjmp 1f\n 1:" );
#define lcd_e_toggle() toggle_e()
volatile uint8_t dataport = 0;
static void toggle_e(void);
// сама реализация задержек
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" );
else
__asm__ __volatile__ (
"1: sbiw %0,1" "\n\t"
"brne 1b"
: "=w" (__count)
: "0" (__count)
);
}
// тупа оборачиваем функцию в макрос
#define delay(us) _delayFourCycles( ( ( 1*(F_CPU/4000) )*us)/1000 )
// переключение пина для начала записи команды
static void toggle_e(void)
{
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
}
// отправка байта для контроллера LCD
static void lcd_write(uint8_t data,uint8_t rs)
{
if (rs) //отправка данных (RS=1, RW=0)
dataport |= _BV(LCD_RS_PIN);
else // отпрака инструкций(RS=0, RW=0)
dataport &= ~_BV(LCD_RS_PIN);
dataport &= ~_BV(LCD_RW_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
// отправка старшего полубайта
dataport &= ~_BV(LCD_DATA3_PIN);
dataport &= ~_BV(LCD_DATA2_PIN);
dataport &= ~_BV(LCD_DATA1_PIN);
dataport &= ~_BV(LCD_DATA0_PIN);
if(data & 0x80) dataport |= _BV(LCD_DATA3_PIN);
if(data & 0x40) dataport |= _BV(LCD_DATA2_PIN);
if(data & 0x20) dataport |= _BV(LCD_DATA1_PIN);
if(data & 0x10) dataport |= _BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
// отправка младшего полубайта
dataport &= ~_BV(LCD_DATA3_PIN);
dataport &= ~_BV(LCD_DATA2_PIN);
dataport &= ~_BV(LCD_DATA1_PIN);
dataport &= ~_BV(LCD_DATA0_PIN);
if(data & 0x08) dataport |= _BV(LCD_DATA3_PIN);
if(data & 0x04) dataport |= _BV(LCD_DATA2_PIN);
if(data & 0x02) dataport |= _BV(LCD_DATA1_PIN);
if(data & 0x01) dataport |= _BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
// завершаем передачу
dataport |= _BV(LCD_DATA0_PIN);
dataport |= _BV(LCD_DATA1_PIN);
dataport |= _BV(LCD_DATA2_PIN);
dataport |= _BV(LCD_DATA3_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
}
// чтение байта
static uint8_t lcd_read(uint8_t rs)
{
uint8_t data;
if (rs) // запись данных (RS=1, RW=0)
dataport |= _BV(LCD_RS_PIN);
else // запись инструкций (RS=0, RW=0)
dataport &= ~_BV(LCD_RS_PIN);
dataport |= _BV(LCD_RW_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
// чтение страшего полубайта
data = pcf8574_getoutputpin(LCD_PCF8574_DEVICEID, LCD_DATA0_PIN) << 4;
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
// чтение младшего полубайта
data |= pcf8574_getoutputpin(LCD_PCF8574_DEVICEID, LCD_DATA0_PIN) &0x0F;
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
return data;
}
// ждем пока ЖК освободится
static uint8_t lcd_waitbusy(void)
{
register uint8_t c;
// ждем
while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) {}
// задержка
delay(2);
// получаем адрес
return (lcd_read(0));
}
// перемещение курсора по строкам
static inline void lcd_newline(uint8_t pos)
{
register uint8_t addressCounter;
#if LCD_LINES==1
addressCounter = 0;
#endif
#if LCD_LINES==2
if ( pos < (LCD_START_LINE2) )
addressCounter = LCD_START_LINE2;
else
addressCounter = LCD_START_LINE1;
#endif
#if LCD_LINES==4
if ( pos < LCD_START_LINE3 )
addressCounter = LCD_START_LINE2;
else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4) )
addressCounter = LCD_START_LINE3;
else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2) )
addressCounter = LCD_START_LINE4;
else
addressCounter = LCD_START_LINE1;
#endif
lcd_command((1<<LCD_DDRAM)+addressCounter);
}
// служебная функция для отправки команд дисплею
void lcd_command(uint8_t cmd)
{
lcd_waitbusy();
lcd_write(cmd,0);
}
// отправка байта на дисплей
void lcd_data(uint8_t data)
{
lcd_waitbusy();
lcd_write(data,1);
}
// перемещение курсора по координатам
void lcd_gotoxy(uint8_t x, uint8_t y)
{
#if LCD_LINES==1
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
#endif
#if LCD_LINES==2
if ( y==0 )
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
else
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
#endif
#if LCD_LINES==4
if ( y==0 )
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
else if ( y==1)
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
else if ( y==2)
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+x);
else
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+x);
#endif
}
// тырим координаты
int lcd_getxy(void)
{
return lcd_waitbusy();
}
// очистка дисплея
void lcd_clrscr(void)
{
lcd_command(1<<LCD_CLR);
}
// вкл и откл подсветки
void lcd_led(uint8_t onoff)
{
if(onoff)
dataport &= ~_BV(LCD_LED_PIN);
else
dataport |= _BV(LCD_LED_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
}
// курсов в начало координат
void lcd_home(void)
{
lcd_command(1<<LCD_HOME);
}
// отображение символа в текущей позиции курсора
void lcd_putc(char c)
{
uint8_t pos;
pos = lcd_waitbusy();
if (c=='\n')
{
lcd_newline(pos);
}
else
{
#if LCD_WRAP_LINES==1
#if LCD_LINES==1
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#elif LCD_LINES==2
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
}else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ){
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#elif LCD_LINES==4
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
}else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE3,0);
}else if ( pos == LCD_START_LINE3+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE4,0);
}else if ( pos == LCD_START_LINE4+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#endif
lcd_waitbusy();
#endif
lcd_write(c, 1);
}
}
// вывод строки на дисплей
void lcd_puts(const char *s)
{
register char c;
while ( (c = *s++) ) {
lcd_putc(c);
}
}
// вывод строки из памяти
void lcd_puts_p(const char *progmem_s)
{
register char c;
while ( (c = pgm_read_byte(progmem_s++)) ) {
lcd_putc(c);
}
}
// инициализация дисплея
void lcd_init(uint8_t dispAttr)
{
#if LCD_PCF8574_INIT == 1
//инициализация pcf
pcf8574_init();
#endif
dataport = 0;
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
delay(16000);
// первоначальная запись на ЖК-дисплей — 8 бит
dataport |= _BV(LCD_DATA1_PIN); // _BV(LCD_FUNCTION)>>4;
dataport |= _BV(LCD_DATA0_PIN); // _BV(LCD_FUNCTION_8BIT)>>4;
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
// дрючим дисплей чтобы он начал работать
lcd_e_toggle();
delay(4992);
lcd_e_toggle();
delay(64);
lcd_e_toggle();
delay(64);
// переходим в 4 битный режим
dataport &= ~_BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
delay(64);
lcd_command(LCD_FUNCTION_DEFAULT); // настраиваем кол-во строк
lcd_command(LCD_DISP_OFF); // вырубаем дисплей
lcd_clrscr(); // чистим экран
lcd_command(LCD_MODE_DEFAULT); // запускаемся в стандартном режиме
lcd_command(dispAttr); // отправляем настройки
}
#include "MyLCD.h"
// задержеки через асемблер
#define lcd_e_delay() __asm__ __volatile__( "rjmp 1f\n 1:" );
#define lcd_e_toggle() toggle_e()
volatile uint8_t dataport = 0;
static void toggle_e(void);
// сама реализация задержек
static inline void _delayFourCycles(unsigned int __count)
{
if ( __count == 0 )
__asm__ __volatile__( "rjmp 1f\n 1:" );
else
__asm__ __volatile__ (
"1: sbiw %0,1" "\n\t"
"brne 1b"
: "=w" (__count)
: "0" (__count)
);
}
// тупа оборачиваем функцию в макрос
#define delay(us) _delayFourCycles( ( ( 1*(F_CPU/4000) )*us)/1000 )
// переключение пина для начала записи команды
static void toggle_e(void)
{
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
}
// отправка байта для контроллера LCD
static void lcd_write(uint8_t data,uint8_t rs)
{
if (rs) //отправка данных (RS=1, RW=0)
dataport |= _BV(LCD_RS_PIN);
else // отпрака инструкций(RS=0, RW=0)
dataport &= ~_BV(LCD_RS_PIN);
dataport &= ~_BV(LCD_RW_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
// отправка старшего полубайта
dataport &= ~_BV(LCD_DATA3_PIN);
dataport &= ~_BV(LCD_DATA2_PIN);
dataport &= ~_BV(LCD_DATA1_PIN);
dataport &= ~_BV(LCD_DATA0_PIN);
if(data & 0x80) dataport |= _BV(LCD_DATA3_PIN);
if(data & 0x40) dataport |= _BV(LCD_DATA2_PIN);
if(data & 0x20) dataport |= _BV(LCD_DATA1_PIN);
if(data & 0x10) dataport |= _BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
// отправка младшего полубайта
dataport &= ~_BV(LCD_DATA3_PIN);
dataport &= ~_BV(LCD_DATA2_PIN);
dataport &= ~_BV(LCD_DATA1_PIN);
dataport &= ~_BV(LCD_DATA0_PIN);
if(data & 0x08) dataport |= _BV(LCD_DATA3_PIN);
if(data & 0x04) dataport |= _BV(LCD_DATA2_PIN);
if(data & 0x02) dataport |= _BV(LCD_DATA1_PIN);
if(data & 0x01) dataport |= _BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
// завершаем передачу
dataport |= _BV(LCD_DATA0_PIN);
dataport |= _BV(LCD_DATA1_PIN);
dataport |= _BV(LCD_DATA2_PIN);
dataport |= _BV(LCD_DATA3_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
}
// чтение байта
static uint8_t lcd_read(uint8_t rs)
{
uint8_t data;
if (rs) // запись данных (RS=1, RW=0)
dataport |= _BV(LCD_RS_PIN);
else // запись инструкций (RS=0, RW=0)
dataport &= ~_BV(LCD_RS_PIN);
dataport |= _BV(LCD_RW_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
// чтение страшего полубайта
data = pcf8574_getoutputpin(LCD_PCF8574_DEVICEID, LCD_DATA0_PIN) << 4;
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
pcf8574_setoutputpinhigh(LCD_PCF8574_DEVICEID, LCD_E_PIN);
lcd_e_delay();
// чтение младшего полубайта
data |= pcf8574_getoutputpin(LCD_PCF8574_DEVICEID, LCD_DATA0_PIN) &0x0F;
pcf8574_setoutputpinlow(LCD_PCF8574_DEVICEID, LCD_E_PIN);
return data;
}
// ждем пока ЖК освободится
static uint8_t lcd_waitbusy(void)
{
register uint8_t c;
// ждем
while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) {}
// задержка
delay(2);
// получаем адрес
return (lcd_read(0));
}
// перемещение курсора по строкам
static inline void lcd_newline(uint8_t pos)
{
register uint8_t addressCounter;
#if LCD_LINES==1
addressCounter = 0;
#endif
#if LCD_LINES==2
if ( pos < (LCD_START_LINE2) )
addressCounter = LCD_START_LINE2;
else
addressCounter = LCD_START_LINE1;
#endif
#if LCD_LINES==4
if ( pos < LCD_START_LINE3 )
addressCounter = LCD_START_LINE2;
else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4) )
addressCounter = LCD_START_LINE3;
else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2) )
addressCounter = LCD_START_LINE4;
else
addressCounter = LCD_START_LINE1;
#endif
lcd_command((1<<LCD_DDRAM)+addressCounter);
}
// служебная функция для отправки команд дисплею
void lcd_command(uint8_t cmd)
{
lcd_waitbusy();
lcd_write(cmd,0);
}
// отправка байта на дисплей
void lcd_data(uint8_t data)
{
lcd_waitbusy();
lcd_write(data,1);
}
// перемещение курсора по координатам
void lcd_gotoxy(uint8_t x, uint8_t y)
{
#if LCD_LINES==1
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
#endif
#if LCD_LINES==2
if ( y==0 )
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
else
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
#endif
#if LCD_LINES==4
if ( y==0 )
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
else if ( y==1)
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
else if ( y==2)
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+x);
else
lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+x);
#endif
}
// тырим координаты
int lcd_getxy(void)
{
return lcd_waitbusy();
}
// очистка дисплея
void lcd_clrscr(void)
{
lcd_command(1<<LCD_CLR);
}
// вкл и откл подсветки
void lcd_led(uint8_t onoff)
{
if(onoff)
dataport &= ~_BV(LCD_LED_PIN);
else
dataport |= _BV(LCD_LED_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
}
// курсов в начало координат
void lcd_home(void)
{
lcd_command(1<<LCD_HOME);
}
// отображение символа в текущей позиции курсора
void lcd_putc(char c)
{
uint8_t pos;
pos = lcd_waitbusy();
if (c=='\n')
{
lcd_newline(pos);
}
else
{
#if LCD_WRAP_LINES==1
#if LCD_LINES==1
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#elif LCD_LINES==2
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
}else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ){
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#elif LCD_LINES==4
if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);
}else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE3,0);
}else if ( pos == LCD_START_LINE3+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE4,0);
}else if ( pos == LCD_START_LINE4+LCD_DISP_LENGTH ) {
lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
}
#endif
lcd_waitbusy();
#endif
lcd_write(c, 1);
}
}
// вывод строки на дисплей
void lcd_puts(const char *s)
{
register char c;
while ( (c = *s++) ) {
lcd_putc(c);
}
}
// вывод строки из памяти
void lcd_puts_p(const char *progmem_s)
{
register char c;
while ( (c = pgm_read_byte(progmem_s++)) ) {
lcd_putc(c);
}
}
// инициализация дисплея
void lcd_init(uint8_t dispAttr)
{
#if LCD_PCF8574_INIT == 1
//инициализация pcf
pcf8574_init();
#endif
dataport = 0;
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
delay(16000);
// первоначальная запись на ЖК-дисплей — 8 бит
dataport |= _BV(LCD_DATA1_PIN); // _BV(LCD_FUNCTION)>>4;
dataport |= _BV(LCD_DATA0_PIN); // _BV(LCD_FUNCTION_8BIT)>>4;
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
// дрючим дисплей чтобы он начал работать
lcd_e_toggle();
delay(4992);
lcd_e_toggle();
delay(64);
lcd_e_toggle();
delay(64);
// переходим в 4 битный режим
dataport &= ~_BV(LCD_DATA0_PIN);
pcf8574_setoutput(LCD_PCF8574_DEVICEID, dataport);
lcd_e_toggle();
delay(64);
lcd_command(LCD_FUNCTION_DEFAULT); // настраиваем кол-во строк
lcd_command(LCD_DISP_OFF); // вырубаем дисплей
lcd_clrscr(); // чистим экран
lcd_command(LCD_MODE_DEFAULT); // запускаемся в стандартном режиме
lcd_command(dispAttr); // отправляем настройки
}

220
lcdpcf8574.h → MyLCD/lcdpcf8574.h
View File

@ -1,110 +1,110 @@
#ifndef LCD_H
#define LCD_H
#define LCD_PCF8574_INIT 1 //èíèöèàëèçàöèÿ pcf
#define LCD_PCF8574_DEVICEID 0 //id óñò-âà
#define LCD_FUNCTION_DEFAULT LCD_FUNCTION_4BIT_2LINES
// óñòàíîâêà ðåæèìà ââîäà: âêëþ÷åíèå/âûêëþ÷åíèå ñìåùåíèÿ äèñïëåÿ, íàïðàâëåíèå ïåðåìåùåíèÿ êóðñîðà óìåíüøàòü/óâåëè÷èâàòü
#define LCD_ENTRY_DEC 0x04 // ñìåùåíèå äèñïëåÿ âûêëþ÷åíî, êóðñîð ïåðåìåùàåòñÿ ïî íàêëîíó
#define LCD_ENTRY_DEC_SHIFT 0x05 // âêëþ÷åíèå ñäâèãà äèñïëåÿ, ïåðåìåùåíèå êóðñîðà ïî íàêëîíó
#define LCD_ENTRY_INC_ 0x06 // ñìåùåíèå äèñïëåÿ âûêëþ÷åíî, âêë. ïåðåìåùåíèå êóðñîðà â íàïðàâëåíèè
#define LCD_ENTRY_INC_SHIFT 0x07 // âêëþ÷åíèå ñìåùåíèÿ äèñïëåÿ, óâåëè÷åíèå íàïðàâëåíèÿ ïåðåìåùåíèÿ êóðñîðà
// âêëþ÷åíèå/âûêëþ÷åíèå äèñïëåÿ, âêëþ÷åíèå/âûêëþ÷åíèå êóðñîðà, ìèãàþùèé ñèìâîë â ïîçèöèè êóðñîðà
#define LCD_DISP_OFF 0x08 // äèñïëåé âûêëþ÷åí
#define LCD_DISP_ON 0x0C // äèñïëåé âêë, êóðñîð âûêë
#define LCD_DISP_ON_BLINK 0x0D // äèñïëåé âêë, êóðñîð âûêë, åñòü ìèãàþùèé ñèìâë
#define LCD_DISP_ON_CURSOR 0x0E // äèñïëåé âêë, êóðñîð âêë
#define LCD_DISP_ON_CURSOR_BLINK 0x0F // äèñïëåé âêë, êóðñîð âêë, åñòü ìèãàþùèé ñèìâë
// ïåðåìåùåíèå êóðñîðà/ñìåùåíèå äèñïëåÿ
#define LCD_MOVE_CURSOR_LEFT 0x10 // êóðñîð íàëåâî
#define LCD_MOVE_CURSOR_RIGHT 0x14 // êóðñîð íàïðàâî
#define LCD_MOVE_DISP_LEFT 0x18 // ñäâèã âëåâî
#define LCD_MOVE_DISP_RIGHT 0x1C // ñäâèã âïðàâî
// íàáîð ôóíêöèé: óñòàíîâêà äëèíû äàííûõ èíòåðôåéñà è êîëè÷åñòâà ñòðîê îòîáðàæåíèÿ
#define LCD_FUNCTION_4BIT_1LINE 0x20 // 4-áèòíûé èíòåðôåéñ, îäíà ñòðîêà, 5x7 òî÷åê
#define LCD_FUNCTION_4BIT_2LINES 0x28 // 4-áèòíûé èíòåðôåéñ, äâóõñòðî÷íûé, 5x7 òî÷åê
#define LCD_FUNCTION_8BIT_1LINE 0x30 // 8-áèòíûé èíòåðôåéñ, îäíà ñòðîêà, 5x7 òî÷åê
#define LCD_FUNCTION_8BIT_2LINES 0x38 // 8-áèòíûé èíòåðôåéñ, äâóõñòðî÷íûé, 5x7 òî÷åê
#define LCD_LINES 2 // êîë-âî ñòðîê
#define LCD_DISP_LENGTH 16 // êîë-âî ñèìâîëîâ â ñòðîêå
#define LCD_LINE_LENGTH 0x40 // âíóòðåííÿÿ äëèíà ñòðîêè äèñïëåÿ
#define LCD_START_LINE1 0x00 // DDRM àäðåñ äëÿ 1 ñòðîêè
#define LCD_START_LINE2 0x40 // DDRM àäðåñ äëÿ 2 ñòðîêè
#define LCD_WRAP_LINES 1 // ïåðåíîñ ñòðîêè
#define LCD_DATA0_PIN 4 // ïèí äëÿ äàííûõ
#define LCD_DATA1_PIN 5 // ïèí äëÿ äàííûõ
#define LCD_DATA2_PIN 6 // ïèí äëÿ äàííûõ
#define LCD_DATA3_PIN 7 // ïèí äëÿ äàííûõ
#define LCD_RS_PIN 0 // ïèí ëèíèè RS
#define LCD_RW_PIN 1 // ïèí ëèíèè RW
#define LCD_E_PIN 2 // ïèí ëèíèè òàêòèðîâàíèÿ
#define LCD_LED_PIN 3 // ïèí ïîäñâåòêè
// Ïîçèöèè áèòîâ ðåãèñòðà êîìàíä HD44780U.
#define LCD_CLR 0 // îò÷èñòèòü äèñïëåé
#define LCD_HOME 1 // âåðíóòü êóðñîð äîìîé
#define LCD_ENTRY_MODE 2 // óñòàíîâêà ðåæèìà ââîäà
#define LCD_ENTRY_INC 1 // èíêðåìåíò
#define LCD_ENTRY_SHIFT 0 // âêë ñìåùåíèå
#define LCD_ON 3 // âêë êóðñîðà
#define LCD_ON_DISPLAY 2 // âûêë äèñïëåé
#define LCD_ON_CURSOR 1 // âûêë êóðñîð
#define LCD_ON_BLINK 0 // ìèãàíèå êóðñîðà
#define LCD_MOVE 4 // ïåðåäâèæåíèå êóðñîðà
#define LCD_MOVE_DISP 3 // ïåðåäâèæåíèå êóðñîðà
#define LCD_MOVE_RIGHT 2 // ïåðåäâèæåíèå êóðñîðà íàïðàâî
#define LCD_FUNCTION 5 // íàñòðîéêà ôóíêöèé
#define LCD_FUNCTION_8BIT 4 // 8 áèòíûé ðåæèì
#define LCD_FUNCTION_2LINES 3 // àêòèâàöèÿ ñòðîê
#define LCD_FUNCTION_10DOTS 2 // øðèôòû
#define LCD_CGRAM 6 // óñòàíîâêà àäðåñà CG RAM
#define LCD_DDRAM 7 // óñòàíîâêà àäðåñà DD RAM
#define LCD_BUSY 7 // äèñïëåé çàíÿò
// ñòàíäàðòíûé ðåæèì
#define LCD_MODE_DEFAULT ((1<<LCD_ENTRY_MODE) | (1<<LCD_ENTRY_INC) )
// èíèöèàëèçàöèÿ äèñïëåÿ
void lcd_init(uint8_t dispAttr);
// î÷èñòêà äèñïëåÿ
void lcd_clrscr(void);
// êóðñîâ â íà÷àëî êîîðäèíàò
void lcd_home(void);
// ïåðåìåùåíèå êóðñîðà ïî êîîðäèíàòàì
void lcd_gotoxy(uint8_t x, uint8_t y);
// âêë è îòêë ïîäñâåòêè
void lcd_led(uint8_t onoff);
// îòîáðàæåíèå ñèìâîëà â òåêóùåé ïîçèöèè êóðñîðà
void lcd_putc(char c);
// âûâîä ñòðîêè íà äèñïëåé
void lcd_puts(const char *s);
// âûâîä ñòðîêè èç ïàìÿòè
void lcd_puts_p(const char *progmem_s);
// ñëóæåáíàÿ ôóíêöèÿ äëÿ îòïðàâêè êîìàíä äèñïëåþ
void lcd_command(uint8_t cmd);
// îòïðàâêà áàéòà íà äèñïëåé
void lcd_data(uint8_t data);
// ìàêðîñû äëÿ àâòîìàòè÷åñêîãî ñîõðàíåíèÿ ñòðîêîâîé êîíñòàíòû â ïàìÿòè ïðîãðàììû
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
#endif
#ifndef LCD_H
#define LCD_H
#define LCD_PCF8574_INIT 1 //èíèöèàëèçàöèÿ pcf
#define LCD_PCF8574_DEVICEID 0 //id óñò-âà
#define LCD_FUNCTION_DEFAULT LCD_FUNCTION_4BIT_2LINES
// óñòàíîâêà ðåæèìà ââîäà: âêëþ÷åíèå/âûêëþ÷åíèå ñìåùåíèÿ äèñïëåÿ, íàïðàâëåíèå ïåðåìåùåíèÿ êóðñîðà óìåíüøàòü/óâåëè÷èâàòü
#define LCD_ENTRY_DEC 0x04 // ñìåùåíèå äèñïëåÿ âûêëþ÷åíî, êóðñîð ïåðåìåùàåòñÿ ïî íàêëîíó
#define LCD_ENTRY_DEC_SHIFT 0x05 // âêëþ÷åíèå ñäâèãà äèñïëåÿ, ïåðåìåùåíèå êóðñîðà ïî íàêëîíó
#define LCD_ENTRY_INC_ 0x06 // ñìåùåíèå äèñïëåÿ âûêëþ÷åíî, âêë. ïåðåìåùåíèå êóðñîðà â íàïðàâëåíèè
#define LCD_ENTRY_INC_SHIFT 0x07 // âêëþ÷åíèå ñìåùåíèÿ äèñïëåÿ, óâåëè÷åíèå íàïðàâëåíèÿ ïåðåìåùåíèÿ êóðñîðà
// âêëþ÷åíèå/âûêëþ÷åíèå äèñïëåÿ, âêëþ÷åíèå/âûêëþ÷åíèå êóðñîðà, ìèãàþùèé ñèìâîë â ïîçèöèè êóðñîðà
#define LCD_DISP_OFF 0x08 // äèñïëåé âûêëþ÷åí
#define LCD_DISP_ON 0x0C // äèñïëåé âêë, êóðñîð âûêë
#define LCD_DISP_ON_BLINK 0x0D // äèñïëåé âêë, êóðñîð âûêë, åñòü ìèãàþùèé ñèìâë
#define LCD_DISP_ON_CURSOR 0x0E // äèñïëåé âêë, êóðñîð âêë
#define LCD_DISP_ON_CURSOR_BLINK 0x0F // äèñïëåé âêë, êóðñîð âêë, åñòü ìèãàþùèé ñèìâë
// ïåðåìåùåíèå êóðñîðà/ñìåùåíèå äèñïëåÿ
#define LCD_MOVE_CURSOR_LEFT 0x10 // êóðñîð íàëåâî
#define LCD_MOVE_CURSOR_RIGHT 0x14 // êóðñîð íàïðàâî
#define LCD_MOVE_DISP_LEFT 0x18 // ñäâèã âëåâî
#define LCD_MOVE_DISP_RIGHT 0x1C // ñäâèã âïðàâî
// íàáîð ôóíêöèé: óñòàíîâêà äëèíû äàííûõ èíòåðôåéñà è êîëè÷åñòâà ñòðîê îòîáðàæåíèÿ
#define LCD_FUNCTION_4BIT_1LINE 0x20 // 4-áèòíûé èíòåðôåéñ, îäíà ñòðîêà, 5x7 òî÷åê
#define LCD_FUNCTION_4BIT_2LINES 0x28 // 4-áèòíûé èíòåðôåéñ, äâóõñòðî÷íûé, 5x7 òî÷åê
#define LCD_FUNCTION_8BIT_1LINE 0x30 // 8-áèòíûé èíòåðôåéñ, îäíà ñòðîêà, 5x7 òî÷åê
#define LCD_FUNCTION_8BIT_2LINES 0x38 // 8-áèòíûé èíòåðôåéñ, äâóõñòðî÷íûé, 5x7 òî÷åê
#define LCD_LINES 2 // êîë-âî ñòðîê
#define LCD_DISP_LENGTH 16 // êîë-âî ñèìâîëîâ â ñòðîêå
#define LCD_LINE_LENGTH 0x40 // âíóòðåííÿÿ äëèíà ñòðîêè äèñïëåÿ
#define LCD_START_LINE1 0x00 // DDRM àäðåñ äëÿ 1 ñòðîêè
#define LCD_START_LINE2 0x40 // DDRM àäðåñ äëÿ 2 ñòðîêè
#define LCD_WRAP_LINES 1 // ïåðåíîñ ñòðîêè
#define LCD_DATA0_PIN 4 // ïèí äëÿ äàííûõ
#define LCD_DATA1_PIN 5 // ïèí äëÿ äàííûõ
#define LCD_DATA2_PIN 6 // ïèí äëÿ äàííûõ
#define LCD_DATA3_PIN 7 // ïèí äëÿ äàííûõ
#define LCD_RS_PIN 0 // ïèí ëèíèè RS
#define LCD_RW_PIN 1 // ïèí ëèíèè RW
#define LCD_E_PIN 2 // ïèí ëèíèè òàêòèðîâàíèÿ
#define LCD_LED_PIN 3 // ïèí ïîäñâåòêè
// Ïîçèöèè áèòîâ ðåãèñòðà êîìàíä HD44780U.
#define LCD_CLR 0 // îò÷èñòèòü äèñïëåé
#define LCD_HOME 1 // âåðíóòü êóðñîð äîìîé
#define LCD_ENTRY_MODE 2 // óñòàíîâêà ðåæèìà ââîäà
#define LCD_ENTRY_INC 1 // èíêðåìåíò
#define LCD_ENTRY_SHIFT 0 // âêë ñìåùåíèå
#define LCD_ON 3 // âêë êóðñîðà
#define LCD_ON_DISPLAY 2 // âûêë äèñïëåé
#define LCD_ON_CURSOR 1 // âûêë êóðñîð
#define LCD_ON_BLINK 0 // ìèãàíèå êóðñîðà
#define LCD_MOVE 4 // ïåðåäâèæåíèå êóðñîðà
#define LCD_MOVE_DISP 3 // ïåðåäâèæåíèå êóðñîðà
#define LCD_MOVE_RIGHT 2 // ïåðåäâèæåíèå êóðñîðà íàïðàâî
#define LCD_FUNCTION 5 // íàñòðîéêà ôóíêöèé
#define LCD_FUNCTION_8BIT 4 // 8 áèòíûé ðåæèì
#define LCD_FUNCTION_2LINES 3 // àêòèâàöèÿ ñòðîê
#define LCD_FUNCTION_10DOTS 2 // øðèôòû
#define LCD_CGRAM 6 // óñòàíîâêà àäðåñà CG RAM
#define LCD_DDRAM 7 // óñòàíîâêà àäðåñà DD RAM
#define LCD_BUSY 7 // äèñïëåé çàíÿò
// ñòàíäàðòíûé ðåæèì
#define LCD_MODE_DEFAULT ((1<<LCD_ENTRY_MODE) | (1<<LCD_ENTRY_INC) )
// èíèöèàëèçàöèÿ äèñïëåÿ
void lcd_init(uint8_t dispAttr);
// î÷èñòêà äèñïëåÿ
void lcd_clrscr(void);
// êóðñîâ â íà÷àëî êîîðäèíàò
void lcd_home(void);
// ïåðåìåùåíèå êóðñîðà ïî êîîðäèíàòàì
void lcd_gotoxy(uint8_t x, uint8_t y);
// âêë è îòêë ïîäñâåòêè
void lcd_led(uint8_t onoff);
// îòîáðàæåíèå ñèìâîëà â òåêóùåé ïîçèöèè êóðñîðà
void lcd_putc(char c);
// âûâîä ñòðîêè íà äèñïëåé
void lcd_puts(const char *s);
// âûâîä ñòðîêè èç ïàìÿòè
void lcd_puts_p(const char *progmem_s);
// ñëóæåáíàÿ ôóíêöèÿ äëÿ îòïðàâêè êîìàíä äèñïëåþ
void lcd_command(uint8_t cmd);
// îòïðàâêà áàéòà íà äèñïëåé
void lcd_data(uint8_t data);
// ìàêðîñû äëÿ àâòîìàòè÷åñêîãî ñîõðàíåíèÿ ñòðîêîâîé êîíñòàíòû â ïàìÿòè ïðîãðàììû
#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s))
#endif

228
pcf8574.cpp → MyLCD/pcf8574.cpp
View File

@ -1,115 +1,115 @@
#include "MyLCD.h"
uint8_t pcf8574_pinstatus[PCF8574_MAXDEVICES];
// инициализация pcf
void pcf8574_init() {
#if PCF8574_I2CINIT == 1
// инитим i2c
i2c_init();
_delay_us(10);
#endif
uint8_t i = 0;
for(i=0; i<PCF8574_MAXDEVICES; i++)
pcf8574_pinstatus[i] = 0;
}
// получаем статус вывода
int8_t pcf8574_getoutput(uint8_t deviceid) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
data = pcf8574_pinstatus[deviceid];
}
return data;
}
// получаем статус пинов вывода
int8_t pcf8574_getoutputpin(uint8_t deviceid, uint8_t pin) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
data = pcf8574_pinstatus[deviceid];
data = (data >> pin) & 0b00000001;
}
return data;
}
// настройка вывода
int8_t pcf8574_setoutput(uint8_t deviceid, uint8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
pcf8574_pinstatus[deviceid] = data;
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(data);
i2c_stop();
return 0;
}
return -1;
}
// установить выходные контакты, заменить фактический статус устройства из pinstart для i2c
int8_t pcf8574_setoutputpins(uint8_t deviceid, uint8_t pinstart, uint8_t pinlength, int8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pinstart - pinlength + 1 >= 0 && pinstart - pinlength + 1 >= 0 && pinstart < PCF8574_MAXPINS && pinstart > 0 && pinlength > 0)) {
uint8_t b = 0;
b = pcf8574_pinstatus[deviceid];
uint8_t mask = ((1 << pinlength) - 1) << (pinstart - pinlength + 1);
data <<= (pinstart - pinlength + 1);
data &= mask;
b &= ~(mask);
b |= data;
pcf8574_pinstatus[deviceid] = b;
//рестартим
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(b);
i2c_stop();
return 0;
}
return -1;
}
// настройка пинов вывода
int8_t pcf8574_setoutputpin(uint8_t deviceid, uint8_t pin, uint8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
uint8_t b = 0;
b = pcf8574_pinstatus[deviceid];
b = (data != 0) ? (b | (1 << pin)) : (b & ~(1 << pin));
pcf8574_pinstatus[deviceid] = b;
//рестартим
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(b);
i2c_stop();
return 0;
}
return -1;
}
// установка высокого уровня на выходных пинах
int8_t pcf8574_setoutputpinhigh(uint8_t deviceid, uint8_t pin) {
return pcf8574_setoutputpin(deviceid, pin, 1);
}
// установка низкого уровня на выходных пинах
int8_t pcf8574_setoutputpinlow(uint8_t deviceid, uint8_t pin) {
return pcf8574_setoutputpin(deviceid, pin, 0);
}
// получение входных данных
int8_t pcf8574_getinput(uint8_t deviceid) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_READ);
data = ~i2c_readNak();
i2c_stop();
}
return data;
}
// получение входного контакта (высокий или низкий)
int8_t pcf8574_getinputpin(uint8_t deviceid, uint8_t pin) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
data = pcf8574_getinput(deviceid);
if(data != -1) {
data = (data >> pin) & 0b00000001;
}
}
return data;
#include "MyLCD.h"
uint8_t pcf8574_pinstatus[PCF8574_MAXDEVICES];
// инициализация pcf
void pcf8574_init() {
#if PCF8574_I2CINIT == 1
// инитим i2c
i2c_init();
_delay_us(10);
#endif
uint8_t i = 0;
for(i=0; i<PCF8574_MAXDEVICES; i++)
pcf8574_pinstatus[i] = 0;
}
// получаем статус вывода
int8_t pcf8574_getoutput(uint8_t deviceid) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
data = pcf8574_pinstatus[deviceid];
}
return data;
}
// получаем статус пинов вывода
int8_t pcf8574_getoutputpin(uint8_t deviceid, uint8_t pin) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
data = pcf8574_pinstatus[deviceid];
data = (data >> pin) & 0b00000001;
}
return data;
}
// настройка вывода
int8_t pcf8574_setoutput(uint8_t deviceid, uint8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
pcf8574_pinstatus[deviceid] = data;
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(data);
i2c_stop();
return 0;
}
return -1;
}
// установить выходные контакты, заменить фактический статус устройства из pinstart для i2c
int8_t pcf8574_setoutputpins(uint8_t deviceid, uint8_t pinstart, uint8_t pinlength, int8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pinstart - pinlength + 1 >= 0 && pinstart - pinlength + 1 >= 0 && pinstart < PCF8574_MAXPINS && pinstart > 0 && pinlength > 0)) {
uint8_t b = 0;
b = pcf8574_pinstatus[deviceid];
uint8_t mask = ((1 << pinlength) - 1) << (pinstart - pinlength + 1);
data <<= (pinstart - pinlength + 1);
data &= mask;
b &= ~(mask);
b |= data;
pcf8574_pinstatus[deviceid] = b;
//рестартим
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(b);
i2c_stop();
return 0;
}
return -1;
}
// настройка пинов вывода
int8_t pcf8574_setoutputpin(uint8_t deviceid, uint8_t pin, uint8_t data) {
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
uint8_t b = 0;
b = pcf8574_pinstatus[deviceid];
b = (data != 0) ? (b | (1 << pin)) : (b & ~(1 << pin));
pcf8574_pinstatus[deviceid] = b;
//рестартим
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_WRITE);
i2c_write(b);
i2c_stop();
return 0;
}
return -1;
}
// установка высокого уровня на выходных пинах
int8_t pcf8574_setoutputpinhigh(uint8_t deviceid, uint8_t pin) {
return pcf8574_setoutputpin(deviceid, pin, 1);
}
// установка низкого уровня на выходных пинах
int8_t pcf8574_setoutputpinlow(uint8_t deviceid, uint8_t pin) {
return pcf8574_setoutputpin(deviceid, pin, 0);
}
// получение входных данных
int8_t pcf8574_getinput(uint8_t deviceid) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES)) {
i2c_start(((PCF8574_ADDRBASE+deviceid)<<1) | I2C_READ);
data = ~i2c_readNak();
i2c_stop();
}
return data;
}
// получение входного контакта (высокий или низкий)
int8_t pcf8574_getinputpin(uint8_t deviceid, uint8_t pin) {
int8_t data = -1;
if((deviceid >= 0 && deviceid < PCF8574_MAXDEVICES) && (pin >= 0 && pin < PCF8574_MAXPINS)) {
data = pcf8574_getinput(deviceid);
if(data != -1) {
data = (data >> pin) & 0b00000001;
}
}
return data;
}

42
pcf8574.h → MyLCD/pcf8574.h
View File

@ -1,21 +1,21 @@
#ifndef PCF8574_H_
#define PCF8574_H_
#define PCF8574_ADDRBASE (0x27) // àäðåñ óñò-âà
#define PCF8574_I2CINIT 1 // èíèöèàëèçàöèÿ i2c
#define PCF8574_MAXDEVICES 1 // ìàêñ êîë-âî óòðîéñòâ
#define PCF8574_MAXPINS 8 // ìàêñ êîë-âî ïèíîâ
void pcf8574_init();
int8_t pcf8574_getoutput(uint8_t deviceid);
int8_t pcf8574_getoutputpin(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_setoutput(uint8_t deviceid, uint8_t data);
int8_t pcf8574_setoutputpins(uint8_t deviceid, uint8_t pinstart, uint8_t pinlength, int8_t data);
int8_t pcf8574_setoutputpin(uint8_t deviceid, uint8_t pin, uint8_t data);
int8_t pcf8574_setoutputpinhigh(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_setoutputpinlow(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_getinput(uint8_t deviceid);
int8_t pcf8574_getinputpin(uint8_t deviceid, uint8_t pin);
#endif
#ifndef PCF8574_H_
#define PCF8574_H_
#define PCF8574_ADDRBASE (0x27) // àäðåñ óñò-âà
#define PCF8574_I2CINIT 1 // èíèöèàëèçàöèÿ i2c
#define PCF8574_MAXDEVICES 1 // ìàêñ êîë-âî óòðîéñòâ
#define PCF8574_MAXPINS 8 // ìàêñ êîë-âî ïèíîâ
void pcf8574_init();
int8_t pcf8574_getoutput(uint8_t deviceid);
int8_t pcf8574_getoutputpin(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_setoutput(uint8_t deviceid, uint8_t data);
int8_t pcf8574_setoutputpins(uint8_t deviceid, uint8_t pinstart, uint8_t pinlength, int8_t data);
int8_t pcf8574_setoutputpin(uint8_t deviceid, uint8_t pin, uint8_t data);
int8_t pcf8574_setoutputpinhigh(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_setoutputpinlow(uint8_t deviceid, uint8_t pin);
int8_t pcf8574_getinput(uint8_t deviceid);
int8_t pcf8574_getinputpin(uint8_t deviceid, uint8_t pin);
#endif

117
MyLCD/twimaster.cpp Normal file
View File

@ -0,0 +1,117 @@
#include "MyLCD.h"
// инициализация интерфейса i2c
void i2c_init(void)
{
// предделитель тактовой частоты равен 1
TWSR = 0;
// рассчет скорости передачи данных
TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
}
// передача условия СТАРТ на шину
unsigned char i2c_start(unsigned char address)
{
uint8_t twst;
// отправка условия СТАРТ
TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
// ожидание завершения передачи условия СТАРТ
while(!(TWCR & (1<<TWINT)));
// проверка значений регистра
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;
// отправка адреса устрой-ва
TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN);
// ожидание ответа от ведомого уст-ва
while(!(TWCR & (1<<TWINT)));
// проверка полученных значений
twst = TW_STATUS & 0xF8;
if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;
return 0;
}
// ждем, если устрой-во занято, а потом передаем условие СТАРТ на шину
void i2c_start_wait(unsigned char address)
{
uint8_t twst;
for(;;)
{
// отправка условия СТАРТ
TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
// ожидание завершения передачи условия СТАРТ
while(!(TWCR & (1<<TWINT)));
// проверка значений регистра
twst = TW_STATUS & 0xF8;
if ( (twst != TW_START) && (twst != TW_REP_START)) continue;
// отправка адреса устрой-ва
TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN);
// ожидание ответа от ведомого уст-ва
while(!(TWCR & (1<<TWINT)));
// проверка занято ли ведомое уст-во
twst = TW_STATUS & 0xF8;
if ( (twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK) )
{
// устройство занято, отправьте условие остановки для прекращения операции записи
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
// ждем освобождения шины
while(TWCR & (1<<TWSTO));
continue;
}
break;
}
}
// тупа повторяем условие СТАРТ
unsigned char i2c_rep_start(unsigned char address)
{
return i2c_start(address);
}
// передача условия СТОП на шину
void i2c_stop(void)
{
// отправка условия СТОП
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
// ждем выполнения условия остановки
while(TWCR & (1<<TWSTO));
}
// отправка данных, если функция вернет 0, то все успешно, иначе нет
unsigned char i2c_write( unsigned char data )
{
uint8_t twst;
// отправляем данные на уст-во
TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);
// ждем завершения передачи
while(!(TWCR & (1<<TWINT)));
// записываем ответ от ведомого уст-ва
twst = TW_STATUS & 0xF8;
if( twst != TW_MT_DATA_ACK) return 1;
return 0;
}
// читаем данные и продолжаем вещание
unsigned char i2c_readAck(void)
{
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);
while(!(TWCR & (1<<TWINT)));
return TWDR;
}
// читаем данные и после их получения передаем услови СТОП
unsigned char i2c_readNak(void)
{
TWCR = (1<<TWINT) | (1<<TWEN);
while(!(TWCR & (1<<TWINT)));
return TWDR;
}

64
display_functions.c
View File

@ -1,64 +0,0 @@
#include "display_functions.h"
#include <Wire.h>
#define LCD_ADDRESS 0x27 // Адрес дисплея на шине I2C
#define LCD_WIDTH 16 // Ширина дисплея в символах
#define LCD_HEIGHT 2 // Высота дисплея в строках
void lcd_send_command(uint8_t command) {
Wire.beginTransmission(LCD_ADDRESS);
i2c_send_byte(0x80); // Co = 0, Rs = 0 (управляющий байт)
i2c_send_byte(command);
Wire.endTransmission();
}
void lcd_send_data(uint8_t data) {
Wire.beginTransmission(LCD_ADDRESS);
i2c_send_byte(0xC0); // Co = 0, Rs = 1 (байт данных)
i2c_send_byte(data);
Wire.endTransmission();
}
void lcd_send_string(const char *str) {
while (*str) {
lcd_send_data(*str);
str++;
}
}
void lcd_clear() {
lcd_send_command(0x01); // Очистка дисплея
_delay_ms(2); // Небольшая пауза для завершения очистки
}
void lcd_init() {
Wire.begin();
lcd_send_command(0x38); // Установка интерфейса: 8 бит данных, 2 строки, 5x8 точек
lcd_send_command(0x08); // Отключение дисплея, курсора и мигания курсора
lcd_send_command(0x01); // Очистка дисплея
_delay_ms(2); // Небольшая пауза для завершения очистки
lcd_send_command(0x06); // Установка направления текста: курсор увеличивается, сдвиг дисплея
lcd_send_command(0x0C); // Включение дисплея без курсора и мигания курсора
}
void lcd_print_char(char c) {
lcd_send_data(c);
}
void lcd_print_string(const char *str) {
lcd_send_string(str);
}
void lcd_update(const DisplayData *displayData, const TextCounter *textCounter) {
lcd_clear(); // Очистка дисплея перед выводом новой информации
// Вывод данных на первую строку
lcd_send_command(0x80); // Установка курсора на начало первой строки
lcd_send_string(displayData->topLine);
// Вывод данных на вторую строку
lcd_send_command(0xC0); // Установка курсора на начало второй строки
char buffer[17];
snprintf(buffer, sizeof(buffer), "%d.%d.%d", displayData->value1, displayData->value2, displayData->value3);
lcd_send_string(buffer);
}

24
display_functions.h
View File

@ -1,24 +0,0 @@
#ifndef DISPLAY_FUNCTIONS_H
#define DISPLAY_FUNCTIONS_H
#include "i2c_functions.h"
#include <stdint.h>
struct DisplayData {
char topLine[64];
int value1;
int value2;
int value3;
};
struct TextCounter {
unsigned long startTime;
int incrementValue;
};
void lcd_init();
void lcd_print_char(char c);
void lcd_print_string(const char *str);
void lcd_update(const DisplayData *displayData, const TextCounter *textCounter);
#endif

2
hdlc/main.c
View File

@ -1,5 +1,5 @@
//#include "hdlc.h"
#include "stdio.h"
#include "client.h"
int main(){

24
i2c_functions.c
View File

@ -1,24 +0,0 @@
#include "i2c_functions.h"
#include <util/delay.h>
// Здесь можно вставить код инициализации I2C, если требуется
void i2c_delay() {
_delay_us(2);
}
void i2c_start() {
// Реализация отправки стартового условия I2C
}
void i2c_stop() {
// Реализация отправки стопового условия I2C
}
void i2c_send_byte(uint8_t data) {
// Реализация отправки одного байта данных по I2C
}
void i2c_send_bytes(const uint8_t *data, uint8_t length) {
// Реализация отправки массива данных (длиной length) по I2C
}

12
i2c_functions.h
View File

@ -1,12 +0,0 @@
#ifndef I2C_FUNCTIONS_H
#define I2C_FUNCTIONS_H
#include <stdint.h>
void i2c_delay();
void i2c_start();
void i2c_stop();
void i2c_send_byte(uint8_t data);
void i2c_send_bytes(const uint8_t *data, uint8_t length);
#endif

53
main.c
View File

@ -1,53 +0,0 @@
#include <avr/io.h>
#include <util/delay.h>
#include "display_functions.h"
// Основной код вашего проекта
int main() {
// Настройка портов и другие инициализации
lcd_init(); // Инициализация дисплея
// Ваш код в функции setup()
while (1) {
unsigned long currentTime = millis(); // Текущее время
// Проверяем, прошло ли 500 мс с момента последнего увеличения incrementValue
if (currentTime - textCounter.startTime >= 500) {
textCounter.incrementValue++; // Увеличиваем incrementValue на 1
textCounter.startTime = currentTime; // Обновляем время
}
DisplayData displayData;
strncpy(displayData.topLine, "we are responsible for those who have been tame ", sizeof(displayData.topLine) - 1);
displayData.topLine[sizeof(displayData.topLine) - 1] = '\0';
displayData.value1 = 500;
displayData.value2 = 800;
displayData.value3 = 855;
// Буферы для заполнения данных
char buffer1[17];
char buffer2[17];
// Заполнение буфера 1
fillBuffer1(displayData.topLine, buffer1, sizeof(buffer1), textCounter.incrementValue);
// Заполнение буфера 2
fillBuffer2(displayData.value1, displayData.value2, displayData.value3, buffer2, sizeof(buffer2));
// Создание массива для вывода на дисплей
char displayArray[32];
strncpy(displayArray, buffer1, 16); // Копирование первых 16 символов из buffer1 в displayArray
strncpy(displayArray + 16, buffer2, 16); // Копирование первых 16 символов из buffer2 в displayArray, начиная с позиции 16
// Вывод данных на экран
lcd.setCursor(0, 0);
lcd.print(displayArray);
lcd.setCursor(0, 1);
lcd.print(displayArray + 16); // Вывод второй половины displayArray
// Ваш код в функции loop() может быть здесь или в другом месте
// Обновление данных на дисплее
lcd_update(&displayData, &textCounter);
}
return 0;
}

73
main_sketch/main_sketch.ino Normal file
View File

@ -0,0 +1,73 @@
#include "lcd.h"
#include "client.h"
#include "uart.h"
#include "stdbool.h"
#include "stdio.h"
struct Client hdlc;
bool flag_connection = false;
void setup() {
Lsd_inciliation();
UART_init();
init_hdlc_client(&hdlc, 200);
}
void loop() {
if (!flag_connection){
hdlc_control_t frame;
hdlc_connect(&hdlc, &frame);
uint8_t buffer;
hdlc_get_raw_frame(&hdlc, &frame, &buffer, sizeof(buffer));
UART_send(&buffer, sizeof(buffer));
bool flag_recive = true;
while(flag_recive){
uint8_t buffer;
UART_receive(&buffer, sizeof(buffer));
int err = hdlc_timeout_handler(&hdlc, 1);
if (err != 0){
return err;
}
int ret = hdlc_decode_recived_raw_data(&hdlc, &fake_buffer, sizeof(fake_buffer), 0, 0);
if (ret == -6){
uint8_t buffer;
hdlc_get_raw_frame(&hdlc, &hdlc->frame_rej, &buffer, sizeof(buffer));
UART_send(&buffer, sizeof(buffer));
}
if (ret == 0 && client->state == READY_STATE){
flag_connection = true;
}
}
} else {
bool flag_recive = true;
while(flag_recive){
uint8_t buffer;
UART_receive(&buffer, sizeof(buffer));
int err = hdlc_timeout_handler(&hdlc, 1);
if (err != 0){
return err;
}
uint8_t recived_data;
size_t len_recived_data;
int ret = hdlc_decode_recived_raw_data(&hdlc, &fake_buffer, sizeof(fake_buffer), &recived_data, &len_recived_data);
if (ret == -6){
uint8_t buffer;
hdlc_get_raw_frame(&hdlc, &hdlc->frame_rej, &buffer, sizeof(buffer));
UART_send(&buffer, sizeof(buffer));
}
printLsd(recived_data);
}
}
}

83
sketch_sep19a.ino
View File

@ -1,83 +0,0 @@
#include "MyLCD.h"
struct DisplayData {
char topLine[64];
int value1;
int value2;
int value3;
};
struct TextCounter {
unsigned long startTime;
int incrementValue;
};
TextCounter textCounter;
void setup() {
lcd_init(LCD_DISP_ON_BLINK); // инициализация дисплея
lcd_home(); // домой курсор
lcd_led(0); // вкл подсветки
textCounter.startTime = millis(); // Запоминаем время запуска программы
}
void loop() {
unsigned long currentTime = millis(); // Текущее время
// Проверяем, прошло ли 500 мс с момента последнего увеличения incrementValue
if (currentTime - textCounter.startTime >= 500) {
textCounter.incrementValue++; // Увеличиваем incrementValue на 1
textCounter.startTime = currentTime; // Обновляем время
}
DisplayData displayData;
strncpy(displayData.topLine, "we are responsible for those who have been tame ", sizeof(displayData.topLine) - 1);
displayData.topLine[sizeof(displayData.topLine) - 1] = '\0';
displayData.value1 = 500;
displayData.value2 = 800;
displayData.value3 = 855;
// Буферы для заполнения данных
char buffer1[17];
char buffer2[17];
// Заполнение буфера 1
fillBuffer1(displayData.topLine, buffer1, sizeof(buffer1), textCounter.incrementValue);
// Заполнение буфера 2
fillBuffer2(displayData.value1, displayData.value2, displayData.value3, buffer2, sizeof(buffer2));
// Создание массива для вывода на дисплей
char displayArray[32];
strncpy(displayArray, buffer1, 16); // Копирование первых 16 символов из buffer1 в displayArray
strncpy(displayArray + 16, buffer2, 16); // Копирование первых 16 символов из buffer2 в displayArray, начиная с позиции 16
// Вывод данных на экран
lcd_gotoxy(0, 0);
lcd_puts(displayArray);
lcd_gotoxy(0, 1);
lcd_puts(displayArray + 16); // Вывод второй половины displayArray
}
void fillBuffer1(const char* source, char* buffer, size_t bufferSize, int incrementValue) {
int startIndex = incrementValue % strlen(source); // Определяем начальный индекс на основе incrementValue
int endIndex = startIndex + 16;
if (endIndex > strlen(source)) {
// Если endIndex превышает длину строки source, переносим его на начало строки
endIndex = endIndex - strlen(source);
// Копируем символы с конца строки source
strncpy(buffer, source + startIndex, strlen(source) - startIndex);
// Копируем оставшиеся символы с начала строки source
strncat(buffer, source, endIndex);
} else {
strncpy(buffer, source + startIndex, endIndex - startIndex);
}
buffer[endIndex - startIndex] = '\0'; // Установка нулевого символа в конце буфера
}
void fillBuffer2(int value1, int value2, int value3, char* buffer, size_t bufferSize) {
snprintf(buffer, bufferSize, "%d.%d.%d", value1, value2, value3);
}

55
пример с библиотеками ардуино.txt
View File

@ -1,55 +0,0 @@
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(32, 16, 2);
byte MasArray[32] = {
78, 69, 71, 82, 32, 77, 65, 78, 68, 65, 82, 73, 78, 33, 33, 33,
32, 32, 32, 32, 46, 32, 32, 32, 32, 46, 32, 32, 32, 46, 37, 33
};
char colum1[17];
char colum2[17];
unsigned long previousTime = 0;
const unsigned long interval = 200;
void delay_ms(unsigned long milliseconds) {
unsigned long startTime = millis();
while (millis() - startTime < milliseconds) {
// Wait until the specified time has passed
}
}
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
for (int i = 0; i < 32; i++) {
if (i < 16) {
colum1[i] = (char)MasArray[i];
} else {
colum2[i - 16] = (char)MasArray[i];
}
}
colum1[16] = '\0';
colum2[16] = '\0';
}
void loop() {
unsigned long currentTime = millis();
if (currentTime - previousTime >= interval) {
previousTime = currentTime;
for (int i = 15; i > 0; i--) {
lcd.setCursor(i, 0);
lcd.print(colum1);
lcd.setCursor(0, 1);
lcd.print(colum2);
delay_ms(200); // Use the custom delay_ms() function instead of delay()
lcd.clear();
}
}
}

93
типо с.txt
View File

@ -1,93 +0,0 @@
#include <Wire.h>
#define LCD_ADDRESS 0x27
#define LCD_ROWS 2
#define LCD_COLUMNS 16
byte MasArray[32] = {
78, 69, 71, 82, 32, 77, 65, 78, 68, 65, 82, 73, 78, 33, 33, 33,
32, 32, 32, 32, 46, 32, 32, 32, 32, 46, 32, 32, 32, 46, 37, 33
};
char colum1[17];
char colum2[17];
unsigned long previousTime = 0;
const unsigned long interval = 200;
void delay_ms(unsigned long milliseconds) {
unsigned long startTime = millis();
while (millis() - startTime < milliseconds) {
// Wait until the specified time has passed
}
}
void lcdCommand(uint8_t command) {
Wire.beginTransmission(LCD_ADDRESS);
Wire.write(0x00);
Wire.write(command);
Wire.endTransmission();
}
void lcdWrite(uint8_t value) {
Wire.beginTransmission(LCD_ADDRESS);
Wire.write(0x40);
Wire.write(value);
Wire.endTransmission();
}
void lcdSetCursor(uint8_t row, uint8_t col) {
uint8_t row_offsets[] = { 0x00, 0x40 };
uint8_t offset = row_offsets[row] + col;
lcdCommand(0x80 | offset);
}
void lcdClear() {
lcdCommand(0x01); // Clear display
delay_ms(2); // Delay for clear display command
}
void lcdInit() {
Wire.begin();
lcdCommand(0x38); // Function set: 8-bit mode, 2 lines, 5x8 font
lcdCommand(0x0C); // Display control: Display ON, Cursor OFF, Blinking OFF
lcdClear();
}
void lcdPrint(const char* str) {
while (*str) {
lcdWrite(*str++);
}
}
void setup() {
Serial.begin(9600);
lcdInit();
for (int i = 0; i < 32; i++) {
if (i < 16) {
colum1[i] = (char)MasArray[i];
} else {
colum2[i - 16] = (char)MasArray[i];
}
}
colum1[16] = '\0';
colum2[16] = '\0';
}
void loop() {
unsigned long currentTime = millis();
if (currentTime - previousTime >= interval) {
previousTime = currentTime;
for (int i = 15; i > 0; i--) {
lcdSetCursor(i, 0);
lcdPrint(colum1);
lcdSetCursor(0, 1);
lcdPrint(colum2);
delay_ms(200); // Use the custom delay_ms() function instead of delay()
lcdClear();
}
}
}