Posts com Tag ‘software’

Caro(a) Colega,

não perca essa oportunidade de baixar o livro sobre padrões de arquitetura de software. Clique na figura a seguir para obter acesso ao livro.

Abraço,

.

Henrique

consulte sempre um engenheiro eletrônico

===========================================

Software Architecture Patterns

The success of any application or system depends on the architecture pattern you use. By describing the overall characteristics of the architecture, these patterns not only guide designers and developers on how to design components, but also determine the ways in which those components should interact.

This O’Reilly report takes a deep dive into many common software architecture patterns. Each pattern includes a full explanation of how it works, explains the pattern’s benefits and considerations, and describes the circumstances and conditions it was designed to address. The report also includes an analysis and scorecard for each pattern based on several architecture and software development quality attributes.

Patterns include:

  • Layered architecture
  • Event-driven architecture
  • Microkernel architecture
  • Microservices architecture
  • Space-based architecture

In addition to these specific patterns, you’ll also learn about the Architecture by Implication anti-pattern and the causes and effects of not using architecture patterns.

By downloading this content, you agree to receive regular updates from O’Reilly Media including a weekly newsletter.

Offered Free by: O’Reilly Media
See All Resources from: O’Reilly Media

Caro Colega,

na próxima semana o destaque é para o mini curso sobre Desenvolvimento de Software Embarcado com Phyton e Raspberry Pi. Confira também os demais treinamentos programados para a próxima semana.

Abraço,

Henrique

consulte sempre um engenheiro eletrônico

===============================================

DESTAQUES:

  • 18 a 22/08/2014 – Mini Curso: Embedded Software Development With Python & the Raspberry Pi
    • August 18 – Day 1: Introduction to Python – This session will introduce the Python programming language. It will provide an overview of where to get it, how to install it, and why an embedded engineer should learn Python. Since most embedded engineers are familiar with C, an in-depth comparison between language syntax will be covered to help attendees quickly leap into this powerful language.
    • August 19 – Day 2: Python Fundamentals – This session will present basic concepts on how to design embedded software using Python. Concepts such as lists, dictionaries, string, and file system manipulations are a few examples of what will be covered. How to develop object-oriented code and even how to import C code will also be presented. Example scripts will be provided so that attendees can follow along and take the language for a spin.
    • August 20 – Day 3: An Overview of the Raspberry Pi (& Single-Board Computers) : This session will dig into the details of single-board computers and how they are revolutionizing how we do things. The famous Raspberry Pi hardware will be discussed in addition to how to set up the hardware for experiments in future sessions. This will include a look at available operating systems, tools, and expansion boards that can be used to quickly get a prototype system up and running.
    • August 21 – Day 4: Controlling Raspberry Pi Peripherals With Python: Writing software can be fun, but when the software controls hardware and starts interfacing with the external world is when things really get going! The Raspberry Pi has a number of common interfaces that can be used to communicate with the external world and this session will cover how to use Python to access each of those interfaces. By the end of this session attendees will be ready to connect just about anything!
    • August 22 – Day 5: An Internet of Things Weather Station Example: Sensor networks and moving data through the internet and web are becoming absolutely critical with concepts such as the Internet of Things on the near horizon. Each of the previous sessions have covered critical building blocks to create a system using a single-board computer. This session pulls it all together by providing an example weather station that interfaces to sensors such as humidity and temperature. The data is streamed through the Internet and accessible via a website.

======================================================================================

  • 20/08/2014 – Protect Your Device Against Power-Related Damage During Test
  • 20/08/2014 – Meeting Today’s IoT Device Challenges with Virtualization and Consolidation
  • 21/08/2014 – How to Leverage Open Architectures for Existing Systems
  • 21/08/2014 – Finding Victims Trapped in Rubble with NASA Radar Device
  • 21/08/2014 – One Size Doesn’t Fit All: Which connectivity technology is right for your IoT design and how to easily get started

“Clicke” na figura abaixo para abrir a agenda detalhada:

 

Calendário Agosto 2014

Caro(a) Colega,

Arduino é certamente um tema que despertou o interesse de muitos. Assim, para enriquecer o conteúdo técnico do nosso blog, resolvi publicar um excelente artigo técnico introdutório sobre esse assunto. Esse artigo foi publicado originalmente no site Embarcados e é de autoria de Fábio Souza. Outros artigos sobre esse assunto você pode conferir no  site Embarcados ou no site FBS Eletrônica (A eletrônica ao alcance de todos).

Aproveite! Abraço,

Henrique

consulte sempre um engenheiro eletrônico

==================================================================================================

logo-Arduino_1

