ASM51

.


Depois de mais de 1 ano de trabalho escravo, finalmente consegui dominar a coisa.





O que é isso?
Isso é um Tablet de U$68,00. Como eu havia dito a 1 ano atrás, o Brasil esta indo para o saco, não compensa mais desenvolver plaquinhas com ARM.

No inicio de 2011, percebi que o melhor seria adequar um tablet para meus projetos de automação.

Para isso deveria conseguir fazer ele se comunicar com o mundo externo, para ler tensões, enviar e receber comandos para o exterior etc.

Ao final, o tablet acabaria se tornando uma interface humana (IHM) sofisticada.

Mas as coisas nao são tão faceis assim. O tablet vem com a P**** do Android instalado em cima do Linux. Fazer uma IHM para uma maquina sofisticada, rodando Android não é legal. Android demora muito pra inicializar, tem aquele monte de icones que nao serão usados, trava pacas e principalmente, nenhum cliente vai querer uma IHM dedicada para sua maquina com isso.

Eu até que instalei todo o ambiente de desenvolvimento para o Android (Eclipse + SDK Android). Até que aprendi coisa legais pacas mas...., não dá. A P**** do Android nao foi feito pra isso (automaçao de maquinas ou processos).

O que fazer então?

Oras, arrancar o Android e usar o tablet como uma placa convencional de ARM. Mas e o Linux?

Outro drama. É horrivel trabalhar com desenvolvimento de Linux em ambiente Windows.

Maquina Virtual + Linux + Ambiente de desenvolvimento Linux + aquelas linhas de comandos que só alienígenas entendem. Tortura pura.

Graças ao Lucas Zampar (o Mestre dos Mestres), consegui chegar até ai.

Descobri que precisava fazer um troço chamado Rooting no tablet, para ter acesso aos diretorios e poder instalar e desistalar qualquer coisa.

Meses depois consegui desinstalar o Android do tablet. Claro que tablet nao faz nada depois do boot do Linux mas a partir desse boot , eu colocaria minha aplicação. Não foi tão facil assim.

Tirar o Android significa também tirar todas as chamadas do Linux para ele, sem deixar o Linux reclamar.

Alguns meses depois, eureka. Ao ligar o tablet, entra o boot do Linux e após, meu "Olá Mundo" aparece na tela.

Mas como fazer tudo isso, sem ter o codigo fonte do Kernel do Linux?
Onde conseguir o kernel original e drivers desse tablet?

Descobre-se coisas interessantes quando se vai atras disso.

Primeiro passo: descobrir quem é o fabricante do ARM usado no tablet. Não perca tempo tentando contactar o fabricante do tablet e nem perca tempo com kernel achado em forum da internet, que dizem ser o kernel do tablet.

O ARM usado no meu tablet:
http://www.telechips.com/eng/Product/mobile_pro08.asp

O kernel fornecido gratuitamente por esse fabricante:
https://www.telechips.com/technical_sup ... .asp?idx=2

Descoberta numero 1: Chineses não desenvolvem tablets. Eles pegam o projeto pronto (hardware e software) fornecido pelo fabricante do ARM. Tipo Aplication Note. É isso que eles fazem.

O kernel fornecido pelo fabricante é lindo. Vem com todos os drivers da placa e dá entender a sequencia de chamadas de inicialização do hardware interno e como ele deixa tudo prontinho para funcionar.

Depois da inicializaçao do Linux, aparece a chamada para a inicialização da P**** do android.

Até eu chegar a esse ponto, já se passou 1 ano.

Depois de ser torturado e amaldiçoado pelas linhas de comandos do Linux, acordei um dia e disse: " vão pra P*t* que los pariu, quem inventou essa P**** de linha de comando.

Por que não criam icones ou e teclas de atalho para essas linhas de comando? Vão se fudeire. Pra compilar, montar e linkar um projeto no Keil, basta clicar num icone. Por que não fazem isso nos ambientes de desenvolvimento do Linux?

Não me respondam, nao quero saber.

Bem no fim das contas os argumentos que te falei tinham uma certa razão, e macho o senhor, por tirar o Android do tablet.

