50 / 4 / 0
Регистрация: 02.04.2011
Сообщений: 60
1

LCD для ATmega 32

03.08.2012, 03:09. Показов 4318. Ответов 2
Метки нет (Все метки)

Здравствуйте, учусь программированию микроконтроллеров, и решил выполнить банальную задачу вывод на жк информации, наткнулся на англоязычный сайт(знаю Инглиш плохо, что объясняет - мало понимаю), где рассказывают о работе LCD и ATmega 32. Из за того что не обжился нужными деталями, решил делать в Proteus, залаил прошивку и кроме курсора посредине дисплея ни чего не выводится. Что я сделал не так?

Вот листинг си кода
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <avr/io.h>
#include <util/delay.h>
 
#define MrLCDsCrib PORTB
#define DataDir_MrLCDsCrib DDRB
#define MrLCDsControl PORTD
#define DataDir_MrLCDsControl DDRD
#define LightSwitch 5
#define ReadWrite 7
#define BiPolarMood 2
 
void Check_IF_MrLCD_isBusy(void);
void Peek_A_Boo(void);
void Send_A_Command(unsigned char command);
void Send_A_Character(unsigned char character);
 
int main(void)
{
    DataDir_MrLCDsControl |= 1<<LightSwitch | 1<<ReadWrite | 1<<BiPolarMood;
    _delay_ms(15);
 
    Send_A_Command(0x01); //Clear Screen 0x01 = 00000001
    _delay_ms(2);
    Send_A_Command(0x38);
    _delay_us(50);
    Send_A_Command(0b00001110);
    _delay_us(50);
 
    Send_A_Character(0x4E); //N
    Send_A_Character(0x65); //e
    Send_A_Character(0x77); //w
    Send_A_Character(0x62); //b
    Send_A_Character(0x69); //i
    Send_A_Character(0x65); //e
    Send_A_Character(0x48); //H
    Send_A_Character(0x61); //a
    Send_A_Character(0x63); //c
    Send_A_Character(0x6B); //k
    Send_A_Character(0x2E); //.
    Send_A_Character(0x63); //c
    Send_A_Character(0x6F); //o
    Send_A_Character(0x6D); //m
 
    
    while(1)
    {
        
    }
}
 
void Check_IF_MrLCD_isBusy()
{
    DataDir_MrLCDsCrib = 0;
    MrLCDsControl |= 1<<ReadWrite;
    MrLCDsControl &= ~1<<BiPolarMood;
 
    while (MrLCDsCrib >= 0x80)
    {
        Peek_A_Boo();
    }
    DataDir_MrLCDsCrib = 0xFF; //0xFF means 0b11111111
}
 
void Peek_A_Boo()
{
    MrLCDsControl |= 1<<LightSwitch;
    asm volatile ("nop");
    asm volatile ("nop");
    MrLCDsControl &= ~1<<LightSwitch;
}
 
void Send_A_Command(unsigned char command)
{
    Check_IF_MrLCD_isBusy();
    MrLCDsCrib = command;
    MrLCDsControl &= ~ ((1<<ReadWrite)|(1<<BiPolarMood));
    Peek_A_Boo();
    MrLCDsCrib = 0;
}
 
void Send_A_Character(unsigned char character)
{
    Check_IF_MrLCD_isBusy();
    MrLCDsCrib = character;
    MrLCDsControl &= ~ (1<<ReadWrite);
    MrLCDsControl |= 1<<BiPolarMood;
    Peek_A_Boo();
    MrLCDsCrib = 0;
}


Есть масса инфы по данной теме, но переварить сразу что то не получается, то что в листинге я понимаю(но самому такое написать, - надо тренироваться), вот залип малость с этим, подозрение на неправильную установку железа.

А вот что выводит в Proteus (Во вложении)
Миниатюры
LCD для ATmega 32  
__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
03.08.2012, 03:09
Ответы с готовыми решениями:

Подключение LCD дисплея на ATmega на ассемблере
Есть исходный код, и схема DTMF генератора. Нужно добавить lcd дисплей, который будет выводить...