Arduino é uma plataforma de código aberto (hardware e software) criada em 2005 pelo italiano Massimo Banzi (e outros colaboradores) para auxiliar no ensino de eletrônica para estudantes de design e artistas. O objetivo principal foi o de criar uma plataforma de baixo custo, para que os estudantes pudessem desenvolver seus protótipos com o menor custo possível. Outro ponto interessante do projeto, foi a proposta de criar uma plataforma de código aberto, disponível para a comunidade o que ajudou em muito no seu desenvolvimento.

site da plataforma Arduino o define como:

“O Arduino é uma plataforma de prototipagem eletrônica open-source que se baseia em hardware e software flexíveis e fáceis de usar. É destinado a artistas, designers, hobbistas e qualquer pessoa interessada em criar objetos ou ambientes interativos.

O Arduino pode sentir o estado do ambiente que o cerca por meio da recepção de sinais de sensores e pode interagir com os seus arredores, controlando luzes, motores e outros atuadores. O microcontrolador na placa é programado com a linguagem de programação Arduino, baseada na linguagem Wiring, e o ambiente de desenvolvimento Arduino, baseado no ambiente Processing. Os projetos desenvolvidos com o Arduino podem ser autônomos ou podem comunicar-se com um computador para a realização da tarefa, com uso de software específico (ex: Flash, Processing, MaxMSP).”

Plataforma de desenvolvimento Arduino

O Arduino é formado por dois componentes principais: Hardware e Software.

hardware é composto por uma placa de prototipagem na qual são construídos os projetos.

software é uma IDE, que é executado em um computador onde é feita a programação, conhecida como sketch, na qual será feita upload para a placa de prototipagem Arduino, através de uma comunicação serial. O sketch feito pelo projetista dirá à placa o que deve ser executado durante o seu funcionamento.

Hardware do Arduino

Existem diversas placas oficiais de Arduino e muitas outras não oficiais. Vamos abordar a placa Arduino Uno nesse artigo. A seguir é exibida a placa Arduino Uno REV3:


Arduino_2

Conforme visto na imagem acima a placa Arduino UNO possui diversos conectores que servem para interface com o mundo externo. Vejamos como estão organizados os pinos na placa:

  • 14 pinos de entra e saída digital (pinos 0-13):
    • Esses pinos podem ser utilizados como entradas ou saídas digitais de acordo com a necessidade do projeto e conforme foi definido no sketch criado na IDE.
  • 6 pinos de entradas analógicas (pinos A0 – A5):
    • Esses pinos são dedicados a receber valores analógicos, por exemplo, a tensão de um sensor. O valor a ser lido deve estar na faixa de 0 a 5 V onde serão convertidos para valores entre 0 e 1023.
  • 6 pinos de saídas analógicas (pinos 3, 5, 6, 9, 10 e 11):
    • São pinos digitais que podem ser programados para ser utilizados como saídas analógicas, utilizando modulação PWM.

A alimentação da placa pode ser feita a partir da porta USB do computador ou através de um adaptador AC. Para o adaptador AC recomenda-se uma tensão de 9 a 12 volts.

Software do Arduino

O software para programação do Arduino é uma IDE que permite a criação de sketches para a placa Arduino.  A linguagem de programação é modelada a partir da linguagem Wiring . Quando pressionado o botão upload da IDE, o código escrito é traduzido para a linguagem C e é transmitido para o compilador avr-gcc, que realiza a tradução dos comandos para uma linguagem que pode ser compreendida pelo microcontrolador.

A IDE apresenta um alto grau de abstração, possibilitando o uso de um microcontrolador sem que o usuário conheça o mesmo, nem como deve ser usado os registradores internos de trabalho.

A IDE do Arduino possui uma linguagem própria baseada na linguagem C e C++.

O Ciclo de programação do Arduino pode ser dividido da seguinte maneira:

  1. Conexão da placa a uma porta USB do computador;
  2. Desenvolvimento de um sketch com comandos para a placa;
  3. Upload do sketch para a placa, utilizando a comunicação USB.
  4. Aguardar a reinicialização, após ocorrerá à execução do sketch criado.

A partir do momento que foi  feito o upload o Arduino não precisa mais do computador: o Arduino executará o sketch criado, desde que seja ligado a uma fonte de energia.

IDE do Arduino

A IDE pode ser baixada gratuitamente no site do Arduino, onde pode ser escolhida a melhor opção de download conforme plataforma utilizada.

Quando se abre o IDE do Arduino, será exibido algo semelhante à figura abaixo:


Arduino_3

O IDE é dividido em três partes: A Toolbar no topo, o código ou a Sketch Window no centro, e a janela de mensagens na base, conforme é exibido na figura anterior.

