How to create modbus rtu request

If you have serial Modbus/RTU slaves attached to embebbed serial modules, then you'll need to create the original Modbus/RTU requests to send. This is quite easily done with Python.

Projeto utilizando Device Drivers

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

quinta-feira, 7 de novembro de 2013

Mobile Software Development: Free courses!

  




These courses (from harvard summer school) are very complete: slides, source codes, video and audio available for download or watch online.

 Mobile Software Engineering

"Introduction to principles of software engineering for mobile devices and best practices, including code reviews, source control, and unit tests. Topics include Ajax, encapsulation, event handling, HTTP, memory management, MVC, object-oriented design, and user experience. Languages include HTML5, JavaScript, Objective-C, and PHP. Projects include mobile web apps and native iOS apps."
Link :  http://cs164.tv/2012/spring/


Mobile Software Engineering

"Today's applications are increasingly mobile. Computers are no longer confined to desks and laps but instead live in our pockets and hands. This course teaches students how to build mobile apps.Students learn to write native and web apps"
Link:  http://cs76.tv/2013/summer/

quarta-feira, 14 de agosto de 2013

How to create Modbus/RTU request in Python

If you have serial Modbus/RTU slaves attached to embebbed serial modules, then you'll need to create the original Modbus/RTU requests to send. This is quite easily done with Python.
In the last weeks I have researched a lot about this subject. Many forums say to use libraries: Pymodbus, Minimal Modbus or Modbus-tk. Tested all and say: that it is easier to use and create PySerial polling messages directly than using these libraries.

Requirement: Download PySerial Library

 These tests have been compiled in python 2.7


First i created the CRC16.py

What is CRC?

 Wikipedia says:
"A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data. Blocks of data entering these systems get a short check value attached, based on the remainder of a polynomial division of their contents; on retrieval the calculation is repeated, and corrective action can be taken against presumed data corruption if the check values do not match." 

 CRC16 on Python:

#!/usr/bin/python   
# crc16_Init() - Initialize the CRC-16 table (crc16_Table[])
def init_table( ):
    global table

    if( (len( table) == 256) and (table[1] == 49345)):
        # print "Table already init!"
        return
   
    lst = []
    i = 0
    while( i < 256):
        data = (i << 1)
        crc = 0
        j = 8
        while( j > 0):
            data >>= 1
            if( (data ^ crc) & 0x0001):
                crc = (crc >> 1) ^ 0xA001
            else:
                crc >>= 1
            j -= 1
           
        lst.append( crc)
        # print "entry %d = %x" % ( i, table[i])
        i += 1

    table = tuple( lst)      
    return

# given a Byte, Calc a modbus style CRC-16 by look-up table
def calcByte( ch, crc):
    init_table( )
    if( type(ch) == type("c")):
        by = ord( ch)
    else:
        by = ch
    crc = (crc >> 8) ^ table[(crc ^ by) & 0xFF]
    return (crc & 0xFFFF)

def calcString( st, crc):
    init_table()
    # print "st = ", list(st)
    for ch in st:
        crc = (crc >> 8) ^ table[(crc ^ ord(ch)) & 0xFF]
        # print " crc=%x" % crc
    return crc

# EXECUTE
table = tuple()


def main():
    testCRC()

if __name__ == "__main__":
    main()




 Now you import the function CRC16 on the modbus application

MODBUS on Python

This is my modbus simulator (Slave).

#!/usr/bin/python   
#!/usr/bin/env python

import serial
import time



#Import function CRC16
from CRC16 import calcString

# SERIAL PC CONFIG.
ser = serial.Serial(port='COM2',baudrate=19200)

# FUNCTIONS
# Decimal to Hex.
def dec2hex(n):
    lo = n & 0x00FF
    hi = (n & 0xFF00) >> 8
    return chr(hi) + chr(lo)
    #return "%02x" % n

# Hex. to Decimal
def hex2dec(s):
    return int(s, 16)

# Invert byte ( LO and HI )
def swapLoHi(n):
    lo = n & 0x00FF
    hi = (n & 0xFF00) >> 8
    return  lo << 8 | hi

