PIC Controlar um cubo de leds 10X10X10

Vini Marques Raimundo · 31 de outubro de 2018

Criei um programação no DEV C++ onde são criadas 10 matrizes 10x10 referentes aos 1000 LEDS que existem no cubo, preciso fazer um algoritmo para o computador entender que todos os pontos das matrizes são LEDS e que se estão com valor 1 o led tem q ligar e que se estão com valor 0 tem q apagar, me ajudem por favor, isto é urgente. Vou deixar a programação feita no DEV C++ e os prints das matrizes que são criadas com o programa.

#include <stdio.h>           // biblioteca padrão de entrada e saída
#include <stdlib.h>          // biblioteca padrão 
#include <fcntl.h>           // biblioteca controle de arquivos para ler a porta serial
#include <conio.h>           // Biblioteca para funções como getch() e funções graficas
#include <math.h>
#include<windows.h>
#include <time.h>
//------------------------------------------------------------------------------
//VARIAVEIS
HANDLE  hCom;

DCB dcb; 

int porta=1;                 // Ponteiro para porta cerial

char dado[5];                 // Variavel para recebimento de dado

char Serial_Port[4];         // Variavel para a seleção da porta a ser utilizada

char SelecionarForma;

char continua;

int matriz[10][10][10]; //DECLARA MATRIZ DE 10 LINHAS E 10 COLUNAS

char send [14];

int i,j,k;

int v1,v2,v3;
   
int a,b,c,d,r;
//------------------------------------------------------------------------------
//CONFIGURA PORTA SERIAL.
int ConfiguraControle(void)
{
   if(!GetCommState(hCom, &dcb))
   {
      return(0);
   }
   dcb.BaudRate = CBR_9600; 
   dcb.ByteSize = 8;
   dcb.Parity = NOPARITY;
   dcb.StopBits = ONESTOPBIT;

   if( SetCommState(hCom, &dcb) == 0 )
   {
      return(0);
   }
   return (1);
}
//------------------------------------------------------------------------------
//Abre a Porta Serial COMx
int AbrirPorta(char *NomePorta)
{
   hCom = CreateFile(
             NomePorta,
             GENERIC_READ | GENERIC_WRITE,
             0, // dispositivos comm abertos com acesso exclusivo
             NULL, // sem atributos de segurança
             OPEN_EXISTING, // deve usar OPEN_EXISTING
             0, //Entrada e saída sem ovelap.
             NULL // hTemplate deve ser NULL para comm
          );
   if(hCom == INVALID_HANDLE_VALUE)
   {
      return(0);
   }
   return (1);
}      
//------------------------------------------------------------------------------       
//FUNÇÃO DO PLANO
int Plano()
{
 printf("Digite os coeficientes do plano \na:");                      
            scanf("%i", &a);
            printf("\nb:");
            scanf("%i", &b);
            printf("\nc:");
            scanf("%i", &c);
            printf("\nd:");
            scanf("%i", &d);
            printf("\n\n");    
                                       
                         for(i=0;i<10;i++)
                          { 
                           for(j=0;j<10;j++)
                            {
                             for(k=0;k<10;k++)
                              {
                               if( a*i + b*j + c*k + d == 0 )
                              { 
                               matriz[i][j][k]=1;
                               printf("1");
                              }
                             else
                              { 
                               matriz[i][j][k]=0;
                               printf("0");
                              } 
                              }
                              printf("\n");
                              }
                              printf("\n\n\n");
                           }  
                                
}
//------------------------------------------------------------------------------
//FUNÇÃO DA RETA
void Reta()
{
 printf("Digite os coeficientes da reta\na:");                      
            scanf("%i", &a);
            printf("\nb:");
            scanf("%i", &b);
            printf("\nc:");
            scanf("%i", &c);
            printf("\nv1:");       
            scanf("%i", &v1);
            printf("\nv2:");
            scanf("%i", &v2);
            printf("\nv3:");
            scanf("%i", &v3); 
                                       
                         for(i=0;i<10;i++)
                          { 
                           for(j=0;j<10;j++)
                            {
                             for(k=0;k<10;k++)
                              {
                               if( (((i-a)/v1) == ((j-b)/v2)) && (((j-b)/v2)  == ((k-c)/v3)) )
                                 { 
                                  matriz[i][j][k]=1;
                                  printf("1");
                                 }
                               else
                                 { 
                                  matriz[i][j][k]=0;
                                  printf("0");
                                 } 
                                 }
                              printf("\n");
                              }
                              printf("\n\n\n");
                           }      
                    
                                  
}    
//------------------------------------------------------------------------------
//FUNÇÃO DA ESFERA
void Esfera()
{
     printf("Digite o raio da esfera");                      

            printf("\nr:");
            scanf("%i", &r);
             
                                       
                         for(i=0;i<10;i++)
                          { 
                           for(j=0;j<10;j++)
                            {
                             for(k=0;k<10;k++)
                              {
                               if( ( (i*i) + (j*j) + (k*k) ) <= r*r )
                               { 
                                matriz[i][j][k]=1;
                                printf("1");
                               }
                               else
                               { 
                                matriz[i][j][k]=0;
                                printf("0");
                               } 
                               }
                              printf("\n");
                              }
                              printf("\n\n\n");
                           }      
}                           
//------------------------------------------------------------------------------                                                                                                          
//ROTINA PRINCIPAL
int main(int argc, char *argv[])
{        
   // Recebe a por5ta que deve conectar
     printf("\n\nEntre com o nome da porta a ser utilizada : (EX: COM1,COM2 ...)\n\n");
     scanf("%s",Serial_Port); 
         
    AbrirPorta(Serial_Port);
    ConfiguraControle();
    CloseHandle(hCom);       
   
    porta = open(Serial_Port, O_RDWR);                  //abrir porta COMX
   // Trata erro na abertura da porta
   if (porta == -1) 
   { 
     printf("\n\nImpossivel abrir a porta. Ou porta não encontrada!\n\n");
   }
   else
       {

        // Se tudo ocorreu nos conformes limpa a tela e escreve o cabeçalho no arquivo
       // E informa que a porta selecionada foi conectada com sucesso     
                 system("cls"); 
                 printf("\nPorta %s Conectada\n\n",Serial_Port);                 
       }  
        sleep(1000);                 
//---------------------MENU DE FUNÇÕES------------------------------------------  
      do
        { 
          printf("Selecione a forma geometrica desejada" "\n");

          SelecionarForma = getche();
          
                 if(SelecionarForma=='p')
                   { 
                    Plano();
                   } 
                 if(SelecionarForma=='r')
                   {
                    Reta();
                   }
                 if(SelecionarForma=='e')
                   {
                    Esfera();
                   }                                     
        
          printf("Executar Novamente (s/n)\n\n");
          continua = getch();           
        }
     while((continua=='s')||(continua=='S'));
//------------------------------------------------------------------------------        
 system("PAUSE");	
 return 0;
}

