C letreiro em dinamico de lec em c

19 de dezembro de 2021

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <conio.h>

typedef enum{BLACK,BLUE,GREEN,CYAN,RED,MAGENTA,BROWN,LIGHTGRAY,DARKGRAY,
LIGHTBLUE,LIGHTGREEN,LIGHTCYAN,LIGHTRED,LIGHTMAGENTA,YELLOW,WHITE} COLORS;

static int __BACKGROUND = BLACK;
static int __FOREGROUND = RED;

void textcolor (int color){
    __FOREGROUND = color;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
    color + (__BACKGROUND << 4));}
int main(){
   
   char alphabet[] = "                                                   ***   *   *  *   *  *****  *   *  *   *  *   *  ****   *   *  *   *  ****   *   *  *   *  ****    ****  *      *      *      *      *       ****  ****   *   *  *   *  *   *  *   *  *   *  ****   *****  *      *      *****  *      *      *****  *****  *      *      *****  *      *      *       ****  *      *      *  **  *   *  *   *   ***   *   *  *   *  *   *  *****  *   *  *   *  *   *    *      *      *      *      *      *      *        *      *      *      *  *   *  *   *   ***   *    * *   *  *  *   * *    *  *   *   *  *    * *      *      *      *      *      *      ***** *     ***   *** * * **  *  **     **     **     **     ***    ** *   **  *  **   * **    ***     *  ***   *   *  *   *  *   *  *   *  *   *   ***   ****   *   *  *   *  ****   *      *      *      ****  *    * *    * *    * *  * * *    *  **** * ****   *   *  *   *  ****   * *    *  *   *   *   ***   *   *  *       ***       *  *   *   ***   *****    *      *      *      *      *      *    *   *  *   *  *   *  *   *  *   *  *   *   ***  *     **     **     **     * *   *   * *     *   *     **     **     **  *  ** * * ***   ***     **     * *   *   * *     *     * *   *   * *     **     * *   *   * *     *      *      *      *    ******     *     *     *     *     *     ******    *      *      *      *      *             *                                                  *   ***   *   *      *     *     *             *   ";
   
   int index[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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};
   int textMaxLength = 50; 
   int mapLength = textMaxLength * 49 + 1;
   char text[textMaxLength];
   char eterno ='s';
   int i, j, k, letter, count = 0,cor;
   printf("Entre com o texto\n");
   fgets(text, textMaxLength - 2, stdin);
    cor=5;
    textcolor(cor);
   int textLength = strlen(text);
   char map[mapLength];
   if(textLength == 0){
      printf("Texto vazio");
      exit(0);
   }
   for(j = 0; j < textLength; j++){ 
      for(i = 0; i < 49; i++){
        letter = index[(int)text[j] >= 65 && (int)text[j] <= 90 ? ((int)text[j] + 32) : (int)text[j]]; 
        map[count] = alphabet[letter * 49 + i]; 
        count++;
       
      }
   }

   for(j = 0; j < 7; j++){ 
      for(i = j * 7; i < textLength * 49; i += 49){
         for(k = 0; k < 6; k++){
            printf("%c ", map[i + k]);
         }
      }
      printf("\n");
   }
             
}

boa tarde estou com uma grande dificuldade com esse trabalho , eu ja consegui fazer as letras porém não consigo fazer com que ele rodem em loop infinito da direita pra esquerda ;alguém poderia me dar uma luz

devair1010 · 20 de dezembro de 2021

@Henrique S Medeiros tem um exemplo no post #18 desse link aqui :

https://www.clubedohardware.com.br/forums/topic/1360025-menu-selecionável-em-c/

e você pode fazer de três modos :

1 ) crie o desenho de cada letra e coloque em uma matriz , depois puxe os elementos da matriz da esquerda para a direita , e o primeiro coloque novamente lá na última posição de cada linha , e depois de movimentar a matriz toda , escreva o conteúdo da matriz ,.

2 ) faça um scroll da direita para a esquerda na tela toda , pegando o conteúdo de cada posição da tela .

3 ) use uma função criada pelo usuário , comumente chamada de gotoxy , igual a que está nesse código desse link aí de cima .

arfneto · 20 de dezembro de 2021

Nunca escreva um programa interativo para uma coisa dessas. Ou se puder evitar nunca escreva um, para qualquer coisa. Só vai te atrasar.

Sobre o programa

18 horas atrás, Henrique S Medeiros disse:
  int i, j, k, letter, count = 0,cor;

nunca use variáveis globais com esses nomes tipo i, j e k, aux, isso sempre cai na sua cabeça.

