LoRa Range Test #2 “Miradouro do Caramulinho”

Excited with the success of the previous attempt (read it here) and following the sugestion of a colleague, my aim was now targeted at “Miradouro do Caramulinho” another viewpoint about 70km from my home.

View from the top of “Miradouro do Caramulinho”
Continuar a ler

LoRa Range Test “Miradouro da Bandeira”

In previous posts I’ve been discussing the hardware and software components for a LoRa communication system. In this post I’ll document a range test made with the those components.

Near my place (around 35km from here) there is a small mountain called “Serra da Boa Viagem”, near its highest point (almost 262m) there is a viewpoint called “Miradouro da Bandeira”. I wanted to test if I could send data from there to my place. This location was selected because it should provide line of sight to my home.

To check if it was the case I’ve used Google Earth and added a path with start at “Miradouro da Bandeira” and end at my place. This allowed to check that the distance in straight line is about 27km, furthermore inspecting the elevation profile is possible to check that there is no obstruction from start fo finish.

Path and Elevation profile.
Continuar a ler

Running Gateway SW using Screen

On a previous post I’ve presented the method I’ve used to automatically launch and run the Gateway SW (python script) on the OrangePi. You can read about it here LoRa and LoRa”Gateway”.

The previous method uses Linux cron jobs to start python and execute the script but it poses some limitations such as:

  • Command Line output is not accessible, it can only be written to a log file.
  • If the script stops for some reason a reboot is required so the cron job lauches it again.

The previous limitations can be overcome using Linux “Screen” command. As per the manual “Screen is a full-screen window manager that multiplexes a physical terminal between several processes (typically interactive shells)”. In this application we will create a Screen session (and provide an alias to it) during startup using cron jobs as before. The script will continue to execute in this session and we can reattach to it and check the command line output at any time.

the crontab needs to be changed using the following command:

crontab -e

The following line is added to the crontab:

@reboot screen -dm -S rfstick /home/pi/app/launcher.sh
crontab editor
Continuar a ler

Designing End Node for LoRa

The aim was to develop a small end node capable of reading some sensors and send the information through LoRa. Furthermore the end node is battery powered so power consumption plays an important role.

Continuar a ler

LoRa and LoRa”Gateway”

Introduction to LoRa.

LoRa (short for Long Range) is a type of RF communication designed for low-power and high range. Due to these characteristics it enables small end nodes (typically battery powered microcontrollers and sensors) to send information for IoT applications. LoRa has been developed by Semtech that licenses this technology to other vendors such as HopeRF, ST, Microchip, etc.

LoRaWAN concept illustration by www.libelium.com.
Continuar a ler

Led Display

Neste projecto foram usadas 10 matrizes da Kingbright que contêm 7 linhas e 5 colunas no total de 35 leds por matriz perfazendo 350 leds em todo o painel.
Foram usados 7 shift registers (74HC164) para activar uma linha completa e 7 transístores pnp (visto que o painel é de ânodo comum) para ir comutando entre as diferentes linhas. O controlo do painel está a cargo de um PIC18F2680.

led_controller_assembly
Continuar a ler

VFDclock

Displays VFD (Vacuum Fluorescent Display) são um tipo de display muito usado em electrónica de consumo capazes de mostrar símbolos, texto e números com alto brilho e contraste. São constituídos por um filamento, grelhas de controlo e dígitos revestidos com fósforo. Com o pretexto de usar um destes displays e tendo recentemente adquirido um tubo IV18 decidi fazer um relógio.

vfdclockprojecto
Continuar a ler

Conversor DC-DC Step Up

No projecto de um relógio que construí, decidi usar um display VFD (Vacuum Fluorescent Display). Trata-se de um display muito usado em electrónica de consumo capaz de mostrar símbolos, texto e números com alto brilho e contraste. Este tipo de displays são constituídos por um filamento, grelhas de controlo e dígitos revestidos com fósforo. O modelo  usado é o IV18, precisa de uma tensão de alimentação do filamento de 5V e de pelo menos 25V para para as grelhas e dígitos.

vfdgrelha

Como mais facilmente se consegue um transformador de 230Vac para 12Vdc decidi usar um para alimentar o relógio e usar um conversor DC-DC para gerar as tensões necessárias para o funcionamento do tubo.

