Вопрос по кодам

Песочница. Раздел для новичков
1

Всем здравствуйте, объясните пожалуйста строку в коде

digitalWrite(row?PIN_LOAD2:PIN_LOAD, LOW);  //  что означает???

сам код

const unsigned char fnt5x7[]={
0x00,0x00,0x00,0x00,0x00,0x00,0x00,//SPC
0x04,0x04,0x04,0x04,0x04,0x00,0x04,//!
0x0A,0x0A,0x00,0x00,0x00,0x00,0x00,//"
0x0A,0x0A,0x1F,0x0A,0x1F,0x0A,0x0A,//#
0x04,0x0F,0x14,0x0E,0x05,0x1E,0x04,//$
0x18,0x19,0x02,0x04,0x08,0x13,0x03,//%
0x08,0x14,0x14,0x08,0x15,0x12,0x0D,//&
0x0C,0x0C,0x04,0x08,0x00,0x00,0x00,//'
0x02,0x04,0x04,0x04,0x04,0x04,0x02,//(
0x08,0x04,0x04,0x04,0x04,0x04,0x08,//)
0x00,0x0A,0x04,0x1F,0x04,0x0A,0x00,//*
0x00,0x04,0x04,0x1F,0x04,0x04,0x00,//+
0x00,0x00,0x00,0x18,0x18,0x08,0x10,//,
0x00,0x00,0x00,0x1F,0x00,0x00,0x00,//-
0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,//.
0x00,0x01,0x02,0x04,0x08,0x10,0x00,///
0x0E,0x11,0x13,0x15,0x19,0x11,0x0E,//0
//0x1E,0x05,0x1E,0x00,0x1F,0x14,0x1C,
0x04,0x0C,0x04,0x04,0x04,0x04,0x0E,//1
0x0E,0x11,0x01,0x06,0x08,0x10,0x1F,//2
0x0E,0x11,0x01,0x0E,0x01,0x11,0x0E,//3
0x02,0x06,0x0A,0x12,0x1F,0x02,0x02,//4
0x1F,0x10,0x1E,0x01,0x01,0x01,0x1E,//5
0x06,0x08,0x10,0x1E,0x11,0x11,0x0E,//6
0x1F,0x01,0x02,0x04,0x08,0x08,0x08,//7
0x0E,0x11,0x11,0x0E,0x11,0x11,0x0E,//8
0x0E,0x11,0x11,0x0F,0x01,0x02,0x0C,//9

0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00,//:
0x0C,0x0C,0x00,0x0C,0x0C,0x04,0x08,//;
0x01,0x02,0x04,0x08,0x04,0x02,0x01,//<
0x00,0x00,0x1F,0x00,0x1F,0x00,0x00,//=
0x10,0x08,0x04,0x02,0x04,0x08,0x10,//>
0x0E,0x11,0x01,0x02,0x04,0x00,0x04,//?
0x0E,0x11,0x17,0x15,0x17,0x10,0x0E,//@
0x0E,0x11,0x11,0x1F,0x11,0x11,0x11,//A
0x1E,0x11,0x11,0x1E,0x1E,0x11,0x1E,//B
0x0E,0x11,0x10,0x10,0x10,0x11,0x0E,//C
0x1E,0x11,0x11,0x11,0x11,0x11,0x1E,//D
0x1F,0x10,0x10,0x1E,0x10,0x10,0x1F,//E
0x1F,0x10,0x10,0x1E,0x10,0x10,0x10,//F
0x0E,0x11,0x10,0x10,0x13,0x11,0x0E,//G
0x11,0x11,0x11,0x1F,0x11,0x11,0x11,//H
0x1E,0x04,0x04,0x04,0x04,0x04,0x1E,//I
0x01,0x01,0x01,0x01,0x01,0x11,0x0E,//J
0x11,0x12,0x14,0x18,0x14,0x12,0x11,//K
0x10,0x10,0x10,0x10,0x10,0x10,0x1F,//L
0x11,0x1B,0x15,0x15,0x11,0x11,0x11,//M
0x11,0x11,0x19,0x15,0x13,0x11,0x11,//N
0x0E,0x11,0x11,0x11,0x11,0x11,0x0E,//O
0x1E,0x11,0x11,0x1E,0x10,0x10,0x10,//P
0x0E,0x11,0x11,0x11,0x15,0x12,0x0D,//Q
0x1E,0x11,0x11,0x1E,0x14,0x12,0x11,//R
0x0E,0x11,0x10,0x0E,0x01,0x11,0x0E,//S
0x1F,0x04,0x04,0x04,0x04,0x04,0x04,//T
0x11,0x11,0x11,0x11,0x11,0x11,0x0E,//U
0x11,0x11,0x11,0x0A,0x0A,0x04,0x04,//V
0x11,0x11,0x11,0x15,0x15,0x1B,0x11,//W
0x11,0x11,0x0A,0x04,0x0A,0x11,0x11,//X
0x11,0x11,0x0A,0x04,0x04,0x04,0x04,//Y
0x1F,0x01,0x02,0x04,0x08,0x10,0x1F,//Z
0x07,0x04,0x04,0x04,0x04,0x04,0x07,//[
0x00,0x10,0x08,0x04,0x02,0x01,0x00,// SLASH
0x1C,0x04,0x04,0x04,0x04,0x04,0x1C,//]
0x04,0x0E,0x15,0x04,0x04,0x04,0x04,//^
0x00,0x00,0x00,0x00,0x00,0x00,0x1F,//_
0x0C,0x0C,0x08,0x04,0x00,0x00,0x00,//'
0x00,0x00,0x0E,0x12,0x12,0x12,0x0D,//a
0x10,0x10,0x10,0x16,0x19,0x11,0x1E,//b
0x00,0x00,0x0E,0x10,0x10,0x11,0x0E,//c
0x01,0x01,0x01,0x0D,0x13,0x11,0x0F,//d
0x00,0x00,0x0E,0x11,0x1E,0x10,0x0E,//e
0x04,0x0A,0x08,0x1C,0x08,0x08,0x08,//f
0x00,0x00,0x0F,0x11,0x0F,0x01,0x06,//g
0x10,0x10,0x16,0x19,0x11,0x11,0x11,//h
0x00,0x04,0x00,0x0C,0x04,0x04,0x0E,//i
0x02,0x00,0x06,0x02,0x02,0x12,0x0C,//j
0x10,0x10,0x12,0x14,0x18,0x14,0x12,//k
0x0C,0x04,0x04,0x04,0x04,0x04,0x0E,//l
0x00,0x00,0x0A,0x15,0x11,0x11,0x11,//m
0x00,0x00,0x16,0x19,0x11,0x11,0x11,//n
0x00,0x00,0x0E,0x11,0x11,0x11,0x0E,//o
0x00,0x00,0x0E,0x11,0x19,0x16,0x10,//p
0x00,0x00,0x0F,0x11,0x13,0x0D,0x01,//q
0x00,0x00,0x0B,0x0C,0x08,0x08,0x08,//r
0x00,0x00,0x0E,0x10,0x0E,0x01,0x1E,//s
0x08,0x08,0x1C,0x08,0x08,0x0A,0x04,//t
0x00,0x00,0x11,0x11,0x11,0x13,0x0D,//u
0x00,0x00,0x11,0x11,0x11,0x0A,0x04,//v
0x00,0x00,0x11,0x11,0x15,0x15,0x0A,//w
0x00,0x00,0x11,0x0A,0x04,0x0A,0x11,//x
0x00,0x00,0x11,0x0A,0x04,0x04,0x08,//y
0x00,0x00,0x1F,0x02,0x04,0x08,0x1F,//z
0x02,0x04,0x04,0x08,0x04,0x04,0x02,//{
0x04,0x04,0x04,0x00,0x04,0x04,0x04,//|
0x08,0x04,0x04,0x02,0x04,0x04,0x08,//}
0x00,0x00,0x08,0x15,0x02,0x00,0x00,//~
0x0A,0x15,0x0A,0x15,0x0A,0x15,0x0A //
};

