Stepper Motors

O que são?
stepper

Os motores de passo também conhecidos do Inglês como “Stepper Motor” são motores síncronos largamente utilizados na industria bem com em electrónica de consumo. Têm como vantagem relativamente aos motores DC permitirem um controlo preciso sobre a sua posição angular através de impulsos de relógio e de a manter sem a necessidade de encoders e controladores exageradamente dispendiosos (permitem o controlo em “Open Loop”). Os motores de passo são fabricados com diferentes números de passos por revolução (número de impulsos de relógio necessários para completar uma rotação de 360º), existem por exemplo, motores com 48 passos/volta ou dito doutra forma 7.5º por passo (step). Quanto mais passos o motor tiver por volta maior será a resolução; valores de 7.5, 1.8 ou 0.9º/step são comuns. Dependendo da aplicação é necessário um compromisso entre o numero de passos e a velocidade pretendida uma vez que os motores de passo perdem binário quanto maior a sua velocidade angular (maior número de steps por segundo). Na continuação podem ver-se as curvas típicas de binário vs steps/segundo destes motores.

Estruturalmente este tipo de motores têm tipicamente todos os enrolamentos no “stator” e o “rotor” é um íman permanente “dentado”. Na imagem seguinte pode ver-se o estator (cor cinza), o rotor (rosa) e o enrolamento (winding) a violeta:

Stepper_motor_1

Vista explodida de um motor de passo:

MAY_15_ECN-Titus CS Motors Fig 3

Pormenor do rotor:

rotor_detail

Tipos
Existem dois tipos de motores de passo, os UNIPOLARES e os BIPOLARES. Esta distinção diz respeito à forma como os enrolamentos estão organizadas internamente. Esta organização influencia também a “etapa de potencia”  necessária para controlar cada um. Os motores unipolares têm tipicamente 5 ou 6 fios correspondendo aos extremos e ponto médio de dois enrolamentos e os motores bipolares têm tipicamente 4 fios correspondendo aos extremos dos dois enrolamentos. Existem motores com mais ligações que permitem ser usados tanto como uni ou bipolares como iremos ver mais abaixo.

Organização interna de um motor UNIPOLAR:

uni

Organização interna de um motor BIPOLAR:

bipo

Diferentes Tamanhos
O tamanho dos motores está estandardizado pela “NEMA – National Electrical Manufacturers Association (Estados Unidos)”. Na figura podem ver-se alguns dos tamanhos mais comuns (NEMA08 até NEMA42):

nemas

Curva Binário vs Velocidade
Os gráficos seguintes pretendem demonstrar a relação entre o binário do motor e o número de steps/segundo. Como é possível visualizar, o binário decresce de forma acentuada à medida que a velocidade (número de steps/segundo) aumenta. Como foi dito anteriormente é necessário conjugar bem quatro variáveis aquando da escolha dos motores, são elas (sem ordem de importância): Tamanho (NEMA 23, 48, etc.); Binário Máximo (5, 10, 21Kg/cm); Número de passos por volta (48, 200, 400) e Velocidade (n.º steps/segundo). A ultima característica é possível obter através dos datasheets dos motores, no entanto estes nem sempre são fáceis de obter.

slosynm091
vextapk245

Sequência de accionamento
Para permitir ao motor rodar num determinado sentido é necessário que os enrolamentos sejam accionados numa determinada sequencia. Existem pelo menos três sequencias possíveis. A primeira (Full Step) faz rodar o motor e tem apenas um enrolamento ligado de cada vez logo consome menos corrente. A segunda (Alternate Full Step) usa uma sequencia diferente e usa dois enrolamentos ligados de cada vez para aumentar o binário. A terceira sequência também usa dois enrolamentos de cada vez mas permite que o motor avance em meios passos (Half Step) e assim aumenta a resolução do motor para o dobro! Uma vez que estão dois enrolamentos ligados de cada vez esta sequência tem a desvantagem de consumir mais corrente.
Gerar estas sequências é o papel do controlador (entre outras funções como veremos mais abaixo) e existe um bastante conhecido “L297” da “ST” que iremos observar mais abaixo.

Sequência normal “Full Step”:

unipolar

Sequência normal mais binário “Full Step” e sequencia de meio passo”Half Step”:

stepper sequence

Diferentes tipos de ligações

con_bipolar8 con_bipolar6
Motor Bipolar com 8 terminais Motor Bipolar com 6 terminais
con_bipolar4 con_unipolar8
Motor Bipolar com 4 terminais Motor Unipolar com 8 terminais
con_unipolar6 con_unipolar
Motor Unipolar com 6 terminais Motor Unipolar com 5 terminais

Como controlar