Ta pensando o que, aqui em casa todo mundo é macho, até minha mãe!

O kernel fornecido gratuitamente por esse fabricante:
https://www.telechips.com/technical_sup ... .asp?idx=2

No link acima nao precisa fazer Logim, clique no botão "Open Source SW"

.

Massa, proex. Tomara que o fabricante não descontinue o produto amanhã e coloque outro no mercado, mandando todo o teu desenvolvimento pro ralo.
Pelo menos o know-how adquirido, você não vai perder.

xultz escreveu:Massa, proex. Tomara que o fabricante não descontinue o produto amanhã e coloque outro no mercado, mandando todo o teu desenvolvimento pro ralo.
Pelo menos o know-how adquirido, você não vai perder.

Gente vim dar uma péssima noticia, o junior largou a eletrônica e ta fazendo cachorro quente na av paulista !!

Quem é Júnior?

Parabéns pelo trabalho putex! Legal esse feedback aqui no fórum!

Antes que o fabim comece com as brincadeiras, eu não quero cachorro quente e sim hot-dog, sem salsicha e molho oka?

xultz escreveu:Quem é Júnior?

Proex.

Estranhamente, sem o Android, só rodando com Linux, o tablet parou de travar.

Esse é outro motivo de cair fora do android, para esse tipo de aplicaçao.

.

proex escreveu:Estranhamente, sem o Android, só rodando com Linux, o tablet parou de travar.

Esse é outro motivo de cair fora do android, para esse tipo de aplicaçao.

.

Proex.
Na pratica então, você esta com o linux, com as librarys, etc, com uma biblioteca gráfica qualquer rodando o aplicativo que você criou ?

tipo KERNEL + ROOTFS ENXUTO + UI SIMPLES ?

Não tem biblioteca gráfica. O Android era responsavel por isso. Alias, grande parte do Android é geraçao e manipulaçao de telas.

Eu desenho as telas pixel a pixel, escrevendo diretamente na ram (buffer de display).

A vantagem é que o buffer do display pode ter até 128MB. Vc define a regiao desse buffer que estará visivel no display. Vc pode tambem escrever numa regiao Nao Visivel e depois torna-la visivel.

Este é um exemplo de uma tecla que eu fiz.

Código: Selecionar todos

 unsigned char MTeclaUp[106] = {
 32,
 106,
  ________,________,________,________,
  ________,________,________,________,
  ________,________,________,________,
  ________,_______X,X_______,________,
  ________,______XX,XX______,________,
  ________,_____XXX,XXX_____,________,
  ________,____XXXX,XXXX____,________,
  ________,___XXXXX,XXXXX___,________,
  ________,__XXXXXX,XXXXXX__,________,
  ________,_XXXXXXX,XXXXXXX_,________,
  ________,XXXXXXXX,XXXXXXXX,________,
  _______X,XXXXXXXX,XXXXXXXX,X_______,
  ______XX,XXXXXXXX,XXXXXXXX,XX______,
  _____XXX,XXXXXXXX,XXXXXXXX,XXX_____,
  ____XXXX,XXXXXXXX,XXXXXXXX,XXXX____,
  ___XXXXX,XXXXXXXX,XXXXXXXX,XXXXX___,
  ________,_XXXXXXX,XXXXXXX_,________,
  ________,XXXXXXXX,XXXXXXXX,________,
  _______X,XXXXXXXX,XXXXXXXX,X_______,
  ______XX,XXXXXXXX,XXXXXXXX,XX______,
  _____XXX,XXXXXXXX,XXXXXXXX,XXX_____,
  ____XXXX,XXXXXXXX,XXXXXXXX,XXXX____,
  ___XXXXX,XXXXXXXX,XXXXXXXX,XXXXX___,
  ________,________,________,________,
  ________,________,________,________,
  ________,________,________,________};


Esta é a funçao que desenha aquela escala tipo BarGraph que vc vê no canto direito da tela:

Código: Selecionar todos


