Arduino.ru

Для начала скажите как пример для трех светодиодов, причем когда то написанный мной же (или это у меня какой-то глюк) попал в ваш LCD_A70_101x64.c ? )))

К сожалению в Atmega8 просто скомпилить и залить не удастся, потому как у него отсутствует некоторая переферия в отличии от Atmega88/168/328. Поэтому в вашем случае без редактирования можно залить только в Atmega328.

Сделайте так: откройте Arduino IDE, копируете в один скейтч сначала содержимое LCD_A70_101x64.c затем содержимое main.c (естественно убрав оттуда мои труды), далее нажимаете кнопку сохранить, сохраняете, закрываете IDE. После находите папку куда сохранили скейтч (она называется так же как и скейтч) и кладете в нее файлы Font_A70.h и LCD_A70_101x64.h. Запускаете Arduino IDE, открываете этот скейтч и у вас должны появиться вкладки с названиями Font_A70.h и LCD_A70_101x64.h, компилируете.

Только-что посмотрел! Действительно есть такой баг! Наверное он получился из-за нажатия "Control V",  вместо "Control C", когда в буфере обмена был код предыдущей проги!

Для просмотра файлов и примеров кода я копирую их в Notepad++, в котором можно открывать сколько угодно вкладок и окон! Главное только не запутаться, что и куда копировать :)

Вот правильный код исходного LCD_A70_101x64.c 

//----------------------------------------------------------------------------------------
// Displayroutinen fьr LCD Siemens A70 (3.3Volt / Controller: ?PCF8812 o.д.)
//----------------------------------------------------------------------------------------
#include "LCD_A70_101x64.h"
//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
//  Pinbelegung: LCD A60 101x64 Pixel (auf Rьckseite geschaut)
//
//
//  -----------------------------------
// |                                   |
// |             O O O O O O O O O O   |
// |             | | | | | | | | | |   |
// |             | | | | | | | | | |   |
// |             L L L G V D C D R C   |
// |             e e e n c a l / e s   |
// |             d d d d c t k C s     |
// |             1   2           e     |
// |             + - +           t     |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// | Displayrьckseite                  |
//  -----------------------------------
//
//
//----------------------------------------------------------------------------------------
//                                                               PortPin am µC        

#define Data_HI PORTD |=  (1<<PORTD5);        // Data=1;           PD5
#define Data_LO PORTD &= ~(1<<PORTD5);        // Data=0;

#define Clock_HI PORTD |=  (1<<PORTD4);       // Clock=1;          PD4
#define Clock_LO PORTD &= ~(1<<PORTD4);       // Clock=0;

#define Control_HI PORTD |=  (1<<PORTD2);     // Control=1; D/C    PD2
#define Control_LO PORTD &= ~(1<<PORTD2);     // Control=0;

#define Reset_HI PORTB |=  (1<<PORTB0);       // Reset=1;          PB0
#define Reset_LO PORTB &= ~(1<<PORTB0);       // Reset=0;  

#define ChipSelect_HI PORTD |=  (1<<PORTD6);  // ChipSelect=1;     PD6
#define ChipSelect_LO PORTD &= ~(1<<PORTD6);  // ChipSelect=0;

//----------------------------------------------------------------------------------------



//----------------------------------------------------------------------------------------
// init LCD incl. Reset
//----------------------------------------------------------------------------------------
void Init_LCD(void)
{
  Reset_LCD();

  SendCommand(0x21);  // Function set: extended instruction set
  SendCommand(0x14);  // Bias System
  SendCommand(0x0A);  // HV-gen stages
  SendCommand(0x05);  // Temperature Control
  SendCommand(0xCC);  // Contrast: 204
  SendCommand(0x20);  // Function set: standard instruction set
  SendCommand(0x11);  // VLCD programming range: high
  SendCommand(0x0C);  // Display control: normal (inverted = 0x0D)
}   


//----------------------------------------------------------------------------------------
// reset LCD
//----------------------------------------------------------------------------------------
void Reset_LCD(void)
{
  _delay_us(10);
  Data_LO;
  Clock_LO;
  Control_LO;
  _delay_us(10);
  Reset_HI;
  _delay_us(10);
  ChipSelect_LO;
  _delay_us(10);
  Reset_LO;
  _delay_us(10);  
  Reset_HI;
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
// Funktion stellt ein Zeichen dar 8x8  Zeile 1..8 Spalte 1..12
// column 00..16 Spalten 17 X
// row     0...9 Zeilen  10 Y Reihe
//----------------------------------------------------------------------------------------
void PaintCharC64(BYTE sign, BYTE zeile, BYTE spalte) 
{
BYTE y,tmp;
int pos;

  if ((zeile<9) && (spalte<13)) {
    GotoLineRow(zeile-1, 100-spalte*8);
    if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
    pos = 8*(sign-0x20);
    for (y=0; y<8; y++) 
    {  
      tmp = pgm_read_byte(&code8x8[pos++]);
      WriteDisplay(tmp);
    }
  }
}


//----------------------------------------------------------------------------------------
void PaintChar8x12(BYTE sign, BYTE column, BYTE row) 
{
BYTE CharCol_1, CharCol_2, CharCol_3, CharCol_4, CharCol_5;
BYTE CharCol_6, CharCol_7, CharCol_8, CharCol_9, CharCol_10, CharCol_11, CharCol_12;
BYTE char_r_y_p12, char_r_y_p34, char_r_y_p56, char_r_y_p78, char_r_y_p910, char_r_y_p1112;
BYTE pz, y;
unsigned int pos;
BYTE tmp;

  GotoLineRow(row, 101-column);
  
  if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
  pos = 12*(sign-0x20);

  CharCol_1 = pgm_read_byte(&code8x12[pos++]);
  CharCol_2 = pgm_read_byte(&code8x12[pos++]);
  CharCol_3 = pgm_read_byte(&code8x12[pos++]);
  CharCol_4 = pgm_read_byte(&code8x12[pos++]);
  CharCol_5 = pgm_read_byte(&code8x12[pos++]);

  CharCol_6 = pgm_read_byte(&code8x12[pos++]);
  CharCol_7 = pgm_read_byte(&code8x12[pos++]);
  CharCol_8 = pgm_read_byte(&code8x12[pos++]);
  CharCol_9 = pgm_read_byte(&code8x12[pos++]);
  CharCol_10 = pgm_read_byte(&code8x12[pos++]);
  CharCol_11 = pgm_read_byte(&code8x12[pos++]);
  CharCol_12 = pgm_read_byte(&code8x12[pos++]);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_1 & pz)  { tmp |= 0x80; }
    if (CharCol_2 & pz)  { tmp |= 0x40; }
    if (CharCol_3 & pz)  { tmp |= 0x20; }
    if (CharCol_4 & pz)  { tmp |= 0x10; }
    if (CharCol_5 & pz)  { tmp |= 0x08; }    
    if (CharCol_6 & pz)  { tmp |= 0x04; }
    if (CharCol_7 & pz) { tmp |= 0x02; }
    if (CharCol_8 & pz) { tmp |= 0x01; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }

  GotoLineRow(row+1, 101-column);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_9 & pz)  { tmp |= 0x80; }
    if (CharCol_10 & pz)  { tmp |= 0x40; }
    if (CharCol_11 & pz)  { tmp |= 0x20; }
    if (CharCol_12 & pz)  { tmp |= 0x10; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }
}


//----------------------------------------------------------------------------------------
// send a string
//
// xPos: 0..16 (17 Spalten a 6 Pixel breit)
// yPos: 0.. 9 (10 Zeilen a 8 Pixel breit)
// Str:  max 17 Zeichen 
//----------------------------------------------------------------------------------------
void WriteString(BYTE xPos, BYTE yPos, char *Str) 
{
BYTE c,st,s;

  st = 0;
  s = *Str;
  while ((*Str!=0) && (xPos<100) && (st<17)) 
  { 
    c = *Str;
    PaintCharC64(c,xPos,yPos);
    yPos++;
    Str++;
    st++;
  }
}