//LED screen pins definitions
#define PIN_LOAD        6
#define PIN_DATA        7
#define PIN_CLK         5
#define PIN_RESET       2
#define PIN_INT_OC      3
#define PIN_LOAD2       4


//LED screen commands
#define CMD_CLEAR       0b11000000   //clear display
#define CMD_BR_BRIGHT   0b11101111   //100% brightness
#define CMD_BR_MED      0b11101001   //50% brightness
#define CMD_BR_DIM      0b11100001   //13% brightness

#define CMD_DIG_ADR     0b10100000   //digit adress mask

//
#define SCR_BUF_LEN  7

//Icons defines
#define ICN_R0_ENVELOPE  0x1
#define ICN_R0_GREEN     0x2
#define ICN_R0_RED       0x4
#define ICN_R0_YELLOW    0x8
#define ICN_RO_BAR_0     0x10
#define ICN_RO_BAR_1     0x20
#define ICN_RO_BAR_2     0x40
#define ICN_RO_BAR_3     0x80
#define ICN_RO_BAR_4     0x100

#define ICN_R1_BATTERY   0x8001
#define ICN_R1_SIG_0     0x8002
#define ICN_R1_SIG_1     0x8004
#define ICN_R1_SIG_2     0x8008
#define ICN_R1_BOOK      0x8010
#define ICN_R1_CLOCK     0x8020
#define ICN_R1_BELL      0x8040
#define ICN_R1_LOCK      0x8080
#define ICN_R1_PHONE     0x8100


