domingo, 12 de março de 2017

O programa "Triângulo", só que escrito em Linguagem Python

Eu escrevi o mesmo programa (calcula as mesmas coisas: Área, ângulos internos e também as 3 alturas relativas a cada um dos lados de um triângulo) também em linguagem Python.  Aqui você deve colocar os valores dos 3 lados do triângulo utilizando ponto decimal e não vírgula nos números.  Este programa roda naquela famosa "telinha preta do DOS" pois não tem interface gráfica (embora seja possível criar interfaces gráficas utilizando linguagem Python e um aplicativo chamado Pyqt ... eu não sei fazer). Para quem quiser experimentar o Cálculo das Medidas do Triângulo em Python, o link para o código executável é: Programa Triangulo em Python
O código-fonte está aqui: Link no Github

Material de Estudo sobre ARM Cortex M4

Material baseado nas Placas Tiva Launchpad (microcontrolador TM4C123G )  e Stellaris Launchpad (LM4F120)  ambas fabricadas e distribuidas pela Texas.
O compilador abordado é o Code Composer Studio (CCS) versão 6.0.
Todos os exemplos estão em Linguagem C.

Aproveitem e façam o download, pois deixarei este link e este post disponíveis por pouco tempo.
Link:  Material sobre ARM Cortex M4

sexta-feira, 10 de março de 2017

Comunicação Serial com Arduino em Linguagem Python - Um teste de desempenho

A nova versão da IDE do Arduino é a de número 1.8.1 e pode ser baixada neste site: Site do Arduino

Nesta nova versão temos um monitor serial (para comunicar o Arduino com o PC através da porta USB do PC) cuja velocidade máxima chega a 250.000 bps  (ou seja, 250 mil bits por segundo).

Isso já foi um avanço, porque em versões mais antigas da Plataforma Arduino, a máxima velocidade de comunicação serial era de 115200 bps apenas.

Pode parecer muito, mas dependendo da quantidade de dados que precisam ser transferidos do Arduino para o computador PC, esta velocidade de 250 000 bps pode não ser suficiente.

A Texas escreveu um excelente artigo aqui: Texas USB CDC Benchmarking,  justamente abordando quais seriam as máximas velocidades que podem ser alcançadas na comunicação serial USB (usando o sistema CDC)  com as suas placas Launchpad Tiva (Tiva TM4C123G Link) e com o microcontrolador Concerto (F28M35H52C1).

Baseado neste artigo, resolvi fazer meu próprio script para um rápido Benchmarking envolvendo Comunicação Serial em Linguagem Python com o PC, e uma placa Arduino Mega2560 (Arduino Mega).

O resultado serve também como um exemplo para quem quiser trabalhar com Comunicação Serial em Linguagem Python.  O código em Python, que deve ser executado no computador PC, faz uso da biblioteca pySerial (você terá que instalar esta biblioteca antes de rodar este código, ela não faz parte do Python 2.7) e é mostrado na figura 1 abaixo:
Figura 1- Código em Python para receber dados do Arduino através da Porta Serial.


Na placa Arduino, eu gravei o seguinte código (Figura 2 abaixo) o qual vai gerar 1000 blocos, cada bloco contendo 612 caracteres ASCii  do tipo "ab", totalizando blocos de 1024 bytes.
Serão gerados então 1000 blocos contendo 1024 bytes em cada bloco.
Figura 2- Script que deve ser gravado na Placa Arduino Mega2560 e que gera 1024000 bytes pela porta serial USB COM3

PROCEDIMENTO

1- Gravar o Script da Figura 2 na placa Arduino Mega;
2- Abrir o Script em Python na tela do PC e executar o código em Python, dando "RUN";
3- Verifique se a porta USB onde você conectou o Arduino é realmente a COM3 no seu caso. Pode ser que seu PC tenha dado a ela outro número (COM5 por exemplo) e você terá que alterar isto no software em Python.

Para quem quiser experimentar, deixei aqui os códigos utilizados:Arquivos Python e Arduino



RESULTADOS 

Para uma velocidade ajustada no software de 250000 bps, transmitir 1024000 bytes demorou cerca de 42 segundos, produzindo uma velocidade calculada pelo script da Figura 1 de 24485 Bytes por segundo (ou 24485 x 10 =  244850 bits por segundo). A figura 3 mostra o "log" que é gravado pelo script de benchmarking da Figura 1.
Figura 3- Resultados do teste de desempenho da Comunicação Serial.