void MontaEscalaBargraf   (unsigned int refX,unsigned int refY )
{
         unsigned int cor= Cinza;
          unsigned int iniciox;
          unsigned int inicioy;
         unsigned int espessura=2;
          unsigned int largura=28;
           unsigned char contador=9;
   
           BargrafX=refX+30;
           BargrafY=refY-409;
         iniciox= refX;
            inicioy= refY;
         BACK_COLOR=Preto;

       // escala da esquerda
   
         while (contador!=0)
         {   
                 TFT_Fill(               
               iniciox,             // Inicio X
               inicioy,             // Inicio Y
               iniciox+largura,       //Fim X
               inicioy+espessura,       //Fim Y
               cor
                    );
         POINT_COLOR=ConvertColor(160,160,160);
         BACK_COLOR=ConvertColor(77,77,77);   
         inicioy=inicioy-50;
         contador--;
         }
         MostraTextoF24(refX-16,refY-9,"0");   
         
         MostraTextoF24(refX-34,refY-59,"0");
         MostraTextoF24(refX-23,refY-59,".");
         MostraTextoF24(refX-16,refY-59,"5");
         
         MostraTextoF24(refX-34,refY-109,"1");
         MostraTextoF24(refX-23,refY-109,".");
         MostraTextoF24(refX-16,refY-109,"0");
         
         MostraTextoF24(refX-34,refY-159,"1");
         MostraTextoF24(refX-23,refY-159,".");
         MostraTextoF24(refX-16,refY-159,"5");
         
         MostraTextoF24(refX-34,refY-209,"2");
         MostraTextoF24(refX-23,refY-209,".");
         MostraTextoF24(refX-16,refY-209,"0");
         
         MostraTextoF24(refX-34,refY-259,"2");
         MostraTextoF24(refX-23,refY-259,".");
         MostraTextoF24(refX-16,refY-259,"5");
         
         MostraTextoF24(refX-34,refY-309,"3");
         MostraTextoF24(refX-23,refY-309,".");
         MostraTextoF24(refX-16,refY-309,"0");
         
         MostraTextoF24(refX-34,refY-359,"3");
         MostraTextoF24(refX-23,refY-359,".");
         MostraTextoF24(refX-16,refY-359,"5");
         
         MostraTextoF24(refX-34,refY-409, "4");
         MostraTextoF24(refX-23,refY-409, ".");
         MostraTextoF24(refX-16,refY-409, "0");
         
         iniciox=refX+14;
         inicioy=refY-10;
          largura=14;
           contador=39;
         
         while (contador!=0)
         {   
                 TFT_Fill(               
               iniciox,             // Inicio X
               inicioy,             // Inicio Y
               iniciox+largura,       //Fim X
               inicioy+espessura,       //Fim Y
               cor
                    );
            
            inicioy=inicioy-10;
            contador--;
         }
         
   // escala da direita      
         iniciox=refX+62;
         inicioy=refY;
          largura=28;
           contador=9;
   
         while (contador!=0)
         {   
                 TFT_Fill(               
               iniciox,             // Inicio X
               inicioy,             // Inicio Y
               iniciox+largura,       //Fim X
               inicioy+espessura,       //Fim Y
               cor
                    );
            
            inicioy=inicioy-50;
            contador--;
         }

         MostraTextoF24(refX+94,refY-9,"0");   
         
         MostraTextoF24(refX+94,refY-59,"0");
         MostraTextoF24(refX+105,refY-59,".");
         MostraTextoF24(refX+112,refY-59,"5");
         
         MostraTextoF24(refX+94,refY-109,"1");
         MostraTextoF24(refX+105,refY-109,".");
         MostraTextoF24(refX+112,refY-109,"0");
         
         MostraTextoF24(refX+94,refY-159,"1");
         MostraTextoF24(refX+105,refY-159,".");
         MostraTextoF24(refX+112,refY-159,"5");
         
         MostraTextoF24(refX+94,refY-209,"2");
         MostraTextoF24(refX+105,refY-209,".");
         MostraTextoF24(refX+112,refY-209,"0");
         
         MostraTextoF24(refX+94,refY-259,"2");
         MostraTextoF24(refX+105,refY-259,".");
         MostraTextoF24(refX+112,refY-259,"5");
         
         MostraTextoF24(refX+94,refY-309,"3");
         MostraTextoF24(refX+105,refY-309,".");
         MostraTextoF24(refX+112,refY-309,"0");
         
         MostraTextoF24(refX+94,refY-359,"3");
         MostraTextoF24(refX+105,refY-359,".");
         MostraTextoF24(refX+112,refY-359,"5");
         
         MostraTextoF24(refX+94,refY-409, "4");
         MostraTextoF24(refX+105,refY-409, ".");
         MostraTextoF24(refX+112,refY-409, "0");
         
      
         iniciox=refX+62;;
         inicioy=refY-10;
          largura=14;
           contador=39;
         
         while (contador!=0)
         {   
                 TFT_Fill(               
               iniciox,             // Inicio X
               inicioy,             // Inicio Y
               iniciox+largura,       //Fim X
               inicioy+espessura,       //Fim Y
               cor
                    );
            
            inicioy=inicioy-10;
            contador--;
         }
         
                POINT_COLOR=Branco;

            MostraTextoF24(refX-94,refY-15,"V");
            MostraTextoF24(refX-80,refY-15,"p");
            MostraTextoF24(refX-67,refY-15,"p");
         
                POINT_COLOR=Laranja;
            MostraTextoF24(refX+8,refY+10,"LEVEL");
            MostraTextoF24(refX-200,368,"Level");

         

}