const unsigned char str[]="TATUAJ - 120 ming, MANIKYUR - 80 ming, ";
unsigned char scr_buf[ SCR_BUF_LEN ] = {' ',' ',' ',' ',' ',' ',' '};
 
//-----------------------------------------------------------
// Send byte to LED screen
//-----------------------------------------------------------
void led_tx_byte( uint8_t data,uint8_t row )
{
  uint8_t i;
        //digitalWrite(PIN_LOAD2, LOW);

  //PIN_LOAD = 0;
  digitalWrite(row?PIN_LOAD2:PIN_LOAD, LOW);
  for( i=0; i<8; i++ )
    {
                delayMicroseconds(1);
                
                digitalWrite(PIN_CLK, LOW);
    //PIN_CLK = 0;
    if( data & (1<<i) )
                        digitalWrite(PIN_DATA, HIGH);
      //PIN_DATA = 1;
    else
                        digitalWrite(PIN_DATA, LOW);
      //PIN_DATA = 0;
    delayMicroseconds(1);
                
                digitalWrite(PIN_CLK, HIGH);
    //PIN_CLK = 1;
    delayMicroseconds(1);
    }

        digitalWrite(row?PIN_LOAD2:PIN_LOAD, HIGH);
        
        digitalWrite(PIN_CLK, LOW);
        delayMicroseconds(1);
}

//-----------------------------------------------------------
// Print single char
// Arguments:
//char,
//symbol position(0-7)
//Row 0,1
//-----------------------------------------------------------
void led_putchar( uint8_t c, uint8_t adr ,uint8_t row)
{    
  uint8_t i;
  const uint8_t *fnt_ptr;
  
  led_tx_byte( adr | CMD_DIG_ADR,row); 
  
  c -= ' ';
  fnt_ptr = &fnt5x7[ ((uint16_t)c)*7 ];

  for( i=0; i<7; i++ )
  {
    led_tx_byte( *fnt_ptr++ & 0x1F,row);
  };
  
}

void led_puticon_i(uint16_t c,uint8_t row)
{
  led_tx_byte( 7 | CMD_DIG_ADR,row); 
  
  led_tx_byte( c & 0x1F,row);
  led_tx_byte( 0,row);
  led_tx_byte( (c>>4)&0x1F,row);
}

void led_puticon(uint16_t icon)
{
  led_puticon_i(icon&0x7FFF,(icon&0x8000)!=0);
}

void led_putstring(const char *str,uint8_t row)
{
  uint8_t i=0;
  while(i<7 && str[i]!=NULL)
  {
      led_putchar( str[i], i,row);
      i++;
  }
} 
//-----------------------------------------------------------
// Send scr_buf to LED screen
//-----------------------------------------------------------
void led_update()
{
  uint8_t i;
  
  for( i=0; i<SCR_BUF_LEN; i++ )
  { 
    led_putchar( scr_buf[i], i,1);
  };  

        led_putstring("=XUMOR=",0);
}
 
//-----------------------------------------------------------
// Shift string buffer left
//-----------------------------------------------------------
void buf_shift( void )
{
  uint8_t i;
  
  for( i=0; i<(SCR_BUF_LEN-1); i++ )
    {
    scr_buf[ i ] = scr_buf[ i+1 ];
    };
  scr_buf[ SCR_BUF_LEN-1 ] = ' ';
}

//-----------------------------------------------------------
// Scroll text buf string for 1 char
//-----------------------------------------------------------
void buf_scroll( void )
{ 
  static unsigned char str_cnt = 0;
  
  buf_shift();
  
  if( str_cnt < (sizeof(str)-1) )
    {
    scr_buf[ SCR_BUF_LEN-1 ] = str[ str_cnt++ ];
    }
  else
    { 
    str_cnt = 0;
    };  
}