Um conversor “DC-DC step-up” (ou boost) é um conversor de energia em corrente contínua, em que a tensão de saída é maior do que a sua tensão de entrada. Trata-se de uma fonte de alimentação comutada (em Inglês SMPS – Switch Mode Power Supply) e contém (na sua forma mais simples) dois comutadores; um díodo e um transístor (regra geral um mosfet) e dois elementos de armazenamento de energia; um indutor e um condensador. O diagrama destes conversores é o que se segue:

dcdcdiagrama
dcdcstage1
Continuar a ler

GUI com IronPython

Na continuação do artigo anterior que mostrava como criar e executar um script em IronPython, iremos agora ver como pode ser criado um GUI (Graphical User Interface) utilizando Python e os componentes do “.NET”.

O GUI que pretendemos construir é constituido por uma janela (Form), uma caixa de texto (TextBox) e tem o seguinte aspecto:

gui

A Microsoft agrupa “funcionalidades” (classes) em “NameSpaces” e “Assemblies”. Os “NameSpaces” são usados para organizar de forma lógica classes que estejam de alguma forma relacionada, têm também como objectivo evitar conflitos entre classes provenientes de várias fontes. As “Assemblies” são código compilado, tipicamente um ficheiro DLL e podem conter vários “NameSpaces”.

Windows Forms (WinForms) é o nome dado à API (Application Programming Interface) de interface gráfica usada nas aplicações. Esta API proporciona o acesso a elementos nativos do interface do Windows como janelas, botões, caixas de texto, labels entre muitos outros. O “.NET” possui um namespace chamado “System.Windows.Forms” que iremos usar para importar para a nossa aplicação a janela e a caixa de texto.

Na documentação online disponível na MSDN (Microsoft Developer Network) pode ver-se quais as classes que pertencem ao namespace “System.Windows.Forms” em http://msdn.microsoft.com/en-us/library/k50ex0x9.aspx. Pesquisando um pouco é fácil de encontrar dentro deste namespace a class “Form” em http://msdn.microsoft.com/en-us/library/system.windows.forms.form.aspx e a class “TextBox” em http://msdn.microsoft.com/en-us/library/system.windows.forms.textbox.aspx

O código necessário para gerar esta aplicação pode ser escrito utilizando o Notepad++ e é o que se segue:

import clr
clr.AddReference('System.Windows.Forms')
clr.AddReference('System.Drawing')

from System.Windows.Forms import Application, Form, TextBox
from System.Drawing import Point

form = Form()
form.Text = 'Exemplo GUI'

#http://msdn.microsoft.com/en-us/library/system.windows.forms.textbox.aspx
#http://msdn.microsoft.com/en-us/library/a19tt6sk.aspx

posicao=Point(20,30)

texto=TextBox()
texto.Location=posicao
texto.Text='Hello World'

form.Controls.Add(texto)

Application.Run(form)

Para que um programa possa usar uma assembly/namespace, é necessário adicionar explicitamente uma referência para este. Para adicionar referências usa-se o módulo CLR e para usar o módulo CLR é necessário importá-lo. É precisamente isso que faz a primeira linha de código:

import clr

As referencias são adicionadas através do método “AddReference”. Para este programa vamos adicionar duas referências para os namespaces “System.Windows.Forms” e “System.Drawing”:

clr.AddReference('System.Windows.Forms')
clr.AddReference('System.Drawing')

Destes namespaces vamos importar a class “Application” a “Form” e a “TextBox” bem como a estrutura “Point” para tal usamos o seguinte:

from System.Windows.Forms import Application, Form, TextBox
from System.Drawing import Point

Agora que o nosso código já tem acesso a estas classes vamos instanciar (criar um objecto de um tipo) uma janela (form):

form = Form()
form.Text = 'Exemplo GUI'

O código acima também mostra como aceder e alterar a propriedade Text (Nome da janela) através do operador “.”.

De seguida vamos criar (instanciar) uma caixa de texto. O código seguinte também inicializa uma estrutura do tipo “Point” para escolhermos as coordenadas da caixa de texto em relação à janela e altera o texto para “Hello World”.

texto=TextBox()
posicao=Point(20,30)
texto.Location=posicao
texto.Text='Hello World'

As ultimas duas linhas adicionam a caixa de texto à janela e executam a aplicação:

form.Controls.Add(texto)

Application.Run(form)

Para executarmos o nosso programa assumindo que lhe chamámos “gui.py” podemos (na consola) chamar a aplicação da seguinte forma:

ipy gui.py

esta forma é mais correcta para fazer debug da aplicação.