Como vc vê, linguagem C bem básica.

Para desenhar esse bargraph na tela, basta chamar a funçao e apontar para a regiao da tela ele deverá aparecer:

MontaEscalaBargraf(120,200);

Assim eu posso colocar o Bargraph em qualquer posiçao da tela.

.

Bom, se eu entendi bem então.
Você pegou o kernel, deixou ele em root, e compilou um programa normal em um loop infinito.
E o kernel fica rodando o seu programa ?

Depende do que vc entende por kernel, veja:

Como vc ja deve saber, ao ser energizada, a CPU automaticamente configura o barramento das RAM e Flash, isso é transparente ao usuário.

Depois ela vai na Flash e busca o Boot primario do linux e carrega na Ram externa.

Depois larga pau nesse boot. A partir dai, o boot primario do Linux certifica a memoria ram, testa a integridade dela a começa a carregar o boot principal do Linux na ram.

Nesse boot principal estao todos os drivers de funçoes que serao usados pelo sistema. Depois entra isso:

Inicializaçao do clock da CPU com a freqeuncia certa;
Inicializacao da MMU;
Inicializaçao dos perifericos e pinos da cpu;
Inicializaçao dos buffers de display e hardware;
Inicializaçao do Display e Touch;
Boot principal do Linux com a inicializaçao das funçoes de hardware
Dai começam a aparecer no display as infrmaçoes de boot do Linux.

Código: Selecionar todos


