Entre em Contato com a Maurinsoft – Página: 40

Compilação Cruzada em C – Parte 2

No primeiro artigo, definimos o que seria compilação cruzada, e criamos nosso primeiro exemplo de compilação. Gerando binário de 32bits em máquina 64bits.

http://maurinsoft.com.br/index.php/2022/01/22/compilacao-cruzada-em-c/

Neste segundo artigo, iremos dar continuação.

Agora apresentando como compilar em um sistema operaciona x64 para arm.

Pré requisitos

Instale os seguintes pacotes

sudo apt-get install libc6-armel-cross libc6-dev-armel-cross binutils-arm-linux-gnueabi
sudo apt install libncurses5-dev build-essential bison flex libssl-dev bc
sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf
sudo apt-get install gcc-arm-linux-gnueabi g++-arm-linux-gnueabi
Pré requisitos de instalação

Estes pacotes irão instalar as dependencias do ARM nesta plataforma.

Eles irão criar duas pastas arm-linux-gnueabi e
arm-linux-gnueabihf , ambas com pastas lib para inclusão de respectivas bibliotecas.

Git do projeto

https://github.com/marcelomaurin/croxcompile

Usaremos o git do projeto anterior, agora com uma nova diretiva.

Exemplo

Não apresentarei o fonte em C, pois já foi feito no artivo anterior, me atendo realmente o que foi adicionado neste artigo.

Makefile


PROGRAMA=HELLO
PROGRAMA32=HELLO32
PROGRAMAARM=HELLOARM

CC=gcc
CCARM=arm-linux-gnueabi-gcc

SOURCE= crox.c

all32: clean compile32


all: clean compile

clean:
        rm -f *.o
        rm -f $(PROGRAMA)

compile32:
        $(CC) -m32  $(SOURCE) -o $(PROGRAMA32)

compile:
        $(CC) $(SOURCE) -o $(PROGRAMA)

compileARM:
        $(CCARM) $(SOURCE) -o $(PROGRAMAARM)

Podemos ver que adicionamos, a diretiva compileARM, onde chamamos o CCARM, que tem valor arm-linux-gnueabi-gcc

A outra diferença é o target de execução, que chamamos de programaarm, para diferenciar dos demais binários.

Podemos compilar o programa, chamando a seguinte rotina:

make compileARM
compilação do programa

Rodando o programa

Agora iremos demonstrar a efetividade do binário, executando o mesmo em um raspberry pi. Que é uma máquina ARM, rodando linux.

Para tanto copiaremos o binário e colocaremos na maquina alvo.

Para esse feito usarei o bitviser.

Copiando o binário gerado para a máquina alvo

Agora iremos dár as permissões na máquina.

Por fim, executaremos o binário, e veremos seu resultado.

Conclusão

Podemos aproveitar o poder de processamento e velocidade dos desktop e gerar binários nativos para mais de um tipo de equipamento.

No próximo post irei apresentar como fazer isso no android.

Referências

https://www.acmesystems.it/arm9_toolchain

Cross compiling for arm or aarch64 on Debian or Ubuntu

https://howtoinstall.co/pt/gcc-arm-linux-gnueabihf

https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-a/downloads/10-2-2020-11

Blog C/C++

Marcelo Martins

Compilação cruzada em C

Este será o primeiro de alguns artigos que irei abordar sobre compilação cruzada.

Definição

Compilação Cruzada é a capacidade de compilar um aplicativo para um processador que não é o que esta usando.
Definição grosseira, no wiki deve ter alguma melhor, rs.

O processo de compilação cruzada depende de como, e do alvo (target) que iremos compilar.

No nosso caso, iremos compilar uma aplicação 32bits em um sistema 64bits.

O nosso primeiro caso, é montar nossa aplicação.

Objetivo

Como objetivo deste artigo, apresentaremos compilação cruzada, desenvolvendo uma aplicação 32bits em um sistema 64bits linux.

Pré requisitos

Antes de começar precisamos preparar a máquina para compilação cruzada. Para isso, é necessário instalar as libs 32 bits em uma máquina 64 bits.

O primeiro passo é baixar o pacote:

sudo apt-get install gcc-multilib
sudo apt-get install g++-multilib
pacotes para compilação cruzada

Ao instalar o pacote, seu sistema criará várias pastas.