Quanto tudo funcionar correctamente podemos executar a aplicação (através de um atalho por exemplo) com o comando:

ipyw gui.py

Usando o “ipyw” em vez do “ipy” a aplicação não vai abrir uma janela da consola quando se executa.

Python + .NET = IronPython

Introdução:

Python é uma linguagem de programação de alto nível multi plataforma (Windows, Linux, MAC),  interpretada (os programas em Python são muitas vezes chamados scripts) e orientada a objectos. A linguagem foi projectada com a filosofia de diminuir o esforço do programador bem como da  legibilidade do código. Combina uma sintaxe concisa e recursos poderosos através da sua biblioteca padrão e de módulos e frameworks desenvolvidos por terceiros. A distribuição padrão é conhecida como CPython, é desenvolvida em “C” e pode-se encontrar em http://www.python.org/.

Microsoft .NET é uma iniciativa da Microsoft, que visa uma plataforma única para desenvolvimento e execução de sistemas e aplicações. Com uma ideia semelhante à plataforma Java, o programador deixa de escrever código para um sistema ou dispositivo específico, e passa a escrever para a plataforma .NET. Esta plataforma é executada sobre uma Common Language Runtime – CLR  (Ambiente de Execução Independente de Linguagem) interagindo com um Conjunto de Bibliotecas Unificadas (framework).

Actualmente o .NET suporta um conjunto de Linguagens de Programação através do seu IDE, o Microsoft Visual Studio ou Visual Studio Express (gratuito mas com algumas funções limitadas), entre elas encontram-se o Visual Basic, o Visual C++ e  o C#.

IronPython é uma implementação de Python escrita integralmente em C# utilizando o .NET (em oposição ao CPython escrito em C) e permite aos utilizadores de Python o uso da estrutura .NET e todas as funcionalidades compatíveis, tornando Python outra linguagem do .NET ao lado do Visual Basic ou do C#. O IronPython pode ser descarregado em http://ironpython.net/

Instalação:

Para poder usar o IronPython é necessário fazer o download do installer na página oficial em: http://ironpython.net/ (versão mais actual à data deste artigo 2.7.3).

De seguida executa-se o “installer” e seguem-se os passos normais na instalação de um programa. Findado o processo de instalação é necessário adicionar ao “System Path” (variável de sistema que especifica um conjunto de directorias contendo os executáveis de diversos programas) a  directoria de instalação do IronPython de forma a que este seja reconhecido em qualquer lado.

Nas “Definições Avançadas de Sistema” escolher o separador “Avançadas” e a opção “Variáveis de Ambiente”:

systemvars

De seguida escolher:

systemvars2

Na janela que aparece navega-se até ao fim do texto e adiciona-se um “;” seguido da directoria de instalação do IronPython, no meu caso:

systemvars3

Teste:

Para confirmar que tudo está a funcionar correctamente abram uma janela da consola (DOS) e escrevam “ipy” seguido de “enter”. Deverão obter o seguinte resultado:

ipy

A consola deverá  mostrar a versão do IronPython usada e ficar com o cursor a piscar a seguir a “>>>” . Este é o modo interactivo e permite testar todos os comandos e funções do IronPython (o CPython também tem um modo equivalente).

Podemos criar um programa “Hello World”, para tal escreva na consola:

print('Hello World')

Deverá obter algo do género:
helloPara sair do modo interactivo e voltar à consola, basta escrever o comando “quit()” seguido de “enter”:

quit()

Escrever Scripts:

Podem-se criar ficheiros com código dentro e depois executá-los sem que para isso necessitemos de usar o modo interactivo da consola. Para isso podemos usar um programa como o Notepad++ disponivel em http://notepad-plus-plus.org/. O exemplo anterior ficaria:

scriptpy

No Notepad++ pode-se escolher qual a linguagem de programação de forma a que ele faça o “highlight” do código de forma correcta. De seguida é necessário guardar o ficheiro na localização e com o nome pretendido através de “File-> Save As”:

saveas

Como anteriormente tinha sido escolhido a linguagem de programação o Notepad++ sabe que é um ficheiro com código Python e vai adicionar automaticamente a extensão “.py” ao ficheiro. Neste exemplo o nome do ficheiro vai ser “helloworld.py”.

Para executar o nosso script voltamos à consola e navegamos até à directoria onde guardámos o script e escrevemos:

ipy helloworld.py

O resultado deverá ser:
exec
No próximo tutorial avançaremos para a utilização de componentes .NET e ambiente gráfico.