void setup() {
  pinMode(PIN_LOAD, OUTPUT);
  pinMode(PIN_DATA, OUTPUT);
  pinMode(PIN_CLK, OUTPUT);
  
  pinMode(PIN_RESET, OUTPUT);
  
  pinMode(PIN_INT_OC,OUTPUT);
  
  pinMode(PIN_LOAD2,OUTPUT);
  
  digitalWrite(PIN_RESET, HIGH);
  digitalWrite(PIN_INT_OC, HIGH);
  
  //LED screen init
  led_tx_byte( CMD_CLEAR,0);
  led_tx_byte( CMD_CLEAR,1);
  led_tx_byte( CMD_BR_BRIGHT,0); //You can set brightness per row
  led_tx_byte( CMD_BR_BRIGHT,1); //You can set brightness per row
  //led_tx_byte( CMD_BR_DIM,1);

}

void loop() {
  delay( 100 );
  buf_scroll();
  led_update();
  //Each row has to be on a different call to led_puticon
  //led_puticon(ICN_R0_RED|ICN_R0_YELLOW|ICN_R0_GREEN|ICN_RO_BAR_2);
  
  //led_puticon(ICN_R1_SIG_0|ICN_R1_BATTERY|ICN_R1_SIG_1);
}
2

сокращенное if()

1 лайк
3

можете написать? как выглядит?

4

Почитай:

1 лайк
5

Если значение переменной row «истина», то вместо всего выражения «подставится» только PIN_LOAD2, в обратном случае «подставится» PIN_LOAD.))

1 лайк
6

Сделал так на Atmel Studio 7 PIN_LOAD не коректно работает, PIN_LOAD2 отлично

void led_tx_byte( uint8_t data,uint8_t row )
{
	uint8_t i;
	if(row == 1)
	{
		PORTC &= ~(1<<PC4); //PIN_LOAD2
	}
	
	PORTC &= ~(1<<PC1); //PIN_LOAD
	for( i=0; i<8; i++ )
		{
         _delay_us(10);
         PORTC &= ~(1<<PC5); //PIN_CLK
		if( data & (1<<i) )
		
         PORTC |= (1<<PC0); // PIN_DATA
		
		else
         PORTC &= ~(1<<PC0); // PIN_DATA
		_delay_us(10);
         PORTC |= (1<<PC5); //PIN_CLK
		_delay_us(10);
		}
	if(row == 1)
	{
		PORTC |= (1<<PC4); //PIN_LOAD2
	}
	
	PORTC |= (1<<PC1); //PIN_LOAD
        PORTC &= ~(1<<PC5); //PIN_CLK
        _delay_us(10);
}
7

Это из Ардуино

Arduino
Arduino1054×543 76.4 KB

Atmel Studio без бутлодер

Atmel Studio 7
Atmel Studio 71295×470 83.4 KB

в PIN_LOAD нет паузы

8

Потому что не правильно сделал.
Тут нужно выражение не if () {} использовать, а if () {} else {}.

1 лайк
9

Спасибо вам большое, код заработал

Снимок
Снимок499×501 35.4 KB

1 лайк
10

форум можно и по русски написать, только расширить таблицу символов

11

Глубокая мысль))

2 лайка
12

А есть какой нибудь программа которые создаёт массив букв

13

есть сообщество, которое через это уже прошло )))

// Standard ASCII 5x7 font