# Calc. CRC16
def stCRC(msg):
    crc = calcString(msg, 0xFFFF)
    crc = swapLoHi(crc)
    return dec2hex(crc)
    

def HiLo(n):
    lo = n & 0x00FF
    hi = (n & 0xFF00) >> 8
    return  hi | lo
    
# MODBUS PROTOCOL DEFINES
READ_HOLDING = 3
READ_INPUT = 4
PRESET_SINGLE = 6
PRESET_MULTIPLE = 10
    
# INPUT VALUES
nb = input('Value 1: ')
nc = input('Value 2: ')
nd = input('Value 3: ')
ne = input('Value 4: ')

# CONVERT VALUE TO STRING HEX
value1=  chr(nb)    

value2 = chr(nc)
value3 = chr(nd)

value4 = chr(ne)

### DEBUG MSG. ###
ReadHolding = "\x01\x03\x02\x00" + value1
stMsg = ReadHolding + stCRC(ReadHolding)
ReadInput1 = "\x02\x04\x02\x00" + value2 + "\x00"+ value3 +"\x84"
ReadInput2 = "\x03\x04\x02\x00" + value2+ "\x00\x0a\x84" 
PresetSingle1 = "\x01\x06\x00\x00\x00\x0A"
PresetMultiple1 = "\x01\x10\x70\x00\x06"
PresetMultiple = PresetMultiple1 + stCRC(PresetMultiple1)
PresetSingle = PresetSingle1 + stCRC(PresetSingle1)

## LOOP MODBUS
while True:
    out = ''
# let's wait one second before reading output (let's give device time to answer)
    time.sleep(1)
    
# MODBUS READ BUFFER
    while ser.inWaiting() > 0:
        out += ser.read(1)

### DEBUG ###
    if out != '':
        print "uC Response"
        print out[0].encode('hex_codec') 
        print out[1].encode('hex_codec') 
        print out[2].encode('hex_codec')
        print out[3].encode('hex_codec')
        print out[4].encode('hex_codec')
        print out[5].encode('hex_codec')
        print out[6].encode('hex_codec')
        print out[7].encode('hex_codec')

# GET PROTOCOL
    value = int(out[1].encode('hex_codec'),16)
    print value 

# READ HOLDING MSG.
    if value is READ_HOLDING:
        print "read holding"
        ReadHolding = "\x01\x03\x02\x00" + value1
        stMsg = ReadHolding + stCRC(ReadHolding)
        ser.write(stMsg)
        time.sleep(1) # for 100 millisecond delay
       
# READ INPUT MSG.
    elif value is READ_INPUT:
        print "read input"
        nc = nc + 1
        nd = nd + 1
        ne = ne + 1
             
        value2 = chr(nc)
        value3 = chr(nd)
        value4 = chr(ne)
        ReadInput1 = "\x01\x04\x22\x00" + value1+ "\x00"+ value2 + "\x00" + value3 + "\x00"            
        stMsg1 = ReadInput1 + stCRC(ReadInput1)
        ser.write (stMsg1)
        time.sleep(1) #for 100 millisecond delay

# PRESET SINGLE MSG.
    elif value is PRESET_SINGLE:
        print "preset single"
        val = int(out[5].encode('hex_codec'),16)
        power = chr(val) # debug pot
        ser.write (PresetSingle)
       
               
# PRESET MULTIPLE MSG.
    elif value is PRESET_MULTIPLE:
        print "preset multiple"
        ser.write (PresetMultiple)
        time.sleep(1) # for 100 millisecond delay
    
    
    RecievedData = ""

    #while ser.inWaiting() > 0:
    #    RecievedData = ser.read(1)
    #print RecievedData  



What is Modbus?

The best site ever to explain it : Modbus

 
 

quinta-feira, 15 de setembro de 2011