Na Toolbar há uma guia, ou um conjunto de guias, com o nome do sketch. Ao lado direito há um botão que habilita o serial monitor. No topo há uma barra de menus, com os itens File, Edit, Sketch, Tools e Help. Os botões na Toolbar fornecem acesso rapido às funções mais utilizadas dentro desses menus.

Abaixo são identificados os ícones de atalho da IDE:

  • Verify
    • Verifica se existe erro no código digitado.
  • Upload
    • Compila o código e grava na placa Arduino se corretamente conectada;
  • New
    • Cria um novo sketch em branco.
  • Open
    • Abre um sketch, presente no sketchbook.
  • Save
    • Salva o sketch ativo
  • Seria monitor
    • Abre o monitor serial.

Os demais comandos presentes na barra de menus podem ser consultados através do menu <help><Environment>.

Após a conexão do Arduino ao computador, é atribuído a placa uma COM. A primeira vez que o programa Arduino for executado deve-se selecionar o modelo de placa utilizado, no nosso caso escolheremos Arduino Uno, conforme figura abaixo:


Arduino_4

Após a definição do modelo, deve-se selecionar em qual COM a placa foi atribuída:

Arduino_5

Após estas configurações o ambiente está preparado para uso e pode-se testar qualquer um dos exemplos que acompanham a IDE ou até mesmo com um novo sketch.

“Hello World” – Blink

O exemplo mais simples para iniciar a programação do Arduino, que pode ser considerado como o conhecido “Hello World” das linguagens de programação, consiste em acionar um LED através de uma saída digital.

A placa Arduino Uno já possui um Led ligado ao pino digital 13 que pode ser utilizado para o teste, e na IDE podemos carregar o exemplo Blink:


Arduino_6

Para verificar de o código está correto deve-se clicar no ícone verify, após a compilação é exibida uma mensagem de status da operação e caso esteja tudo certo será exibida a quantidade de bytes gerados pelo programa:


Arduino_7

Para grava o código na memória flash do microcontrolador é necessário clicar no ícone Upload, será transferido o código para a placa e após alguns segundos o LED ligado ao pino 13 começará a piscar em intervalos de 1 segundo.

Analisando o Código

O código do exemplo Blink é relativamente simples, porém apresenta a estrutura básica de um programa desenvolvido na IDE Arduino. Inicialmente nota-se que existem duas funções obrigatórias em um programa Arduino, setup() e loop().

A função setup () é executada na inicialização do programa e é responsável pelas configurações iniciais do microcontrolador, tal como definição dos pinos de I/O, inicialização da comunicação serial, entre outras.

A função loop () será onde ocorrerá o laço infinito da programação, ou seja, onde será inserido o código que será executado continuamente pelo microcontrolador.

Dentro do loop principal está o código que fará o led ligado pino 13 piscar em intervalos de 1 segundo.

A função digitalWrite(led, HIGH); coloca o pino em nível lógico 1, ligando o led.

A função delay(1000); aguarda o tempo de 1000 ms, ou seja, 1 segundo para que possa ser executada a próxima instrução.

A função digitalWrite(led, LOW); coloca o pino em nível lógico 0, desligando o led.

E novamente é esperado 1 segundo com a função delay();

O loop é repetido infinitamente enquanto a placa estiver ligada.

A referência da linguagem Arduino pode ser acessada através do menu <help>:


Arduino_8

Testar outros exemplos básicos, é um bom começo para aprender mais sobre a plataforma Arduino.

Referências

http://arduino.cc/

http://playground.arduino.cc//Portugues/HomePage

Licença Creative Commons
Arduino – Primeiros Passos. por Fábio Souza. Esta obra está licenciado com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Caro(a) Colega,

já se encontram na nossa estante virtual as novas edições das revistas:

  • NASA Techbriefs – Motion, Control & Automation Technology;
  • NASA Techbriefs – Defense;
  • LEDs Magazine;
  • Revista PROGRAMAR;
  • COTS Journal;
  • Design News;
  • Machine Design;
  • Electronics Cooling;
  • RTC Magazine;
  • Medical Design Technology;
  • New Electronics;
  • Laser Focus World;
  • HF-Praxis.

Boa leitura! Abraço,

Henrique

consulte sempre um engenheiro eletrônico

———————————————–

NASA Techbriefs - Motion, Control and Automation Technology NASA Techbriefs - Defense Tech Briefs, Aerospace Engineering, RF & Microwave Technology, and Embedded Technology  LEDs Magazine - June 2013 Programar - Edição -  Junho 2013 COTS Journal - June 2013 Design News - June 2013 Machine Design - June 2013 Electronics Cooling - June 2013 RTC Magazine - June 2013 Medical Design Technology - May 2013 New Electronics - June 2013 Laser Focus World - June 2013