Observe que para calcular o valor em bps (bits por segundo) temos que multiplicar por 10 e não por 8. Embora cada byte contenha 8 bits, na transmissão serial ASCii são transmitidos 10 bits para representar cada byte, pois o primeiro é o start-bit e o último é o stop-bit, que indica que aquele byte encerrou sua transmissão.
Desta forma, a velocidade efetiva de 250 000 bits por segundo nunca é atingida, o melhor valor foi de 244850 bps.
Isso pode não ser importante dependendo da aplicação. Mas em algumas outras aplicações (Por exemplo: deseja-se construir um Osciloscópio no PC, para visualizar formas de onda em tempo real) a velocidade da Comunicação Serial se torna muito importante e altas taxas de transferência são necessárias. A velocidade com que o Arduino é capaz de se comunicar com o PC pode ser lenta e ineficiente, dependendo da aplicação.
Este é o caso do meu trabalho de Doutorado, onde eu precisarei registrar 60 canais de conversor AD, com taxa de captura de 5kHz (5000 amostras por segundo em cada canal) e transmitir todos estes dados ao computador PC no menor tempo possível.
No caso da minha Tese de Doutorado, eu necessitarei transmitir  675 000 Bytes por segundo se desejar amostrar os canais em tempo real porque  são 60 canais, 5000 amostras por segundo em cada canal e o conversor AD tem resolução de 16 bits, transmitindo efetivamente 18 bits em cada word:

                                       60 x 5000 x 18 =  5400 000 bps (bits por segundo)

Esta taxa de 675 KB/s  talvez só possa ser atingida por outras técnicas, como a Comunicação "Bulk" entre o microcontrolador e o computador USB e usando-se DMA (Direct Memory Acess) para que o processador não gaste tempo durante uma aquisição e outra. A técnica de comunicação serial tipo CDC se mostra lenta para esta tarefa.
Agradeço ao professor  Lucas Vinicius Hartmann e aos colegas da PicList (piclistbr@googlegroups.com) pela revisão efetuada neste texto.



sexta-feira, 3 de março de 2017

Identificação de faces usando Python e OpenCV

Se você acompanhou o post anterior (sobre a instalação do Python e OpenCV) e instalou a sua versão, então você pode experimentar um simples programa que faz identificação de faces em Python. Segue o código:
import cv2
arqCasc = 'haarcascade_frontalface_default.xml'
faceCascade = cv2.CascadeClassifier(arqCasc)
webcam = cv2.VideoCapture(0)  #instancia o uso da webcam
while True:
    s, imagem = webcam.read() #pega efeticamente a imagem da webcam
    imagem = cv2.flip(imagem,180) #espelha a imagem
    faces = faceCascade.detectMultiScale(
        imagem,
        minNeighbors=5,
        minSize=(30, 30),
maxSize=(200,200)
    )
    # Desenha um retângulo nas faces detectadas
    for (x, y, w, h) in faces:
        cv2.rectangle(imagem, (x, y), (x+w, y+h), (0, 255, 0), 2)
    cv2.imshow('Video', imagem) #mostra a imagem captura na janela
    #o trecho seguinte é apenas para parar o código e fechar a janela
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
webcam.release()         #dispensa o uso da webcam
cv2.destroyAllWindows() #fecha todas a janelas abertas
# ------------------------------------------------------------------------------------

Para este programa funcionar, é necessário acrescentar na mesma pasta o arquivo  "haarcascade_frontalface_default.xml"   que é o arquivo em formato de banco de dados que traz os vetores do Classificador de faces haar cascade.  O link para baixar este arquivo está aqui: Arquivo Classificador haar cascade

O resultado deve ser este da foto a seguir: o programa abre a imagem da sua webcam na tela e vai encontrar seu rosto, desenhando um retângulo em volta.  Veja a foto:
Figura 1- Script que faz a detecção de faces em funcionamento.

Se você desejar detectar outros elementos (que não seja a face humana) como por exemplo: nariz, olhos, pedestres andando na rua, relógio de parede, etc,  você encontra uma coleção de arquivos Classificadores Haar Cascade neste site:  Site com diversos arquivos .xml  com bancos de dados para Classificadores Haar Cascade  para SimpleCV e OpenCV:

Como instalar o Python, OpenCV e todas as suas dependências no Windows de 64-bit

Neste Tutorial pretendo descrever uma passo-a-passo sobre como instalar o Python versão 2.7.6 para Windows 64-bit (estou usando aqui no Windows 10 64-bit), bem como a biblioteca para Processamento de Imagens OpenCV compatível com esta mesma versão.
Para instalar a biblioteca OpenCV é necessário antes instalar algumas dependências, que são:
- A biblioteca para trabalhar com matrizes numéricas:  Numpy
- A biblioteca para plotar gráficos: Matplotlib

Vou descrever uma sequencia de passos para instalar bibliotecas e dependências todas compatíveis entre si.

Primeiro, instale o Python versão 2.7.6 obtido neste link: http://www.lfd.uci.edu/~gohlke/pythonlibs/
A versão que estou usando é EXATAMENTE esta:   python-2.7.6.amd64.msi

O fato de ser um arquivo .msi  significa que trata-se de um pacote pronto para instalação no Windows 64-bit