//----------------------------------------------------------------------------------------
// paint a picture
//----------------------------------------------------------------------------------------
void PaintPic(const volatile uint8_t *Ptr, BYTE line, BYTE row)
{
BYTE tmp,tm;
WORD i;
BYTE hoehe,breite;

  hoehe = pgm_read_byte(&Ptr[1]);
  breite = pgm_read_byte(&Ptr[2]);
  GotoLineRow(line,8);
  for (i=0; i<(hoehe*breite/8); i++) 
  {
    if ((i%breite==0) && (i>=breite)) 
    {
      line++;
      GotoLineRow(line,8);
    }
    tmp = pgm_read_byte(&Ptr[i+3]);
    tm=0;
    if (tmp & 0x80) tm |= 0x01;
    if (tmp & 0x40) tm |= 0x02;
    if (tmp & 0x20) tm |= 0x04;
    if (tmp & 0x10) tm |= 0x08;
    if (tmp & 0x08) tm |= 0x10;
    if (tmp & 0x04) tm |= 0x20;
    if (tmp & 0x02) tm |= 0x40;
    if (tmp & 0x01) tm |= 0x80;
    WriteDisplay(tm);
  }
}


//----------------------------------------------------------------------------------------
// lцscht gesamtes Grafikdisplay
//----------------------------------------------------------------------------------------
void ClearDisplay(void)
{
  GotoLineRow(0,0);
  for (WORD i=0; i<((101*64)/8+8); i++) // eigentlich 101*64/8 aber Display-SOC 
  {                                     // unterstьtzt 0..101, also 102 Spalten pro Zeile 
    WriteDisplay(0x00);                 // es sind aber nur 101 Spalten vorhanden!
  }
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void GotoLineRow(BYTE Line, BYTE Row) // Line: 0..7, Row 0..101;
{   
  SendCommand( 0b00101000);
  SendCommand((0b01000000 + Line));
  SendCommand((0b10000000 + Row ));
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void SendCommand(BYTE Command)
{
BYTE i,s;

  s=0x80;

  Data_LO;
  Clock_LO;
  Control_LO;
  ChipSelect_LO;
  for (i=0; i<8; i++) 
  {
    if (Command & s) { Data_HI; } 
    else             { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
// command or data to display
//----------------------------------------------------------------------------------------
void WriteDisplay(BYTE Value)
{          
  BYTE i,s;

  s=0x80;
  Data_LO;
  Clock_LO;
  Control_HI;
  ChipSelect_LO;

  for (i=0; i<8; i++) 
  {
    if (Value & s) { Data_HI; } 
    else           { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------

Большое спасибо за то, что объяснили как использовать файлы библиотеки! Остался только вопрос, к каким контактам Arduino, подключать контакты дисплея! Возможно они заданы этим фрагментом кода в файле LCD_A70_101x64.c  Или  я ошибаюсь???

//----------------------------------------------------------------------------------------
//  Pinbelegung: LCD A60 101x64 Pixel (auf Rьckseite geschaut)
//
//
//  -----------------------------------
// |                                   |
// |             O O O O O O O O O O   |
// |             | | | | | | | | | |   |
// |             | | | | | | | | | |   |
// |             L L L G V D C D R C   |
// |             e e e n c a l / e s   |
// |             d d d d c t k C s     |
// |             1   2           e     |
// |             + - +           t     |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// | Displayrьckseite                  |
//  -----------------------------------
//
//
//----------------------------------------------------------------------------------------
//                                                               PortPin am µC        

#define Data_HI PORTD |=  (1<<PORTD5);        // Data=1;           PD5
#define Data_LO PORTD &= ~(1<<PORTD5);        // Data=0;

#define Clock_HI PORTD |=  (1<<PORTD4);       // Clock=1;          PD4
#define Clock_LO PORTD &= ~(1<<PORTD4);       // Clock=0;

#define Control_HI PORTD |=  (1<<PORTD2);     // Control=1; D/C    PD2
#define Control_LO PORTD &= ~(1<<PORTD2);     // Control=0;

#define Reset_HI PORTB |=  (1<<PORTB0);       // Reset=1;          PB0
#define Reset_LO PORTB &= ~(1<<PORTB0);       // Reset=0;  

#define ChipSelect_HI PORTD |=  (1<<PORTD6);  // ChipSelect=1;     PD6
#define ChipSelect_LO PORTD &= ~(1<<PORTD6);  // ChipSelect=0;

//----------------------------------------------------------------------------------------

На самом деле это не библиотека, если не ошибаюсь это проэкт AtmelStudio просто он состоит из нескольких исполнительных и заголовочных файлов. Все верно, подключать надо к PD5, PD4, PD2, PB0, PD6. PIN Mapping

И еще столкнулся с такой проблемой, не у всех Arduino IDE подключает стандартные хэдэры (заголовочные файлы), как это лечится не знаю, но если компилятор начнет ругаться на  PD5, PD4, PD2, PB0, PD6 или PORTD5, PORTD4 и т.д. то можно заменить например PD5 на 5, PD2 на 2, PORTD4 на 4 и т.д. 

Наверняка этот код писался не в Arduino IDE и не для Arduino, поскольку эта среда не понимает его! Попробовал только-что скомпилировать, вылазит вот такое сообщение!

Подскажите пожалуйста, что здесь "говорит" компилятор!

Только-что попробовал добавить все эти файлы в новый проект  AvrStudio!

Всё откомпилировалось без проблем! Но можно ли как-то "залить" получившийся на выходе  "  .hex"  файл в Arduino???

Если я вытяну мелкосхему и загружу в неё прошивку программатором, то "слетит" бутлоадер????

Подскажите пожалуйста, что можно сделать???

Перечитайте еще раз внимательно сообщение #2, сделайте все пошагово и все скомпилируется. У вас не компилируется из-за того что LCD_A70_101x64.c и main.c находятся в разных файлах!

Да, действительно ! Вся прога скомпилировалась нормально!  Большое спасибо за совет!

Как  подключить к одному контроллеру 3 дисплея А70?  Выводить буду только циверки, оринтеровочно Atmega168 или Atmega8 если вытянет.

Параллелите все выводы дисплеев кроме ChipSelect эти выводы от каждого дисплея к своему выводу дуины, и когда хотите что-то вывести на тот или иной дислей выбираете его опуская к земле соответсятвующий ChipSelect.

всё понял, благодарю

При компелировании выдаёт 2 ошибки:

....\hardware\arduino\cores\arduino/main.cpp:11: undefined reference to `setup'

....\hardware\arduino\cores\arduino/main.cpp:14: undefined reference to `loop'

Что ему тут не нравится?

#include <Arduino.h>

int main(void)
{
	init();

#if defined(USBCON)
	USBDevice.attach();
#endif
	
	setup();
    
	for (;;) {
		loop();
		if (serialEventRun) serialEventRun();
	}
        
	return 0;
}

а должно что делать? ему явно не нравится ВСЕ! отформатируйте и сами все увидите.

#include <Arduino.h>

int main(void)
{
  init();

#if defined(USBCON)
  USBDevice.attach();
#endif

  //setup();

  for (;;) {
    //loop();
    if (serialEventRun) serialEventRun();
  }

  return 0;
}

Благодарю. Так и оставлять или после работы с дисплеем вернуть как было?

Незнаю. А зачем вы вообще используете эту конструкцию?

Это файл ....\hardware\arduino\cores\arduino/main.cpp который не нравится IDE при компелировании

Но дело в том, что если я убираю  setup(); и loop(); , МК отказывается работать. Пишет загрузка выполнена, но даже диод не светится...

Пошу прощения, был невнимателен, не помеслил main в скетч. Теперь куча ошибок:

LCD_A70_101x64.ino: In function 'void Timer1_init()':
LCD_A70_101x64:519: error: 'TIMSK1' was not declared in this scope
и так далее. Все файлы расположены как разъясняется выше.

Помочь можно?

Если компилится и работает, то просто забей на эти ошибки.

))) обычно так и делаю если работает. Не тот случай. Даже не компелирует

Ну, так глючный код публикуй, а не ошибки.

Код тот, который вначале темы( уже без диодов) публикуют. не менял пока ничего. Задача пока что то "зажечь".

жалуется на Atmega 8, на 168 , 328 компелирует. Но у вас как то ж на Atm8 работает

А при таком коде вобще что то должно выводится?

//----------------------------------------------------------------------------------------
// Displayroutinen fьr LCD Siemens A70 (3.3Volt / Controller: ?PCF8812 o.д.)
//----------------------------------------------------------------------------------------
#include "LCD_A70_101x64.h"
//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
//  Pinbelegung: LCD A60 101x64 Pixel (auf Rьckseite geschaut)
//
//
//  -----------------------------------
// |                                   |
// |             O O O O O O O O O O   |
// |             | | | | | | | | | |   |
// |             | | | | | | | | | |   |
// |             L L L G V D C D R C   |
// |             e e e n c a l / e s   |
// |             d d d d c t k C s     |
// |             1   2           e     |
// |             + - +           t     |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// |                                   |
// | Displayrьckseite                  |
//  -----------------------------------
//
//
//----------------------------------------------------------------------------------------
//                                                               PortPin am µC        

#define Data_HI PORTC |=  (1<<PORTC0);        // Data=1;           PD5
#define Data_LO PORTC &= ~(1<<PORTC0);        // Data=0;

#define Clock_HI PORTC |=  (1<<PORTC1);       // Clock=1;          PD4
#define Clock_LO PORTC &= ~(1<<PORTC1);       // Clock=0;

#define Control_HI PORTC |=  (1<<PORTC2);     // Control=1; D/C    PD2
#define Control_LO PORTC &= ~(1<<PORTC2);     // Control=0;

#define Reset_HI PORTC |=  (1<<PORTC3);       // Reset=1;          PB0
#define Reset_LO PORTC &= ~(1<<PORTC3);       // Reset=0;  

#define ChipSelect_HI PORTC |=  (1<<PORTC4);  // ChipSelect=1;     PD6
#define ChipSelect_LO PORTC &= ~(1<<PORTC4);  // ChipSelect=0;

//----------------------------------------------------------------------------------------



//----------------------------------------------------------------------------------------
// init LCD incl. Reset
//----------------------------------------------------------------------------------------
void Init_LCD(void)
{
  Reset_LCD();

  SendCommand(0x21);  // Function set: extended instruction set
  SendCommand(0x14);  // Bias System
  SendCommand(0x0A);  // HV-gen stages
  SendCommand(0x05);  // Temperature Control
  SendCommand(0xCC);  // Contrast: 204
  SendCommand(0x20);  // Function set: standard instruction set
  SendCommand(0x11);  // VLCD programming range: high
  SendCommand(0x0C);  // Display control: normal (inverted = 0x0D)
}   


//----------------------------------------------------------------------------------------
// reset LCD
//----------------------------------------------------------------------------------------
void Reset_LCD(void)
{
  _delay_us(10);
  Data_LO;
  Clock_LO;
  Control_LO;
  _delay_us(10);
  Reset_HI;
  _delay_us(10);
  ChipSelect_LO;
  _delay_us(10);
  Reset_LO;
  _delay_us(10);  
  Reset_HI;
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
// Funktion stellt ein Zeichen dar 8x8  Zeile 1..8 Spalte 1..12
// column 00..16 Spalten 17 X
// row     0...9 Zeilen  10 Y Reihe
//----------------------------------------------------------------------------------------
void PaintCharC64(BYTE sign, BYTE zeile, BYTE spalte) 
{
BYTE y,tmp;
int pos;

  if ((zeile<9) && (spalte<13)) {
    GotoLineRow(zeile-1, 100-spalte*8);
    if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
    pos = 8*(sign-0x20);
    for (y=0; y<8; y++) 
    {  
      tmp = pgm_read_byte(&code8x8[pos++]);
      WriteDisplay(tmp);
    }
  }
}


//----------------------------------------------------------------------------------------
void PaintChar8x12(BYTE sign, BYTE column, BYTE row) 
{
BYTE CharCol_1, CharCol_2, CharCol_3, CharCol_4, CharCol_5;
BYTE CharCol_6, CharCol_7, CharCol_8, CharCol_9, CharCol_10, CharCol_11, CharCol_12;
BYTE char_r_y_p12, char_r_y_p34, char_r_y_p56, char_r_y_p78, char_r_y_p910, char_r_y_p1112;
BYTE pz, y;
unsigned int pos;
BYTE tmp;

  GotoLineRow(row, 101-column);
  
  if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
  pos = 12*(sign-0x20);

  CharCol_1 = pgm_read_byte(&code8x12[pos++]);
  CharCol_2 = pgm_read_byte(&code8x12[pos++]);
  CharCol_3 = pgm_read_byte(&code8x12[pos++]);
  CharCol_4 = pgm_read_byte(&code8x12[pos++]);
  CharCol_5 = pgm_read_byte(&code8x12[pos++]);

  CharCol_6 = pgm_read_byte(&code8x12[pos++]);
  CharCol_7 = pgm_read_byte(&code8x12[pos++]);
  CharCol_8 = pgm_read_byte(&code8x12[pos++]);
  CharCol_9 = pgm_read_byte(&code8x12[pos++]);
  CharCol_10 = pgm_read_byte(&code8x12[pos++]);
  CharCol_11 = pgm_read_byte(&code8x12[pos++]);
  CharCol_12 = pgm_read_byte(&code8x12[pos++]);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_1 & pz)  { tmp |= 0x80; }
    if (CharCol_2 & pz)  { tmp |= 0x40; }
    if (CharCol_3 & pz)  { tmp |= 0x20; }
    if (CharCol_4 & pz)  { tmp |= 0x10; }
    if (CharCol_5 & pz)  { tmp |= 0x08; }    
    if (CharCol_6 & pz)  { tmp |= 0x04; }
    if (CharCol_7 & pz) { tmp |= 0x02; }
    if (CharCol_8 & pz) { tmp |= 0x01; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }

  GotoLineRow(row+1, 101-column);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_9 & pz)  { tmp |= 0x80; }
    if (CharCol_10 & pz)  { tmp |= 0x40; }
    if (CharCol_11 & pz)  { tmp |= 0x20; }
    if (CharCol_12 & pz)  { tmp |= 0x10; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }
}


//----------------------------------------------------------------------------------------
// send a string
//
// xPos: 0..16 (17 Spalten a 6 Pixel breit)
// yPos: 0.. 9 (10 Zeilen a 8 Pixel breit)
// Str:  max 17 Zeichen 
//----------------------------------------------------------------------------------------
void WriteString(BYTE xPos, BYTE yPos, char *Str) 
{
BYTE c,st,s;

  st = 0;
  s = *Str;
  while ((*Str!=0) && (xPos<100) && (st<17)) 
  { 
    c = *Str;
    PaintCharC64(c,xPos,yPos);
    yPos++;
    Str++;
    st++;
  }
}


//----------------------------------------------------------------------------------------
// paint a picture
//----------------------------------------------------------------------------------------
void PaintPic(const volatile uint8_t *Ptr, BYTE line, BYTE row)
{
BYTE tmp,tm;
WORD i;
BYTE hoehe,breite;

  hoehe = pgm_read_byte(&Ptr[1]);
  breite = pgm_read_byte(&Ptr[2]);
  GotoLineRow(line,8);
  for (i=0; i<(hoehe*breite/8); i++) 
  {
    if ((i%breite==0) && (i>=breite)) 
    {
      line++;
      GotoLineRow(line,8);
    }
    tmp = pgm_read_byte(&Ptr[i+3]);
    tm=0;
    if (tmp & 0x80) tm |= 0x01;
    if (tmp & 0x40) tm |= 0x02;
    if (tmp & 0x20) tm |= 0x04;
    if (tmp & 0x10) tm |= 0x08;
    if (tmp & 0x08) tm |= 0x10;
    if (tmp & 0x04) tm |= 0x20;
    if (tmp & 0x02) tm |= 0x40;
    if (tmp & 0x01) tm |= 0x80;
    WriteDisplay(tm);
  }
}


//----------------------------------------------------------------------------------------
// lцscht gesamtes Grafikdisplay
//----------------------------------------------------------------------------------------
void ClearDisplay(void)
{
  GotoLineRow(0,0);
  for (WORD i=0; i<((101*64)/8+8); i++) // eigentlich 101*64/8 aber Display-SOC 
  {                                     // unterstьtzt 0..101, also 102 Spalten pro Zeile 
    WriteDisplay(0x00);                 // es sind aber nur 101 Spalten vorhanden!
  }
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void GotoLineRow(BYTE Line, BYTE Row) // Line: 0..7, Row 0..101;
{   
  SendCommand( 0b00101000);
  SendCommand((0b01000000 + Line));
  SendCommand((0b10000000 + Row ));
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void SendCommand(BYTE Command)
{
BYTE i,s;

  s=0x80;

  Data_LO;
  Clock_LO;
  Control_LO;
  ChipSelect_LO;
  for (i=0; i<8; i++) 
  {
    if (Command & s) { Data_HI; } 
    else             { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
// command or data to display
//----------------------------------------------------------------------------------------
void WriteDisplay(BYTE Value)
{          
  BYTE i,s;

  s=0x80;
  Data_LO;
  Clock_LO;
  Control_HI;
  ChipSelect_LO;

  for (i=0; i<8; i++) 
  {
    if (Value & s) { Data_HI; } 
    else           { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------
// rudimentдre Umsetzung einer Displayansteuerung ьber die UART
// bei Ansteuerung ьber die serielle PC-Schnittstelle Pegelwandler Max3232 o.д. erforderlich
//
// Testumgebung ATmega168 + 14.318180 MHz 3.3V
// HTerm (19200 8N1)
//
// Kommandos: (ZeilenabschluЯ mit CR+LF (0x0D + 0x0A))
//
//    txt 1,1,"Hello World!"
//    cls
//    demo
//    time "12:59"
//    help
//    black
//
//----------------------------------------------------------------------------------------
#define XTAL F_CPU

#include <avr/sleep.h>
#include <compat/deprecated.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "LCD_A70_101x64.h"

//----------------------------------------------------------------------------------------
//  Pinbelegung:        mega 48, 88, 168, 328 (PDIP)
//
//                            ----v----
// (PCINT14/RESET)......PC6 -| 1     28|- PC5 (ADC5/SCL/PCINT13)
// (PCINT16/RXD)        PD0 -| 2     27|- PC4 (ADC4/SDA/PCINT12)
// (PCINT17/TXD)........PD1 -| 3     26|- PC3 (ADC3/PCINT11)
// (PCINT18/INT0)       PD2 -| 4     25|- PC2 (ADC2/PCINT10)
// (PCINT19/OC2B/INT1)..PD3 -| 5     24|- PC1 (ADC1/PCINT9)
// (PCINT20/XCK/T0)     PD4 -| 6     23|- PC0 (ADC0/PCINT8)
//                      Vcc -| 7     22|- Gnd
//                      Gnd -| 8     21|- Aref
// (PCINT6/XTAL1/TOSC1).PB6 -| 9     20|- AVcc
// (PCINT7/XTAL2/TOSC2) PB7 -|10     19|- PB5 (SCK/PCINT5)
// (PCINT21/OC0B/T1)....PD5 -|11     18|- PB4 (MISO/PCINT4)
// (PCINT22/OC0A/AIN0)  PD6 -|12     17|- PB3 (MOSI/OC2A/PCINT3)
// (PCINT23/AIN1).......PD7 -|13     16|- PB2 (SS/OC1B/PCINT2)
// (PCINT0/CLKO/ICP1)   PB0 -|14     15|- PB1 (OC1A/PCINT1)
//                            ---------
//
//----------------------------------------------------------------------------------------
#define BYTE  unsigned char
#define WORD  unsigned short
#define DWORD unsigned long
#define uchar unsigned char
#define uint unsigned int

//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
#define max 40
#define BaudRate 19200UL
//----------------------------------------------------------------------------------------
#define	BAUD	BaudRate
#define bauddivider (uint)(XTAL / BAUD / 16 - 0.5)

//----------------------------------------------------------------------------------------
char puffer[max+1];

volatile char *schreibzeiger;
volatile char *lesezeiger;
volatile BYTE csum=0;
volatile BYTE cmdcnt=0;
volatile BYTE IdxLaenge;
volatile BYTE RXready;
volatile BYTE RXfull;
volatile int RXcnt;

BYTE hh,mm,ss;

//-------------------------------------------------------------------------------------------------
WORD freemilli=0;
volatile BYTE z001ms=0, z010ms=0, z100ms=0, z01sec=0, z10sec=0, buffer;
volatile BYTE Ovl10ms=0, Ovl100ms=0, Ovl1sec=0, Ovl10sec=0, Ovl1min=0;

//----------------------------------------------------------------------------------------
void InitUart(uint32_t baudrate);
void uart_puts (char *s);
void sendc(BYTE aa);

//-------------------------------------------------------------------------------------------------
void Timer1_init(void);
void delay_10ms(WORD t);

BYTE CheckCmd(char *ptrbuff);

signed char searchPos1(char *pt, BYTE kommaanz);
void Cmd_txt(void);
void Cmd_cls(void);
void Cmd_demo(void);
void Cmd_help(void);
void Cmd_black(void);
void Cmd_time(void);
void ClockShow(void);
void ClockTick(void);

WORD searchTxtMarker(char *pt);
BYTE clockshow;

//----------------------------------------------------------------------------------------
// m a i n 
//----------------------------------------------------------------------------------------
int main(void) {

// DDRx:   data direction registetr
// PORTx:  input / output
  DDRB = 0b00000001;
  DDRC = 0b00000000;
  DDRD = 0b01110110;

//----------------------------------------------------------------------------------------
  // Initialisierung der Zeiger
  lesezeiger = &puffer[0];
  schreibzeiger = &puffer[0];

  cli();
  InitUart(BaudRate);
  Timer1_init();
  sei();

  Init_LCD();
  ClearDisplay();

//----------------------------------------------------------------------------------------

  Cmd_demo();
  Cmd_help();

// ------------------------------------------------------------------------------------------------
// - while(1) -- while(1) -- while(1) -- while(1) -- while(1) -- while(1) -- while(1) -- while(1) -
// ------------------------------------------------------------------------------------------------
  while(1)
  {
    // ------------------------------------------------------------------------
    // zeitgesteuerte Funktionen:
    // ------------------------------------------------------------------------

    //-----------------------10ms----------------------------------------------
    if (Ovl10ms)
    {
      Ovl10ms = 0;
    }

    //-----------------------100ms---------------------------------------------
    if (Ovl100ms)
    {
      Ovl100ms = 0;
      if (RXfull==1) { CheckCmd((char *) puffer); }
    }

    //-----------------------1s------------------------------------------------
    if (Ovl1sec) 
    {
      Ovl1sec = 0;
      ClockTick();
      if (clockshow==1) { ClockShow(); }
    }

    //-----------------------10s-----------------------------------------------
    if (Ovl10sec) 
    {
      Ovl10sec = 0;
    }

    //-----------------------1min----------------------------------------------
    if (Ovl1min) 
    {
      Ovl1min = 0;
    }

  // --------------------------------------------------------------------------

  }  // --> while(1) {}

  return 0;         // never!
}                   // end of main


//---------------------------------------------------------------------------------


//----------------------------------------------------------------------------------------
// Init Timer1A 1ms Bsp fьr 8MHz: OCR1A = 8000000/256/1000-1 = 31,..
//----------------------------------------------------------------------------------------
void Timer1_init(void)
{
  TCCR1A  = 0x00;
  TCCR1B = ((1<<WGM12) | (1<<CS12));   // (CTC - clear counter on match) Prescaler 256 S.137 .doc8025.pdf
  OCR1A = (uint16_t) (F_CPU/256/1000-1);
  TIMSK1 = (1<<OCIE1A); 
}


//----------------------------------------------------------------------------------------
// ISR: 1ms Timer1 Interrupt
//----------------------------------------------------------------------------------------
ISR(TIMER1_COMPA_vect)
{
  freemilli++;
  z001ms++;
  if (z001ms > 9) { z001ms = 0;  z010ms++;  Ovl10ms = 1;  }
  if (z010ms > 9) { z010ms = 0;  z100ms++;  Ovl100ms = 1; }
  if (z100ms > 9) { z100ms = 0;  z01sec++;  Ovl1sec = 1;  }
  if (z01sec > 9) { z01sec = 0;  z10sec++;  Ovl10sec = 1; }
  if (z10sec==6)  { z10sec = 0;             Ovl1min = 1;  }
}


//----------------------------------------------------------------------------------------
// Initialisierung UART
//----------------------------------------------------------------------------------------
void InitUart(uint32_t Baud_Rate)
{
  UCSR0B = (0<<RXEN0);
  UBRR0H=(F_CPU/16/Baud_Rate-1) >> 8;
  UBRR0L=(F_CPU/16/Baud_Rate-1) & 0xFF;
  UCSR0A=0x00;
  UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0); // Enable receiver and transmitter 
  UCSR0C = ((1<<UCSZ01)|(1<<UCSZ00));         // Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit 
}


//----------------------------------------------------------------------------------------
// USART - Transmit - String
//----------------------------------------------------------------------------------------
void uart_puts (char *s)
{
BYTE dd;
  while (*s) {   // loop until *s != NULL
    dd = *s;
    sendc(dd);
    s++;
  }
}

//----------------------------------------------------------------------------------------
// USART - Transmit - Char
//----------------------------------------------------------------------------------------
void sendc(BYTE aa)
{
	while(!(UCSR0A & (1 << UDRE0)));    // wait until UDR ready
	UDR0 = aa;                          // send character
}

 
//----------------------------------------------------------------------------------------
// USART Receive-Interrupt 
//----------------------------------------------------------------------------------------
ISR (USART_RX_vect) 
{
  while ( !(UCSR0A & (1<<RXC0)) );
  if (RXfull==0) {
    *schreibzeiger=UDR0;
    RXcnt++;
    if (*schreibzeiger <= 0x0A) { RXfull=1; }
    schreibzeiger++;
  }
}


//----------------------------------------------------------------------------------------
// Uhr: ss: Sekunden
//      mm: Minuten
//      hh: Stunden
//----------------------------------------------------------------------------------------
void ClockTick(void)
{
  if (ss<59) { ss++; }
  else 
  {
    ss=0;
    if (mm<59) { mm++; }
    else {
      mm=0;
      if (hh<23) { hh++; }
      else { hh=0; }
    }
  }
}


//-------------------------------------------------------------------------------------------------
// UART-Daten checken und Kommandos ausfьhren
//-------------------------------------------------------------------------------------------------
BYTE CheckCmd(char *ptrbuff)
{
BYTE err,i;
  err=0;
  if ( strncmp( (char*)(puffer+0),"?", 1 ) == 0 ) {  }
  else if ( strncmp( (char*)(puffer+0),"help",  4 ) == 0 ) { Cmd_help();  }
  else if ( strncmp( (char*)(puffer+0),"cls",   3 ) == 0 ) { Cmd_cls();   }
  else if ( strncmp( (char*)(puffer+0),"txt ",  4 ) == 0 ) { Cmd_txt();   }
  else if ( strncmp( (char*)(puffer+0),"black", 5 ) == 0 ) { Cmd_black(); }
  //else if ( strncmp( (char*)(puffer+0),"off",   3 ) == 0 ) {              }
  else if ( strncmp( (char*)(puffer+0),"demo",  4 ) == 0 ) { Cmd_demo();  }
  else if ( strncmp( (char*)(puffer+0),"time",  4 ) == 0 ) { Cmd_time();  }
  //else if ( strncmp( (char*)(puffer+0),"txtb",  4 ) == 0 ) {              }
  else { err = 1; }

  i=0;
  while ((*(puffer+i)>0x0D) && (i<20)) 
  {
    sendc(*(puffer+i));
    i++;
  }
  if (!err) { uart_puts(" ...ok!"); }
  else      { uart_puts(" ...error!"); }
  schreibzeiger=&puffer[0];
  RXfull=0;
  return(err);
}


//----------------------------------------------------------------------------------------
// Set Time: 'time "12:59" 0D 0A'
//----------------------------------------------------------------------------------------
void Cmd_time(void)
{
BYTE pos,h10,h01,m01,m10;

  pos =  searchTxtMarker((char*)lesezeiger)>>8;
  if (pos != 0)
  {
    h10 = (*(lesezeiger+pos+0) & 0x0F);
    h01 = (*(lesezeiger+pos+1) & 0x0F);
    m10 = (*(lesezeiger+pos+3) & 0x0F);
    m01 = (*(lesezeiger+pos+4) & 0x0F);
    hh = h10*10+h01;
    mm = m10*10+m01;
    ss = 0;
    clockshow = 1;                            // Uhranzeige aktivieren
  }

}


//----------------------------------------------------------------------------------------
// Uhr anzeigen 1.Zeile
//----------------------------------------------------------------------------------------
void ClockShow(void)
{
BYTE x,y,h10,h01,m01,m10,s10,s01;

  y = 1;
  x = 3;
  h10 = hh/10+'0';
  h01 = hh-hh/10*10+'0';
  m10 = mm/10+'0';
  m01 = mm-mm/10*10+'0';
  s10 = ss/10+'0';
  s01 = ss-ss/10*10+'0';

  PaintCharC64(h10,y,x++); sendc(h10);
  PaintCharC64(h01,y,x++); sendc(h01);
  PaintCharC64(':',y,x++); sendc(':');
  PaintCharC64(m10,y,x++); sendc(m10);
  PaintCharC64(m01,y,x++); sendc(m01);
  PaintCharC64(':',y,x++); sendc(':');
  PaintCharC64(s10,y,x++); sendc(s10);
  PaintCharC64(s01,y,x++); sendc(s01); sendc(0x0D); sendc(0x0A);
}


//----------------------------------------------------------------------------------------
// Pixeltest: alle an
//----------------------------------------------------------------------------------------
void Cmd_black(void)
{
  GotoLineRow(0,0);
  for (WORD i=0; i<((101*64)/8+8); i++) // eigentlich 101*64/8 aber Display-SOC 
  {                                     // unterstьtzt 0..101, also 102 Spalten pro Zeile 
    WriteDisplay(0xFF);                 // es sind aber nur 101 Spalten vorhanden!
  }
}

//----------------------------------------------------------------------------------------
// Display lцschen
//----------------------------------------------------------------------------------------
void Cmd_cls(void)
{
  clockshow = 0;                        // Uhranzeige deaktivieren
  ClearDisplay();
}


//----------------------------------------------------------------------------------------
// Info
//----------------------------------------------------------------------------------------
void Cmd_help(void)
{
  WriteString(1,1,"************");
  WriteString(2,1,"            ");
  WriteString(3,1," A70 101x64 ");
  WriteString(4,1,"------------");
  WriteString(5,1,"            ");
  WriteString(6,1,"-> 19200 8N1");
  WriteString(7,1,"            ");
  WriteString(8,1,"************");
}


//----------------------------------------------------------------------------------------
// Demo: kleiner Font, groЯer Font, Schiff
//----------------------------------------------------------------------------------------
void Cmd_demo(void)
{
BYTE c=0;
  for (int x=0; x<12; x++) {
    for (int y=0; y<12; y++) {
      PaintCharC64(c+' ',1+x,1+y);
      c++;
    }
  }
  delay_10ms(200);
  ClearDisplay();
  c = 0;
  for (int x=0; x<7; x=x+2) {
    for (int y=0; y<10; y++) {
      PaintChar8x12(c+' ',10+y*10,x);
      c++;
    }
  }
  delay_10ms(200);
  ClearDisplay();
  for (int x=0; x<7; x=x+2) {
    for (int y=0; y<10; y++) {
      PaintChar8x12(c+' ',10+y*10,x);
      c++;
    }
  }
  delay_10ms(200);
  ClearDisplay();
  PaintPic(&Schiff[0],1,0);
  delay_10ms(200);
  ClearDisplay();
}


//----------------------------------------------------------------------------------------
// Textdarstellung
//----------------------------------------------------------------------------------------
void Cmd_txt(void)
{
BYTE x,y,pos,i;
volatile char *abs;
BYTE start,end;
WORD StartEnd;

  x = 0;
  y = 0;
  pos =  searchPos1((char*)lesezeiger,1);
  if (pos != 0) {

    if (*(lesezeiger+pos-3)<'0') { x = (*(lesezeiger+pos-2) & 0x0F); }
    else {
        x = (*(lesezeiger+pos-3) & 0x0F)*10;
        x = x + (*(lesezeiger+pos-2) & 0x0F);
    }

    if (*(lesezeiger+pos+1)<'0') { y = (*(lesezeiger+pos) & 0x0F); }
    else {
      if (*(lesezeiger+pos+2)<'0') {
        y = (*(lesezeiger+pos) & 0x0F)*10;
        y = y + (*(lesezeiger+pos+1) & 0x0F);
      }
    }
  }

  StartEnd = searchTxtMarker((char*)lesezeiger);
  start = StartEnd>>8;
  end = StartEnd & 0x00FF;

  abs=(char*)(lesezeiger+start);
  i=0;
    while ((*(abs+i)>0x19) && (*(abs+i)<=0x7F) && (i<(end-start)))
    {
      PaintCharC64(*(abs+i),y,x+i);
      i++;
    }
}


//----------------------------------------------------------------------------------------
//  Textmarker " Anfang + Ende
//----------------------------------------------------------------------------------------
WORD searchTxtMarker(char *pt)
{
BYTE start, end, i;
i=0;
start = 0;
end = 0;

  for (i=0; i<max; i++)
  {
    if ((*pt=='"') && (start == 0)) { start = i+1; }
    if (*pt=='"') { end = i; }
    pt++;
    if (*pt<0x20) break;;
  }
  return ((start<<8)+end);
}


//----------------------------------------------------------------------------------------
//  searchPos
//----------------------------------------------------------------------------------------
signed char searchPos1(char *pt, BYTE kommaanz)
{
BYTE i;

  for (i=0; i<max; i++)
  {
    if (*pt==',') { kommaanz--; }
    if (kommaanz==0) { return i+1; }           // die position nach dem letzten komma
    pt++;
    if (*pt<0x20) return 0;
  }
  return 0;
}


//-----------------------------------------------------------------------------
// q&d Delayfunktion
//
// ACHTUNG: Interrupts global aus!
//-----------------------------------------------------------------------------
void delay_10ms(WORD t)
{
  cli();
  for (WORD x=0; x<t; x++) {
    _delay_ms(10);
  }
  sei();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

На сколько я вижу должно, но может что то пропустил.

P.S. подключил к дуине

 доброго времени суток. а можно вопросик по индикатору. опыт работы  с ардуино имеется, а вот с индикаторами - никакого.

а можно получить самый простенький скеч чтоб индикатор написал "здравствуй мир"

я не могу понять, проблема с библиотеками, я не так инициализирую индикатор ...... ?

у меня ардуино про мини на атмега 328п согласно библиотеке: 

1 нога индикатора идет на PD6 - 10 нога микры пін D6

2 нога индикатора идет на PB0 - 12 ногу микры пін D8

3 нога индикатора идет на PD2 - 32 ногу микры пін D2

4 нога индикатора идет на PD4 - 2 ногу микры пін D4

5 нога индикатора идет на PD5 - 2 ногу микры пін D5

6 +2....+3.3

7 GND

1. Не совсем понятно какую библиотеку используете.

2. Если это вышеупомянутая, но поздаровкаться по русски не получится, просто нет русских символов.

3. Неизвестно как Вы подключили. По написаному Вами я понял что напрямую к дуине. Или через делители?

библиотека вышеупомянутая. подключил на прямую. если критично, могу подключить через делитель. *пока проблема с тестовой програмой 

а конкретно слова кириллицей писать мне и не надо. "hello world" типа тестовый пример, чтоб было от чего отталкиваться. *первое знакомство с ЖКИ *подозреваю что надоест быстро, и куплю фирменный *на который идут стандартные библиотеки, и есть примеры  скетча. 

до  этого момента выводил показатели датчиков в порт, или на шаговые двигателя от приборных панелей, экраны от мобилок есть, хочу использовать

спасибо за потраченное на мене время 

Здравия желаю. Если ещё актуально - прошу прощения за задержку! Лето, море, пляж и прочая фиЗня. 

В общем так: Я в прошлый раз так и не дал ладу этому экранчику, а экранчики остались. Вот решил подвспомнить.

Как и просили - поздоровкались. Немного подкоректил то, что выше. Делаем следующее:

1. Создаём файл "срр" с названием  "PCF8812" и вставляем в него :

#include <inttypes.h>
#if defined(__AVR__)
# include <avr/io.h>
# include <avr/interrupt.h>
# include <avr/pgmspace.h>
# include <util/delay.h>
#include <wiring.h>
#endif
#if ARDUINO >= 100
# include "Arduino.h"
#else
# include "WProgram.h"
#endif
//----------------------------------------------------------------------------------------
// Displayroutinen for LCD Siemens A70 (3.3Volt / Controller: ?PCF8812 o.д.)
//----------------------------------------------------------------------------------------
#include "PCF8812.h"
//----------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------
//                                                               PortPin am µC        

#define Data_HI PORTD |=  (1<<PORTD5);        // Data=1;           PD5
#define Data_LO PORTD &= ~(1<<PORTD5);        // Data=0;

#define Clock_HI PORTD |=  (1<<PORTD4);       // Clock=1;          PD4
#define Clock_LO PORTD &= ~(1<<PORTD4);       // Clock=0;

#define Control_HI PORTD |=  (1<<PORTD2);     // Control=1; D/C    PD2
#define Control_LO PORTD &= ~(1<<PORTD2);     // Control=0;

#define Reset_HI PORTB |=  (1<<PORTB0);       // Reset=1;          PB0
#define Reset_LO PORTB &= ~(1<<PORTB0);       // Reset=0;  

#define ChipSelect_HI PORTD |=  (1<<PORTD6);  // ChipSelect=1;     PD6
#define ChipSelect_LO PORTD &= ~(1<<PORTD6);  // ChipSelect=0;

//----------------------------------------------------------------------------------------



//----------------------------------------------------------------------------------------
// init LCD incl. Reset
//----------------------------------------------------------------------------------------
void Init_LCD(void)
{
	DDRD |= (1<<2) | (1<<4) | (1<<5) | (1<<6);
	DDRB |= (1<<0);
  Reset_LCD();

  SendCommand(0x21);  // Function set: extended instruction set
  SendCommand(0x14);  // Bias System
  SendCommand(0x0A);  // HV-gen stages
  SendCommand(0x05);  // Temperature Control
  SendCommand(0xCC);  // Contrast: 204
  SendCommand(0x20);  // Function set: standard instruction set
  SendCommand(0x11);  // VLCD programming range: high
  SendCommand(0x0C);  // Display control: normal (inverted = 0x0D)
  ClearDisplay();
}   


//----------------------------------------------------------------------------------------
// reset LCD
//----------------------------------------------------------------------------------------
void Reset_LCD(void)
{
  _delay_us(10);
  Data_LO;
  Clock_LO;
  Control_LO;
  _delay_us(10);
  Reset_HI;
  _delay_us(10);
  ChipSelect_LO;
  _delay_us(10);
  Reset_LO;
  _delay_us(10);  
  Reset_HI;
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
// Funktion stellt ein Zeichen dar 8x8  Zeile 1..8 Spalte 1..12
// column 00..16 Spalten 17 X
// row     0...9 Zeilen  10 Y Reihe
//----------------------------------------------------------------------------------------
void PaintCharC64(BYTE sign, BYTE zeile, BYTE spalte) 
{
BYTE y,tmp;
int pos;

  if ((zeile<9) && (spalte<13)) {
    GotoLineRow(zeile-1, 100-spalte*8);
    if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
    pos = 8*(sign-0x20);
    for (y=0; y<8; y++) 
    {  
      tmp = pgm_read_byte(&code8x8[pos++]);
      WriteDisplay(tmp);
    }
  }
}


//----------------------------------------------------------------------------------------
void PaintChar8x12(BYTE sign, BYTE column, BYTE row) 
{
BYTE CharCol_1, CharCol_2, CharCol_3, CharCol_4, CharCol_5;
BYTE CharCol_6, CharCol_7, CharCol_8, CharCol_9, CharCol_10, CharCol_11, CharCol_12;
BYTE char_r_y_p12, char_r_y_p34, char_r_y_p56, char_r_y_p78, char_r_y_p910, char_r_y_p1112;
BYTE pz, y;
unsigned int pos;
BYTE tmp;

  GotoLineRow(row, 101-column);
  
  if ((sign<0x20) || (sign>0x7F)) { sign = 0x20; } 
  pos = 12*(sign-0x20);

  CharCol_1 = pgm_read_byte(&code8x12[pos++]);
  CharCol_2 = pgm_read_byte(&code8x12[pos++]);
  CharCol_3 = pgm_read_byte(&code8x12[pos++]);
  CharCol_4 = pgm_read_byte(&code8x12[pos++]);
  CharCol_5 = pgm_read_byte(&code8x12[pos++]);

  CharCol_6 = pgm_read_byte(&code8x12[pos++]);
  CharCol_7 = pgm_read_byte(&code8x12[pos++]);
  CharCol_8 = pgm_read_byte(&code8x12[pos++]);
  CharCol_9 = pgm_read_byte(&code8x12[pos++]);
  CharCol_10 = pgm_read_byte(&code8x12[pos++]);
  CharCol_11 = pgm_read_byte(&code8x12[pos++]);
  CharCol_12 = pgm_read_byte(&code8x12[pos++]);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_1 & pz)  { tmp |= 0x80; }
    if (CharCol_2 & pz)  { tmp |= 0x40; }
    if (CharCol_3 & pz)  { tmp |= 0x20; }
    if (CharCol_4 & pz)  { tmp |= 0x10; }
    if (CharCol_5 & pz)  { tmp |= 0x08; }    
    if (CharCol_6 & pz)  { tmp |= 0x04; }
    if (CharCol_7 & pz) { tmp |= 0x02; }
    if (CharCol_8 & pz) { tmp |= 0x01; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }

  GotoLineRow(row+1, 101-column);

  pz = 0x01;                                                  //pixelzeile
  for (y=0; y<8; y++) 
  {
    char_r_y_p12=char_r_y_p34=char_r_y_p56=char_r_y_p78=char_r_y_p910=char_r_y_p1112=0;
    tmp = 0;
    if (CharCol_9 & pz)  { tmp |= 0x80; }
    if (CharCol_10 & pz)  { tmp |= 0x40; }
    if (CharCol_11 & pz)  { tmp |= 0x20; }
    if (CharCol_12 & pz)  { tmp |= 0x10; }
    WriteDisplay(tmp);
    pz = pz << 1;
  }
}


//----------------------------------------------------------------------------------------
// send a string
//
// xPos: 0..16 (17 Spalten a 6 Pixel breit)
// yPos: 0.. 9 (10 Zeilen a 8 Pixel breit)
// Str:  max 17 Zeichen 
//----------------------------------------------------------------------------------------
void WriteString(BYTE xPos, BYTE yPos, char *Str) 
{
BYTE c,st,s;

  st = 0;
  s = *Str;
  while ((*Str!=0) && (xPos<100) && (st<17)) 
  { 
    c = *Str;
    PaintCharC64(c,xPos,yPos);
    yPos++;
    Str++;
    st++;
  }
}


//----------------------------------------------------------------------------------------
// paint a picture
//----------------------------------------------------------------------------------------
void PaintPic(const volatile uint8_t *Ptr, BYTE line, BYTE row)
{
BYTE tmp,tm;
WORD i;
BYTE hoehe,breite;

  hoehe = pgm_read_byte(&Ptr[1]);
  breite = pgm_read_byte(&Ptr[2]);
  GotoLineRow(line,8);
  for (i=0; i<(hoehe*breite/8); i++) 
  {
    if ((i%breite==0) && (i>=breite)) 
    {
      line++;
      GotoLineRow(line,8);
    }
    tmp = pgm_read_byte(&Ptr[i+3]);
    tm=0;
    if (tmp & 0x80) tm |= 0x01;
    if (tmp & 0x40) tm |= 0x02;
    if (tmp & 0x20) tm |= 0x04;
    if (tmp & 0x10) tm |= 0x08;
    if (tmp & 0x08) tm |= 0x10;
    if (tmp & 0x04) tm |= 0x20;
    if (tmp & 0x02) tm |= 0x40;
    if (tmp & 0x01) tm |= 0x80;
    WriteDisplay(tm);
  }
}


//----------------------------------------------------------------------------------------
// lцscht gesamtes Grafikdisplay
//----------------------------------------------------------------------------------------
void ClearDisplay(void)
{
  GotoLineRow(0,0);
  for (WORD i=0; i<((101*64)/8+8); i++) // eigentlich 101*64/8 aber Display-SOC 
  {                                     // unterstьtzt 0..101, also 102 Spalten pro Zeile 
    WriteDisplay(0x00);                 // es sind aber nur 101 Spalten vorhanden!
  }
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void GotoLineRow(BYTE Line, BYTE Row) // Line: 0..7, Row 0..101;
{   
  SendCommand( 0b00101000);
  SendCommand((0b01000000 + Line));
  SendCommand((0b10000000 + Row ));
}


//----------------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------------
void SendCommand(BYTE Command)
{
BYTE i,s;

  s=0x80;

  Data_LO;
  Clock_LO;
  Control_LO;
  ChipSelect_LO;
  for (i=0; i<8; i++) 
  {
    if (Command & s) { Data_HI; } 
    else             { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}
//----------------------------------------------------------------------------------------
// command or data to display
//----------------------------------------------------------------------------------------
void WriteDisplay(BYTE Value)
{          
  BYTE i,s;

  s=0x80;
  Data_LO;
  Clock_LO;
  Control_HI;
  ChipSelect_LO;

  for (i=0; i<8; i++) 
  {
    if (Value & s) { Data_HI; } 
    else           { Data_LO; }
    s = s>>1;
    Clock_HI;
    Clock_LO;
  }
  ChipSelect_HI;
}


//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------

2. Создаём файл "h" с названием "PCF8812" и вставляем тудЫ 

#include "Arduino.h"
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include <util/delay.h>
//****************************************************************************************
#ifndef PCF8812_H
#define PCF8812_H
//----------------------------------------------------------------------------------------
// LCD Siemens A60 Handy 101x64

//----------------------------------------------------------------------------------------
//  Pinbelegung: LCD A60 101x64 Pixel (auf Rьckseite geschaut)
//
//
//  -----------------------------------
// |                                   |
// |             O O O O O O O O O O   |
// |             | | | | | | | | | |   |
// |             | | | | | | | | | |   |
// |             L L L G V D C D R C   |
// |             e e e n c a l / e s   |
// |             d d d d c t k C s     |
// |             1   2           e     |
// |             + - +           t     |
// |                                   |
// |                                   |
// |                                   |
// | Displayrьckseite                  |
//  -----------------------------------
//
//
//----------------------------------------------------------------------------------------
//                                                               PortPin am µC   
//--------------------------------------------------------------------------------------
#include <avr/io.h>
#include <compat/deprecated.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>

#include "Font_A70.h"

//--------------------------------------------------------------------------------------
#define ack  1
#define nack 0
//-------------------------------------------------------------------------------------------------
#define BYTE  unsigned char
#define WORD  unsigned short
#define DWORD unsigned long
//-------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
void Reset_LCD(void);
void Init_LCD(void);
void SendCommand(BYTE Command);
void GotoLineRow(BYTE Line, BYTE Row);
void WriteDisplay(BYTE Value);

void ClearDisplay(void);
void WriteString(BYTE xPos, BYTE yPos, char *Str);
void PaintCharC64(BYTE sign, BYTE column, BYTE row);
void PaintChar8x12(BYTE sign, BYTE zeile, BYTE spalte);
void PaintPic(const volatile uint8_t *Ptr, BYTE column, BYTE row);
//--------------------------------------------------------------------------------------
#endif

3. Создаём файл "h" с названием "Font_A70" и там то, что выше....(одно и тоже вставлять не буду, в шрифте ничего не менял).

4. Всё это аккуратно кладём в папку и затем эту папку в библиотеки.

5. Запускаем Arduino и вставляем :

#include <PCF8812.h> 
#include "Font_A70.h"
void setup(){
  Init_LCD();
}
void loop(){
  WriteString(3, 1, "hello world!");
  delay(1000);
}

Теперь дополнение. 

Подключать или через делители или (как я) всё через кренку 3,3 В. Там и подсветка и питание, удобней в общем.

Подключение к микроконтроллеру в файле "срр" от строки 23. В строке 47 и 48 инициализация портов - НЕ ЗАБЫВАЕМ!!!

Пример на Atmega8. В верху обсуждали и рекомендовали файлы библиотеки (ну типа библиотеки) забросить в папку со скетчем... НЕ НУЖНО. Всё как обычно.

Вроде всё, дальше сами..... Удачи.

P.S. Тактируется от внутреннего осцелятора 8 мГц. 

Вобще я незря назвал недобиблиотекой. Хотя там самое основное, она может только писать и картинки показывать. Я не так давно дописал бибу для PCF8814 (nokia 1100, 1202, 1203, 1280) - поддерживает граффику, рисунки, растягивает в ширину / увеличивает в двое - втрое шрифт, выводит значения с датчиков и т.п. и даже  по русски говорить может.Есть желание перекроить её под А70. Если заинтересует........

На здоровье

 огромное  спасибо. тема актуальная :) я сам на некоторое время выпал из жизни. то народу данные с поврежденного винчестера восстанавливал, то другу ваяю доводчик для свеклоподъемников, а теперь от ищу компоненты  для апгрейда старого компьютера. раньше на нем слушали музыку, а теперь хотят фильмов в хд качестве.

постараюсь сегодня разобраться  с делами, и подключить индикатор.

ещё раз огромное спасибо, крепкого здравия, и успехов в делах.

P.S.

меня приятно удивляет что есть еще люди которые что то делают руками, что особенно радует, что готовы и помочь

забросил библиотеки, посмотрел даташит на контроллер все правильно. текста нету поставил делители *переходник с 5 вольтовй логики на 3х по такой схеме http://we.easyelectronics.ru/uploads/images/00/01/10/2011/04/18/a5a8b3.gif безрезультатно. я не знаю что надо инициализировать. это первый индикатор с которым сталкиваюсь. скеч залил без изменений. может проблема в том, что частота моего микроконтроллера на 8 а 16 мгц.

я не знаю что делать. с хардом еще разбирался а вот хард-софт ето дебри 

Так, видимо я не зря написал что тактирую от внутреннего на 8 мГц. Сечас попробовал раскачать от 12, тоже самое - нет ничего. Погляжу сейчас что там с инициализацией. Пока прошейте фьюзы на 8 и в "борде" подправьте....

Подключить рекомендую как описано в первом посте http://arduino.ru/forum/programmirovanie/rabota-s-knopkami-v-pomoshch-novichku

дільники вже поставив класичні. а з програмуванянм в мене туго 

А.а.а, это вам 28 пост не понравился))). Я забыл, что вы на дуине работаете. Ну как знаете.

то что делаю обычно требует быстродействия. и этот индикатор планировал на барометр поставить. жду пока привезут. та зараза нуждается в высокой такмової частоте.

благодарю за потраченное время.

а у Вас здесь какая-то система рейтингов есть, чтобы хоть как-то отблагодарить ?

А есть возможность заменить дуину на отдельный контроллер?

возможность есть, но есть и проблема. не пишу на ассемблер. С++ в универе преподавали, от чтото и осталось, а язык дуины его напоминает, да и команд немного. считать состояние ноги, задать уровень, задать заполненя шима. в большинстве случаев сложные датчики имеют уже готовые библиотеку которые для меня черный ящик, который выдаёт значения в переменную, а с ней могу работать типа если уровень такой - ничего, а если выше или ниже изменить коэффициент шима, или подать-убрать высокий уровень с ноги. такой я программист. все что сложнее - я пас 

Ну во первых я на асамблере тоже не пишу. Во вторых я тоже не особый програмист, так... Ну и соглашусь, что действительно, это проблема, что от 16, даже 12 мГц работать не хочет.

У тебя хоть с++ преподавали. Я в универе в паскале кажется две цифры сумел сложить, а про микроконтроллеры вобще что то вскользь сказали, какой то отечественный изучили немного, сдали зачёт и забыли. Но.... как сказал один дядька, памятники которого сейчас у вас повально сносят, - "учиться никогда не поздно".

а зачем барометру высокая тактовая частота? 

а я знаю... написано 3.5 мгц. а в режиме экономим  электроэнергии 1 мгц http://www.ebay.com/itm/1PC-BMP180-Digital-Barometric-Pressure-Sensor-Bo....

а если будет длинный скеч, с делеями *с шаговыми двигателями по другому никак, то могут быть проблемы . вот и брал высокоскоростной и бюджетный контроллер.

а что касается учёбы то нам рассказали что они есть, некоторым группам повезло они в "протеусе"  емулировали контроллер и писали под него. но когда я задал вопрос преподу по контроллеру не касающийся лекции он сдулся. а как познакомился с первой дуиной просто прикол. студики попросили сделать лабу на С а у меня это отняло 3 дня задумался. мозги то сохнут надо себя заставить. а как заставить ? а привязать программу к железу. брат интересовался дуинами, почитал. не надо ничего перебрасывать с регистра в регистр ..... и язык простой. от и купил себе первый arduino uno. а он не в кондиции сварил мозг себе и народу который с ними сталкивался. собрал програматор и начал прошивать контроллер, неправильно зашил фюзы, сделал примочку к контроллеру для розблокировки, нашел правильный  бутлудер. так и познакомился. а теперь дешевые про мини юзаю. а уна как полигон. атмега 8 почти не убиваемая 

Это у тебя УНО на восьмой??? Капец она древняя )) 

И снова дошли рученьки к А70. Пошарил в библиотеке с инициализацией, иногда бывает нужно побольше паузы между "перидёргиванием " выдержать. Там вроде всё нормально. Замерил напряжение на контроллере (2,9В). На 8 мГц от внутреннего достаточно было, а на 16 мГц заработал когда поднял до 3,3, и на контроллере и на экране. Пробуй.

да на 8 атмеге. старая но крепкая микруха. уже более 100 раз заливал скеч, раз 5 перезаливал бутлудер. мелкие шаговые двигатели можно подключать на прямую, а 328 перегревается потому и нельзя оставлять стопорящее напряжение.

так тут еще одна проблема у меня 5 вольтовые контроллеры попробую понизить питание но не знаю что получиться. сделаю отпишусь.

огромное спасибо 

Мегу можно и от 5 -ти питать, на подсветку тоже не принципиально, по "книжке" вобще на А70 питается от 2,9 вольт но на практике отлично работает от 3,3. Я думаю самой меге 2,8 - 2,9 оказалось мало для инициализации. На управление там тоже не принципмально напряжение(только не больше 3,3В). Я думаю тебе нужно убедиться что правельно подключил. Попробуй следующее: Продифайни пин порта к которому подключаешь первый пин экрана (как в библиотеке), подключи к нему светик и помигай.

в библиотеке :

#define Data_HI PORTD |=  (1<<PORTD5);        // Data=1;           PD5
#define Data_LO PORTD &= ~(1<<PORTD5);        // Data=0;

а в свою УНО загрузи только:

.....
void setup(){
DDRD |= 1<<5;
}
void loop(){
Data_HI;
delay(250);
Data_LO;
}

Вешай светик. Мигает - правельно. Следующий....

как раз на 2х ножках нет сигнала. контроллер исправен. завтра уже соберу схему и установлю на каких. кажется клок и дата *самые ненужные сигналы. сначала думал что там сигналы высокой частоты и не могу их засеч. *осциллограф до 1 мгц старенький. а их может и не быть.  этих сигналов нет ни на одном незадействованном выводе, ни на цыфровом ни на аналоговом. на 8 атмеге говорят какой то периферии нету потому и провожу на 328. но может попробовать как раз на 8. сегодня не было времени обновлял компьютер, катастрофичести подешевели запчасти. может завтра попробую

большое спасибо что возитесь со мной 

Да я за одно и с собой вожусь, взялся так добить надо. Для тех двух можно просто поменять порты. В 28-м посте я писал где и как. На самом деле работа от внешнего кварца на 12 и 16 нестабильная. Копаю дальше

если бы еще понимал. у меня нет знаний в этой отрасли. это как из нуля выучить квантовую физику

плохо переключаюсь :( извините 

#define Data_HI PORTD |=  (1<<PORTD5);        // Data=1;           PD5

Тут дефайним Data_HI как установку пятого пина порта D. Т.е. пин 5 еденичка, но нужно ещё задать его как выход

DDRD |= 1<<5;  // пин 5 порта D - выход

Если при загрузке "мигалки" ни один пин не отвечает, можно просто поменять пин на любой свободный, допустим пин 3 порта B:

#define Data_HI PORTB |=  (1<<PORTB3);        // Data=1;           PB3
.... //тут сброс пина  //Data=0;

а в сетапе;

DDRB |= 1<<3;  // пин 3 порта B - выход

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

 извиняюсь. так и не дошел. весь день не дома :"( 

на "дате" и на "клоку" нету сигнала.

перевесил дату с "пд5" на "пд7", и клок с "пд4" на "пд3"

#define Data_HI PORTD |= (1<<PORTD7); // Data=1; PD7
#define Data_LO PORTD &= ~(1<<PORTD7); // Data=0;

#define Clock_HI PORTD |= (1<<PORTD3); // Clock=1; PD3
#define Clock_LO PORTD &= ~(1<<PORTD3); // Clock=0;

.......

//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
// init LCD incl. Reset
//----------------------------------------------------------------------------------------
void Init_LCD(void)
{
DDRD |= (1<<2) | (1<<3) | (1<<7) | (1<<6);
DDRB |= (1<<0);
Reset_LCD();

скеч

#include <PCF8812.h>
#include "Font_A70.h"
void setup(){
Init_LCD();
}
void loop(){
WriteString(3, 1, "hello world!");
delay(1000);
}

может чтото делаю не так ? еще попробую с 8 атмегой, если и она не даст результата - здаюсь

ну во первых не так выкладываеш на форуме код. Сторожилы будут обижаться и мне достанется за то, что вожусь как с маленьким дитём, и тебе за несоблюдение правил. Посмотри тут:http://arduino.ru/forum/obshchii/vstavka-programmnogo-koda-v-temukommentarii

Вобще местные любят чтоб сами догоняли что не так, пережовывать и класть в рот не их удел, надо немного поумничать, постороить из себя мега праграмистов, потом написать что то умное, что могут понять только они и добавить после вопроса - "а это что?" - " ну что тут не ясно, уже вам всё сказали".. Как то так.

А по нашему вопросу скожу следующую хорошую новость. Как обещал, начал перекраивать бибу под этот индикатор. Инициализация проходит, работает на 16 мГц легко. Пока лаги с координатами. После первого сентября выйду из камотоза, будем продолжать по мере сил.... "А СИЛ У МЕНЯ НЕМЕРЕННО"