static const unsigned char font[] PROGMEM = {
0, 0, 0, 0, 0, // Empty Cell
62, 91, 79, 91, 62, // Sad Smiley
62, 107, 79, 107, 62, // Happy Smiley
28, 62, 124, 62, 28, // Heart
24, 60, 126, 60, 24, // Diamond
28, 87, 125, 87, 28, // Clubs
28, 94, 127, 94, 28, // Spades
24, 60, 24, 0, 0, // Bullet Point
255, 231, 195, 231, 255, // Rev Bullet Point
24, 36, 24, 0, 0, // Hollow Bullet Point
255, 231, 219, 231, 255, // Rev Hollow BP
48, 72, 58, 6, 14, // Male
38, 41, 121, 41, 38, // Female
64, 127, 5, 5, 7, // Music Note 1
64, 127, 5, 37, 63, // Music Note 2
90, 60, 231, 60, 90, // Snowflake
127, 62, 28, 28, 8, // Right Pointer
8, 28, 28, 62, 127, // Left Pointer
20, 34, 127, 34, 20, // UpDown Arrows
95, 95, 0, 95, 95, // Double Exclamation
6, 9, 127, 1, 127, // Paragraph Mark
102, 137, 149, 106, 0, // Section Mark
96, 96, 96, 96, 96, // Double Underline
148, 162, 255, 162, 148, // UpDown Underlined
8, 4, 126, 4, 8, // Up Arrow
16, 32, 126, 32, 16, // Down Arrow
8, 8, 42, 28, 8, // Right Arrow
8, 28, 42, 8, 8, // Left Arrow
30, 16, 16, 16, 16, // Angled
12, 30, 12, 30, 12, // Squashed #
48, 56, 62, 56, 48, // Up Pointer
6, 14, 62, 14, 6, // Down Pointer
0, 0, 0, 0, 0, // Space
95, 0, 0, 0, 0, // !
3, 0, 3, 0, 0, // "
20, 62, 20, 62, 20, // #
36, 106, 43, 18, 0, // $
99, 19, 8, 100, 99, // %
54, 73, 86, 32, 80, // &
3, 0, 0, 0, 0, // '
28, 34, 65, 0, 0, // (
65, 34, 28, 0, 0, // )
40, 24, 14, 24, 40, // *
8, 8, 62, 8, 8, // +
176, 112, 0, 0, 0, // ,
8, 8, 8, 8, 0, // -
96, 96, 0, 0, 0, // .
96, 24, 6, 1, 0, // /
62, 65, 65, 62, 0, // 0
66, 127, 64, 0, 0, // 1
98, 81, 73, 70, 0, // 2
34, 65, 73, 54, 0, // 3
24, 20, 18, 127, 0, // 4
39, 69, 69, 57, 0, // 5
62, 73, 73, 48, 0, // 6
97, 17, 9, 7, 0, // 7
54, 73, 73, 54, 0, // 8
6, 73, 73, 62, 0, // 9
80, 0, 0, 0, 0, // :
128, 80, 0, 0, 0, // ;
16, 40, 68, 0, 0, // <
20, 20, 20, 0, 0, // =
68, 40, 16, 0, 0, // >
2, 89, 9, 6, 0, // ?
62, 73, 85, 93, 14, // @
126, 17, 17, 126, 0, // A
127, 73, 73, 54, 0, // B
62, 65, 65, 34, 0, // C
127, 65, 65, 62, 0, // D
127, 73, 73, 65, 0, // E
127, 9, 9, 1, 0, // F
62, 65, 73, 122, 0, // G
127, 8, 8, 127, 0, // H
65, 127, 65, 0, 0, // I
48, 64, 65, 63, 0, // J
127, 8, 20, 99, 0, // K
127, 64, 64, 64, 0, // L
127, 2, 12, 2, 127, // M
127, 4, 8, 16, 127, // N
62, 65, 65, 62, 0, // O
127, 9, 9, 6, 0, // P
62, 65, 65, 190, 0, // Q
127, 9, 9, 118, 0, // R
70, 73, 73, 50, 0, // S
1, 1, 127, 1, 1, // T
63, 64, 64, 63, 0, // U
15, 48, 64, 48, 15, // V
63, 64, 56, 64, 63, // W
99, 20, 8, 20, 99, // X
7, 8, 112, 8, 7, // Y
97, 81, 73, 71, 0, // Z
127, 65, 0, 0, 0, // [
1, 6, 24, 96, 0, // 
65, 127, 0, 0, 0, // ]
2, 1, 2, 0, 0, // ^
64, 64, 64, 64, 0, // _
1, 2, 0, 0, 0, // `
32, 84, 84, 120, 0, // a
127, 68, 68, 56, 0, // b
56, 68, 68, 40, 0, // c
56, 68, 68, 127, 0, // d
56, 84, 84, 24, 0, // e
4, 126, 5, 0, 0, // f
152, 164, 164, 120, 0, // g
127, 4, 4, 120, 0, // h
68, 125, 64, 0, 0, // i
64, 128, 132, 125, 0, // j
127, 16, 40, 68, 0, // k
65, 127, 64, 0, 0, // l
124, 4, 124, 4, 120, // m
124, 4, 4, 120, 0, // n
56, 68, 68, 56, 0, // o
252, 36, 36, 24, 0, // p
24, 36, 36, 252, 0, // q
124, 8, 4, 4, 0, // r
72, 84, 84, 36, 0, // s
4, 63, 68, 0, 0, // t
60, 64, 64, 124, 0, // u
28, 32, 64, 32, 28, // v
60, 64, 60, 64, 60, // w
68, 40, 16, 40, 68, // x
156, 160, 160, 124, 0, // y
100, 84, 76, 0, 0, // z
8, 54, 65, 0, 0, // {
127, 0, 0, 0, 0, // |
65, 54, 8, 0, 0, // }
8, 4, 8, 4, 0, // ~
0, 0, 0, 0, 0, // Hollow Up Arrow
252, 36, 36, 24, 0, // р
56, 68, 68, 40, 0, // с
4, 124, 4, 0, 0, // т
156, 160, 160, 124, 0, // у
24, 36, 252, 36, 24, // ф
68, 40, 16, 40, 68, // х
124, 64, 64, 124, 192, // ц
28, 16, 16, 124, 0, // ч
124, 64, 112, 64, 124, // ш
124, 64, 112, 64, 252, // щ
4, 124, 72, 72, 48, // ъ
124, 72, 48, 0, 124, // ы
124, 72, 72, 48, 0, // ь
68, 84, 84, 56, 0, // э
124, 16, 56, 68, 56, // ю
72, 52, 20, 124, 0, // я
126, 17, 17, 126, 0, // А
127, 73, 73, 49, 0, // Б
127, 73, 73, 54, 0, // В
127, 1, 1, 1, 0, // Г
192, 126, 65, 127, 192, // Д
127, 73, 73, 65, 0, // Е
119, 8, 127, 8, 119, // Ж
34, 65, 73, 54, 0, // З
127, 32, 16, 127, 0, // И
127, 32, 17, 125, 0, // Й
127, 8, 20, 99, 0, // К
64, 60, 2, 127, 0, // Л
127, 2, 12, 2, 127, // М
127, 8, 8, 127, 0, // Н
62, 65, 65, 62, 0, // О
127, 1, 1, 127, 0, // П
127, 9, 9, 6, 0, // Р
62, 65, 65, 34, 0, // С
1, 1, 127, 1, 1, // Т
71, 72, 72, 63, 0, // У
14, 17, 127, 17, 14, // Ф
99, 20, 8, 20, 99, // Х
127, 64, 64, 127, 192, // Ц
15, 8, 8, 127, 0, // Ч
127, 64, 124, 64, 127, // Ш
127, 64, 124, 64, 255, // Щ
1, 127, 72, 72, 48, // Ъ
127, 72, 48, 0, 127, // Ы
127, 72, 72, 48, 0, // Ь
65, 73, 73, 62, 0, // Э
127, 8, 62, 65, 62, // Ю
70, 41, 25, 127, 0, // Я
0, 0, 0, 0, 0,
32, 84, 84, 120, 0, // а
60, 74, 74, 49, 0, // б
126, 89, 86, 32, 0, // в
124, 4, 4, 4, 0, // г
192, 120, 68, 124, 192, // д
56, 84, 84, 24, 0, // е
108, 16, 124, 16, 108, // ж
72, 132, 148, 104, 0, // з
124, 32, 16, 124, 0, // и
124, 33, 17, 124, 0, // й
124, 16, 40, 68, 0, // к
64, 56, 4, 124, 0, // л
124, 8, 16, 8, 124, // м
124, 16, 16, 124, 0, // н
56, 68, 68, 56, 0, // о
124, 4, 4, 124, 0, // п
125, 84, 84, 85, 0, // Ё
57, 84, 84, 73, 0 // ё
};
#endif // FONT5X7_H
14

А мне больше интересно другое. Без if-ов конструкция может быть? Например такая работать будет?

PORTC &= ~(1<<(row:PC4?PC1));
И
PORTC |= (1<<(row:PC4?PC1));
15

Чуть позже проверю

16

Такая не скомпилируется даже.

17

Это ж досовская кодировка. В win-1251 заглавные буквы идут первыми

18

Вот тут в нормальной кодировке - shMAX72xxMini/font.h at main · VAleSh-Soft/shMAX72xxMini · GitHub

19

На экране SDA5714 разрешения 5х7

Screenshot_20230105_162203_Samsung Notes
Screenshot_20230105_162203_Samsung Notes933×1328 143 KB

20

То есть только через if? Короче не записать?