Em geral, um programa não roda sozinho, ele chama uma série de libs que são associadas a funcionálidades. Uma aplicação 64 bits, nativa, aponta sempre para as /usr/lib, porem ao criar um ambiente misto, criamos dois conjuntos de pastas.

Ao compilar um ambiente 32 bits, as libs associadas ao ambiente 32 deverão estar instaladas na pasta /usr/lib32.

Agora para o ambiente 64bits, temos as libs /usr/lib64.

Ao instalar este pacote criamos esta divisão. Porem vale lembrar que criamos os pacotes básicos, cabe ao programador desenvolver e aferir qual o conjunto de pacotes ele irá necessitar, fazendo a instalação do referido pacote para cada uma das pastas necessárias.

Dado a explicação conceitual, vamos ao que interessa!

GIT

Para isso iremos montar um projeto no git, conforme nossa explicação:

https://github.com/marcelomaurin/croxcompile

Neste projeto, iremos fornecer um exemplo que pode ser baixado e utilizado como modelo.

Source: crox.c

#include <stdio.h>

void main(void){
        printf("\nHello World\n");
}

Source: Makefile


PROGRAMA=HELLO
PROGRAMA32=HELLO32

CC=gcc

SOURCE= crox.c

all32: clean compile32


all: clean compile

clean:
        rm -f *.o
        rm -f $(PROGRAMA)

compile32:
        $(CC) -m32  $(SOURCE) -o $(PROGRAMA32)

compile:
        $(CC) $(SOURCE) -o $(PROGRAMA)

O programa crox, irá ser a base para gerar o nosso binário, de fato o mais importante aqui, será o Makefile.

Agora, o primeiro passo é compilar:

Para tanto, iremos executar:

make compile
compilação nativa, deve ser sempre padrão.

Neste caso, nossa máquina é 64 bits, então executaremos um binário quando chamado, 64bits puro.

make compile32
compilação 32 bits em uma máquina 64 bits

Agora, criando uma aplicação 32 bits, podemos comprovar isso, conforme demonstrado na nossa figura abaixo:

Gerados os binários temos que comprovar, que os mesmos, foram gerados nas plataformas alvo desejadas.

O LDD foi apresentado em artigo anterior, conforme link abaixo:

http://maurinsoft.com.br/index.php/2020/11/25/analisando-uma-lib/

Desta forma irei me ater, apenas a apresentar a demonstração do binário.

ldd HELLO
Análise do binário gerado

agora iremos confirmar o resultado do 32 bits:

ldd HELLO32
análise do binário 32bits

Por fim, a tela apresentando os resultados executados.

Bibliografia e referências

https://www.geeksforgeeks.org/compile-32-bit-program-64-bit-gcc-c-c/

https://www.filipeflop.com/blog/o-que-e-compilacao-cruzada/

ESCPOS Fila

Marcelo Martins Elgin, Elgin i9, ESC POS, SERIAL

Mudando Elgin i9 para ESC POS

A impressora Elgin i9 trabalha com dois modos possíveis de impressão.

Utilizando o padrão ESC POS, e o modo tradicional com impressão como impressora Windows.

Ao pegar uma impressora desconhecida, o mais provavel é pegar no modo ESC POS.

A diferença entre um modo e outro, é que o modo ESC POS, cria uma porta serial ao ser conectada.

Porta 38 é a impressora Elgin i9 conectada

Caso voce não encontre esta porta ao plugar sua impressora, deve ser feito o procedimento de instalação dos drivers descritos no arquivo abaixo:

Configurar a Elgin i9

Após instalar os drivers e utilitários Elgin, execute o aplicativo chamado:

Utilitário Impressora térmica

Configurações avançadas

Entre outras funções o botão de configurações avançadas, permite selecionar o tipo de perfil que a impressora irá rodar.

Click no botão CONFIGURAÇÕES PORTA USB , em seguida na tela abaixo:

Selecione o item PORTA SERIAL VIRTUAL, e click no botão CONFIGURAR.

Pronto, sua impressora esta configurada como SERIAL ESC POS.

ESCPOS

Marcelo Martins ESC POS, projeto

Primeiro Post sobre o Projeto ESC POS

Fico feliz que arrumei a casa.

Estou postando hoje o primeiro post do projeto ESC POS.

O Objetivo deste post é publicar as novidades realizadas no projeto.

Hoje arrumei a casa. Incluí a página do projeto na aba de projetos de automação comercial.