OpenCV : Guia de sites úteis



  O OpenCV (Open Source Computer Vision Library) é uma biblioteca multiplataforma com um conjunto bem definido de funções, totalmente livre (open source) ao uso acadêmico e comercial, para o desenvolvimento de aplicativos na área de Visão Computacional 

  É uma biblioteca originalmente desenvolvida pela Intel, mas agora com suporte  da Willow Garage. É open source, multiplataforma, principalmente com foco no processamento de imagem em tempo real.

   Exemplos de aplicação da biblioteca OpenCV são Human-Computer Interaction (HCI); identificação de objetos, Segmentação e Reconhecimento; Face Recognition, Reconhecimento de gestos; Rastreamento de Movimento, Movimento Ego, Compreensão de Movimento; Estrutura De Motion (SFM); Calibração Stereo e Multi-Camera Profundidade e Computação Robótica Móvel.

A biblioteca OpenCV fornece muito bem as funções avançadas para armazenamento de imagens, manipulação e objeto de identificação tornando as coisas mais simples. Por exemplo: Com apenas 2  funções simples cvHaarDetectObjects() e cvGetSeqElem () são suficientes para realizar o reconhecimento facial!!

Eu passei por muitos links para meus preparativos iniciais sobre OpenCV. Existem muitos tutoriais por aí, mas eu consegui reunir alguns dos melhores que eu encontrei e pensei em publicá-las aqui. A ideia deste post é fornecer um bom material para iniciar um estudo sobre openCV.


Links
 
  1. Tutorial por Noah Kuntz
    • Eu encontrei este tutorial OpenCV melhor para um iniciante. Ele nos mostra todos os detalhes, juntamente com programas de exemplo.
    • Ele categorizou o tutorial em 11 partes e cada parte é explicado muito bem.
    • No caso de você não ser familiarizado com linguagem de programação C há um tutorial para isso também.
    • Clique aqui para ver o tutorial  


2. Tutorial sobre Sourceforge.net
    • Este tutorial faz uso do plugin Flowdesigner em conjunto com OpenCV. Você pode baixar o plugin aqui (open source).
    • Tutorial fornece uma explicação detalhada de todas as funções da biblioteca básica.
    • Melhor parte é que as funções da biblioteca são explicados, juntamente com amostras de imagem. Que pode realmente ajudar no melhor entendimento do conceito.
    • Clique aqui para ver o tutorial
3. Guia OpenCV
    • Este tutorial fornece programas de exemplo para mostrar para você algumas das aplicações do OpenCV. Por exemplo. Captura de um quadro da câmera de um robô, trabalhando com histogramas, detectando linha e círculos em uma imagem, etc..
    • Clique aqui para ver o tutorial
 
4. Processamento de imagens e Análise de guia de referência

    • Este link nos fornece uma explicação detalhada das funções da biblioteca.
    • Cada parâmetro das funções são bem explicados.
    • Clique aqui para ir para pagina  


5. Referência OpenCV Willowgarage
    • Este é o site de referência oficial do OpenCV.
    • Fornece informações sobre funcionalidades Core, imgproc, highgui, e detecção de recurso.
    • Clique aqui


6. Introdução ao OpenCV
    • Este guia começa com a introdução básica e, em seguida passa a explicar alguns dos comandos gui e estruturas de dados básicos.
    • Também oferece programas de exemplo que explica como trabalhar com seqüências de imagens, vídeo e matrizes.
    • Clique aqui para ir para pagina

7. CV Manual de referência

    • Este manual trata de alguns mecanismos avançados.
    • Se você pretende fazer alguma imagem séria de processamento este link vai te ajudar.
    • Clique aqui para o manual


8. AI Shack
    • Este site tem alguns programas de referência que nos mostra a implementação de alguns mecanismos de visão computacional.
    • Clique aqui para ir para o site


9. Site do Nashruddin
    •  Se você pesquisar no google programas relacionados opencv este é o site que você verá no top 10. O site fornece a implementação de algumas consultas de processamento de imagem bastante comuns.
    • Programas como detecção de rosto e olhos, os valores de pixels de leitura de imagem, eye tracking em tempo real são alguns programas interessantes que o site proporciona.
    • Clique aqui para ir para o site


10. Site do Damiles
Se você ainda não começou sua programação OpenCV então aqui está um guia de introdução para a programação OpenCV

OBS: Lembrando que todos os links estão em inglês. Caso necessite de uma tradução "não muito confiável" dependendo do conteúdo utilize o famoso google translator , colando o link e abrindo ja traduzido para pt.