Para que este tutorial seja útil para você, é extremamente importante que você instale EXATAMENTE as versões que são descritas aqui.  Tive muitos problemas com versões diferentes de bibliotecas, que são todas incompatíveis entre si, e estou escrevendo este tutorial para que você não passe pelo que eu passei até achar as versões compatíveis com cada coisa.

As versões 2.7.9 e versão 3.4 do Python já tem o instalador "pip" internamente.
Mas a versão 2.7.6  que recomendarei neste tutorial (pelo fato de ser para Windows 64-bit, foi a única que eu achei que está compilada para Windows 64-bit...) não tem.
Então você precisará instalar o aplicativo "pip" primeiramente dentro do python.
O  "PIP" é um descompactador e instalador de arquivos do Python, que roda no terminal do DOS.

As versões que são compatíveis entre si e com o Python 2.7.6  indicado  são:

NUMPY
 numpy-1.12.0+mkl-cp27-cp27m-win_amd64.whl

MATPLOTLIB
matplotlib-2.0.0-cp27-cp27m-win_amd64.whl

OPENCV
opencv_python-3.1.0-cp27-cp27m-win_amd64.whl


Instalação passo-a-passo
------------------------------------------------------
As dependencias do OpenCV são arquivos do tipo .whl, então você vai precisar do instalador "pip" do Python para instalar arquivos tipo .whl


1. baixar get-pip.py  neste  site:   https://bootstrap.pypa.io/get-pip.py
   Copie a pasta   get-pip.py    dentro  de    >C:\python27\

2. Instalar o  get-pip.py  no diretorio  python27

       >C:\python27\ python  get-pip.py

3. para atualizar o pip no windows (as vezes não é necessário):

       >C:\python27\   python -m pip install -U pip

4. O pip será instalado dentro de uma pasta chamada Scripts (com "S" maiusculo)
   Existe outra pasta scripts com "s" minusculo, não é essa.

       >C:\python27\Scripts

5. O "pip" só funciona se executado de dentro da pasta Scripts
(observe que o aplicativo "pip.exe" existe somente dentro da Pasta Scripts)


6. Baixar os arquivos a partir deste site:  http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy
    Para instalar os pacotes:

7.  De dentro da Pasta   >C:python27\Scripts    digite:


pip install  numpy-1.12.0+mkl-cp27-cp27m-win_amd64.whl

pip install matplotlib-2.0.0-cp27-cp27m-win_amd64.whl

pip install opencv_python-3.1.0-cp27-cp27m-win_amd64.whl
------------------------------------------------------------------------------------------------------------

Baixe aqui TUDO o que você precisa para instalar o Python 64-bit com OpenCV
Python 2.7.6 64-bit + OpenCv + Numpy + MatplotLib
--------------------------------------------------------------------------------------------------------------
Links importantes:
Instalando o PIP  para o Python
https://pip.pypa.io/en/stable/installing/

TODOS OS ARQUIVOS PYTHON PARA 64 BITS
http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy

COMO INSTALAR O OPENCV
https://rogerresmini.wordpress.com/2013/12/30/instalacao-do-opencv-no-windows-7-64bits-com-mingw-w64/
----------------------------------------------------------------------------------------------------------

segunda-feira, 13 de fevereiro de 2017

Software para calcular Área, Angulos e Alturas de um Triângulo qualquer

Este programa (em anexo) pede que o usuário digite as medidas dos 3 lados de um Triângulo qualquer: Lado AB, Lado BC e Lado AC.   O triângulo pode ser qualquer (não é necessário que seja retângulo ou isósceles).  Uma vez digitada as 3 medidas dos lados, o usuário aperta o botão "CALCULAR" e o programa calcula automaticamente a área, os 3 ângulos internos e também as três alturas do Triângulo, relativas a cada uma das bases. ATENÇÃO:  Use "," (vírgula) e  não  ponto decimal, ao digitar os números.  O programa foi escrito no Microsoft Visual C# Studio Express (gratuito) por isso a pasta vem com vários arquivos (é preciso enviar o manifesto juntamente com o código .exe executável). O programa está em sua versão inicial e não checa a validade dos dados que foram digitados. Assim, por exemplo, se o usuário digitar  5,  5,  10   isso obviamente não forma um triângulo porque  5+5 não é maior do que 10 (o triângulo não fecha) e o resultado será 0 para todos os campos e 180graus para apenas um dos ângulos. Experimentem e comentem.
Figura 1: Aspecto da IDE do programa

O link para fazer o download (gratuito) é esse:  programa WinTraingulo

https://drive.google.com/file/d/0B0T8omiWkMq8UUluWndlSFhYbG8/view?usp=sharing

Para quem quiser melhorar o código-fonte, fique à vontade, ele está aqui:  https://github.com/ffambrini/Triangulo


sábado, 4 de junho de 2016