MultiMote/mmote.ru
MultiMote/mmote.ru
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity
0c78c130ce
mmote.ru/content/posts/avr-siemens-lcd/index.md

1202 lines
45 KiB
Markdown
Raw Normal View History

Первый коммит
2023-01-01 18:21:01 +03:00
---
title: "Подключение дисплея от Siemens C55/A55/A52 к AVR"
categories: ["mcu", "archive"]
date: 2016-02-19T00:00:00+03:00
draft: false
featured_image: miniature.jpg
---
Вот на днях решил порыться в своих запасах запчастей от мобильных телефонах. И заметил дисплей с маркировкой LPH8694-3. Погуглив, я выяснил что это дисплей от телефонов Siemens C55/A55/A52. Ну что ж добру пропадать, будем подключать.
<!--more-->
> :hint: Статья не закончена.
> Когда-нибудь она будет доработана.
![Маркировка экрана|400](lcd.jpg)
Экран имеет весьма странное разрешение экрана – 101 на 64 точки (в [даташите](PCF8812.pdf) вообще написано, что 102x64). Это намного больше, чем у дисплея, которым я обычно пользуюсь (у nokia 5110 – 64 на 48 точек).
За основу я решил использовать [библиотеку](https://github.com/gresolio/N3310Lib) уважаемого товарища [gresolio](https://github.com/gresolio). Дисплеи очень похожи, но немного отличается инициализация. Да и доработать библиотеку под новое разрешение экрана тоже нужно.
![Распиновка дисплея (вид со стороны контактов)|338](lph8684.png)
Главное отличие в инициализации, без чего дисплей не запустится вообще – способ питания.
Нужно найти вот эту строку в **LcdInit**:
``` c
LcdSend( 0x13, LCD_CMD ); // Настройка питания (LCD bias mode 1:48)
```
И заменить на:
```c
LcdSend( 0x16, LCD_CMD );
```
**LcdGotoXYFont**, до:
```c
byte LcdGotoXYFont ( byte x, byte y )
{
// Проверка границ
if( x > 13 || y > 5 ) return OUT_OF_BORDER;
// Вычисление указателя. Определен как адрес в пределах 504 байт
LcdCacheIdx = x * 6 + y * 84;
return OK;
}
```
После:
```c
byte LcdGotoXYFont ( byte x, byte y )
{
// Проверка границ
if( x > LCD_COLS || y > LCD_LINES ) return OUT_OF_BORDER;
// Вычисление указателя. Определен как адрес в пределах 504 байт
LcdCacheIdx = x * LCD_LINES + y * LCD_X_RES;
return OK;
}
```
**LcdChr**, до:
```c
else if ( size == FONT_2X )
{
tmpIdx = LcdCacheIdx - 84;
```
После:
```c
else if ( size == FONT_2X )
{
tmpIdx = LcdCacheIdx - LCD_X_RES;
```
До:
```c
// Копируем две части в кэш
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx + 82] = b2;
LcdCache[tmpIdx + 83] = b2;
```
После:
```c
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx + LCD_X_RES - 2] = b2;
LcdCache[tmpIdx + LCD_X_RES - 1] = b2;
```
**LcdPixel**, до:
```c
// Пересчет индекса и смещения
index = ( ( y / 8 ) * 84 ) + x;
offset = y - ( ( y / 8 ) * 8 );
```
После
```c
// Пересчет индекса и смещения
index = ( ( y / LCD_LINES ) * LCD_X_RES ) + x;
offset = y - ( ( y / 8) * LCD_LINES );
```
**n3310.h**, до:
```c
// Разрешение дисплея в пикселях
#define LCD_X_RES 84 // разрешение по горизонтали
#define LCD_Y_RES 48 // разрешение по вертикали
```
После:
```c
// Разрешение дисплея в пикселях
#define LCD_X_RES 102 // разрешение по горизонтали
#define LCD_Y_RES 65 // разрешение по вертикали
#define LCD_LINES (LCD_Y_RES / 8) // количество строк
#define LCD_COLS (LCD_X_RES / 5) // количество столбцов
```
Возможно, это не всё.
Вот то, что получилось:
sc55.h:
```c
/*
* Имя : n3310.h
*
* Описание : Это заголовочный файл для драйвера графического LCD от Nokia 3310, а также его китайских клонов.
* Базируется на коде библиотек написанных Sylvain Bissonnette и Fandi Gunawan:
* http://www.microsyl.com/index.php/2010/03/24/nokia-lcd-library/
* http://fandigunawan.wordpress.com/2008/06/18/lcd-nokia-3310-pcd8544-driver-in-winavravr-gcc/
* Основные отличия между оригиналом и клоном хорошо описаны в статье от Aheir:
* http://radiokot.ru/articles/29/
*
* Автор : Xander Gresolio <xugres@gmail.com>
* Веб-страница : http://we.easyelectronics.ru/profile/XANDER/
*
* Лицензия : GPL v3.0
*
* Компилятор : WinAVR, GCC for AVR platform
*/
#ifndef _SC55_H_
#define _SC55_H_
#include <avr/pgmspace.h>
// Порт к которому подключен LCD (здесь пример распиновки для ATmega8)
#define LCD_PORT PORTB
#define LCD_DDR DDRB
// Распиновка порта
#define LCD_DC_PIN PB1
#define LCD_CE_PIN PB2
#define LCD_DATA_PIN PB3
#define LCD_RST_PIN PB4
#define LCD_CLK_PIN PB5
// Разрешение дисплея в пикселях
#define LCD_X_RES 102 // разрешение по горизонтали
#define LCD_Y_RES 65 // разрешение по вертикали
#define LCD_LINES (LCD_Y_RES / 8) // количество строк
#define LCD_COLS (LCD_X_RES / 5) // количество столбцов
// Настройки для рисования группы прямоугольников функцией LcdBars ( byte data[], byte numbBars, byte width, byte multiplier )
#define EMPTY_SPACE_BARS 2 // расстояние между прямоугольниками
#define BAR_X 30 // координата x
#define BAR_Y 47 // координата y
// Размер кэша ( 84 * 48 ) / 8 = 504 байта
#define LCD_CACHE_SIZE ( ( LCD_X_RES * LCD_Y_RES ) / 8 )
#define FALSE 0
#define TRUE 1
// Для возвращаемых значений
#define OK 0 // Безошибочная отрисовка
#define OUT_OF_BORDER 1 // Выход за границы дисплея
#define OK_WITH_WRAP 2 // Переход на начало (ситуация автоинкремента указателя курсора при выводе длинного текста)
typedef unsigned char byte;
// Перечисления
typedef enum
{
LCD_CMD = 0, // Команда
LCD_DATA = 1 // Данные
} LcdCmdData;
typedef enum
{
PIXEL_OFF = 0, // Погасить пиксели дисплея
PIXEL_ON = 1, // Включить пиксели дисплея
PIXEL_XOR = 2 // Инвертировать пиксели
} LcdPixelMode;
typedef enum
{
FONT_1X = 1, // Обычный размер шрифта 5x7
FONT_2X = 2 // Увеличенный размер шрифта
} LcdFontSize;
// Прототипы функций, детальную информацию смотрим внутри n3310lcd.c
void LcdInit ( void ); // Инициализация
void LcdClear ( void ); // Очистка буфера
void LcdUpdate ( void ); // Копирование буфера в ОЗУ дисплея
void LcdImage ( const byte *imageData ); // Рисование картинки из массива в Flash ROM
void LcdContrast ( byte contrast ); // Установка контрастности дисплея
byte LcdGotoXYFont ( byte x, byte y ); // Установка курсора в позицию x,y
byte LcdChr ( LcdFontSize size, byte ch ); // Вывод символа в текущей позиции
byte LcdStr ( LcdFontSize size, byte dataArray[] ); // Вывод строки сохраненной в RAM
byte LcdFStr ( LcdFontSize size, const byte *dataPtr ); // Вывод строки сохраненной в Flash ROM
byte LcdPixel ( byte x, byte y, LcdPixelMode mode ); // Точка
byte LcdLine ( byte x1, byte y1, byte x2, byte y2, LcdPixelMode mode ); // Линия
byte LcdCircle ( byte x, byte y, byte radius, LcdPixelMode mode); // Окружность
byte LcdRect ( byte x1, byte y1, byte x2, byte y2, LcdPixelMode mode ); // Прямоугольник
byte LcdSingleBar ( byte baseX, byte baseY, byte height, byte width, LcdPixelMode mode ); // Один
byte LcdBars ( byte data[], byte numbBars, byte width, byte multiplier ); // Несколько
/*
* Таблица для отображения символов (ASCII[0x20-0x7F] + CP1251[0xC0-0xFF] = всего 160 символов)
*/
static const byte FontLookup [][5] PROGMEM=
{
{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x20 32
{ 0x00, 0x00, 0x5F, 0x00, 0x00 }, // ! 0x21 33
{ 0x00, 0x07, 0x00, 0x07, 0x00 }, // " 0x22 34
{ 0x14, 0x7F, 0x14, 0x7F, 0x14 }, // # 0x23 35
{ 0x24, 0x2A, 0x7F, 0x2A, 0x12 }, // $ 0x24 36
{ 0x4C, 0x2C, 0x10, 0x68, 0x64 }, // % 0x25 37
{ 0x36, 0x49, 0x55, 0x22, 0x50 }, // & 0x26 38
{ 0x00, 0x05, 0x03, 0x00, 0x00 }, // ' 0x27 39
{ 0x00, 0x1C, 0x22, 0x41, 0x00 }, // ( 0x28 40
{ 0x00, 0x41, 0x22, 0x1C, 0x00 }, // ) 0x29 41
{ 0x14, 0x08, 0x3E, 0x08, 0x14 }, // * 0x2A 42
{ 0x08, 0x08, 0x3E, 0x08, 0x08 }, // + 0x2B 43
{ 0x00, 0x00, 0x50, 0x30, 0x00 }, // , 0x2C 44
{ 0x10, 0x10, 0x10, 0x10, 0x10 }, // - 0x2D 45
{ 0x00, 0x60, 0x60, 0x00, 0x00 }, // . 0x2E 46
{ 0x20, 0x10, 0x08, 0x04, 0x02 }, // / 0x2F 47
{ 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0 0x30 48
{ 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1 0x31 49
{ 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2 0x32 50
{ 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3 0x33 51
{ 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4 0x34 52
{ 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5 0x35 53
{ 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6 0x36 54
{ 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7 0x37 55
{ 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8 0x38 56
{ 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9 0x39 57
{ 0x00, 0x36, 0x36, 0x00, 0x00 }, // : 0x3A 58
{ 0x00, 0x56, 0x36, 0x00, 0x00 }, // ; 0x3B 59
{ 0x08, 0x14, 0x22, 0x41, 0x00 }, // < 0x3C 60
{ 0x14, 0x14, 0x14, 0x14, 0x14 }, // = 0x3D 61
{ 0x00, 0x41, 0x22, 0x14, 0x08 }, // > 0x3E 62
{ 0x02, 0x01, 0x51, 0x09, 0x06 }, // ? 0x3F 63
{ 0x32, 0x49, 0x79, 0x41, 0x3E }, // @ 0x40 64
{ 0x7E, 0x11, 0x11, 0x11, 0x7E }, // A 0x41 65
{ 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B 0x42 66
{ 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C 0x43 67
{ 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D 0x44 68
{ 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E 0x45 69
{ 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F 0x46 70
{ 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G 0x47 71
{ 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H 0x48 72
{ 0x00, 0x41, 0x7F, 0x41, 0x00 }, // I 0x49 73
{ 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J 0x4A 74
{ 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K 0x4B 75
{ 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L 0x4C 76
{ 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M 0x4D 77
{ 0x7F, 0x04, 0x08, 0x10, 0x7F }, // N 0x4E 78
{ 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O 0x4F 79
{ 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P 0x50 80
{ 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q 0x51 81
{ 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R 0x52 82
{ 0x46, 0x49, 0x49, 0x49, 0x31 }, // S 0x53 83
{ 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T 0x54 84
{ 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U 0x55 85
{ 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V 0x56 86
{ 0x3F, 0x40, 0x38, 0x40, 0x3F }, // W 0x57 87
{ 0x63, 0x14, 0x08, 0x14, 0x63 }, // X 0x58 88
{ 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y 0x59 89
{ 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z 0x5A 90
{ 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [ 0x5B 91
{ 0x02, 0x04, 0x08, 0x10, 0x20 }, // \ 0x5C 92
{ 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ] 0x5D 93
{ 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^ 0x5E 94
{ 0x40, 0x40, 0x40, 0x40, 0x40 }, // _ 0x5F 95
{ 0x00, 0x01, 0x02, 0x04, 0x00 }, // ` 0x60 96
{ 0x20, 0x54, 0x54, 0x54, 0x78 }, // a 0x61 97
{ 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b 0x62 98
{ 0x38, 0x44, 0x44, 0x44, 0x20 }, // c 0x63 99
{ 0x38, 0x44, 0x44, 0x48, 0x7F }, // d 0x64 100
{ 0x38, 0x54, 0x54, 0x54, 0x18 }, // e 0x65 101
{ 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f 0x66 102
{ 0x0C, 0x52, 0x52, 0x52, 0x3E }, // g 0x67 103
{ 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h 0x68 104
{ 0x00, 0x44, 0x7D, 0x40, 0x00 }, // i 0x69 105
{ 0x20, 0x40, 0x44, 0x3D, 0x00 }, // j 0x6A 106
{ 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k 0x6B 107
{ 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l 0x6C 108
{ 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m 0x6D 109
{ 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n 0x6E 110
{ 0x38, 0x44, 0x44, 0x44, 0x38 }, // o 0x6F 111
{ 0x7C, 0x14, 0x14, 0x14, 0x08 }, // p 0x70 112
{ 0x08, 0x14, 0x14, 0x18, 0x7C }, // q 0x71 113
{ 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r 0x72 114
{ 0x48, 0x54, 0x54, 0x54, 0x20 }, // s 0x73 115
{ 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t 0x74 116
{ 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u 0x75 117
{ 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v 0x76 118
{ 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w 0x77 119
{ 0x44, 0x28, 0x10, 0x28, 0x44 }, // x 0x78 120
{ 0x0C, 0x50, 0x50, 0x50, 0x3C }, // y 0x79 121
{ 0x44, 0x64, 0x54, 0x4C, 0x44 }, // z 0x7A 122
{ 0x00, 0x08, 0x36, 0x41, 0x00 }, // { 0x7B 123
{ 0x00, 0x00, 0x7F, 0x00, 0x00 }, // | 0x7C 124
{ 0x00, 0x41, 0x36, 0x08, 0x00 }, // } 0x7D 125
{ 0x08, 0x04, 0x08, 0x10, 0x08 }, // ~ 0x7E 126
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, //  0x7F 127
{ 0x7C, 0x12, 0x11, 0x12, 0x7C }, // А 0xC0 192
{ 0x7F, 0x49, 0x49, 0x49, 0x31 }, // Б 0xC1 193
{ 0x7F, 0x49, 0x49, 0x49, 0x36 }, // В 0xC2 194
{ 0x7F, 0x01, 0x01, 0x01, 0x01 }, // Г 0xC3 195
{ 0x60, 0x3F, 0x21, 0x3F, 0x60 }, // Д 0xC4 196
{ 0x7F, 0x49, 0x49, 0x49, 0x41 }, // Е 0xC5 197
{ 0x77, 0x08, 0x7F, 0x08, 0x77 }, // Ж 0xC6 198
{ 0x22, 0x41, 0x49, 0x49, 0x36 }, // З 0xC7 199
{ 0x7F, 0x10, 0x08, 0x04, 0x7F }, // И 0xC8 200
{ 0x7E, 0x10, 0x09, 0x04, 0x7E }, // Й 0xC9 201
{ 0x7F, 0x08, 0x14, 0x22, 0x41 }, // К 0xCA 202
{ 0x40, 0x3E, 0x01, 0x01, 0x7F }, // Л 0xCB 203
{ 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // М 0xCC 204
{ 0x7F, 0x08, 0x08, 0x08, 0x7F }, // Н 0xCD 205
{ 0x3E, 0x41, 0x41, 0x41, 0x3E }, // О 0xCE 206
{ 0x7F, 0x01, 0x01, 0x01, 0x7F }, // П 0xCF 207
{ 0x7F, 0x09, 0x09, 0x09, 0x06 }, // Р 0xD0 208
{ 0x3E, 0x41, 0x41, 0x41, 0x22 }, // С 0xD1 209
{ 0x01, 0x01, 0x7F, 0x01, 0x01 }, // Т 0xD2 210
{ 0x07, 0x48, 0x48, 0x48, 0x3F }, // У 0xD3 211
{ 0x0E, 0x11, 0x7F, 0x11, 0x0E }, // Ф 0xD4 212
{ 0x63, 0x14, 0x08, 0x14, 0x63 }, // Х 0xD5 213
{ 0x3F, 0x20, 0x20, 0x3F, 0x60 }, // Ц 0xD6 214
{ 0x07, 0x08, 0x08, 0x08, 0x7F }, // Ч 0xD7 215
{ 0x7F, 0x40, 0x7E, 0x40, 0x7F }, // Ш 0xD8 216
{ 0x3F, 0x20, 0x3F, 0x20, 0x7F }, // Щ 0xD9 217
{ 0x01, 0x7F, 0x48, 0x48, 0x30 }, // Ъ 0xDA 218
{ 0x7F, 0x48, 0x30, 0x00, 0x7F }, // Ы 0xDB 219
{ 0x00, 0x7F, 0x48, 0x48, 0x30 }, // Ь 0xDC 220
{ 0x22, 0x41, 0x49, 0x49, 0x3E }, // Э 0xDD 221
{ 0x7F, 0x08, 0x3E, 0x41, 0x3E }, // Ю 0xDE 222
{ 0x46, 0x29, 0x19, 0x09, 0x7F }, // Я 0xDF 223
{ 0x20, 0x54, 0x54, 0x54, 0x78 }, // а 0xE0 224
{ 0x3C, 0x4A, 0x4A, 0x4A, 0x31 }, // б 0xE1 225
{ 0x7C, 0x54, 0x54, 0x28, 0x00 }, // в 0xE2 226
{ 0x7C, 0x04, 0x04, 0x0C, 0x00 }, // г 0xE3 227
{ 0x60, 0x3C, 0x24, 0x3C, 0x60 }, // д 0xE4 228
{ 0x38, 0x54, 0x54, 0x54, 0x18 }, // е 0xE5 229
{ 0x6C, 0x10, 0x7C, 0x10, 0x6C }, // ж 0xE6 230
{ 0x00, 0x44, 0x54, 0x54, 0x28 }, // з 0xE7 231
{ 0x7C, 0x20, 0x10, 0x08, 0x7C }, // и 0xE8 232
{ 0x7C, 0x21, 0x12, 0x09, 0x7C }, // й 0xE9 233
{ 0x7C, 0x10, 0x28, 0x44, 0x00 }, // к 0xEA 234
{ 0x40, 0x38, 0x04, 0x04, 0x7C }, // л 0xEB 235
{ 0x7C, 0x08, 0x10, 0x08, 0x7C }, // м 0xEC 236
{ 0x7C, 0x10, 0x10, 0x10, 0x7C }, // н 0xED 237
{ 0x38, 0x44, 0x44, 0x44, 0x38 }, // о 0xEE 238
{ 0x7C, 0x04, 0x04, 0x04, 0x7C }, // п 0xEF 239
{ 0x7C, 0x14, 0x14, 0x14, 0x08 }, // р 0xF0 240
{ 0x38, 0x44, 0x44, 0x44, 0x00 }, // с 0xF1 241
{ 0x04, 0x04, 0x7C, 0x04, 0x04 }, // т 0xF2 242
{ 0x0C, 0x50, 0x50, 0x50, 0x3C }, // у 0xF3 243
{ 0x08, 0x14, 0x7C, 0x14, 0x08 }, // ф 0xF4 244
{ 0x44, 0x28, 0x10, 0x28, 0x44 }, // х 0xF5 245
{ 0x3C, 0x20, 0x20, 0x3C, 0x60 }, // ц 0xF6 246
{ 0x0C, 0x10, 0x10, 0x10, 0x7C }, // ч 0xF7 247
{ 0x7C, 0x40, 0x7C, 0x40, 0x7C }, // ш 0xF8 248
{ 0x3C, 0x20, 0x3C, 0x20, 0x7C }, // щ 0xF9 249
{ 0x04, 0x7C, 0x50, 0x50, 0x20 }, // ъ 0xFA 250
{ 0x7C, 0x50, 0x20, 0x00, 0x7C }, // ы 0xFB 251
{ 0x00, 0x7C, 0x50, 0x50, 0x20 }, // ь 0xFC 252
{ 0x28, 0x44, 0x54, 0x54, 0x38 }, // э 0xFD 253
{ 0x7C, 0x10, 0x38, 0x44, 0x38 }, // ю 0xFE 254
{ 0x48, 0x54, 0x34, 0x14, 0x7C } // я 0xFF 255
};
#endif /* _N3310_H_ */
```
sc55.c:
```c
/*
* Имя : n3310.c
*
* Описание : Это драйвер для графического LCD от Nokia 3310, а также его китайских клонов.
* Базируется на коде библиотек написанных Sylvain Bissonnette и Fandi Gunawan:
* http://www.microsyl.com/index.php/2010/03/24/nokia-lcd-library/
* http://fandigunawan.wordpress.com/2008/06/18/lcd-nokia-3310-pcd8544-driver-in-winavravr-gcc/
* Основные отличия между оригиналом и клоном хорошо описаны в статье от Aheir:
* http://radiokot.ru/articles/29/
*
* Автор : Xander Gresolio <xugres@gmail.com>
* Веб-страница : http://we.easyelectronics.ru/profile/XANDER/
*
* Лицензия : GPL v3.0
*
* Компилятор : WinAVR, GCC for AVR platform
*
* История :
* Версия 1.0 (06.08.2011)
* + Первая версия
* + Добавлена поддержка китайских клонов LCD Nokia 3310
* + Полный перевод комментариев к исходному коду драйвера
* + Таблица символов драйвера дополнена кириллицей (упрощенная Windows-1251)
* + Добавлена функция рисования окружностей LcdCircle
* - Исправлены ошибки в проверке корректности координат при вызове функций рисования
* - Исправлена ошибка в функции LcdSingleBar (неверная отрисовка по y)
*/
#include <avr/io.h>
#include <string.h>
#include "sc55.h"
// Прототипы приватных функций драйвера
static void LcdSend ( byte data, LcdCmdData cd );
static void Delay ( void );
// Глобальные переменные
// Кэш в ОЗУ 84*48 бит или 504 байта
static byte LcdCache [ LCD_CACHE_SIZE ];
// Чтобы не обновлять весь дисплей, а лишь ту часть что изменилась,
// будем отмечать две границы кэша где произошли изменения. Затем
// можно копировать эту часть кэша между границами в ОЗУ дисплея.
static int LoWaterMark; // нижняя граница
static int HiWaterMark; // верхняя граница
// Указатель для работы с LcdCache[]
static int LcdCacheIdx;
// Флаг изменений кэша
static byte UpdateLcd;
/*
* Имя : LcdInit
* Описание : Производит инициализацию порта МК и контроллера LCD
* Аргумент(ы) : Нет
* Возвращаемое значение : Нет
*/
void LcdInit ( void )
{
// Pull-up на вывод подключенный к reset дисплея
LCD_PORT |= _BV ( LCD_RST_PIN );
// Устанавливаем нужные биты порта на выход
LCD_DDR |= _BV( LCD_RST_PIN ) | _BV( LCD_DC_PIN ) | _BV( LCD_CE_PIN ) | _BV(LCD_DATA_PIN) | _BV(LCD_CLK_PIN);
// Некалиброванная задержка
Delay();
// Дергаем reset
LCD_PORT &= ~( _BV( LCD_RST_PIN ) );
Delay();
LCD_PORT |= _BV ( LCD_RST_PIN );
// Отключаем LCD контроллер - высокий уровень на SCE
LCD_PORT |= _BV( LCD_CE_PIN );
// Отправляем команды дисплею
LcdSend( 0x21, LCD_CMD ); // Включаем расширенный набор команд (LCD Extended Commands)
LcdSend( 0xC8, LCD_CMD ); // Установка контрастности (LCD Vop)
LcdSend( 0x06, LCD_CMD ); // Установка температурного коэффициента (Temp coefficent)
LcdSend( 0x16, LCD_CMD ); // Настройка питания (Bias n=2), siemens
LcdSend( 0x20, LCD_CMD ); // Включаем стандартный набор команд и горизонтальную адресацию (LCD Standard Commands,Horizontal addressing mode)
LcdSend( 0x0C, LCD_CMD ); // Нормальный режим (LCD in normal mode)
// Первичная очистка дисплея
LcdClear();
LcdUpdate();
}
/*
* Имя : LcdClear
* Описание : Очищает дисплей. Далее необходимо выполнить LcdUpdate
* Аргумент(ы) : Нет
* Возвращаемое значение : Нет
*/
void LcdClear ( void )
{
// // Очистка кэша дисплея
// int i;
// for ( i = 0; i < LCD_CACHE_SIZE; i++ )
// {
// LcdCache[i] = 0x00;
// }
// Оптимизация от Jakub Lasinski (March 14 2009)
memset( LcdCache, 0x00, LCD_CACHE_SIZE );
// Сброс указателей границ в максимальное значение
LoWaterMark = 0;
HiWaterMark = LCD_CACHE_SIZE - 1;
// Установка флага изменений кэша
UpdateLcd = TRUE;
}
/*
* Имя : LcdUpdate
* Описание : Копирует кэш в ОЗУ дисплея
* Аргумент(ы) : Нет
* Возвращаемое значение : Нет
*/
void LcdUpdate (void)
{
int i;
if ( LoWaterMark < 0 )
LoWaterMark = 0;
else if ( LoWaterMark >= LCD_CACHE_SIZE )
LoWaterMark = LCD_CACHE_SIZE - 1;
if ( HiWaterMark < 0 )
HiWaterMark = 0;
else if ( HiWaterMark >= LCD_CACHE_SIZE )
HiWaterMark = LCD_CACHE_SIZE - 1;
// Устанавливаем начальный адрес в соответствии к LoWaterMark
LcdSend( 0x80 | ( LoWaterMark % LCD_X_RES ), LCD_CMD );
LcdSend( 0x40 | ( LoWaterMark / LCD_X_RES ), LCD_CMD );
// Обновляем необходимую часть буфера дисплея
for ( i = LoWaterMark; i <= HiWaterMark; i++ )
{
// Для оригинального дисплея не нужно следить за адресом в буфере,
// можно просто последовательно выводить данные
LcdSend( LcdCache[i], LCD_DATA );
}
// Сброс указателей границ в пустоту
LoWaterMark = LCD_CACHE_SIZE - 1;
HiWaterMark = 0;
// Сброс флага изменений кэша
UpdateLcd = FALSE;
}
/*
* Имя : LcdSend
* Описание : Отправляет данные в контроллер дисплея
* Аргумент(ы) : data -> данные для отправки
* cd -> команда или данные (смотри enum в n3310.h)
* Возвращаемое значение : Нет
*/
static void LcdSend ( byte data, LcdCmdData cd )
{
// Включаем контроллер дисплея (низкий уровень активный)
LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
byte i;
if (cd == LCD_DATA)
LCD_PORT |= _BV(LCD_DC_PIN);
else
LCD_PORT &= ~_BV(LCD_DC_PIN);
for (i = 0; i < 8; i++) {
if ((data >> (7 - i)) & 1) {
LCD_PORT |= _BV(LCD_DATA_PIN);
} else {
LCD_PORT &= ~_BV(LCD_DATA_PIN);
}
LCD_PORT |= _BV(LCD_CLK_PIN);
LCD_PORT &= ~_BV(LCD_CLK_PIN);
}
LCD_PORT |= _BV(LCD_DATA_PIN);
LCD_PORT |= _BV(LCD_DC_PIN);
// Отключаем контроллер дисплея
LCD_PORT |= _BV( LCD_CE_PIN );
}
/*
* Имя : LcdContrast
* Описание : Устанавливает контрастность дисплея
* Аргумент(ы) : контраст -> значение от 0x00 к 0x7F
* Возвращаемое значение : Нет
*/
void LcdContrast ( byte contrast )
{
LcdSend( 0x21, LCD_CMD ); // Расширенный набор команд
LcdSend( 0x80 | contrast, LCD_CMD ); // Установка уровня контрастности
LcdSend( 0x20, LCD_CMD ); // Стандартный набор команд, горизонтальная адресация
}
/*
* Имя : Delay
* Описание : Некалиброванная задержка для процедуры инициализации LCD
* Аргумент(ы) : Нет
* Возвращаемое значение : Нет
*/
static void Delay ( void )
{
int i;
for ( i = -32000; i < 32000; i++ );
}
/*
* Имя : LcdGotoXYFont
* Описание : Устанавливает курсор в позицию x,y относительно стандартного размера шрифта
* Аргумент(ы) : x,y -> координаты новой позиции курсора. Значения: 0,0 .. 13,5
* Возвращаемое значение : смотри возвращаемое значение в n3310.h
*/
byte LcdGotoXYFont ( byte x, byte y )
{
// Проверка границ
if( x > LCD_COLS || y > LCD_LINES ) return OUT_OF_BORDER;
// Вычисление указателя. Определен как адрес в пределах 504 байт
LcdCacheIdx = x * LCD_LINES + y * LCD_X_RES;
return OK;
}
/*
* Имя : LcdChr
* Описание : Выводит символ в текущей позиции курсора, затем инкрементирует положение курсора
* Аргумент(ы) : size -> размер шрифта. Смотри enum в n3310.h
* ch -> символ для вывода
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdChr ( LcdFontSize size, byte ch )
{
byte i, c;
byte b1, b2;
int tmpIdx;
if ( LcdCacheIdx < LoWaterMark )
{
// Обновляем нижнюю границу
LoWaterMark = LcdCacheIdx;
}
if ( (ch >= 0x20) && (ch <= 0x7F) )
{
// Смещение в таблице для символов ASCII[0x20-0x7F]
ch -= 32;
}
else if ( ch >= 0xC0 )
{
// Смещение в таблице для символов CP1251[0xC0-0xFF]
ch -= 96;
}
else
{
// Остальные игнорируем (их просто нет в таблице для экономии памяти)
ch = 95;
}
if ( size == FONT_1X )
{
for ( i = 0; i < 5; i++ )
{
// Копируем вид символа из таблицы в кэш
LcdCache[LcdCacheIdx++] = pgm_read_byte( &(FontLookup[ch][i]) ) << 1;
}
}
else if ( size == FONT_2X )
{
tmpIdx = LcdCacheIdx - LCD_X_RES;
if ( tmpIdx < LoWaterMark )
{
LoWaterMark = tmpIdx;
}
if ( tmpIdx < 0 ) return OUT_OF_BORDER;
for ( i = 0; i < 5; i++ )
{
// Копируем вид символа из таблицы у временную переменную
c = pgm_read_byte(&(FontLookup[ch][i])) << 1;
// Увеличиваем картинку
// Первую часть
b1 = (c & 0x01) * 3;
b1 |= (c & 0x02) * 6;
b1 |= (c & 0x04) * 12;
b1 |= (c & 0x08) * 24;
c >>= 4;
// Вторую часть
b2 = (c & 0x01) * 3;
b2 |= (c & 0x02) * 6;
b2 |= (c & 0x04) * 12;
b2 |= (c & 0x08) * 24;
// Копируем две части в кэш
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx++] = b1;
LcdCache[tmpIdx + LCD_X_RES - 2] = b2;
LcdCache[tmpIdx + LCD_X_RES - 1] = b2;
}
// Обновляем x координату курсора
LcdCacheIdx = (LcdCacheIdx + 11) % LCD_CACHE_SIZE;
}
if ( LcdCacheIdx > HiWaterMark )
{
// Обновляем верхнюю границу
HiWaterMark = LcdCacheIdx;
}
// Горизонтальный разрыв между символами
LcdCache[LcdCacheIdx] = 0x00;
// Если достигли позицию указателя LCD_CACHE_SIZE - 1, переходим в начало
if(LcdCacheIdx == (LCD_CACHE_SIZE - 1) )
{
LcdCacheIdx = 0;
return OK_WITH_WRAP;
}
// Иначе просто инкрементируем указатель
LcdCacheIdx++;
return OK;
}
/*
* Имя : LcdStr
* Описание : Эта функция предназначена для печати строки которая хранится в RAM
* Аргумент(ы) : size -> размер шрифта. Смотри enum в n3310.h
* dataArray -> массив содержащий строку которую нужно напечатать
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdStr ( LcdFontSize size, byte dataArray[] )
{
byte tmpIdx=0;
byte response;
while( dataArray[ tmpIdx ] != '\0' )
{
// Выводим символ
response = LcdChr( size, dataArray[ tmpIdx ] );
// Не стоит волноваться если произойдет OUT_OF_BORDER,
// строка будет печататься дальше из начала дисплея
if( response == OUT_OF_BORDER)
return OUT_OF_BORDER;
// Увеличиваем указатель
tmpIdx++;
}
return OK;
}
/*
* Имя : LcdFStr
* Описание : Эта функция предназначена для печати строки которая хранится в Flash ROM
* Аргумент(ы) : size -> размер шрифта. Смотри enum в n3310.h
* dataPtr -> указатель на строку которую нужно напечатать
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
* Пример : LcdFStr(FONT_1X, PSTR("Hello World"));
* LcdFStr(FONT_1X, &name_of_string_as_array);
*/
byte LcdFStr ( LcdFontSize size, const byte *dataPtr )
{
byte c;
byte response;
for ( c = pgm_read_byte( dataPtr ); c; ++dataPtr, c = pgm_read_byte( dataPtr ) )
{
// Выводим символ
response = LcdChr( size, c );
if(response == OUT_OF_BORDER)
return OUT_OF_BORDER;
}
return OK;
}
/*
* Имя : LcdPixel
* Описание : Отображает пиксель по абсолютным координатам (x,y)
* Аргумент(ы) : x,y -> абсолютные координаты пикселя
* mode -> Off, On или Xor. Смотри enum в n3310.h
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdPixel ( byte x, byte y, LcdPixelMode mode )
{
int index;
byte offset;
byte data;
// Защита от выхода за пределы
if ( x >= LCD_X_RES || y >= LCD_Y_RES) return OUT_OF_BORDER;
// Пересчет индекса и смещения
index = ( ( y / LCD_LINES ) * LCD_X_RES ) + x;
offset = y - ( ( y / 8) * LCD_LINES );
data = LcdCache[ index ];
// Обработка битов
// Режим PIXEL_OFF
if ( mode == PIXEL_OFF )
{
data &= ( ~( 0x01 << offset ) );
}
// Режим PIXEL_ON
else if ( mode == PIXEL_ON )
{
data |= ( 0x01 << offset );
}
// Режим PIXEL_XOR
else if ( mode == PIXEL_XOR )
{
data ^= ( 0x01 << offset );
}
// Окончательный результат копируем в кэш
LcdCache[ index ] = data;
if ( index < LoWaterMark )
{
// Обновляем нижнюю границу
LoWaterMark = index;
}
if ( index > HiWaterMark )
{
// Обновляем верхнюю границу
HiWaterMark = index;
}
return OK;
}
/*
* Имя : LcdLine
* Описание : Рисует линию между двумя точками на дисплее (алгоритм Брезенхэма)
* Аргумент(ы) : x1, y1 -> абсолютные координаты начала линии
* x2, y2 -> абсолютные координаты конца линии
* mode -> Off, On или Xor. Смотри enum в n3310.h
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdLine ( byte x1, byte y1, byte x2, byte y2, LcdPixelMode mode )
{
int dx, dy, stepx, stepy, fraction;
byte response;
// dy y2 - y1
// -- = -------
// dx x2 - x1
dy = y2 - y1;
dx = x2 - x1;
// dy отрицательное
if ( dy < 0 )
{
dy = -dy;
stepy = -1;
}
else
{
stepy = 1;
}
// dx отрицательное
if ( dx < 0 )
{
dx = -dx;
stepx = -1;
}
else
{
stepx = 1;
}
dx <<= 1;
dy <<= 1;
// Рисуем начальную точку
response = LcdPixel( x1, y1, mode );
if(response)
return response;
// Рисуем следующие точки до конца
if ( dx > dy )
{
fraction = dy - ( dx >> 1);
while ( x1 != x2 )
{
if ( fraction >= 0 )
{
y1 += stepy;
fraction -= dx;
}
x1 += stepx;
fraction += dy;
response = LcdPixel( x1, y1, mode );
if(response)
return response;
}
}
else
{
fraction = dx - ( dy >> 1);
while ( y1 != y2 )
{
if ( fraction >= 0 )
{
x1 += stepx;
fraction -= dy;
}
y1 += stepy;
fraction += dx;
response = LcdPixel( x1, y1, mode );
if(response)
return response;
}
}
// Установка флага изменений кэша
UpdateLcd = TRUE;
return OK;
}
/*
* Имя : LcdCircle
* Описание : Рисует окружность (алгоритм Брезенхэма)
* Аргумент(ы) : x, y -> абсолютные координаты центра
* radius -> радиус окружности
* mode -> Off, On или Xor. Смотри enum в n3310.h
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdCircle(byte x, byte y, byte radius, LcdPixelMode mode)
{
signed char xc = 0;
signed char yc = 0;
signed char p = 0;
if ( x >= LCD_X_RES || y >= LCD_Y_RES) return OUT_OF_BORDER;
yc = radius;
p = 3 - (radius<<1);
while (xc <= yc)
{
LcdPixel(x + xc, y + yc, mode);
LcdPixel(x + xc, y - yc, mode);
LcdPixel(x - xc, y + yc, mode);
LcdPixel(x - xc, y - yc, mode);
LcdPixel(x + yc, y + xc, mode);
LcdPixel(x + yc, y - xc, mode);
LcdPixel(x - yc, y + xc, mode);
LcdPixel(x - yc, y - xc, mode);
if (p < 0) p += (xc++ << 2) + 6;
else p += ((xc++ - yc--)<<2) + 10;
}
// Установка флага изменений кэша
UpdateLcd = TRUE;
return OK;
}
/*
* Имя : LcdSingleBar
* Описание : Рисует один закрашенный прямоугольник
* Аргумент(ы) : baseX -> абсолютная координата x (нижний левый угол)
* baseY -> абсолютная координата y (нижний левый угол)
* height -> высота (в пикселях)
* width -> ширина (в пикселях)
* mode -> Off, On или Xor. Смотри enum в n3310.h
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdSingleBar ( byte baseX, byte baseY, byte height, byte width, LcdPixelMode mode )
{
byte tmpIdxX,tmpIdxY,tmp;
byte response;
// Проверка границ
if ( ( baseX >= LCD_X_RES) || ( baseY >= LCD_Y_RES) ) return OUT_OF_BORDER;
if ( height > baseY )
tmp = 0;
else
tmp = baseY - height + 1;
// Рисование линий
for ( tmpIdxY = tmp; tmpIdxY <= baseY; tmpIdxY++ )
{
for ( tmpIdxX = baseX; tmpIdxX < (baseX + width); tmpIdxX++ )
{
response = LcdPixel( tmpIdxX, tmpIdxY, mode );
if(response)
return response;
}
}
// Установка флага изменений кэша
UpdateLcd = TRUE;
return OK;
}
/*
* Имя : LcdBars
* Описание : Рисует группу закрашенных прямоугольников (в режиме PIXEL_ON)
* Аргумент(ы) : data[] -> данные которые нужно отобразить
* numbBars -> количество прямоугольников
* width -> ширина (в пикселях)
* multiplier -> множитель для высоты
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
* Примечание : Пожалуйста проверьте значения EMPTY_SPACE_BARS, BAR_X, BAR_Y в n3310.h
* Пример : byte example[5] = {1, 2, 3, 4, 5};
* LcdBars(example, 5, 3, 2);
*/
byte LcdBars ( byte data[], byte numbBars, byte width, byte multiplier )
{
byte b;
byte tmpIdx = 0;
byte response;
for ( b = 0; b < numbBars ; b++ )
{
// Защита от выхода за пределы
if ( tmpIdx > LCD_X_RES - 1 ) return OUT_OF_BORDER;
// Расчет значения x
tmpIdx = ((width + EMPTY_SPACE_BARS) * b) + BAR_X;
// Рисуем один прямоугольник
response = LcdSingleBar( tmpIdx, BAR_Y, data[b] * multiplier, width, PIXEL_ON);
if(response == OUT_OF_BORDER)
return response;
}
// Установка флага изменений кэша
UpdateLcd = TRUE;
return OK;
}
/*
* Имя : LcdRect
* Описание : Рисует незакрашенный прямоугольник
* Аргумент(ы) : x1 -> абсолютная координата x левого верхнего угла
* y1 -> абсолютная координата y левого верхнего угла
* x2 -> абсолютная координата x правого нижнего угла
* y2 -> абсолютная координата y правого нижнего угла
* mode -> Off, On или Xor. Смотри enum в n3310.h
* Возвращаемое значение : смотри возвращаемое значение в n3310lcd.h
*/
byte LcdRect ( byte x1, byte y1, byte x2, byte y2, LcdPixelMode mode )
{
byte tmpIdx;
// Проверка границ
if ( ( x1 >= LCD_X_RES) || ( x2 >= LCD_X_RES) || ( y1 >= LCD_Y_RES) || ( y2 >= LCD_Y_RES) )
return OUT_OF_BORDER;
if ( ( x2 > x1 ) && ( y2 > y1 ) )
{
// Рисуем горизонтальные линии
for ( tmpIdx = x1; tmpIdx <= x2; tmpIdx++ )
{
LcdPixel( tmpIdx, y1, mode );
LcdPixel( tmpIdx, y2, mode );
}
// Рисуем вертикальные линии
for ( tmpIdx = y1; tmpIdx <= y2; tmpIdx++ )
{
LcdPixel( x1, tmpIdx, mode );
LcdPixel( x2, tmpIdx, mode );
}
// Установка флага изменений кэша
UpdateLcd = TRUE;
}
return OK;
}
/*
* Имя : LcdImage
* Описание : Рисует картинку из массива сохраненного в Flash ROM
* Аргумент(ы) : Указатель на массив картинки
* Возвращаемое значение : Нет
*/
void LcdImage ( const byte *imageData )
{
// // Инициализация указателя кэша
// LcdCacheIdx = 0;
// // В пределах кэша
// for ( LcdCacheIdx = 0; LcdCacheIdx < LCD_CACHE_SIZE; LcdCacheIdx++ )
// {
// // Копируем данные из массива в кэш
// LcdCache[LcdCacheIdx] = pgm_read_byte( imageData++ );
// }
// Оптимизация от Jakub Lasinski (March 14 2009)
memcpy_P( LcdCache, imageData, LCD_CACHE_SIZE ); // Тоже самое что и выше, но занимает меньше памяти и быстрее выполняется
// Сброс указателей границ в максимальное значение
LoWaterMark = 0;
HiWaterMark = LCD_CACHE_SIZE - 1;
// Установка флага изменений кэша
UpdateLcd = TRUE;
}
```
main.c:
```c
#include <util/delay.h>
#include "sc55.h"
int main() {
LcdInit();
LcdContrast(0x45);
while (1) {
LcdClear();
LcdRect(0, 0, LCD_X_RES - 2, LCD_Y_RES - 2, PIXEL_ON);
LcdLine(0, 0, LCD_X_RES - 2, LCD_Y_RES - 2, PIXEL_ON);
LcdLine(0, LCD_Y_RES - 2, LCD_X_RES - 2, 0, PIXEL_ON);
LcdUpdate();
_delay_ms(1000);
LcdClear();
LcdGotoXYFont(0, 2);
LcdStr(FONT_2X, "Привет,");
LcdGotoXYFont(0, 4);
LcdStr(FONT_2X, "мир!");
LcdUpdate();
_delay_ms(1000);
}
}
```
![|400](helloworld.jpg) ![|400](lines.jpg)
Reference in New Issue Copy Permalink