Tambem, inclui diversas informações na página principal do projeto.

Cheguei até a compilar o projeto.

Espero nos próximos posts deixar mais novidades, quero começar a liberar versões nas outras plataformas como Linux e ARM e quem sabe MAC.

Blog Dicas

Marcelo Martins dominio, hospedagem, raspberry

Uso do RASPBERRY como servidor WEB

No intuito de desenvolver seu negócio, hoje muitas pessoas tem começado seus próprios blogs e sites.

Os custos relacionado a manter e administrar um site, sempre foi muito caro.

História até aqui

Inicialmente os custos de energia, infra estrutura, ip fixo, domínio, dificultavam muito o acesso a pequenos empresários.

Com o tempo algumas empresas tornaram-se especialistas em hospedagem, o que diminuiu em muito o custo. Porem o preço desta queda, era a massificação dos produtos, e serviços padronizados, que muitas vezes não atendia a necessidade do pequeno empresario.

Em geral os grandes players cobravam taxas até com baixo custo, porem com acesso a banco e limitado a execução de scripts PHP.

De forma geral, quando o negócio precisava de customização mais avançada, tal como scripts, hospedagem de cgi, ou outros programas em background e portas. O custo do serviço voltava a taxas astronomicas.

Em geral os grandes players, baseavam o custo na baixa demanda de pequenos sites, principalmente aqueles rodando wordpress. Pois poderiam subdividir a mesma máquina em vários hosts. Ganhando em escala.

Raspberry

O Raspberry PI já comecou de forma disrruptiva, apresentando em uma pequena placa, um sistema operacional robusto.

E hoje principalmente com as novas versões de 4Gb e 8G, com capacidade de processamento e memória realmente impressionante.

Esta pequena maravilha, com um processador de 4 núcleos, consegue dar conta sem muito esforço de um site.

IP Fixo

Nos conectamos na grande rede (Internet), através do protocolo TCP/IP, que por definição ao fazermos, ganhamos uma identidade (IP), esta identidade, diz quem somos e onde estamos.

O Endereço IP faz bem isso, porem de forma geral as operadoras de internet, tem usado IPs dinâmicos, pois aloca estes ips a medida que os usuários solicitam.

Porem empresas como a Alcans, tem cobrado valores expressivamente próximos dos valores praticados normalmente no mercado, porem com ip fixo.

Isso permitiu de forma geral, a construção e hospedagem de sites.

Compra de Domínios

Ter uma máquina, o IP fixo, não permite ainda ter um site na web. É necessário a compra de um domínio.

O que é um dominio de site, como comprar dominio de site e como registrar dominio?

Domínio de fato é o nome que será encontrado o seu site. No meu caso http://maurinsoft.com.br , o dominio tem diversos formatos e sabores. Podendo ser nacional ou internacional.

Em geral o domínio tem um custo anual que varia em torno de R$69,00 ano. O que não é muito caro. Quase o mesmo que uma pizza por ano.

Conclusão

O uso de equipamentos de baixo custo, e alto rendimento, associado a crescente concorrencia de empresas como a alcans, tem permitido que pequenos empresários consigam o tão sonhado site próprio. Com algum conhecimento técnico, hoje é possivel com um pequeno custo mensal de mais ou menos $50,00 de aumento de energia. Ter seu dominio hospedado em sua própria casa.

C/C++ Sem categoria

Marcelo Martins C, c ansi, fclose, file, fopen, fwrite, manipulação de arquivo, permissão

Teste de Permissão de arquivo

Um erro muito comum em códigos de programadores, é deixar de testar permissão de arquivos.

Muitas vezes programadores experientes usam arquivos para troca de dados ou informações.

Essa prática pode ajudar muito, porem há de se tomar alguns cuidados.

Permissão de arquivos e pastas são dados pelo sistema operacional, em alguns casos, o programador, tenta gravar em locais que exige permissão prévia deste local.

É uma boa prática, antes de ler um arquivo, ler as permissões sobre o mesmo.

Em algumas situações, tentamos escrever dados em arquivos, que possuimos permissão apenas para leitura.

Estarei postando aqui um exemplo simples de programa.

GIT do projeto

https://github.com/marcelomaurin/permissao

Explicação das funcionalidades

Criação de um arquivo

Neste fragmento, criamos um arquivo texto, que servirá de referencia ao nosso programa.