18 horas atrás, Henrique S Medeiros disse:

 for(j = 0; j < 7; j++){ 
      for(i = j * 7; i < textLength * 49; i += 49){
         for(k = 0; k < 6; k++){

Declare as variáveis de controle do loop DENTRO do comando ou no próprio for.

Sobre o painel

Sugiro pensar e implementar da maneira como essas coisas funcionam. O painel não conhece as letras, apenas as colunas, e são as colunas que "movem" e não as letras.

Se usar as letras vai acabar com um efeito estranho com as letras saltando e não uma coisa uniforme.

Veja um painel de verdade. Sempre ajuda. Os símbolos do painel são usados em tamanhos determinados, coisas como 7x9 ou 9 x 14 ou veja isso do Windows:

Pois é, 7 x 16.

Então faça a partir disso. Se o painel vai ter 40 ou 80 caracteres crie o desenho das letras. Pode simplesmente copiar qualquer fonte. E aí vai passando a string pelo painel depois de ir colocando as colunas do lado direito e tirando da esquerda, para dar o efeito de deslizamento. E controle o intervalo entre cada atualização usando um alarme.

Passar a string pelo painel quer dizer colocar os pontos onde vão estar acesos, a partir da direita, uma coluna só por vez. E o loop de rolagem é só passar todas as colunas para a esquerda. a primeira some, no lugar da última aparece a próxima tirinha da última letra.

Se vai usar letras apenas e não como um painel LCD é mais simples: apenas controle o intervalo e gire todo o painel para a esquerda e coloque a ultima letra do lado direito e atualize a tela usando um alarme

20 de dezembro de 2021

@devair1010essa foi a primeira versão codigo fiz exatamente como voce disse , desenhei as letras pores só consegui fazer com que rodassem na vertical , embora tenha pesquisado muito sobre a função gotoxy, não consegui aplicar nela

#include<stdio.h>
#include<string.h>
#include <windows.h>
#include <conio.h>

typedef enum{BLACK,BLUE,GREEN,CYAN,RED,MAGENTA,BROWN,LIGHTGRAY,DARKGRAY,
LIGHTBLUE,LIGHTGREEN,LIGHTCYAN,LIGHTRED,LIGHTMAGENTA,YELLOW,WHITE} COLORS;

static int __BACKGROUND = MAGENTA;
static int __FOREGROUND = RED;

void textcolor (int color){
    __FOREGROUND = color;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
    color + (__BACKGROUND << 4));}
int main(){
	
	int A[7][7]={0,0,1,1,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0};
     int B[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0};
     int C[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0};
     int D[7][7]={1,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,1,1,1,1,1,1,0};
	int E[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0};
	int EP[7][7]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	int F[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0};
	int G[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0};
	int H[7][7]={0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0};
	int I[7][7]={0,1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,1,1,1,1,0};
	int J[7][7]={0,1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,1,1,1,0,0,0};
	int K[7][7]={0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0};
	int L[7][7]={0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0};
	int M[7][7]={0,1,0,0,0,1,0,0,1,1,0,1,1,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0};
	int N[7][7]={0,1,0,0,0,1,0,0,1,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,1,0};
	int O[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0};
	int P[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0};
	int Q[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,1};
	int R[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1};
	int S[7][7]={0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,1,1,1,1,0};
	int T[7][7]={0,1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0};
	int U[7][7]={0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,1,1,0};
	int V[7][7]={0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0};
	int W[7][7]={0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,0,1,0,1,0,0};
	int X[7][7]={0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0};
	int Y[7][7]={0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0};
	int Z[7][7]={0,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,1,1,0};
	int EX[7][7]={0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,1,0,0,0};
	int PF[7][7]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,0};
     int INT[7][7]={0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0};
	char eterno='s';
	char letra[50];             
     int i,j,k=0,cor;
	printf("entre com a letra\n");
	fgets(letra,30,stdin);
  cor=15;
    textcolor(cor);
 while(eterno=='s'){
 while(letra[k]!= '\0'){
 	
	if(letra[k]=='a'|| letra[k]=='A' ){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(A[i][j]==0)
	  	printf(" ");
	  	if(A[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
       printf("\r");
	}
     
	if(letra[k]=='b'|| letra[k]=='B' ){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(B[i][j]==0)
	  	printf(" ");
	  	if(B[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
	
	if(letra[k]=='c'|| letra[k]=='C'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(C[i][j]==0)
	  	printf(" ");
	  	if(C[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
	
	if(letra[k]=='d'|| letra[k]=='D'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(D[i][j]==0)
	  	printf(" ");
	  	if(D[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
 
	if(letra[k]=='e'|| letra[k]=='E'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(E[i][j]==0)
	  	printf(" ");
	  	if(E[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}

	if(letra[k]==' '){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(EP[i][j]==0)
	  	printf(" ");
	  	if(EP[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	 
	if(letra[k]=='f'|| letra[k]=='F'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(F[i][j]==0)
	  	printf(" ");
	  	if(F[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}
	  
	if(letra[k]=='g'|| letra[k]=='G'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(G[i][j]==0)
	  	printf(" ");
	  	if(G[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	  
	if(letra[k]=='h'|| letra[k]=='H'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(H[i][j]==0)
	  	printf(" ");
	  	if(H[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
	 
	if(letra[k]=='i'|| letra[k]=='I'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(I[i][j]==0)
	  	printf(" ");
	  	if(I[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	
	if(letra[k]=='j'|| letra[k]=='J'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(J[i][j]==0)
	  	printf(" ");
	  	if(J[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	  
	if(letra[k]=='k'|| letra[k]=='K'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(K[i][j]==0)
	  	printf(" ");
	  	if(K[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	 
	if(letra[k]=='l'|| letra[k]=='L'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(L[i][j]==0)
	  	printf(" ");
	  	if(L[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	 
	if(letra[k]=='m'|| letra[k]=='M'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(M[i][j]==0)
	  	printf(" ");
	  	if(M[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}
	 
	if(letra[k]=='n'|| letra[k]=='N'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(N[i][j]==0)
	  	printf(" ");
	  	if(N[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	 
	if(letra[k]=='o'|| letra[k]=='O'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(O[i][j]==0)
	  	printf(" ");
	  	if(O[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	
	if(letra[k]=='p'|| letra[k]=='P'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(P[i][j]==0)
	  	printf(" ");
	  	if(P[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}    
	  
	if(letra[k]=='q'|| letra[k]=='Q'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(Q[i][j]==0)
	  	printf(" ");
	  	if(Q[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	 
	if(letra[k]=='r'|| letra[k]=='R'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(R[i][j]==0)
	  	printf(" ");
	  	if(R[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
		printf("\n");  
	if(letra[k]=='s'|| letra[k]=='S'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(S[i][j]==0)
	  	printf(" ");
	  	if(S[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	  
	if(letra[k]=='t'|| letra[k]=='T'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(T[i][j]==0)
	  	printf(" ");
	  	if(T[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
	 
	if(letra[k]=='u'|| letra[k]=='U'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(U[i][j]==0)
	  	printf(" ");
	  	if(U[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}    
	 
	if(letra[k]=='v'|| letra[k]=='V'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(V[i][j]==0)
	  	printf(" ");
	  	if(V[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}  
	
	if(letra[k]=='w'|| letra[k]=='W'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(W[i][j]==0)
	  	printf(" ");
	  	if(W[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	 
	if(letra[k]=='x'|| letra[k]=='X'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(X[i][j]==0)
	  	printf(" ");
	  	if(X[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	} 
	  
	if(letra[k]=='y'|| letra[k]=='Y'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(Y[i][j]==0)
	  	printf(" ");
	  	if(Y[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	  
	if(letra[k]=='z'|| letra[k]=='Z'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(Z[i][j]==0)
	  	printf(" ");
	  	if(Z[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}    	 
	if(letra[k]=='!'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(EX[i][j]==0)
	  	printf(" ");
	  	if(EX[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}   
	if(letra[k]=='.'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(PF[i][j]==0)
	  	printf(" ");
	  	if(PF[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}
	if(letra[k]=='?'){
	
	for(i=0;i<7;i++){
	  for(j=0;j<7;j++){
	  	if(INT[i][j]==0)
	  	printf(" ");
	  	if(INT[i][j]==1)
	  	printf("*");
	  }	
	  printf("\n");
	}	
		
	}                                                                   
	k++;
	Sleep(500);
}
printf("\n");
k=0;
}
                              	
}

arfneto · 20 de dezembro de 2021

Acho que ja sabe que isso dá um trabalho do inferno...

Leia de um arquivo. É muito, mas MUITO mais fácil. Em C é trivial tratar arquivos e você pode desenhar as letras no próprio IDE e o programa cria o resto pra você em poucas linhas.

Do modo como está escrevendo só vai ter mais trabalho e é difícil demais de visualizar.

E como te expliquei o painel de LED não é de letras, é de colunas. É mais fácil de programar assim, e a rolagem é mais suave.

Teste o painel com uma letra só. Não precisa de mais que uma, tipo um 'X' .

20 de dezembro de 2021

@arfneto @devair1010essa foi a primeira versão codigo fiz exatamente como voce disse , desenhei as letras pores só consegui fazer com que rodassem na vertical , embora tenha pesquisado muito sobre a função gotoxy, não consegui aplicar nela

#include <stdio.h>
#include <string.h>
#include <windows.h>
void criacaoFrase(int frase[400][400], int letra[7][9], int posicao){
    int tamanho_j= (posicao-1)*9;
    int i,j,J;
    for(i=0;i<7;i++){
        for(j=0, J=tamanho_j;j<9*posicao;j++, J++){
            frase[i][J] = letra[i][j];
       }
    }
}

void printaFrase(int frase[400][400], int quantidade){
    int i,j;
    int total;
    char eterno='s';
    total=quantidade*9;
   
   while(eterno='s'){
    for(i=0;i<7;i++){
        printf("\n");
         for( j=total ;j>=0;j--){
            if(frase[i][j]==1){
                printf("@");
            }
            else{
                printf(" ");
            }
     Sleep(100);   }
    }printf("\n");}
}

void analisaFrase(char fraseDesejada[0][400], int fraseDigital[400][400], int tamanho){
   int i;
    int A[7][9] =        {{0,0,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0}};

    int B[7][9] =      {{0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0}};

    int C[7][9] =      {{0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,1,1,1,1,0,0,0}};

    int D[7][9] =      {{0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0}};     

    int E[7][9] =      {{0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,1,1,1,1,0,0,0}};     

    int F[7][9] =      {{0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0}};    

    int G[7][9] =      {{0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,1,1,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,1,0,0,0}};   

    int H[7][9] =      {{0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0}};   

    int I[7][9] =      {{0,0,1,1,1,1,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,1,1,1,1,0,0,0}};              
    
    int J[7][9] =      {{0,0,1,1,1,1,1,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,1,0,0,1,0,0,0,0},
                         {0,1,0,0,1,0,0,0,0},
                         {0,0,1,1,0,0,0,0,0}};

    int K[7][9] =      {{0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,1,0,0,0,0},
                         {0,1,0,1,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,0,1,0,0,0,0,0},
                         {0,1,0,0,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0}};
                         
    int L[7][9] =      {{0,1,1,0,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,1,0,0,0,0,0,0},
                         {0,1,1,1,1,1,0,0,0}};

    int M[7][9] =      {{0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,1,0,1,1,1,0},
                         {0,1,1,0,1,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0}};

    int N[7][9] =      {{0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,1,0,0,1,1,0},
                         {0,1,1,0,1,0,1,1,0},
                         {0,1,1,0,0,1,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0}};        

    int O[7][9] =      {{0,0,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,0,1,1,1,1,0,0,0}};        

    int P[7][9] =      {{0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0}};    

    int Q[7][9] =      {{0,0,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,1,0,1,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,0,1,1,1,0,1,0,0}};   

    int R[7][9] =      {{0,1,1,1,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0},
                         {0,1,0,1,0,0,0,0,0},
                         {0,1,0,0,1,0,0,0,0},
                         {0,1,0,0,0,1,0,0,0}};   

    int S[7][9] =      {{0,0,1,1,1,1,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,1,0,0,0,0,0,0,0},
                         {0,0,1,1,1,0,0,0,0},
                         {0,0,0,0,0,1,0,0,0},
                         {0,0,0,0,0,1,0,0,0},
                         {0,1,1,1,1,0,0,0,0}};        

    int T[7][9] =      {{0,1,1,1,1,1,1,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0},
                         {0,0,0,1,1,0,0,0,0}};   

    int U[7][9] =      {{0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,0,1,1,1,1,0,0,0}};    

    int V[7][9] =      {{0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,1,0,0,0,0,1,0,0},
                         {0,0,1,0,0,1,0,0,0},
                         {0,0,0,1,1,0,0,0,0}};     

    int W[7][9] =      {{0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,0,0,1,1,0},
                         {0,1,1,0,1,0,1,1,0},
                         {0,1,1,1,0,1,1,1,0},
                         {0,1,1,0,0,0,1,1,0}};   

    int X[7][9] =      {{0,1,0,0,0,0,0,1,0},
                         {0,0,1,0,0,0,1,0,0},
                         {0,0,0,1,0,1,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,1,0,1,0,0,0},
                         {0,0,1,0,0,0,1,0,0},
                         {0,1,0,0,0,0,0,1,0}};

    int Y[7][9] =      {{0,1,0,0,0,0,0,1,0},
                         {0,0,1,0,0,0,1,0,0},
                         {0,0,0,1,0,1,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,0,1,0,0,0,0}};      

    int Z[7][9] =      {{0,1,1,1,1,1,1,1,0},
                         {0,0,0,0,0,0,1,0,0},
                         {0,0,0,0,0,1,0,0,0},
                         {0,0,0,0,1,0,0,0,0},
                         {0,0,0,1,0,0,0,0,0},
                         {0,0,1,0,0,0,0,0,0},
                         {0,1,1,1,1,1,1,1,0}};

    int espaco[7][9] = {{0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0},
                        {0,0,0,0,0,0,0,0,0}}; 

    int interrogacao[7][9] =   {{0,0,1,1,1,1,0,0,0},
                                 {0,1,0,0,0,0,1,0,0},
                                 {0,0,0,0,0,1,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0}};   

    int exclamacao[7][9] =     {{0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0}};     

    int ponto[7][9] =          {{0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0}}; 
    
  
        for( i=0;i<tamanho-1;i++){  
        char letra = fraseDesejada[0][i];
        if(letra=='A'|| letra=='a'){
            criacaoFrase(fraseDigital, A, i+1);
        }
        if(letra=='B'|| letra=='b'){
            criacaoFrase(fraseDigital, B, i+1);
        }
        if(letra=='C'|| letra=='c'){
            criacaoFrase(fraseDigital, C, i+1);
        }
        if(letra=='D'|| letra=='d'){
            criacaoFrase(fraseDigital, D, i+1);
        }
        if(letra=='E'|| letra=='e'){
            criacaoFrase(fraseDigital, E, i+1);
        }
        if(letra=='F'|| letra=='f'){
            criacaoFrase(fraseDigital, F, i+1);
        }
        if(letra=='G'|| letra=='g'){
            criacaoFrase(fraseDigital, G, i+1);
        }
        if(letra=='H'|| letra=='h'){
            criacaoFrase(fraseDigital, H, i+1);
        }
        if(letra=='I'|| letra=='i'){
            criacaoFrase(fraseDigital, I, i+1);
        }
        if(letra=='J'|| letra=='j'){
            criacaoFrase(fraseDigital, J, i+1);
        }
        if(letra=='K'|| letra=='k'){
            criacaoFrase(fraseDigital, K, i+1);
        }
        if(letra=='L'|| letra=='l'){
            criacaoFrase(fraseDigital, L, i+1);
        }
        if(letra=='M'|| letra=='m'){
            criacaoFrase(fraseDigital, M, i+1);
        }
        if(letra=='N'|| letra=='n'){
            criacaoFrase(fraseDigital, N, i+1);
        }
        if(letra=='O'|| letra=='o'){
            criacaoFrase(fraseDigital, O, i+1);
        }
        if(letra=='P'|| letra=='p'){
            criacaoFrase(fraseDigital, P, i+1);
        }
        if(letra=='Q'|| letra=='q'){
            criacaoFrase(fraseDigital, Q, i+1);
        }
        if(letra=='R'|| letra=='r'){
            criacaoFrase(fraseDigital, R, i+1);
        }
        if(letra=='S'|| letra=='s'){
            criacaoFrase(fraseDigital, S, i+1);
        }
        if(letra=='T'|| letra=='t'){
            criacaoFrase(fraseDigital, T, i+1);
        }
        if(letra=='U'|| letra=='u'){
            criacaoFrase(fraseDigital, U, i+1);
        }
        if(letra=='V'|| letra=='v'){
            criacaoFrase(fraseDigital, V, i+1);
        }
        if(letra=='W'|| letra=='w'){
            criacaoFrase(fraseDigital, W, i+1);
        }
        if(letra=='X'|| letra=='x'){
            criacaoFrase(fraseDigital, X, i+1);
        }
        if(letra=='Y'|| letra=='y'){
            criacaoFrase(fraseDigital, Y, i+1);
        }
        if(letra=='Z'|| letra=='z'){
            criacaoFrase(fraseDigital, Z, i+1);
        }
        if(letra==' '){
            criacaoFrase(fraseDigital, espaco, i+1);
        }
        if(letra=='?'){
            criacaoFrase(fraseDigital, interrogacao, i+1);
        }
        if(letra=='!'){
            criacaoFrase(fraseDigital, exclamacao, i+1);
        }
        if(letra=='.'){
            criacaoFrase(fraseDigital, ponto, i+1);
        }
    }
}




int main(){
    int fraseDigital[400][400];
    char fraseDesejada[1][400];


    printf("Digite a frase desejada: ");
    fgets(fraseDesejada, 400, stdin);
    int tamanho = strlen(fraseDesejada);

    analisaFrase(fraseDesejada, fraseDigital, tamanho);
    printaFrase(fraseDigital, tamanho-1);
}

@arfneto eu fiz em todas as versões possiveis, depois de ver seu comentario alerei o codigo, e consegui imprimir coluna por coluna , porém, a dificuldade eh fazer elas se movimentarem , os professores passaram uma coisa que nunca nem deram em sala de aula , então to meio que por conta propria

JorgeGus · 20 de dezembro de 2021

Um exemplo em C, apenas como sugestão de como fazer a tela correr:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main(void) {
    char v1[40] = {"Coma Mais Pepino. "};
    char v2[40];
    int tam = strlen(v1);
    int tempo;
    for (int c = 0; c < 30; c++) {
        system("cls");
        printf("%s", v1);
        tempo = time(NULL);
        strcpy(v2, v1 + 1);
        v2[tam - 1] = v1[0];
        v2[tam] = 0;
        strcpy(v1, v2);
        while(time(NULL) < tempo + 1);
    }
    return 0;
}

Usando C++ o ideal seria usar Threads e sleep no lugar desse truque com time(), que não deve ser usado em uma situação real, já que mantém o processador ocupado desnecessariamente.

Você pode usar um Map para armazenar a matriz com o desenho das letras e a própria letra como key para não precisar desse monte de ifs, e como já foi dito, o melhor seria fazer a leitura a partir de um arquivo.

Você vai precisar de mais um for dentro do for do exemplo para processar e exibir cada linha da imagem. e caso cada linha seja mais larga que o console, corte a linha armazenando em um vetor temporário apenas para a exibição.

arfneto · 20 de dezembro de 2021

7 horas atrás, Henrique S Medeiros disse:

 int exclamacao[7][9] =     {{0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0}};     

    int ponto[7][9] =          {{0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,0,0,0,0,0},
                                 {0,0,0,0,1,0,0,0,0}}; 
    
  
        for( i=0;i<tamanho-1;i++){  
        char letra = fraseDesejada[0][i];
        if(letra=='A'|| letra=='a'){
            criacaoFrase(fraseDigital, A, i+1);
        }
        if(letra=='B'|| letra=='b'){
            criacaoFrase(fraseDigital, B, i+1);

Esse trecho já dá uma ideia:

do que eu te disse para não fazer
do trabalho do inferno que vai dar escrever algo desse jeito

Sugiro nem continuar assim.

4 horas atrás, JorgeGus disse:

Usando C++ o ideal seria usar Threads e sleep no lugar desse truque com time(), que não deve ser usado em uma situação real, já que mantém o processador ocupado desnecessariamente

Se está usando Windows pode ser bem mais simples em C ou C++ usar CreateTimerQueue() como descrito na documentação. No Unix e derivados talvez alarm() e signal().

Mas nesse caso aqui também pode esperar passivamente usando _Sleep() ou similares, ao invés disso:

4 horas atrás, JorgeGus disse:
 while(time(NULL) < tempo + 1);

devair1010 · 22 de dezembro de 2021

@Henrique S Medeiros aquela primeira opção , de colocar as letras em uma matriz , poderia ser assim :

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#define h GetStdHandle(STD_OUTPUT_HANDLE)
#define getch() _getch()
#define kbhit() _kbhit()
int gotoxy(int, int);
int main()
{
    int letras[26][5] = {
        14,17,31,17,17, ///  A
        30,17,30,17,30, ///  B
        14,17,16,17,14, ///  C
        30,17,17,17,30, ///  D
        31,16,30,16,31, ///  E
        31,16,30,16,16, ///  F
        14,16,19,17,14, ///  G
        17,17,31,17,17, ///  H
        14, 4, 4, 4,14, ///  I
         3, 1, 1,17,14, ///  J
        18,20,24,20,18, ///  K
        16,16,16,16,30, ///  L
        17,27,21,17,17, ///  M
        17,25,21,19,17, ///  N
        14,17,17,17,14, ///  O
        30,17,30,16,16, ///  P
        14,17,21,19,14, ///  Q
        30,17,30,18,17, ///  R
        15,16,14, 1,30, ///  S
        31, 4, 4, 4, 4, ///  T
        17,17,17,17,14, ///  U
        17,17,10,10, 4, ///  V
        17,17,17,21,10, ///  W
        17,10, 4,10,17, ///  X
        17,17,10, 4, 4, ///  Y
        31, 2, 4, 8,31, ///  Z
        0, 0, 0, 0, 0 , ///  espaco
        1, 2, 4, 0,16,  ///  !  exclamacao
    };

    int g,w, px, py, x,lin,col ;                 /// variáveis simples
    char m[5][120] = {0};
    /*
    HANDLE hOut;                                 /// controle dos dispositivos do pc
    hOut = GetStdHandle(STD_OUTPUT_HANDLE);      /// pega a saída padrão
    CONSOLE_SCREEN_BUFFER_INFO SBInfo;           /// informações sobre a buffer da tela
    GetConsoleScreenBufferInfo(hOut, &SBInfo);   /// pega a posição do cursor do console
    px = SBInfo.dwCursorPosition.X;              /// pX será a posição da coluna do cursor no console
    py = SBInfo.dwCursorPosition.Y;              /// pY será a posição da linha do cursor no console
    */
    int y1 = 0, x1 = 5, y2 = y1,
        x2 = x1, j, i = 0, a,  b;                /// y1=linha inicial  y2 para recuperar a linha inicial
    char str[51];                                /// armazenar a Frase
    printf("uma palavra ");                      /// msg
    fgets(str, sizeof(str), stdin);              /// pega a frase toda
    int tm = strlen(str);                        /// calcula o tamanho da frase
    str[tm - 1 ] = ' ';                          /// remove o newLine
    char barra[tm];                              /// moldura do Display de LEDs
    for(i=0; i< ( tm + 1 ) * 7 - 1; i++)
        barra[i] = (char)205;                    /// preenche com esse caractere
    barra[i] = 0;                                /// colocar o finalizador de string's
                                                 /// desenhar os caracteres na matriz m
    for (g = 0; g < tm; g++)                     /// tm eh a qtd de letras
    {
        for (j = 0; j < 5; j++)                  /// o caractere é de 5 linhas e cinco colunas
        {
            x1 = x2;                             /// x1 eh a coluna da direita do caractere
            if(str[g] == ' ')a = 0;
            else
                a = letras[(int)(toupper(
                            str[g])-65)][j];     /// pega o numero da 1 linha do caractere
            for (b = 0; b < 5; b++)              /// aqui eh um numero de apenas 8 bits
            {
                gotoxy(x1, y1);                  /// posiciona o cursor na coluna e linha da Tela
                if (a % 2 != 0)                  /// se bit 0 do numero for igual a 1
                {
                    m[y1][x1-1] = '*';           /// coloca espaço asterisco
                }
                else
                {
                    m[y1][x1-1] = 0;             /// senão coloca espaço normal
                }
                if(a != 0)a = a / 2;             /// dividindo numero por 2 desloca os bits para direita
                x1 -= 1;                         /// move uma coluna para a esquerda
            }
            y1++;                                /// muda para proxima linha
            x1 = x2;                             /// volta para a coluna inicial
        }                                        /// proxima linha
        x2 = x2 + 7;                             /// avança 6 colunas posicionando para o prox caract
        y1 = y2;                                 /// volta para linha inicial
    }                                            /// Desenhou o primeiro caractere

    gotoxy(17,4);
    printf("%s",barra);                          /// desnha o lado de cima da moldura
    do                                           /// repete infinito
    {
        for ( lin = 0; lin < 5; lin++)           /// 5 Linhas da matriz
        {
            gotoxy(17,lin + 5);                  /// inicio da moldura
            printf("%c  ",186);                  /// desenha o lado esquerdo da MolduRa
            for ( col = 0; col < tm*7; col++)    /// percorrer todos os caract da frase
            {
                printf("%c", m[lin][col]);       /// escreve todos os caracteres dessa Linha daa Matriz
            }
            printf("  %c\n",186);                /// desenha o lado direito da Moldura
        }
        gotoxy(17,10);                           /// cursor na pos de baixo do letreiro
        printf("%s",barra);                      /// desenha o lado de baixo da Moldura
        char as;
        for(i=0; i<5; i++)                       /// 5 Linhas
        {
            as = m[i][0];                        /// pega o primeiro caract dessa Linha da Matriz
            for(j=0; j<tm*7; j++)                /// percorrer todos os elementos dessa Linha da frase
            {
                m[i][j] = m[i][j+1];             /// faz o "scroll", puxa os caract para a esQuerda
            }
            m[i][j] = as;                        /// coloca aquele primeiro caract na ultima posicao
        }
        if( kbhit())break;                       /// se precionar alguma tecla , sai desse Loop do / while
        Sleep(30);                               /// faz uma pequena pausa
    }while( 1 );                                 /// Loop etherno
    printf("\n\n\n");                            ///
    return 0;                                    /// retorna para o windows com valor zero
}
int gotoxy(int coluna, int linha)                /// primeiro a coluna depois a linha
{
    COORD c;                                     /// coordenada da tela
    c.X = coluna;                                /// organiza na coluna
    c.Y = linha;                                 /// organiza na Linha
    SetConsoleCursorPosition(h, c);              /// posiciona o cursor , onde escrever
    return 0;                                    /// retorna com o valor zero
}

arfneto · 22 de dezembro de 2021

9 horas atrás, devair1010 disse:

aquela primeira opção , de colocar as letras em uma matriz , poderia ser assim :

Não precisa do 26. Prefira [][5]

   int letras[26][5] = {
        14,17,31,17,17, ///  A
        30,17,30,17,30, ///  B
        14,17,16,17,14, ///  C

Como eu disse antes, é muito melhor usar um arquivo. Prefira

A
.***. 14
*...* 17
****. 31
*...* 17
*...* 17

B
****.
.****
****.
.****
****.

C
.***.
*...*
*....
*...*
.***.

É muito mais fácil de programar, corrigir e visualizar as coisas. Tratar arquivos em C é trivial. Editar matrizes de números é chato pra dizer o mínimo. E vai ter que visalizar em algum OUTRO lugar. E não precisa. Deixe tudo no programa. Mesmo que não queira usar o arquivo pode usar char*[][] e declarar na hora

devair1010 · 22 de dezembro de 2021

@arfneto não consegui captar a ideia , a letra A e C desse arquivo dá para reconhecer , mas o B não , e pegar esses dados no arquivo me parece complicado , e teria que escrever eles todos , do mesmo modo que com matriz ,

arfneto · 23 de dezembro de 2021

17 horas atrás, devair1010 disse:

@arfneto não consegui captar a ideia , a letra A e C desse arquivo dá para reconhecer , mas o B não , e pegar esses dados no arquivo me parece complicado , e teria que escrever eles todos , do mesmo modo que com matriz ,

@devair1010 não há como descrever as letras sem descrever as letras. É a descrição de uma fonte. Seria algo mágico se fosse possível. Tem que descrever cada letra.

Só que se fizer como vocês vem fazendo não dá justamente para visualizar o que vai representar cada letra.

Veja o que você mesmo escreveu

17 horas atrás, devair1010 disse:

a letra A e C desse arquivo dá para reconhecer , mas o B não

voce só pode dizer isso porque "viu" o desenho no arquivo. E se precisar mudar algo é só alterar lá. Não precisa nem compilar o programa...

Compare:

Em 22/12/2021 às 00:07, devair1010 disse:

    int letras[26][5] = {
        14,17,31,17,17, ///  A
        30,17,30,17,30, ///  B
        14,17,16,17,14, ///  C

Ou isso

  int letras[26][5] = {
       30,17,30,17,30, ///  A
       14,17,16,17,14, ///  B
       14,17,31,17,17, ///  C

No segundo bloco A e B estão invertidos. Consegue visualizar uma coisa dessas? E se fossem 256 símbolos?

Desenho de fontes é coisa antiga. Bem antiga. Pense nas impressoras matriciais por exemplo.

Em geral você faz as duas coisas:

Tem um programa que pega o arquivo como mostrei e cria um arquivo de fonte, tipo um Courier.ttf do Windows. Trata-se de um compilador de fonte

Nos programas que usam as fontes tem uma função que carrega a fonte compactada nesse formato para a memória, algo como

    // Algo assim em javascript
    const Fonte_Do_LCD = 
      new FontFace('Letrinhas Regular', 'url(ArquivoCompilado.ttf)');

em javascript (off-topic)

Outra hora mostro um exemplo.

Não adianta o programa parecer mais simples. A solução tem que parecer mais simples.

Escreva em torno dos dados

E os dados são os pontinhos que geram as letras.
Depois OS DADOS são as letras.
Depois os dados são o alfabeto.
Depois os dados são a string que vai para o painel.
Depois um fflush() faz o painel passar as letrinhas mesmo que não tenha a linha completa.

Se o seu programa não seguir essas coisas você vai pagar os custos, em tempos de teste ou erros em tempos de produção ou os dois.

É assim com um painel LCD.

25 de dezembro de 2021

de@devair1010 , tentei compilar o arquivo e ficou assim , o que vou ter que fazer aqui ?

devair1010 · 26 de dezembro de 2021

@Henrique S Medeiros vai depender de qual compilador / IDE você esteja usando , testei aqui no code::blocks 16.01 , e está funcionando bem ,

26 de dezembro de 2021

@devair1010 estou usando o codeblocks 20.03 ,

devair1010 · 26 de dezembro de 2021

@Henrique S Medeiros veja se esse aqui usando o visual studio , vai :

#define _CRT_SECURE_NO_WARNINGS
#define _WIN32_WINNT 0x501
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#define h GetStdHandle(STD_OUTPUT_HANDLE)
#define getch() _getch()
#define kbhit() _kbhit()
int gotoxy   ( int , int );
int textcolor( int , int );
int main()
{
    int letras[40][5] = {
        14,17,31,17,17, ///  A
        30,17,30,17,30, ///  B
        14,17,16,17,14, ///  C
        30,17,17,17,30, ///  D
        31,16,30,16,31, ///  E
        31,16,30,16,16, ///  F
        14,16,19,17,14, ///  G
        17,17,31,17,17, ///  H
        14, 4, 4, 4,14, ///  I
         3, 1, 1,17,14, ///  J
        18,20,24,20,18, ///  K
        16,16,16,16,30, ///  L
        17,27,21,17,17, ///  M
        17,25,21,19,17, ///  N
        14,17,17,17,14, ///  O
        30,17,30,16,16, ///  P
        14,17,21,19,14, ///  Q
        30,17,30,18,17, ///  R
        15,16,14, 1,30, ///  S
        31, 4, 4, 4, 4, ///  T
        17,17,17,17,14, ///  U
        17,17,10,10, 4, ///  V
        17,17,17,21,10, ///  W
        17,10, 4,10,17, ///  X
        17,17,10, 4, 4, ///  Y
        31, 2, 4, 8,31, ///  Z
        0, 0, 0, 0, 0 , ///  espaco
        1, 2, 4, 0,16,  ///  !  exclamacao
    };

    int g, w, px, py, x, lin=0, col;             /// variáveis simples
    char m[5][120] = { 0 };
    int antes, antis;
    CONSOLE_SCREEN_BUFFER_INFO SBInfo;           /// informações sobre a buffer da tela
    if (GetConsoleScreenBufferInfo(h, &SBInfo))
    {
        antes = (SBInfo.wAttributes & 0xFF) & 0x0F;
        antis = ((SBInfo.wAttributes & 0xFF) >> 4) & 0x0F;
    }

    HANDLE hdl;                                  /// controle dos dispositivos do pc
    GetConsoleScreenBufferInfo(h, &SBInfo);      /// pega a posição do cursor do console
    px = SBInfo.dwCursorPosition.X;              /// pX será a posição da coluna do cursor no console
    py = SBInfo.dwCursorPosition.Y;              /// pY será a posição da linha do cursor no console

    int y1 = 0, x1 = 5, y2 = y1,
        x2 = x1, j, i = 0, a, b;                 /// y1=linha inicial  y2 para recuperar a linha inicial
    char str[151];                               /// armazenar a Frase
    textcolor(15,0);
    printf("uma palavra ");                      /// msg
    fgets(str, sizeof(str), stdin);              /// pega a frase toda
    int tm = strlen(str);                        /// calcula o tamanho da frase
    str[tm - 1] = ' ';                           /// remove o newLine
    char barra[150];                             /// moldura do Display de LEDs
    for (i = 0; i < (tm ) * 7 - 5; i++)
        barra[i] = (char)205;                    /// preenche com esse caractere
    barra[i] = 0;                                /// colocar o finalizador de string's
                                                 /// desenhar os caracteres na matriz m
    for (g = 0; g < tm; g++)                     /// tm eh a qtd de letras
    {
        for (j = 0; j < 5; j++)                  /// o caractere é de 5 linhas e cinco colunas
        {
            gotoxy(24,j+10);
            printf("%c  ", 186);                 /// desenha o lado esquerdo da MolduRa
            gotoxy(tm*7+18, j + 10);
            printf("  %c", 186);                 /// desenha o lado esquerdo da MolduRa
            x1 = x2;                             /// x1 eh a coluna da direita do caractere
            if (str[g] == ' ')a = 0;
            else
                a = letras[(int)(toupper(
                    str[g]) - 65)][j];           /// pega o numero da 1 linha do caractere
            for (b = 0; b < 5; b++)              /// aqui eh um numero de apenas 8 bits
            {
                if (a % 2 != 0)                  /// se bit 0 do numero for igual a 1
                {
                    m[y1][x1] = '#';             /// coloca asterisco
                }
                else
                {
                    m[y1][x1] = ' ';             /// senão coloca espaco
                }
                if (a != 0)a = a / 2;            /// dividindo numero por 2 desloca os bits para direita
                x1 -= 1;                         /// move uma coluna para a esquerda
            }
            m[y1][x1] = ' ';
            y1++;                                /// muda para proxima linha
            x1 = x2;                             /// volta para a coluna inicial
        }                                        /// proxima linha
        x2 = x2 + 6;                             /// avança 6 colunas posicionando para o prox caract
        y1 = y2;                                 /// volta para linha inicial
    }                                            /// Desenhou o primeiro caractere
    gotoxy(25, 8);
    printf("%s", barra);                         /// desnha o lado de cima da moldura
    gotoxy(25, 16);
    printf("%s", barra);                         /// desnha o lado de cima da moldura
    do                                           /// repete infinito
    {
        for (lin = 0; lin < 5; lin++)            /// 5 Linhas da matriz
        {
            gotoxy(27, lin + 10);                /// inicio da moldura
            for (col = 0; col < tm * 8; col++)   /// percorrer todos os caract da frase
            {
                if (col >  10 && col < 20)
                         textcolor(12,10);
                else     textcolor( 7, 0);
                printf("%c", m[lin][col]);       /// escreve todos os caracteres dessa Linha da Matriz
            }
        }
        char as;
        for (i = 0; i < 5; i++)                  /// 5 Linhas
        {
            as = m[i][0];                        /// pega o primeiro caract dessa Linha da Matriz
            for (j = 0; j < tm * 8; j++)         /// percorrer todos os elementos dessa Linha da frase
            {
                m[i][j] = m[i][j + 1];           /// faz o "scroll", puxa os caract para a esQuerda
            }
            m[i][j] = as;                        /// coloca aquele primeiro caract na ultima posicao
        }
        if (kbhit())break;                       /// se precionar alguma tecla , sai desse Loop do / while
        gotoxy(79, 25);
        Sleep(1);                               /// faz uma pequena pausa
    } while (1);                                 /// Loop etherno
    textcolor(antes, antis);
    printf("\n\n\n");                            ///
    return 0;                                    /// retorna para o windows com valor zero
}
int gotoxy(int coluna, int linha)                /// primeiro a coluna depois a linha
{
    COORD c;                                     /// coordenada da tela
    c.X = coluna;                                /// organiza na coluna
    c.Y = linha;                                 /// organiza na Linha
    SetConsoleCursorPosition(h, c);              /// posiciona o cursor , onde escrever
    return 0;                                    /// retorna com o valor zero
}
int textcolor(int letras, int fundo)
{
    SetConsoleTextAttribute(h,letras+(fundo << 4));
    return 0;
}

26 de dezembro de 2021

@devair1010 rodou perfeitamente agora , apenas a exclamação qua não ficou com cara de exclamação rsrs

int letras[40][5] = {
        14,17,31,17,17, ///  A
        30,17,30,17,30, ///  B
        14,17,16,17,14, ///  C
        30,17,17,17,30, ///  D
        31,16,30,16,31, ///  E
        31,16,30,16,16, ///  F
        14,16,19,17,14, ///  G
        17,17,31,17,17, ///  H
        14, 4, 4, 4,14, ///  I
         3, 1, 1,17,14, ///  J
        18,20,24,20,18, ///  K
        16,16,16,16,30, ///  L
        17,27,21,17,17, ///  M
        17,25,21,19,17, ///  N
        14,17,17,17,14, ///  O
        30,17,30,16,16, ///  P
        14,17,21,19,14, ///  Q
        30,17,30,18,17, ///  R
        15,16,14, 1,30, ///  S
        31, 4, 4, 4, 4, ///  T
        17,17,17,17,14, ///  U
        17,17,10,10, 4, ///  V
        17,17,17,21,10, ///  W
        17,10, 4,10,17, ///  X
        17,17,10, 4, 4, ///  Y
        31, 2, 4, 8,31, ///  Z
        0, 0, 0, 0, 0 , ///  espaco
        1, 2, 4, 0,16,  ///  !  exclamacao
    };

só uma ultima duvida , descul´pa minha ignorância , estou apenas a 3 meses mexendo com programação como você fez pra esses numeros se tornarem letras , pelo que percebi cada numero traz um padrão

devair1010 · 27 de dezembro de 2021

@Henrique S Medeiros para a exclamação ficou faltando uma verificação na Hora de pegar o valor da posição do caractere na matriz de letras ,

 for (g = 0; g < tm; g++)                     /// tm eh a qtd de letras
    {
        for (j = 0; j < 5; j++)                  /// o caractere é de 5 linhas e cinco colunas
        {
            gotoxy(24,j+10);
            printf("%c  ", 186);                 /// desenha o lado esquerdo da MolduRa
            gotoxy(tm*7+18, j + 10);
            printf("  %c", 186);                 /// desenha o lado esquerdo da MolduRa
            x1 = x2;                             /// x1 eh a coluna da direita do caractere
            if (str[g] == ' ')a = 0;
            //-----------------------------------------------------------------------------         
            //-----------------------------------------------------------------------------
            else
                if (str[g] == '!')a = letras[27][j]; // ficou faltando essa linha
            //-----------------------------------------------------------------------------
            //-----------------------------------------------------------------------------
                else
                    a = letras[(int)(toupper(
                           str[g]) - 65)][j];    /// pega o numero da 1 linha do caractere
            for (b = 0; b < 5; b++)              /// aqui eh um numero de apenas 8 bits
            {
                if (a % 2 != 0)                  /// se bit 0 do numero for igual a 1
                {

e as letras são formada pelos bits que estiverem acesos de cada byte , assim

arfneto · 27 de dezembro de 2021

4 horas atrás, devair1010 disse:

para a exclamação ficou faltando uma verificação na Hora de pegar o valor da posição do caractere na matriz de letras

Pois é. Sugiro escrever como eu disse e deixar as letras em um arquivo. Aí você vê o desenho E O PROGRAMA faz as contas. É o normal, mesmo porque em muitos casos são pessoas diferentes que fazem essas coisas: uma cria as letras e outra programa o display. Tem o cara que sabe desenhar e tem o cara que sabe fazer o programa. E pode não ser o mesmo.

Exemplo

Pode ser ver um exemplo de painel

Um dos mais comuns no planeta é o Hitachi HD44780 e não por acaso pode usar essas letras 5x7

Essa é uma fonte, direto do manual no link acima.

Como diz ao final se pode usar qualquer padrão de pontos, e aí seria o caso desse exercício.

Como eu disse o mais fácil é desenhar as letras num arquivo e dividir a parada em fases:

le o arquivo fonte
cria os padrões para as letras e associa cada um a símbolo, que deve ser a própria letra
acende o display
carrega uma frase pra mostrar
liga o display no modo rotativo controlado pelo programa
fica olhando as letrinhas passando

arfneto · 27 de dezembro de 2021

Acho que não ficou claro o que eu quiz dizer com o exemplo, @devair1010...

Lá no link do controlador tem o manual. E é um PDF. PDF é um formato vetorial. Se você olhar aquele manual a 300% do tamanho vai ver por exemplo na página 17, essa que está aqui acima

E assim você pode simplesmente usar --- copiar --- os pinos como descritos no manual.

Isso podia ser de uma impressora nos anos 80, como um terminal de caixa de banco que tem umas letrinhas assim ruins como essas à esquerda.

Uma impressora acho que usaria algo como 9x14

Imagine um arquivo assim

8 7 linhas colunas
;
;
;
 # grade
 . . H . H . .   1
 . . H . H . .   2
 . H H H H H .   3
 . . H . H . .   4
 . H H H H H .   5
 . . H . H . .   6
 . . H . H . .   7
 . . . . . . .   8
 ;
 ! ponto de exclamacao
 . . . H . . .   1
 . . . H . . .   2
 . . . H . . .   3
 . . . H . . .   4
 . . . . . . .   5
 . . . . . . .   6
 . . . H . . .   7
 . . . . . . .   8
;
# esse serve para copiar e colar e escrever
# as letras conforme preciso. o ~ para a 
# leitura
 ~ gabarito
 . . . . . . .   1
 . . . . . . .   2
 . . . . . . .   3
 . . . . . . .   4
 . . . . . . .   5
 . . . . . . .   6
 . . . . . . .   7
 . . . . . . .   8

;

É claro que eu copiei da fonte do controlador da Hitachi. E é claro que no fim do arquivo tem o gabarito para digitar novas letras com recortar e colar... Veja acima. E o IDE tem insert mode para ser rapidinho. Basta apertar a tecla insert e ir corrigindo o gabarito usando as setas

Entendeu? Agora bastar ler o arquivo no programa e montar a matriz. Na primeira linha tem o tamanho assim pode testar com letras melhores.

Depois as letras estão aí. a Letra e a descrição e depois o desenho.

Não é preciso fazer nada. Só editar no mesmo IDE ao lado do programa por exemplo.

Cria ou copia duas ou 3 letras pra testar e monta o painel.

É claro que o painel poderia ser uma lista ligada de letras, certo? onde cada letra é esse desenho. Assim o painel LCD fica trivial. Ele é ou não é uma série de letras, onde cada letra é uma série de colunas de 8 linhas nesse caso?

Uma letra

typedef struct
{
    char   cor;
    char   fundo;
    char   valor;  // o simbolo
    char   L, C;   // linhas e colunas
    char** col;    // cada linha uma COLUNA da letra

} Letra;

Não podia ser? Nem precisa de tanto aqui, mas assim cada letra poderia ter sua cor e fundo sem nenhum trabalho. Em col está o desenho, montado a partir do arquivo, sem stress, arquivo com as letrinhas copiadas do manual. Não que fosse difícil rabiscar com um lápis sobre um gabarito escrito a caneta com nesse caso 8x7 pontos e depois colocar no arquivo. Afinal nem precisam ser letras.

Um alfabeto

typedef struct
{
    char    L, C;  // linhas e colunas
    short   tam;   // quantas letras no alfabeto?
    Letra** lt;    // vetor de ponteiros para letras

} Alfabeto;

Não é isso? A fonte é uma coleção de letras. Nem precisa nem deve programar muitas.

O painel LCD

typedef struct
{
    Alfabeto* alfa;
    char      cor;     // cor 
    char      fundo;   // e fundo
    short     n_col;   // colunas no painel
    char      estado;  // on/off?

} LCD;