A maior parte dos circuitos controladores são do tipo “Step/Dir”, ou seja são necessárias duas linhas de dados para controlar o motor. A linha “Step” diz respeito aos impulsos de relógio para fazer avançar o motor. A linha “Dir” comanda a direcção de rotação do motor, se a linha estiver a “1” (lógico) o motor rodará num sentido e se estiver a “0” no sentido inverso.
Como já foi visto anteriormente é necessário que o controlador gere as sequencias correctas para o accionamento do motor. Irei dar uma breve introdução sobre o integrado “L297” que é CI usado na placa “CNC3AX” que uso na minha CNC.

O L297 além de gerar as sequencias para “Full Step” e “Half Step” permite ainda controlar a corrente fornecida ao motor através de um circuito tipo “Chopper” (rapidamente ligar e desligar a alimentação de forma a manter a corrente constante).

Pinout do L297:
steppe1



Nome

Função
1 Sync

Saída do oscilador interno do Chopper. O SYNC de todos os L297 são ligados juntos para os sincronizar e apenas 1 dos L297 necessita da malha RC no pino 16. (ver imagem em baixo)

2 GND Ligação Ground (negativo).
3 HOME Saída de colector aberto que indica quando é que o L297 está na fase inicial (ABCD=0101). O transístor está aberto quando o sinal é activado.
4 A Fornecimento energético para a Fase A do motor
5 /INH1 Activa o inhibit control paras as fases A e B. Quando é utilizado uma ponte bipolar este sinal pode ser usado para assegurar a queda rápida da tensão acumulada quando a bobina é descarregada. Pode também ser utilizado pelo chopper para regular a corrente carregada se o CONTROL=0
6 B Fornecimento energético para a Fase B do motor
7 C Fornecimento energético para a Fase C do motor
8 /INH2 Activa o inhibit control para as fases C e B. Mesmas funções do INH1
9 D Fornecimento energético para a Fase D do motor
10 Enable Interruptor do chip. Quando baixo (inactivo) INH1, INH2,A,B,C e D estão desligados
11 Control É a entrada control que define a acção do chopper. Quando=0 o chopper actua no INH1 e INH2. Quando =1 actua nas linhas de fase ABCD
12 Vs Entrada de energia (5V)
13 Sens2 Entrada do sensor de voltagem carregada vinda das fases C e D
14 Sens1 Entrada do sensor de voltagem carregada vinda das fases A e B
15 Vref Voltagem de referencia para o circuito do chopper. A voltagem aplicada neste pin determina o pico máximo de corrente carregada
16 Osc Uma rede RC (R to Vcc, C para o GND) é ligada a este terminal para getar o rate do chopper. Este terminal é ligado ao GND quando há sincronização pelo SYNC (f = 1/0.69 RC)
17 CW/CCW Determina o sentido do motor. 1= Sentido do Relógio. 0=Contrário do Sentido do Relógio. A direcção física do motor depende da ligação das bobinas. Pode-se alterar a direcção a qualquer momento
18 Clock Relógio do passo. Um pulso 0 nesta entrada faz o motor avançar 1 incremento. O passo ocorre durante a queda do sinal
19 Half/Full Selector de meio passo ou passo completo. Quando =1 selecionamos a operação em meio passo quando =0 seleccionamos o modo de passo completo. One-phase-on full step mode é obtido selecionando FULL quando o L297 está num numero par. O two-phase-on full step é seleccionado quando activamos o FULL e o tradutor está num numero impar.
20 /RESET Um impulso 0 faz o tradutor reiniciar e regressar à posição HOME (ABCD=0101)

Sincronização de vários L297:

steppe2

Circuito Chopper para regulação da corrente fornecida. Vref é normalmente fornecido através de um potenciómetro muti-volta.

steppe3

Circuito típico de controlo de um motor bipolar com L297 e fase de potência L298:

l297_typical

Anúncios

Led Display

Há já algum tempo que tinha planeada a construção de um Display de Leds. 

Estes displays encontram-se com frequência e constituem um projecto interessante e com utilidade.

Hardware

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_schematic

O layout da board de controlo e da board que contém as matrizes foi feito no EAGLE.

led_display

Board que contem as 10 matrizes é um “shield” da placa de controlo.

led_controller_3D

Placa de controlo com os 7 shift registers e as resistências para os leds.

led_controller_assembly

Algoritmo

O firmware foi desenvolvido utilizando o C18 segundo o seguinte algoritmo.

algoritmo

Suporte

Foi desenhado um suporte para o Led Display utilizando o SolidWorks e posteriormente maquinado na CNC em PVC expandido de 5mm de espessura.

5423388810_50ec31f1cc_b

Imagem CAD do suporte.

5418795618_a68eee9de4_b