int cria_arquivo(char *arquivo){
  FILE *file;
  file = fopen(arquivo,"w");
  if(file==NULL){
      printf("Erro na criacao do arquivo\n");
      return(1);
  } else {
      fwrite("123456",6,1,file);
  }
  fclose(file);
  return 0;
}

A variavel file, é o descritor, que é um ponteiro do arquivo, que será usado como referência, toda véz que uma operação for realizada nele.

O fopen, cria o arquivo, pois tem o parametro “w” que é write, outro parametro util é o “a” de append, que adiciona no final do arquivo.

Lendo a permissão do arquivo

Neste fragmento apresento o processo de leitura da permissão.

char* permissao(char *file, char* modeval){
  struct stat st;

  memset(modeval,'\0',sizemodeval);
  if(stat(file, &st) == 0){
      mode_t perm = st.st_mode;
      modeval[0] = (perm & S_IRUSR) ? 'r' : '-';
      modeval[1] = (perm & S_IWUSR) ? 'w' : '-';
      modeval[2] = (perm & S_IXUSR) ? 'x' : '-';
      modeval[3] = (perm & S_IRGRP) ? 'r' : '-';
      modeval[4] = (perm & S_IWGRP) ? 'w' : '-';
      modeval[5] = (perm & S_IXGRP) ? 'x' : '-';
      modeval[6] = (perm & S_IROTH) ? 'r' : '-';
      modeval[7] = (perm & S_IWOTH) ? 'w' : '-';
      modeval[8] = (perm & S_IXOTH) ? 'x' : '-';
      modeval[9] = '\0';
      return (char*)modeval;
  } else{
     return strerror(errno);
  }
}

O comando stat, permite ler a permissão de um arquivo.

Alem do stat, temos outros:

stat() e fstatat() recuperam informações sobre o arquivo apontado pelo nome do caminho; as diferenças para fstatat() são descritas abaixo.
lstat() é idêntico a stat(), exceto que se pathname for um link simbólico, ele retornará informações sobre o link em si, não o arquivo ao qual o link se refere.
fstat() é idêntico a stat(), exceto que o arquivo sobre o qual a informação deve ser recuperada é especificado pelo descritor de arquivo fd.

fonte: https://man7.org/linux/man-pages/man2/lstat.2.html

Parte do código gerado neste exemplo foi baseado no artigo:

https://stackoverflow.com/questions/8812959/how-to-read-linux-file-permission-programmatically-in-c-c

Outra forma de testar permissão

Outra forma é o comando access, nele é possivel fazer o teste direto da permissão, sem necessidade de enrolação.