.if · 31 de outubro de 2018

Uma matriz tridimensional na memória pode ser fácil mas pra montar no mundo real é xatinha... acho.

Uma semente... Já que estás no pc e este não tem muita limitação de recursos, uma ideota conceitual semiminimalista que da até pra fazer com mc (o dono deste forum) é fazer com 2 doubles ou longs de 32 bits. Vai ter 1024 leds mas é só ignorar 24. O lance é você distribuir fisicamente os leds de modo a saber a posição de cada um. Algo como:

unsigned long x,y;

P.ex. pra acender o led do meio você faria

x=0b0000000000000001000000000000000; //catodo
y=0b1111111111111110111111111111111; //anodo

Perceba que é relativamente fácil de "ver" o led aceso. Ah sim... repensei.... você vai ter que fazer um sistema de varredura 32x32 com anodo um catodo comum num dos longs. O que torna o sistema um pouco menos fácil. A cada deslocamento horizontal p.ex. você controla 32 leds verticais. Como são 32 deslocamentos... já sabe.

Uma manipulação "na pinça" dos bits e você monta a figura que desejar. Uma opção curiosa é você usar uma das mais sinistras entidades do c que é o union. Pesquise por campo de bits com union e faça uma estrutura de controle maluca. P.ex. talvez você consegue "incorporar" literalmente 128 bytes nesta estrutura doida sendo cada bit seu led: exatamente o que você quer. É conceitual, to com preguiça de pensar, mas teoricamente possível.

A parte do hw vislumbro 8 74hc595. Com led de alto brilho penso que nem precisa de driver: montagem minimalista ... meu mundo.

Bem... acho que enfeitei o pavão. Basta-te uma matriz de 32 elementos de 32 bits

unsigned long leds[32];//ou double

que conterá a imagem bit a bit dos leds. você pode/deve montar seu desenho tridimensional dentro dela. Pra colocar nos leds depende do seu hw (se achar que deve, fale sobre ele) mas pra imprimir na tela, algo como

leds[0]=0xAFBABACA;
unsigned long temp;
temp=leds[0];
for (i=0;i<32;i++)
{
if(temp&0x80000000) printf("1"); else printf("0");
temp<<=1;
}

Um up bem bacana seria você criar um programa que pega uma imagem 3d e monte seu padrão de leds. Mas já que é pra sonhar, que tal uma imagem 3d em movimento? Um holograma... acho que já vi este filme.

Acha que acabou? você ainda nem digeriu e lá vai...

Olha como é trisimples uma maneira teórica de você controlar os 1024 leds num mc de 32 bits p.ex. atsam3n4c:

unsigned long leds[32],k=1; //pode ser char pois mc é de 32 bits
unsigned char i=0;

//teorizo uma interrupt duns 1500Hz. Cintilação de ~50Hz não deve ser percebida
static void interrupt 
timer_int(void)
{
//setup do timer
PORTA=~k;//catodo comum
PORTC=leds[i];
i++;
k<<=1;
if (i>32) {i=0;k=1;}
}

void main(void)
{
unsigned char j;
//setup do hw
for(j=0;j<32;j++) led[j]=1<<j;//um risco!

for(;;)
{

}

}

Espero não ter te causado ainda mais indigestão...kk