Suporte depois de maquinado e montado.

Resultado Final

5418199443_37f0851863_b

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.

O IV18 e seus constituintes podem ser vistos na imagem seguinte:

vfdgrelha

Existem muitos projectos que usam este tubo em diversas configurações como por exemplo:

confs

A configuração que mais gostei foi a ultima que se encontra na imagem anterior, assim usando um programa CAD desenhei o meu futuro relógio a ser construído em PVC expandido:vfdclockprojecto

Dentro do PVC expandido foi deixado espaço para alojar toda a electrónica necessária ao funcionamento do relógio como se pode ver no seguinte corte do desenho 3D:

vfdclockcorte

As peças são de PVC expandido de 1cm de espessura e foram cortadas na CNC. Os dois lados são ligados através de 4 varões de Inox e parafusos:
Foto0088

A placa de circuito impresso desenvolvida terá de encaixar no espaço reservado e conter os drivers para o tubo, o conversor DC-DC o microcontrolador e o RTC (Real Time Clock). Para este projecto foi usado o PIC18F4620, o RTC MCP79410 e o driver MAX6921.

pcbvfdclock

O layout da PCB foi feito no EAGLE e mede 5x5cm:

pcb

Uma representação 3D pode ser criada usando o EAGLE UP:

pcb2

Na imagem seguinte pode-se ver a PCB já feita e o primeiro teste para verificar as dimensões:

Foto0007_001

PCB montada e componentes mecânicos. Foi necessário usar duas peças intermédias em vez de uma originalmente prevista:

Foto0018_001

Relógio praticamente montado, faltando apenas os varões a unir as duas metades:

Foto0015_002

Primeiros testes ao firmware nomeadamente ao Led RGB montado na base do tubo:

Foto0013_002

Por fim o relógio já completamente montado e a funcionar:

Foto0035_001

Vídeo em funcionamento:

Under construction sign

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

O conversor trabalha em duas etapas. Na primeira, o díodo encontra-se inversamente polarizado e o comutador (mosfet) permite a passagem de corrente pela bobine. Durante esta fase, a carga é alimentada exclusivamente pelo condensador de saída.  dcdcstage1

Na segunda fase o comutador é aberto e gera-se uma tensão mais elevada aos terminais da indutância descrita pela equação:

V_l = L \frac{d_i}{d_t}

Nesta situação o díodo fica directamente polarizado e a energia armazenada na indutância durante a primeira fase é transferida para o condensador de saída  numa tensão mais elevada.

dcdcstage2

Os requisitos do conversor DC-DC para uso no relógio são:

Tensão de entrada Vin minimo 11.9V; nominal 12V ; máximo 12.1V

Tensão de saída Vout 25V ± 5%

Corrente de saída Iout 10mA

O tempo que o mosfet conduz (Ton) é de extrema importância porque controla a tensão de saída. A relação entre o Ton e o período de comutação (Ton+Toff) é conhecida por Dutty Cycle e é representado como sendo uma percentagem.

A equação seguinte relaciona a tensão de entrada e de saída para calcular o Dutty Cycle necessário:

D = 1 - \frac{ V_{inmin} }{ V_{out} } = 1 - \frac{ 11.9 }{ 25 } \equiv D = 52.4 \%

Os conversores DC-DC podem funcionar em dois modos, descontinuo ou continuo. Esta designação diz respeito ao facto da corrente no indutor se anular (modo descontinuo) ou não (modo contínuo) durante o funcionamento do conversor. O modo continuo é regra geral mais desejado pois proporciona uma maior eficiência. Para que o conversor trabalhe no modo contínuo é necessário que a indutância usada seja maior que a indutância crítica (valor mínimo que garante o funcionamento no modo contínuo).

 L_{min} = D \cdot V_ { in } \cdot \frac { 1 - D } {f \cdot 2 \cdot I_{out} }

Pela equação anterior, pode-se concluir que quanto maior a frequência, menor será a indutância necessária. Assumindo uma frequência de 50kHz:

L_{ min } = 0.524 \cdot 11.9 \cdot \frac{ 1 - 0.524 }{ 50000 \cdot 2 \cdot 0.01 } \equiv L_{ min} = 2968 \mu H

Neste caso foi usada uma indutância de 3900uH ( > que Lmin ) que já possuía. Com estes dados obtemos as seguintes formas de onda:

L3900_F50000_Vinmin_11.9_Vinmax_12.1

Como a frequência é 50kHz, o período T=20µS e o tempo que o mosfet está ligado Ton=T*D=10.48µS. Com esta informação podemos calcular a corrente máxima que atravessa a bobine através de:

\Delta I_L = \frac{V_{inmax} \cdot T_{on}}{L} = \frac{12.1 \cdot 10.48 E^{-6}}{3900 E^{-6}} \simeq 33 mA

A corrente de entrada é calculada através de:

 I_{in} = I_{out} \cdot \frac{V_{out} + V_D }{V_{in}} \simeq 21.17mA

e a corrente máxima:

I_{pk} = I_{in} + \frac{\Delta I_{L}} {2} \simeq 38mA

Tanto a indutância como o mosfet têm de conseguir suportar este valor. Para terminar falta calcular o condensador de saída e podemos fazê-lo através de:

 C_{out _{min}} = \frac{ I_{out _{max}} \cdot D }{f_s \cdot \Delta V_{ out } } = \frac{0.01 \cdot 0.524 }{50 E^{3} \cdot 1.25} = 85nF \Rightarrow 100nF

Com todos os componentes dimensionados pode-se simular o circuito para ver como se comporta, para isso usei o LTspice com o seguinte circuito:simulacaodcdcschematic

Utilizando um condensador de 100nF obtiveram-se os seguintes resultados:

dcdc100nf

A tensão de ripple situa-se dentro das especificações de 25V±5%=1.25V com um valor de aproximadamente 1V. Para melhorar esta situação usei um condensador de 300nF com os seguintes resultados:

dcdc300nf

Os resultados do circuito real são os seguintes onde a onda azul representa a tensão de saída e a vermelha o comando do mosfet (PWM):

com condensador de saída de 100nF:

25V_100nF

com condensador de saída de 300nF:

25V_300nF

Serial Port com IronPython

Na continuação desta série de pequenos tutoriais sobre IronPython veremos como usar a porta série para comunicar com um micro controlador.

O framework “.NET” possui uma classe “SerialPort” que possui todas as funções necessárias para usar este periférico. É apenas necessário inicializar o periférico e ler o seu buffer.

O código seguinte inicializa a porta (neste caso a COM5) para uma velocidade de 9600bps, sem paridade, 8 bits de dados e 1 stop bit. O programa fica em execução mostrando a cada 10 segundos o numero de mensagens já recebido.

Cada vez que o programa recebe o caracter “\n” (newline), lança um evento de “DataReceived” que será processado por uma função definida pelo programado e é automaticamente chamada em resposta ao evento. Neste caso a função criada é a “ondata”.

import clr, time
clr.AddReference('System')

contador=0

def ondata(sender, event):
    global contador
    print("Recebeu")
    string=sender.ReadLine()
    print(string)
    contador=contador+1

from System.IO.Ports import SerialPort, Parity, StopBits

serialPort = SerialPort("COM5", 9600, Parity.None , 8, StopBits.One)
serialPort.NewLine="\n"
serialPort.DataReceived+=ondata

serialPort.Open()

while True:
   time.sleep(10) # delays for 10 seconds
   print("Ja contei "+str(contador)+" mensagens recebidas")

serialPort.Close()

É necessário adicionar uma referencia para a assembly “System” que contem o namespace “System.IO.Ports”.

import clr, time
clr.AddReference('System')

contador=0

O namespace “System.IO.Ports” contem a classe “SerialPort” e pode ser importada (juntamente com outras propriedades) através de:

from System.IO.Ports import SerialPort, Parity, StopBits

É necessário instanciar a classe “SerialPort” usando neste caso um construtor que permite definir logo o nome da porta, a velocidade, entre outros. Define-se qual o caracter de paragem, o ‘\n’ e qual a função a ser chamada quando este é recebido, neste caso a função “ondata”. Por fim abre-se a porta para que fique activa:

serialPort = SerialPort("COM5", 9600, Parity.None , 8, StopBits.One)
serialPort.NewLine="\n"
serialPort.DataReceived+=ondata

serialPort.Open()

O programa fica agora “preso” num loop infinito estando a “dormir” durante 10 segundos e de seguida “acorda” e mostra o numero de mensagens já recebido. O numero de mensagens recebido é incrementado cada vez que há um evento “DataReceived” e é automaticamente chamada a funcao “ondata”.

while True:
time.sleep(10) # delays for 10 seconds
print("Ja contei "+str(contador)+" mensagens recebidas")

Falta analisar a funcao que processa o evento. Esta função, utiliza a variavel global “contador” e incrementa-o de cada vez que é chamada.

Um dos argumentos de uma função que processe eventos é o “sender” e este argumento é uma referência para a instância que criou o evento, neste caso, a porta serie. Para ler o que foi recebido na porta usamos o método “ReadLine” associado à referência “sender”.

def ondata(sender, event):
    global contador
    print("Recebeu")
    string=sender.ReadLine()
    print(string)
    contador=contador+1

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.

Anúncios