Espero ter ajudado alguém com esse guia de sites sobre openCV.





quarta-feira, 14 de setembro de 2011

Monte o seu Arduino!

  

 O que é Arduino e como funciona?

 Para saber detalhes de seu funcionamento e entender o que é o arduino, tem um  site excelente que mostra detalhadamente como funciona, os modelos, componentes,pinos, instalação e a parte de software.

Monte seu Arduino Severino 

Hoje eu estava pesquisando na net sobre arduino, preços e tudo mais, porém um projeto me chamou a atenção: Monte seu arduino severino (adotada placa oficial do arduino team). Neste link do projeto você vai ter acesso ao manual, diagrama, esquema eletrico, etc. Todo suporte pra você montar o seu. ( Arduino Single-Sided Serial version 3)

Neste albúm no flickr você pode visualizar as pessoas que desenvolveram seu proprio arduino mundo afora :) aventure-se também e agradeçam ao Adilson Akashi.




segunda-feira, 12 de setembro de 2011

PandaBoard - kit de desenvolvimento ARM



Hoje vou falar um pouco de um kit que pretendo adquirir mês que vem e porque eu escolhi este.
O kit PandaBoard é projetado para ser uma atualização (sucessor) da plataforma BeagleBoard.

Caracteristicas:
BeagleBoard são baseados em ARM Cortex-A8 SoCs e orientadas para o mercado de dispositivos gerais incorporado, o 4,0 x 4,5 polegadas. Já a PandaBoard sobe para o Cortex-A9-base de 1 GHz OMAP4430 SoC e é mais utilizada para desenvolvimento de smartphones e outros dispositivos móveis . A placa pode gravar e reproduzir vídeo com qualidade de 1080p a 30 frames por segundo, diz PandaBoard.org.


A idéia é que o uso desta plataforma acelera o desenvolvimento Linux  embarcado e se você sempre quiser entrar nessa de sistemas embarcados, os kits BeagleBoard e PandaBoard são altamente recomendados, lembrando que meu projeto eu fiz no kit ARM Mini 2440 ( e realmente é um kit muito didatico com muitos modulos prontos e faceis de entender) . Porém este kit pandaboard não perde nada em termos de suporte, existem muitas comunidades e muitos projetos open source no qual podemos utilizar para o aprendizado.



 
Como observado na foto ao lado e detalhadamente o diagrama de blocos abaixo, o PandaBoard está equipada com 1GB de DRAM LPDDR2 e um cartão SD / MMC slot para cartão de memória. Um slot de expansão LCD é fornecido, bem como HDMI 1.3 e portas DVI, com suporte simultâneo a dual displays.


O PandaBoard é equipado com chip de múltiplos propósitos da TI sem fio, a 7,0 WILINK . O WILINK fornece a placa com 802.11b/g/n Wi-Fi, bem como Bluetooth 2.1 + EDR, rádio FM, e um receptor GPS.
Também possui uma porta Ethernet 10/100, duas portas USB 2.0 Host, e uma porta USB 2.0 OTG. Uma porta RS-232, câmera de conector, porta JTAG, e áudio estéreo E / S estão disponíveis, junto com um "conector de expansão genérica" ​​que suporta interfaces como SD / MMC, USB, GPMC, DSS, ETM, McSPI , I2C, e UARTs.
O PandaBoard  possui medidas de 4,5 x 4,0 polegadas (114,3 x 101,6 milímetros), acima dos 3,25 × 3,25 centímetros para o BeagleBoard-XM. Equipado com uma fonte de alimentação cinco Volt.





Software
O PandaBoard está otimizado para rodar vários sistemas operacionais de código aberto . Estes incluem Ubuntu 10.10 e também Angstrom :distribuição Linux. Há também um port de Android chamado Android Pandroid.
Além disso, a plataforma está a ser dito, geralmente, compatíveis com as distribuições Linux, como MeeGo e Chrome.
Projetos listados no site da comunidade PandaBoard.org incluem RISC OS na OMAP4, XBMC, Wireless sniffer, Gentoo Linux, MeeGo, GeeXboX, OpenBricks, Pandroid e Ubuntu em PandaBoard.

 Disponibilidade