Revistas Alemãs:

HF Praxis - Juli 2013

Easy-Code-660x92

.

Introdução

 Neste artigo vou apresentar uma ferramenta de software que utilizo há muitos anos, o EASYCODE. Garimpei essa ferramenta para melhorar minha produtividade no desenvolvimento de software embarcado para microcontroladores e DSPs. Eu sempre utilizei o método gráfico para planejamento e projeto de software conhecido como diagramas Nassi-Shneiderman e a abordagem Top-Down para o refinamento dos blocos do software. Essa ferramenta de software utiliza esses mesmos diagramas Nassi-Shneiderman para planejar e gerar o software.

  .

Diagramas Nassi-Shneiderman

 Os diagramas N-S, como são chamados na forma curta,  permitem  representar e desenvolver programas de computador ou algoritmos graficamente. Esses diagramas nos permitem visualizar melhor o sistema como um todo e facilitam o desenvolvimento do projeto e a detecção de eventuais falhas no nosso raciocínio. Na Figura 1 está ilustrado um exemplo de como realizar o cálculo de uma média de notas de um aluno. É muito simples, não? Bem mais fácil de ler ou entender do que o código de programação correspondente.

Media de notas

 Figura 1: Diagrama N-S para cálculo da nota média de um aluno

 .

Os diagramas N-S são associados diretamente aos comandos de programação, tais  como IF-THEN-ELSE, FOR, DO-WHILE, etc. A tradução é direta, quando o programa estiver totalmente detalhado. Para complementar a introdução, faltou explicar que a abordagem Top-Down é a maneira de se desenvolver um projeto, sistema, algoritmo, etc, partindo do plano mais geral (Top) e descendo aos poucos para os detalhes, (Down) até que esteja tudo definido nos mínimos detalhes. Para conhecer um pouco mais sobre a técnica Top-Down, sugiro que você leia o artigo técnico Técnicas: Top-Down, Mocks e TDD.

 .

A ferramenta de desenvolvimento de software

Voltando ao tema da ferramenta de software, eu identifiquei uma que além de facilitar a geração dos diagramas N-S também traduz esses diagramas para uma linguagem de programação, no meu caso optei pela linguagem C/C++. Essa ferramenta também tem o recurso de realizar a engenharia reversa de programas. Você consegue montar os diagramas e escrever os comentários em cima do programa sem documentação. Os diagramas podem ser desenvolvidos de forma hierárquica. Essa ferramenta, originalmente desenvolvido pela Siemens da Áustria, chamava-se EASYCASE, depois foi rebatizada de EASYCODE.

 .

Não é uma ferramenta gratuita. Ela custa caro, mas vale muito a pena. Se você possui uma empresa, ou trabalha numa instituição que pode investir nesse tipo de ferramenta, vale muito a pena adquirí-la. Você pode fazer um test drive gratuito, se quiser no link[1] abaixo. Se observarmos a Figura 2, podemos notar que a ferramenta vai muito além de facilitar a programação em diagramas estruturados. Ela permite planejar e desenvolver todo um projeto.

easycode

Figura 2: Módulos do EASYCODE

 .

Exemplo

Para exemplificar a utilidade e o quanto essa ferramenta é poderosa, vou usar um programa pequeno, que foi apresentado no artigo técnico Sistemas Operacionais de Tempo Real – Teclados Matriciais, como um programa completo para a simulação da operação de timers, displays de 7 segmentos e um teclado matricial em ambientes de tempo real. Esse programa tem apenas em torno de 700 linhas de código. Se impresso em papel, seriam gastos mais de 12 páginas para essa impressão. Veja a seguir.

  Exemplo1Exemplo2Exemplo3Exemplo4Exemplo5Exemplo6Exemplo7Exemplo8Exemplo9Exemplo10Exemplo11Exemplo12

Ficou enorme, não? Já pensou o trabalho que vai dar, se for necessário realizar alterações ou manutenção nesse programa? E se esse programa tivesse mais de 9.000 linhas, como um que desenvolvi para outro projeto?  Dá para notar a dificuldade claramente. Agora veja a Figura 3, onde podemos observar o mesmo programa organizado no EASYCODE.

Principal

Figura 3: Programa exemplo organizado no EASYCODE

A diferença é gritante!!! Pode-se observar claramente as diversas partes do programa, agora organizado em blocos. Esses diagramas têm estrutura hierárquica, que nos permite avançar para o interior do bloco, apenas “clickando” em cima dele. Veja no Figura 4 os detalhes da rotina de interrupção do Timer 0.

Interrupcao

Figura 4: Detalhes do bloco do Timer 0

Na Figura 5, descendo mais um estágio dentro dessa rotina, podemos ver o detalhamento do bloco referente aos displays de 7 segmentos.