void Main(void)
{
   int i;
   U8 key;
   U32 mpll_val = 0 ;
   Port_Init();
   Isr_Disable();
   i = 2 ;   //don't use 100M!
      //boot_params.cpu_clk.val = 3;
   switch ( i ) {
   case 0:   //200
      key = 12;
      mpll_val = (92<<12)|(4<<4)|(1);
      break;
   case 1:   //300
      key = 13;
      mpll_val = (67<<12)|(1<<4)|(1);
      break;
   case 2:   //400
      key = 14;
      mpll_val = (92<<12)|(1<<4)|(1);
      break;
   case 3:   //440!!!
      key = 14;
      mpll_val = (102<<12)|(1<<4)|(1);
      break;
   default:
      key = 14;
      mpll_val = (92<<12)|(1<<4)|(1);
      break;
   }
   
   init FCLK=440M, so change MPLL first

   ChangeMPllValue((mpll_val>>12)&0xff, (mpll_val>>4)&0x3f, mpll_val&3);
   ChangeClockDivider(key, 12);
   cal_cpu_bus_clk();
   boot_cpu_init();

   MMU_Init();
   MMU_EnableICache();
   page_address_init();
   TargetInit();
   TFT_LCD_Init();
   Led_Display(100);
   Touch_Init();
   printk(linux_banner);
   Lcd_printf(50,30,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Inicializando Sistema");
   OSInit ();
   OSTimeSet(0);
   printk(KERN_NOTICE);


   Lcd_printf(50,30,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Build time is: %s  %s\n", __DATE__ , __TIME__  );
       Lcd_printf(50,60,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Image$$RO$$Base  = 0x%x\n", Image$$ER_ROM1$$RO$$Base );
   Lcd_printf(50,90,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1, "Image$$RO$$Limit = 0x%x\n", Image$$ER_ROM1$$RO$$Limit );
   Lcd_printf(50,120,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Image$$RW$$Base  = 0x%x\n", Image$$RW_RAM1$$RW$$Base );
   Lcd_printf(50,150,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Image$$RW$$Limit = 0x%x\n", Image$$RW_RAM1$$RW$$Limit );
      Lcd_printf(50,180,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Image$$ZI$$Base  = 0x%x\n", Image$$RW_RAM1$$ZI$$Base );
       Lcd_printf(50,30,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1, "Image$$ZI$$Limit = 0x%x\n", Image$$RW_RAM1$$ZI$$Limit );

   Uart_Init( 0,115200 );
   Uart_Select( 0 );
   Beep(2000, 100);
   Uart_SendByte('\n');
   
   rMISCCR=rMISCCR&~(1<<3); // USB1 is selected
   rMISCCR=rMISCCR&~(1<<13); // USB port 1 is enabled.
   rDSC0 = 0x2aa;
   rDSC1 = 0x2aaaaaaa;
   rCLKCON = 0xfffff0;
   
   mpll_val = rMPLLCON;

   
/* Desabilito as duas funçoes abaixo. Nao deixo o sistema operacinal criar as tabelas e temporizaçoes de tasks.
    
      OSTaskCreate (MainTask,(void *)0, &MainTaskStk[MainTaskStkLengh - 1], MainTaskPrio);                                             

                                 
   OSStart (); */

/*boot terminado, agora é só chamar sua aplicaçao e chamar as funçoes de hardware do linux para executa-las*/
   
   Lcd_printf(50,30,RGB( 0xff,0x00,0x00),RGB( 0xFF,0xFF,0xFF),1,"Sistema Inicializado");

   while(1)

   {
      Minha aplicaçao();
   }        

}




Desse codigo em diante nao vou poder mostrar muita coisa pois trata-se de aplicaçao que esta sendo desenvolvida para cliente.

Tem muita coisa dentro disso ai, isso ai é o basicao, vai ter que ralar 1 ano ehehehhe.


.

xultz escreveu:Massa, proex. Tomara que o fabricante não descontinue o produto amanhã e coloque outro no mercado, mandando todo o teu desenvolvimento pro ralo.
Pelo menos o know-how adquirido, você não vai perder.

Xultz,

Não esquente se o fabricante for descontinuar o tablete amanha e coloque outro, o kernel continuará o mesmo, talvez algumas versões mais novas, entretanto mantendo a mesma base.

O conhecimento que o Proex obteve é importante, mas nao se perde, por mais que mude o hardware o kernel do linux cria uma base conhecida onde vc pode trabalhar, Imagine um carro. Vc nao fica mudando os tempos dos disparos dos injetores manualmente, voce só controla um pedal de acelerador. quem fornece o serviço do pedal do acelerador do carro antigamente era o carburador, hoje é a ECU, Nao importa o carro, sempre tem um acelerador que geralmente é um potenciometro. No caso do kernel do linux, o Fabricante que se mate em fazer os drivers para vc, vc só precisa chamar as funcoes certas no kernel para fazer o que deseja.

Proex, parabéns pela postagem, voce esta na frente de muita gente aqui. Eu sou um usuário profissional de linux, que ainda não se aventurou no caminho que vc domina, os comandos da linha de comando eu ja domino a anos, entretanto a linguagem C que dominas eu ainda estou arranhando. Não sou especialista em Kernel, mas tenho boa noção de como um usuario pode conversar com ele.

proex escreveu:.


Depois de mais de 1 ano de trabalho escravo, finalmente consegui dominar a coisa.





O que é isso?
Isso é um Tablet de U$68,00. Como eu havia dito a 1 ano atrás, o Brasil esta indo para o saco, não compensa mais desenvolver plaquinhas com ARM.

No inicio de 2011, percebi que o melhor seria adequar um tablet para meus projetos de automação.

Para isso deveria conseguir fazer ele se comunicar com o mundo externo, para ler tensões, enviar e receber comandos para o exterior etc.

Ao final, o tablet acabaria se tornando uma interface humana (IHM) sofisticada.

Mas as coisas nao são tão faceis assim. O tablet vem com a P**** do Android instalado em cima do Linux. Fazer uma IHM para uma maquina sofisticada, rodando Android não é legal. Android demora muito pra inicializar, tem aquele monte de icones que nao serão usados, trava pacas e principalmente, nenhum cliente vai querer uma IHM dedicada para sua maquina com isso.

Eu até que instalei todo o ambiente de desenvolvimento para o Android (Eclipse + SDK Android). Até que aprendi coisa legais pacas mas...., não dá. A P**** do Android nao foi feito pra isso (automaçao de maquinas ou processos).

O que fazer então?

Oras, arrancar o Android e usar o tablet como uma placa convencional de ARM. Mas e o Linux?

Outro drama. É horrivel trabalhar com desenvolvimento de Linux em ambiente Windows.

Maquina Virtual + Linux + Ambiente de desenvolvimento Linux + aquelas linhas de comandos que só alienígenas entendem. Tortura pura.

Graças ao Lucas Zampar (o Mestre dos Mestres), consegui chegar até ai.

Descobri que precisava fazer um troço chamado Rooting no tablet, para ter acesso aos diretorios e poder instalar e desistalar qualquer coisa.

Meses depois consegui desinstalar o Android do tablet. Claro que tablet nao faz nada depois do boot do Linux mas a partir desse boot , eu colocaria minha aplicação. Não foi tão facil assim.

Tirar o Android significa também tirar todas as chamadas do Linux para ele, sem deixar o Linux reclamar.

Alguns meses depois, eureka. Ao ligar o tablet, entra o boot do Linux e após, meu "Olá Mundo" aparece na tela.

Mas como fazer tudo isso, sem ter o codigo fonte do Kernel do Linux?
Onde conseguir o kernel original e drivers desse tablet?

Descobre-se coisas interessantes quando se vai atras disso.

Primeiro passo: descobrir quem é o fabricante do ARM usado no tablet. Não perca tempo tentando contactar o fabricante do tablet e nem perca tempo com kernel achado em forum da internet, que dizem ser o kernel do tablet.

O ARM usado no meu tablet:
http://www.telechips.com/eng/Product/mobile_pro08.asp

O kernel fornecido gratuitamente por esse fabricante:
https://www.telechips.com/technical_sup ... .asp?idx=2

Descoberta numero 1: Chineses não desenvolvem tablets. Eles pegam o projeto pronto (hardware e software) fornecido pelo fabricante do ARM. Tipo Aplication Note. É isso que eles fazem.

O kernel fornecido pelo fabricante é lindo. Vem com todos os drivers da placa e dá entender a sequencia de chamadas de inicialização do hardware interno e como ele deixa tudo prontinho para funcionar.

Depois da inicializaçao do Linux, aparece a chamada para a inicialização da P**** do android.

Até eu chegar a esse ponto, já se passou 1 ano.

Depois de ser torturado e amaldiçoado pelas linhas de comandos do Linux, acordei um dia e disse: " vão pra P*t* que los pariu, quem inventou essa P**** de linha de comando.

Por que não criam icones ou e teclas de atalho para essas linhas de comando? Vão se fudeire. Pra compilar, montar e linkar um projeto no Keil, basta clicar num icone. Por que não fazem isso nos ambientes de desenvolvimento do Linux?

Não me respondam, nao quero saber.

Voce deve ter trocado 47747 e-mails com os chineses em 1 ano
Parabens!!!!