A PandaBoard esta disponivel por $174 pela Digi-Key, aqui.  Mais informações sobre a pandaboard pode ser encontrada  aqui, e mais sobre a comunidade de software (projetos) pode ser encontrado aqui

segunda-feira, 22 de agosto de 2011

Programação Python Networking














O Python fornece dois níveis de acesso aos serviços de rede. Em um nível baixo, você pode acessar o suporte de socket básicos no sistema operacional subjacente, que permite implementar clientes e servidores para ambos os protocolos orientado a conexão e sem conexão.
Python também tem bibliotecas que fornecem o acesso de nível superior  a protocolos específicos em nível de aplicativo de rede, como FTP, HTTP, e assim por diante.
Este post tem como objetivo falar sobre programação de socket.

O que são sockets?
Sockets são interfaces para a comunicação via rede, quando se cria um socket,se está criando um canal de comunicação bidirecional entre o cliente/servidor.

Eles podem se comunicar dentro de um processo, entre processos na mesma máquina, ou entre processos em diferentes continentes.
Pode ser implementado ao longo de vários tipos de canais diferentes: sockets de domínio Unix, TCP, UDP, e assim por diante. A biblioteca de sockets fornece classes específicas para lidar com o transporte comum, bem como uma interface genérica para lidar com o resto.

  • Domain : A família de protocolos que serão utilizados como mecanismo de transporte. Estes valores são constantes, tais como AF_INET, PF_INET, PF_UNIX, PF_X25, e assim por diante.
  • Type : O tipo de comunicação entre os dois terminais, normalmente SOCK_STREAM para orientação a conexão protocolos e SOCK_DGRAM para protocolos de conexão.
  • Protocol :  Geralmente nulo, este campo pode ser usado para identificar uma variante de um protocolo dentro de um domínio e tipo.
  • Hostname :  O identificador de uma interface de rede.
  • Port : Cada servidor lista clientes "chamando" em uma ou mais portas. Uma porta pode ser um número de porta Fixnum, uma string contendo um número de porta, ou o nome de um serviço. 

O módulo de socket 

Para criar um socket, você deve usar a função socket.socket () disponível no módulo de socket, que tem a seguinte sintaxe:

s = socket.socket (socket_family, socket_type, protocol=0)

Parâmetros:
- socket_family : Este é ou AF_UNIX ou AF_INET.
- socket_type : Este é ou SOCK_STREAM ou SOCK_DGRAM.
- protocol : = 0 descartado.

Depois de ter objeto socket, então você pode usar as funções necessárias para criar o seu cliente ou o programa servidor. A tabela a seguir contem a lista de funções necessárias:

























 


Um servidor simples: 


Para escrever servidores de Internet, nós usamos a função de socket disponíveis no módulo para criar um objeto. Um objeto é então usado para chamar outras funções para configurar um servidor socket.
Agora chamar bind (função, hostname porta para especificar uma porta para o seu serviço na máquina host).
Em seguida, chamar o método de aceitar o objeto retornado. Este método aguarda até que um cliente se conecta à porta que você especificou, e retorna um objeto de conexão que representa a conexão com esse cliente.




#!/usr/bin/python           

import socket               # Importa o modulo de socket

s = socket.socket()         # Cria um objeto de socket
host = socket.gethostname() # Retorna o nome da máquina local
port = 12345                # Reserva uma porta para o seu serviço
s.bind((host, port))        # Bind para a porta

s.listen(5)                 # Esperar a conexão do cliente
while True:
   c, addr = s.accept()     # Estabelecer conexão com o cliente
   print 'Recebeu a conexão de', addr
   c.send('Conexão deu certo')
   c.close()                # Encerra a conexão

Um cliente simples: 

Agora vamos escrever um programa cliente muito simples que vai abrir uma conexão com uma determinada porta 12345 e determinado host.
O Socket.connect (hosname, porta) abre uma conexão TCP para o nome na porta.
Depois de ter um socket aberto, você pode lê-lo como qualquer outro objeto IO. Quando terminar, lembre-se de fechá-lo.
O código a seguir é um cliente muito simples que se conecta a um determinado host e porta, lê todos os dados disponíveis a partir do socket, e depois sai:

#!/usr/bin/python           

import socket             

s = socket.socket()         # Cria um objeto de socket
host = socket.gethostname() # Retorna o nome da máquina local
port = 12345                # Reserva uma porta para o seu serviço

s.connect((host, port))
print s.recv(1024)
s.close                     # encerra

Agora execute este server.py ( em background) e em seguida, execute client.py para ver o resultado.

# Após iria iniciar um servidor em background:
 $ Python server.py & 

 # Uma vez servidor é iniciado cliente executado:

 $ Python client.py
 
 Resultado: 

Recebeu a conexão de ('127.0.0.1', 48437) 
Conexão deu certo

quarta-feira, 17 de agosto de 2011

Device Drivers em Linux Embarcado

Recentemente apresentei na faculdade meu ultimo projeto ( trabalho de conclusão de curso) , onde tive a felicidade de poder escolher o tema desejado, eu escolhi : Device Drivers em Linux Embarcado. O desafio estava lançado. A ideia era conseguir explicar o que são device drivers porem voltado para um projeto prático colocando todos os detalhes de implementação.

Parte 1 - Bibliografia
Como já não é novidade , bons materiais sobre device drivers são em inglês, a maioria dos livros que abordam bem especificado este tema . Somente alguns artigos na internet e alguns blogs contém alguma informação util valida para um projeto maior, recomendo o  blog do Sergio Prado .  Como o projeto é uma monografia devemos evitar ao máximo sites, no meu  caso eu utilizei somente sites referente as especificacoes da placa que nós utilizamos e o webserver.

Parte 2 - Teoria
Primeiramente o desafio foi : Como abordar um tema destes de uma forma que qualquer leitor entenda? Não é uma tarefa simples, devemos seguir uma linha lógica de tópicos até chegarmos aonde queremos. No caso deste tema primeiramente, a ideia foi especificar seus métodos de funcionamento, como é a estrutura basica de um device driver , a maneira que ele interage com o sistema ( kernel space / user space) , dentre outras caracteristicas importantes para entendermos a parte prática.

Parte 3- Projeto Prático
O projeto prático foi feito da seguinte forma, com a ajuda do meu colega Ramon, nós escolhemos o kit Friendly ARM Mini 2440 onde decidimos fazer um device driver para a porta GPIO. Como podemos ver na figura abaixo:


O que esta porta irá controlar? Motores ( carro ) . Foi ai que a ideia se concretizou, batizamos de PorscheARM. A ideia era o seguinte : Controlar o carro via browser , ou seja, nós teriamos um webserver embarcado nesta placa, então nós utilizamos um webserver que é pequeno e eficiente para isto o Boa webserver . O sistema que utilizamos foi o Linux 2.6 baixado o ultimo kernel do proprio site da ARM. Para mostrar didaticamente o funcionamento de um device driver criamos um nó device para cada direção : direita, esquerda, pra baixo , pra cima . A pagina web (feita em CGI) mandava os comandos para o device driver que controlava os motores. (WEB) -> DEVICE -> Motores . Abaixo fotos do projeto











 Parte 3 - Utilizando o acelerometro do iphone como controle
Com o intuito de aprimorar mais o sistema foi feito um código em javascript que capturava a posição X,Y,Z do iphone e mandava pro nosso webserver e com isso atraves do device driver comunicava com os motores indo pra direção conforme orientava o celular. Note que não observamos nenhum atraso com este teste.


Parte 4 - Testes
Os testes do projeto foram feitos e filmados pelo Ramon , podemos ver os videos abaixo:

E testado no ginásio da faculdade




Quer ver mais detalhado?
Estou disponibilizando neste link o trabalho completo deste projeto, teórico e prático, onde os códigos fontes estão no anexo deste pdf compartilhado ou no github, segue o link do PDF :  TCC_Device Drivers em Linux Embarcado 

Espero ter ajudado alguém com este post . É uma área que tenho muito interesse e estou sempre disposta a compartilhar conhecimento sobre isto e espero que vocês compartilhem também. =)