Interrupcao_1

Figura 5: Trecho de código ref. aos displays de 7 segmentos inserido na interrupção do Timer 0

Para finalizar, veja na Figura 6 o detalhe do programa principal.

Main

Figura 6: Detalhes do bloco do programa principal

O software EASYCODE também permite copiar, arrastar, mover e deletar um bloco inteiro, se você quiser. Pode-se fazer engenharia reversa de algum código, especialmente naqueles mais antigos, em que você não se lembra mais o que foi feito. Recomendo que você baixe o programa de avaliação e dê uma “voltinha” nele. Você vai ficar com água na boca.

 .

Resumo

Neste artigo técnico foi apresentada uma ferramenta comercial para desenvolvimento de software e mostradas algumas características e vantagens de se utilizá-la.

Licença Creative Commons
Esta obra, “Desenvolvimento de Software – Ferramentas de Produtividade“, de Henrique Frank W. Puhlmann, foi licenciada sob uma Licença Creative Commons Atribuição-NãoComercial-CompartilhaIgual 3.0 Não Adaptada.

Caro Colega,

Nos segmentos anteriores da série Boas práticas para o desenvolvimento de software, foram apresentados: uma introdução ao assunto, onde é mostrada a necessidade de boas práticas como uma forma de melhorar a produtividade na geração e manutenção de software e de qualidade desse software gerado e a primeira parteonde é abordada a ideia de se desenvolver o software de forma estruturada, porém utilizando alguns métodos de encapsulamento de dados. 

 Nessa segunda parte vamos abordar mais alguns aspectos envolvendo ideias para organizar e melhorar o seu software. Aí vão mais algumas sugestões:

Cabeçalho de subrotinas:

Quando for escrever uma nova subrotina para o seu programa, é de grande ajuda você escrever um cabeçalho destacado, conforme pode-se ver na Figura 1, listando nos comentários o nome da subrotina, uma pequena descrição das operações que ela realiza, uma lista de variáveis de entrada, com descrição se necessário e uma descrição das variáveis de saída.

Rotina em C para escrita na E2PROM

Figura 1 – Exemplo de Rotina em C para escrita na E2PROM

Essa figura é um extrato da subrotina mostrada na primeira parte dessa série. As vantagens são óbvias. Quando no decorrer do desenvolvimento do programa você necessitar de  uma rotina que realiza determinada função, você pode conferir se entre as que você já escreveu tem alguma, só lendo a descrição do cabeçalho. Depois, esse esquema facilita a depuração durante uma eventual manutenção após um longo período. O destaque realizado em torno do cabeçalho, facilita encontrar as rotinas quando se vasculha o programa.

Escolher nomes significativos para variáveis e rotinas:

Dar nomes às variáveis, subrotinas, constantes, etc. que façam a relação dessas variáveis com sua função, destino, etc. No exemplo que temos na Figura 1:

  • vEscreveE2PROM(unsigned char nEndereço, unsigned char nDado)
  • bFlagDeErro = DESLIGA;
Na Figura 1, pode-se reparar que algumas variáveis estão escritas em letras maiúsculas, por exemplo, LIGA, DESLIGA, SDA e SCL.
No início do programa, foram definidas as constantes com esses nomes, SCL e SDA fazendo referência aos sinais de controle de uma EEPROM serial com comunicação por dois fios. Isso você pode conferir no extrato do programa exibido na Figura 2 abaixo.
Exemplo de como definir mnemonicamente as variáveis

Figura 2 – Exemplo de como definir algumas variáveis utilizando boas práticas para desenvolver software

 

Para auxiliar na compreensão você pode consultar a Figura 3, onde se vê as conexões entre a CPU e a EEPROM correspondentes a esse programa.

Conexões entre CPU e EEPROM

Figura 3 – Esquema Elétrico mostrando as conexões entre CPU e EEPROm

Na Figura 4,   está ilustrada a primeira página do manual de uma dessas EEPROMs.

EEPROM comunicação 2 fios

Figura 4: Exemplo de EEPROM serial com comunicação a 2 fios

Essas constantes também estão associadas a bits específicos de uma Port do microcontrolador. Nomear uma variável de SDA é bem mais inteligível do que P2_5, por exemplo (Port 2, bit 5). As constantes LIGA e DESLIGA foram definidas como ’1′ e ’0′ respectivamente. Isso tudo nos leva ao próximo tópico desse artigo: A polêmica notação húngara.

Notação Húngara

Segundo a definição do Wikipedia:

Notação Húngara, criada por Charles Simonyi, visa a facilitar o reconhecimento do tipo de variável num programa. O nome foi dado a partir de uma brincadeira comum entre os primeiros a conhecer a notação que a achavam estranha, fazendo o seguinte comentário: “É tão estranho que até parece húngaro”. Quando se confronta com a necessidade de dar um novo nome a uma variável num programa, o programador deve tomar alguns cuidados ao tomar essa decisão:

  • Nome mnemônico – é aquele que facilita a lembrança do significado pelo programador;
  • Nome sugestivo – é aquele em que outros podem ler o código;
  • Formato – é sempre visto como uma ideia estética, tendo sempre uma informação eficiente do programa teste;
  • Velocidade de decisão – não se pode perder muito tempo para ponderar um simples nome, pois não haverá tempo para editar e digitar nomes de variáveis longos.

A adoção deste critério de nomeação é bastante prática e intuitiva, sendo a ideia básica nomear todos os tipos de quantidades, visando-se a simplificar o entendimento do programa. Algumas vantagens deste método:

  • Os nomes em mnemônicos são utilizados num senso muito específico. Se alguém se lembrar da quantidade ou como os nomes foram construídos através de outros tipos, o nome poderá ser lido facilmente.
  • Os nomes sugestivos são muito bons. É capaz de se mapear qualquer nome dentro do seu tipo, tendo as informações necessárias para construir sua interface e utilizar de maneira correta sua quantidade.
  • Os nomes devem ser consistentes, porque eles são construídos pelas mesmas regras.
  • A decisão por um nome deve ser mecânica e rápida.
  • As expressões nos programas devem ser sugestivas, facilitando a leitura e acompanhamento do programa.

Com o objetivo de fazer listas intuitivas de se ler, os programas baseados na plataforma Windows utilizam a Notação húngara para gerar estas listas. As regras para se utilizar a Notação húngara são:

  • Os tipos definidos e/ou criados devem aparecer em letras maiúsculas;
  • constantes e “Macros” que vêm definidas em arquivos inclusos aparecem também em letras maiúsculas;
  • Funções e nomes estruturados começam com letras maiúsculas. Nenhuma marca abaixo são utilizadas para nomes, exceto para os casos que se encontrem nas duas regras anteriores;
  • Nomes de objetos começam com uma ou mais letras maiúsculas, indicando o tipo do objeto.

A tabela abaixo indica os tipos de indicadores mais utilizados na Notação húngara:

Nome Descrição
s String
sz Aponta o primeiro caracter da terminação zero da string
st Ponteiro da string, o primeiro byte é contado dos caracteres
h handle (título)
msg Message
fn function (usada com pointer)
c char (8 bits)
by unsigned char (byte or uchar – 8 bits)
n Int
b Boolean (verdadeiro ou falso)
f Flag (boolean, logical). Se qualificado é usado, pode descrever o estado verdadeiro do flag. Exceção às constantes.
u integer
w Word
ch Char, com texto ASCII
l long int (32 bits)
dw unsigned long int (dword – 32 bits)

==============

Essa notação é um pouco confusa e complicada e é alvo de muita polêmica sobre a sua eficiência e necessidade de uso. Na minha opinião e na minha experiência, essa notação, ou outra qualquer mais simplificada que você queira utilizar, facilita muito o reconhecimento das variáveis e funções, não só pelo nome,  como também o tipo, por exemplo bit, byte, inteiro, float, string, long, etc. Pense no assunto, experimente utilizar, eu tenho certeza que em pouco tempo você vai gostar do resultado final.

Por enquanto é só. Dê  a sua opinião, críticas e sugestões. Confira no próximo artigo:

Abraço!

 

Henrique

consulte sempre um engenheiro eletrônico

 

Licença Creative Commons Esta obra, “Boas práticas para o desenvolvimento de software – Algumas ideias de como organizar o seu software – II“, de Henrique Frank W. Puhlmann, foi licenciada sob uma Licença Creative Commons Atribuição-NãoComercial-CompartilhaIgual 3.0 Não Adaptada.

Caro(a) Colega,

a minha experiência profissional é baseada no desenvolvimento de software básico (firmware) para microprocessadores, microcontroladores de 8 ou 16 bits e DSPs (Digital Signal Processors). Qual o sistema operacional que costumo utilizar? Nenhum desses tradicionais. Na verdade, em geral desenvolvo os sistemas para os meus projetos. Para os tipos de processadores citados dificilmente tem algum sistema operacional que seja enxuto e eficiente.  Afinal, processadores de 8 ou 16  bits são relativamente lentos, possuem pouca memória interna, mas têm grandes vantagens, dependendo da aplicação em que são utilizados: são simples, baratos, diminutos no seu tamanho físico e extremamente eficientes para pequenas aplicações. Tem algumas versões de microcontroladores PIC, por exemplo,  com encapsulamento de 8 pinos.