if(access("info.txt",R_OK) ==0{
  printf("Permite Leitura\n ");
}
if(access("info.txt",W_OK) ==0{
  printf("Permite Escrita\n ");
}
if(access("info.txt",X_OK) ==0{
  printf("Permite Execução\n ");
}

Dicas Sem categoria

Marcelo Martins vnc

Instalar o vnc no Ubuntu

Para instalar o vnc no ubuntu com interface gráfica já configurada, realize os seguintes passo:

Com o usuário root, realize a instalação do pacote:

apt install x11vnc

Pronto, agora vc tem o vnc.

Configurando e Acessando o VNC

Entre na interface X11Windows e digite o aplicativo vnc, conforme figura abaixo:

Selecione X11VNCServer, e aguarde…

Pressione o botão OK, conforme figura acima.

Por fim, indique o check de Accept Connections, e digite sua senha na caixa Password.

Finalizando com o botão OK, conforme figura acima.

Pronto seu vnc esta pronto para ser conectado.

Acessando VNC

Instale o VNC Viewer, recomendo a versão do REALVNC. Conforme figura abaixo:

Digite o IP da máquina que deseja conectar, e pronto.

C/C++ Dicas

Marcelo Martins valgrind

Valgrind

Valgrind é uma ferramenta de analise de vazamento de memória.

Nele é possivel identificar e analisar o uso da memória, bem como encontrar problemas no programa.

Estarei apresentando a ferramenta, sendo eu mesmo, um estudante desta ferramenta.

Instalação

Para instalação no Ubuntu, basta digitar o comando a seguir:

apt install valgrind

Utilização

Para utilizar o valgrind, é muito simples, basta chamar o aplicativo através dele, usando a seguinte sintaxe:

valgrind –leak-check=full <programa>

A imagem abaixo, ilustra o uso deste programa.

O código deste programa, pode ser visto no link abaixo:

http://maurinsoft.com.br/index.php/2022/01/05/core-dump-em-c/

Neste exemplo, criamos uma aplicação que gera excessão, pois o ponteiro não foi inicializado.

No código, podemos ver a seguinte informação

Se olharmos no código:

Perceberemos que a menção a função main, na chamada memset, indicando que o sizeof não foi definido.

Vemos tambem que o valgrind acusa que o info não foi inicializado.

Esta é apenas uma pequena demonstração do valgrind, e como pode ser utilizado.

Existe muito a ser aprendido por mim, por esta importante ferramenta de depuração e analise.

Blog C/C++ Dicas

Marcelo Martins core, core dump, dump

Core dump em C

Estaremos abordando aqui o que é um core dump, como trabalhar com ele.

O Core Dump é gerado através da saída anormal do programa.

O core dump, é criado, como um mapa de memória no momento da excessão, com isso é possivel debugar e identificar o problema no momento da excessão.

Iremos abordar um pouco deste processo.

Ativando o Core Dump

Em alguns sistemas operacionais, o core dump vem desativado.

Para ativa-lo, é necessário digitar o seguinte comando:

ulimit -c unlimited
comando ativa o core dump, com tamanho ilimitado.

Criando um programa exemplo

Para demonstrar isso criamos um programa que gera esta excessão.

Fonte teste.c, é conforme se segue:

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

void main(){
        char *info;
        memset(info,'\0',sizeof(info));
        printf("String:%s",info);

}

Como podemos ver a variavel, info, nunca foi inicializada, e quando chamada pelo memset, irá gerar o core dump.

Arquivo Makefile, é como se segue:

all: compile

compile:
        gcc teste.c -o teste

Ao realizar a operação, podemos verificar a geração do erro.

Redirecionando arquivo core dump

Conforme o post deste site:

https://www.baeldung.com/linux/managing-core-dumps

Alias ótimo site, podemos redirecionar o caminho default do core, através do seguinte comando.

 sudo sysctl -w kernel.core_pattern="./%e_core_dump.%p"

Permitindo gerar o dump, no local que bem preferir.

Lendo arquivo Core Dump

O nosso amigo GCC é o programa que irá ler o core dump, para tanto é necessário, abrir o gcc com o core dump. Assim como se estivesse debugando um programa tradicional.

gcc -c <coredump file>

Para saber mais sobre o GCC leia este outro post.

http://maurinsoft.com.br/index.php/2021/08/20/criando-aplicacao-debugavel-no-linux/

Dicas IA pós graduação Sem categoria

Marcelo Martins NVIDIA

Instalando NVIDIA GTX-1070 no Ubuntu

O processo abaixo descreve como instalar a placa de vídeo GTX-1070 no Ubuntu.

O objetivo deste tutorial é auxiliar programadores e estudantes de IA, pois a GTX1070 é recomendada para processamento de padrões.

Referências:

https://itectec.com/ubuntu/ubuntu-install-driver-for-gtx-1070/

https://gist.github.com/iSkore/ad043b64c8576d8eb818f7027da18b09

Pré requisitos

sudo apt remove nvidia*
sudo apt update

sudo apt install dkms build-essential linux-headers-generic vim gcc

Procedimentos

Primeiro será necessário baixar a versão do instalador do site da NVIDIA.

Para isso entre no site:

https://www.nvidia.com.br/Download/index.aspx?lang=br

Informe primeiro o tipo da sua placa, em seguida a série, e a família.

O sistema operacional vem em seguida. Algumas placas não tem todos os sistemas operacionais.

Ao clicar em procurar, surgirá a seguinte tela:

Click em baixar, e aceite os termos, nas telas subsequentes.

Por fim, irá comecar a baixar o arquivo NVIDIA-Linux-x86_64-470.94.run

sudo sh ./NVIDIA-Linux-x86_64-470.94.run

Rode conforme o comando acima.

O padrão de instalação é o enter, vc pode selecionar, outra opção ou usar enter sempre que perguntar, para selecionar opção padrão.

Por fim, reinicie o computador.

Confirmando a instalação

Dê reboot na maquina, em seguida, encontre o aplicativo:

Drivers Adicionais

Execute o mesmo, e vc verá conforme figura abaixo:

Na aba Drivers Adicionais, a gpu instalada, conforme figura acima.