Макетная плата для Atmega 32?atmega 8
Здравствуйте !Уважаемые мастера нужна помощь (а именно нужна схема макетной платы для меги 32 и...

LCD MODULE HY32D К ATMEGA
Здравствуйте вот приобрел на ebay такой модуль HY32D ...

STM32F4Discovery + LCD через fsmc для индентификации мк LCD
Нужна помощь, может кто поделиться готовым проектом,чтобы на STM32F4-Dyscovery используя...

2
50 / 4 / 0
Регистрация: 02.04.2011
Сообщений: 60
03.08.2012, 10:37  [ТС] 2
Извиняюсь, надо было раньше прикрепить эти файлы. Там сохраненный проект AtmelStudio и для Proteus схема
Вложения
Тип файла: zip LED atmega 32.zip (33.8 Кб, 196 просмотров)
0
50 / 4 / 0
Регистрация: 02.04.2011
Сообщений: 60
06.08.2012, 21:25  [ТС] 3
И снова, здрасти! Разобрался, но на другом железе, ATmega8 +LCD.
В общем сейчас выложил код, он рабочий в "собранном состоянии", но, когда мне захотелось "разбить" его на файлы (я думаю это необходимость в данном случае) - из-за ее размеров, я столкнулся с проблемой.
Почитав как организовать много файловую программу сделал так:

Главный файл

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/****Тестовая программа для LCD****/
//Основной файл(*)
 
#include "function_MC.h"
 
int main (void)
{
    DDRC |= (1 << PC2)|(1 << PC1)|(1 << PC0);           // PC0-3 выходы
    PORTC = 0x00;                               // лог. 0 на выходе
    DDRD = 0xFF;                                // PD0-7 выходы
    PORTB = 0x00;
    lcd_init();                                 // инициализация дисплея
    _delay_us(100);
    unsigned  char ar[] = "Всем привет, меня зовут HOTBED";  // выводим символы на экран
    lcd_string(ar);
}
Заголовочный файл

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef MY_STRUCT
#define MY_STRUCT
#include <avr/io.h>
#include <util/delay.h>
 
#define F_CPU 4000000UL // тактовая частота
#define RS PC0     //RS подключаем к PC0 микроконтроллера
#define EN PC2     //EN подключаем к PC2 микроконтроллера
 
void lcd_init(void);                        //инициализация дисплея
void lcd_com(unsigned char p);              //отправка команд в дисплей
void lcd_dat(unsigned char p);              //отправка данных в дисплей 
void lcd_string(unsigned char ar[]);        //передача массива(строки), обработка функцией decoder (*)
unsigned char decoder(unsigned char code);  //(*)сопоставление кода буквы,  букве кода из таблицы кириллицы
 
#endif
Файл с функциями

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
#include "function_MC.h"
 
/***Функция записи команды в LCD***/
void lcd_com(unsigned char p) //'p' байт команды
{
    PORTC &= ~(1 << RS);   // RS = 0
    PORTC |= (1 << EN);    // EN = 1 (начало записи команды в LCD)
    PORTD = p;             // вывод команды на шину DB0-7 LCD
    _delay_us(100);        // длительность сигнала EN
    PORTC &= ~(1 << EN);   // EN = 0 (конец записи команды в LCD)
    _delay_us(100);        // пауза для выполнения команды
}
 
 
 
/***Функция записи данных в LCD***/
void lcd_dat(unsigned char p)  //'p' байт команды
{
    PORTC |= (1 << RS)|(1 << EN);  //RS = 1, EN = 1 (начало записи команды в LCD)
    PORTD = p;                     //вывод команды на шину DB0-7 LCD
    _delay_us(100);                // длительность сигнала EN
    PORTC &= ~(1 << EN);           // EN = 0 (конец записи команды в LCD)
    _delay_us(100);                // пауза для выполнения команды
}
 
 
/***Функция инициализации LCD***/
void lcd_init(void)
{
    lcd_com(0x08);          // полное выключение дисплея
    lcd_com(0x38);           // 8 бит 2 строки
    _delay_us(100);
    lcd_com(0x38);           // 8 бит 2 строки
    _delay_us(100);
    lcd_com(0x38);           // 8 бит 2 строки
    lcd_com(0x38);
    lcd_com(0x01);           // очистка дисплея
    _delay_us(100);
    lcd_com(0x06);           // сдвиг курсора вправо
    lcd_com(0x0D);           // включение дисплея, мигающий курсор
}
 
 
 
/*Функция вывода строки на дисплей*/
void lcd_string(unsigned char ar[])
{
    int i = 0;                  // для интераций
    int counter = 0;            // для счетчика символов выведенный на дисплей
    unsigned char val;
    while(ar[i]!='\0')
    {
        if ( ar[i] > 0x7F)
        {
            val = (unsigned char)decoder(ar[i]);
                        
            if (val == 0x1F)    //если интерация привела к некорректной команде(default в switch),
            {
                i++;
                continue;       //то переходим к следующей
            }
            
            lcd_dat(val);
            counter++;
            i++;
            
        } else {                        
                lcd_dat(ar[i]); //вывод на дисплей символа
                counter++;
                i++;
                }
        
        if((counter>16)){       // перед выводом 17 символа 1символ
            lcd_com(0x07);      // затирается (получается эффект бегущей строки).
            _delay_us(30000);   
            continue;
            i++;            
        }       
    }   
    _delay_us(2000);
}
 
 
/*Функция для русификации*/
 
char decoder(unsigned char code){
    switch(code){       
        /*---------АЛФАВИТ----------*/       
        case 'А':
        return 0x41;                // А
        break;                    ///
        /************************///
        
        case 'а':
        return 0x61;                // а
        break;                    ///
        /************************///
        
        
        case 'Б':
        return 0xA0;                // Б
        break;                    ///
        /************************///
        
        case 'б':
        return 0xB2;                // б
        break;                    ///
        /************************///
        
        case 'В':
        return 0x42;                // В
        break;                    ///
        /************************///
        
        case 'в':
        return 0xB3;                // в
        break;                    ///
        /************************///
        
        case 'Г':
        return 0xA1;                // Г
        break;                    ///
        /************************///
        
        case 'г':
        return 0xB4;                // г
        break;                    ///
        /************************///
        
        case 'Д':
        return 0xE0;                // Д
        break;                    ///
        /************************///
        
        case 'д':
        return 0xE3;                // д
        break;                    ///
        /************************///
        
        case 'Е':
        return 0x45;                // Е
        break;                    ///
        /************************///
        
        case 'е':
        return 0x65;                // е
        break;                    ///
        /************************///
        
        case 'Ё':
        return 0xA2;                // Ё
        break;                    ///
        /************************///
        
        case 'ё':
        return 0xB5;                // Ё
        break;                    ///
        /************************///
        
        case 'Ж':
        return 0xA3;                // Ж
        break;                    ///
        /************************///
        
        case 'ж':
        return 0xB6;                // ж
        break;                    ///
        /************************///
        
        case 'З':
        return 0xA4;                // З
        break;                    ///
        /************************///
        
        case 'з':
        return 0xB7;                // з
        break;                    ///
        /************************///
        
        case 'И':
        return 0xA5;                // И
        break;                    ///
        /************************///
        
        case 'и':
        return 0xB8;                // и
        break;                    ///
        /************************///
        
        case 'Й':
        return 0xA6;                // Й
        break;                    ///
        /************************///
        
        case 'й':
        return 0xB9;                // й
        break;                    ///
        /************************///
        
        case 'К':
        return 0x4B;                // К
        break;                    ///
        /************************///
        
        case 'к':
        return 0xBA;                // к
        break;                    ///
        /************************///
        
        case 'Л':
        return 0xA7;                // Л
        break;                    ///
        /************************///
        
        case 'л':
        return 0xBB;                // л
        break;                    ///
        /************************///
        
        case 'М':
        return 0x4D;                // М
        break;                    ///
        /************************///
        
        case 'м':
        return 0xBC;                // м
        break;                    ///
        /************************///
        
        case 'Н':
        return 0x48;                // Н
        break;                    ///
        /************************///
        
        case 'н':
        return 0xBD;                // н
        break;                    ///
        /************************///
        
        case 'О':
        return 0x4F;                // О
        break;                    ///
        /************************///
        
        case 'о':
        return 0x6F;                // о
        break;                    ///
        /************************///
        
        case 'П':
        return 0xA8;                // П
        break;                    ///
        /************************///
        
        case 'п':
        return 0xBE;                // п
        break;                    ///
        /************************///
        
        case 'Р':
        return 0x50;                // Р
        break;                    ///
        /************************///
        
        case 'р':
        return 0x70;                // Р
        break;                    ///
        /************************///        
        
        case 'С':
        return 0x43;                // С
        break;                    ///
        /************************///
        
        case 'с':
        return 0x63;                // с
        break;                    ///
        /************************///
        
        
        case 'Т':
        return 0x54;                // Т
        break;                    ///
        /************************///
        
        case 'т':
        return 0xBF;                // т
        break;                    ///
        /************************///
        
        case 'У':
        return 0xA9;                // У
        break;                    ///
        /************************///
        
        case 'у':
        return 0x79;                // у
        break;                    ///
        /************************///
        
        case 'Ф':
        return 0xAA;                 // Ф
        break;                     ///
        /*************************///
        
        case 'ф':
        return 0xE4;                 // ф
        break;                     ///
        /*************************///
        
        
        case 'Х':
        return 0x58;                // Х
        break;                    ///
        /************************///
        
        case 'х':
        return 0x78;                // х
        break;                    ///
        /************************///
        
        case 'Ц':
        return 0xE1;                // Ц
        break;                    ///
        /************************///
                
        case 'ц':
        return 0xE5;                // ц
        break;                    ///
        /************************///
        
        case 'Ч':
        return 0xAB;                // Ч
        break;                    ///
        /************************///
        
        case 'ч':
        return 0xC0;                // ч
        break;                    ///
        /************************///
        
        case 'Ш':
        return 0xAC;                // Ш
        break;                    ///
        /************************///
        
        case 'ш':
        return 0xC1;                // ш
        break;                    ///
        /************************///
        
        case 'Щ':
        return 0xE2;                // Щ
        break;                    ///
        /************************///
        
        case 'щ':
        return 0xE6;                // щ
        break;                    ///
        /************************///
        
        case 'Ъ':
        return 0xAD;                // Ъ
        break;                    ///
        /************************///
        
        case 'ъ':
        return 0xC2;                // ъ
        break;                    ///
        /************************///
        
        case 'Ы':
        return 0xAE;                // Ы
        break;                    ///
        /************************///
        
        case 'ы':
        return 0xC3;                // ы
        break;                    ///
        /************************///
        
        case 'Ь':
        return 0x62;                // Ь
        break;                    ///
        /************************///
        
        case 'ь':
        return 0xC4;                // ь
        break;                    ///
        /************************///
        
        case 'Э':
        return 0xAF;                // Э
        break;                    ///
        /************************///
        
        case 'э':
        return 0xC5;                // э
        break;                    ///
        /************************///
        
        case 'Ю':
        return 0xB0;                // Ю
        break;                    ///
        /************************///
        
        case 'ю':
        return 0xC6;                // ю
        break;                    ///
        /************************///
        
        case 'Я':
        return 0xB1;                // Я
        break;                    ///
        /************************///
        
        case 'я':
        return 0xC7;                // я
        break;                    ///
        /************************///
        
        /*----END___АЛФАВИТ-----*/
        
        /*---------Симвлолы----------*/
        
        case '°':
        return 0xEF;                // градус 
        break;                    ///
        
        
        /*---------END_Симвлолы----------*/
        
        default:
        return 0x1F;                // Команда для continue
        break;
    }   
}
Компилятор не видит функцию lcd_string() и lcd_init, говорит, что ссылка не определена - "undefined reference to `lcd_string'".

В си, я новичок, так что не судите строго за качество и сам код, но вот почему не работает то, пробовал тупо подключать в главном файле файл с функциями(конструкцией #include (файл с функциями)) - все работало, но, почитав понял что так делать нельзя.

Вопрос №2

Почему когда я в функции lcd_string() делаю "Сдвиг" строки в лево , то дисплей выводит только 29 символов (у меня есть подозрение, что я забил память этими символами, а на остальные памяти не хватило), как лучше сделать то?

Выкладываю файлы Там в папке с проектом главный файл GccApplication(х)., рабочий вариант кода с рабочей прошивкой и схемой в proteus
Вложения
Тип файла: zip GccApplication1.zip (63.8 Кб, 53 просмотров)
1
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
06.08.2012, 21:25
Помогаю со студенческими работами здесь

Написать программу для PIC16F877 для работы с LCD дисплеем LM016L
День добрый, форумчане. Только начинаю разбираться с пиками и асмом. Столкнулся с...

Библиотека для LCD 16x2(HD44780) для STM32F4xx
Здравствуйте! Помогите найти рабочую библиотеку для подключения индикатора 16х2(на HD44780) к...

ATmega для Arduino
Здравствуйте! Сделал себе на днях Arduino. Когда дело дошло до контроллера я обзвонил все...

rsa для atmega
Люди, помогите написать реализацию RSA 128 bit для atmega. Необходимо шифрование и генерация...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
3
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2023, CyberForum.ru