Retornando ao assunto do sistema operacional, no meu caso, de certa forma, um loop infinito é um sistema operacional de alta eficiência se associado a outros recursos dos processadores, tais como temporizações e interrupções por hardware. É uma maneira de se unir as vantagens citadas dos microcontroladores e conseguir um desempenho em tempo real adequado para algumas aplicações.

Quando se fala de software de tempo real, deve-se lembrar que isso não implica na necessidade de se realizar as tarefas no menor tempo possível, mas sim em que a velocidade de processamento, monitoramento e controle do seu projeto deve ser suficientemente veloz  e compatível com a velocidade de resposta do sistema para o qual ele foi projetado. Existem processos, principalmente os térmicos,  que levam horas ou até dias para progredirem ou mudarem de estado. Neste caso, não é necessário que o processador execute todo o seu programa em frações de segundos. Poderia até levar horas para isso, pois não afetaria o desempenho do sistema como um todo e ainda assim seria um sistema de tempo real.

Para poder ilustrar o que foi dito até aqui com um resultado prático e real do uso dessas boas práticas, vou apresentar rapidamente algumas características de um projeto que desenvolvi. Trata-se de um equipamento que faz uma varredura periódica em até 32 detectores de vazamento de combustíveis e cuja principal função é a proteção ambiental na medida em que previne a contaminação do solo de postos de combustíveis.

Algumas características do equipamento:

  • Permite a  reconfiguração sempre que necessário;
  • É capaz de detectar curto-circuitos ou rompimento dos cabos dos sensores;
  • Sinaliza a varredura por meio de LEDs;
  • Sinaliza falhas por meio de códigos apresentados em displays de 7 segmentos;
  • Gera um registro em memória não volátil a cada evento anormal, gravando a data e hora dessa ocorrência e a data/hora de quando o a ocorrência foi solucionada;
  • Quando solicitado, gera um relatório formatado para uma  impressora;
  • Gerencia um teclado;
  • Gerencia um relógio de tempo real;
  • Conecta-se em rede a um computador ou à internet para permitir um monitoramento remoto.

Tudo isso  e algumas coisinhas a mais, sendo executado num microcontrolador de 8 bits da família MCS-51, com clock de 4 MHz, 12 kBytes de memória EEPROM, 256 Bytes de RAM e  que custa em torno de R$ 20,00 no varejo.

O software foi todo escrito em C. Seu código fonte tem em torno de 8.000 linhas de programa.  É incrível? Mágica? Nem tanto…

Vale ressaltar que até hoje, 10 anos depois da primeira versão, tive que realizar apenas uma pequena correção no software e alterações decorrentes do upgrade do microprocessador para versões mais atualizadas.

Mas voltemos ao tema. Essas práticas funcionam muito bem se aplicadas a microcontroladores.  Pode ser que não sirva para você, se acaso você trabalha com um software de alto nível, Visual C por exemplo. Desenvolvo meus projetos de software na forma estruturada, aplicando práticas de encapsulamento de entradas e saídas, essas típicas de software orientado a objetos.

O que é um software estruturado?

Para quem não conhece, discorrendo resumidamente sobre o assunto, um software estruturado é organizado em blocos, o fluxo é muito bem definido e tem regras rígidas  para a recursão. Em princípio cada bloco tem uma entrada e uma saída e não se utiliza o recurso do “GOTO” em hipótese alguma, pois ele destrói e corrompe qualquer organização que se tenha realizado no software. A linguagem C, por exemplo, é na sua essência uma linguagem computacional com características de software estruturado. Difícil, não é? A seguir vou explicar e fundamentar porque se deve dar preferência à programação estruturada no caso de microcontroladores e alguns DSPs.

Representação gráfica de um programa estruturado.

Fonte: DEVMEDIA

Porque não usar programação orientada a objeto?

O principal motivo para não usar programação orientada a objeto é o tamanho do código gerado. Outro motivo é o fato de se  perder um pouco o controle de como o código é gerado e de como a memória é utilizada. Isso complica muito quando é necessário otimizar o código principalmente quando a velocidade de processamento é crítica. Quando se utiliza a linguagem C, depois de algum tempo você aprende a escrever seu código de forma a favorecer a sua otimização. Na hora do aperto, dá até para inserir inline pequenos trechos de código em Assembly (Não é recomendado, mas às vezes não há alternativa…).  Isso te dá o controle quase total sobre o que vai ser gerado no final, o quanto de memória vai ser utilizado, como vai ser utilizada essa memória, etc.

Reconheço as qualidades do software orientado a objetos, tais como a portabilidade, velocidade de desenvolvimento de código e, facilidade de manutenção , até porque aproveitei o encapsulamento de dados, típico de programação orientada a objetos,  para melhorar o software estruturado. Apenas afirmo que para o uso em microprocessadores de 8 e 16 bits, frequentemente não é a melhor alternativa. Acredito também, que com o avanço das tecnologias dos compiladores de linguagens orientadas a objeto, pode ser apenas uma questão de tempo para que esses compiladores se tornem mais eficientes e produzam resultados melhores que os compiladores de linguagens estruturadas.

O que é encapsulamento de entradas e saídas?

É um método  de organização do software que determina regras rígidas para o acesso aos parâmetros ou recursos de um determinado periférico. O acesso tem que ser realizado sempre por meio de um mesmo conjunto de rotinas. Por exemplo: suponhamos que você tenha previsto a utilização de um canal de comunicação serial no seu projeto e que haja a necessidade de se utilizar uma rotina para transmitir dados e outra para receber dados. Se o canal de comunicação for organizado de forma encapsulada, qualquer acesso ao canal serial deverá obrigatoriamente se dar por meio dessas mesmas rotinas de qualquer ponto do seu programa. Assemelha-se muito ao conceito de objeto e métodos associados, conforme definido na programação orientada a objetos, não é mesmo? A diferença é que esse objeto e os métodos associados não são genéricos, mas feitos sob medida para essa aplicação. Por isso que ela tem todas as vantagens decorrentes dessa forma de organização aliada às vantagens de ser específica: enxuta, veloz entre outras.

Vale ressaltar que a aplicação desse método a um programa estruturado deve ser realizada por iniciativa e disciplina do desenvolvedor, uma vez que os compiladores de linguagens estruturadas não oferecem ferramentas ou facilidades para fazê-lo.

Qual a vantagem dessa forma de organização?

Uma vez depuradas as rotinas que administram o seu periférico, você não precisa mais se preocupar com elas ou com o funcionamento dele. Se acaso for detectada alguma falha nesse conjunto, você corrige essas rotinas e todo o seu programa volta a funcionar corretamente.

Para ilustrar o que foi dito até aqui, no final desse artigo, disponibilizei o código de duas rotinas que escrevi para acessar uma E2PROM serial. Essas rotinas têm outros elementos recomendados de boas práticas, que discutiremos nos próximos artigos.

Talvez o jovem profissional, já habituado a utilizar ferramentas de produção de software orientadas a objeto ou de alto nível, não perceba a diferença. Isso porque as ferramentas orientadas a objeto já encapsulam os dados naturalmente. É que é muito comum o programador de software básico ou firmware, por pressa ou preguiça, não organizar o programa desse jeito e acessar diretamente o seu periférico de diversos pontos do seu programa.  É uma grande tentação fazer isso e confesso, que se o programa é pequeno, talvez até seja uma solução rápida. Quando funciona bem, que maravilha!!!!! Mas quando dá “pau” …. É um inferno!!! Fica quase impossível encontrar o problema no código e evitar que a correção do problema eventualmente mal planejada se propague de forma negativa e gere  outros defeitos imprevistos em outras partes do código.

Nos próximos artigos são abordadas algumas sugestões de como proceder para dar nomes a rotinas, variáveis e constantes de forma a aumentar a sua eficiência na produção e manutenção do seu software. Vou comentar um pouco sobre a notação húngara. Parece grego?

Também é apresentada uma ferramenta de produtividade pouco conhecida, que porém, para mim, foi um divisor de águas. Não sei como eu conseguia programar antes de utilizar essa ferramenta. Minha velocidade de produção multiplicou-se.

Confira:

Abraço!

Henrique

consulte sempre um engenheiro eletrônico

 

Licença Creative Commons
Esta obra, “Boas práticas para o desenvolvimento de software – Algumas ideias de como organizar o seu software – I“, de Henrique Frank W. Puhlmann, foi licenciada sob uma Licença Creative Commons Atribuição-NãoComercial-CompartilhaIgual 3.0 Não Adaptada.

=================================================================================================

Rotina para escrever na E2PROM:

Rotina em C para escrita na E2PROM

Rotina em C para escrita na E2PROM – Parte 1

Rotina em C para escrita na E2PROM - segunda parte

Rotina em C para escrita na E2PROM – Parte 2

=============================================================================

Rotina para Leitura da E2PROM

Rotina em C para leitura de uma E2PROM - parte 1

Rotina em C para leitura de uma E2PROM – parte 1
Rotina em C para leitura de uma E2PROM - parte 2

Rotina em C para leitura de uma E2PROM – Parte 2

Rotina em C para leitura de uma E2PROM - parte 3

Rotina em C para leitura de uma E2PROM – Parte 3