Livro Passo a Passo C#

8/6/2019 Livro Passo a Passo C#

http://slidepdf.com/reader/full/livro-passo-a-passo-c 1/183

Guia para iniciantes em

C#e

.NET Micro Framework

11 de Agosto de 2010

Rev 1.04

Copyright © 2010 GHI Electronics, LLC

www.GHIElectronics.comwww.TinyCLR.com

Por: Gus Issa

Versão Portuguêsa: Miguel Alexandre Wisintainer

http://www.ghielectronics.com/

http://www.tinyclr.com/





Guia para iniciantes em C# e .NET Micro Framework

Sumário

1.Histórico de mudanças .......................................5

2.Sobre o livro ...................................................... 7

2.1.Público Alvo ...............................................72.2.Traduzindo o livro ...................................... 7

3.Introdução .......................................................... 8

3.1.Vantagens ................................................... 84.Portabilidade ....................................................10

4.1.Ofertas do padrão GHI

........................................................................105.Selecionando um Dispositivo ..........................11

5. 1 ChipworkX ..............................................11

5.2 EMX .........................................................12

5.3USBizi Chipset ..........................................12

5.4 Família FEZ .............................................13FEZ Domino e FEZ Mini ..........................13

FEZ Cobra ................................................................... 15

Outros dispositivos ....................................15

6.Primeiros Passos ..............................................176.1.Configuração do Sistema .........................17

6.2.O emulador ...............................................17

Criando um Projeto ...................................18Selecionando Transporte ..........................19

Executando

................................................................... 20Breakpoints ................................................................... 21

6.3.Executando no Hardware .........................22

MFDeploy pode enviar um ping! ..............22Implantação ao Hardware ..........................24

7.Drivers de Componentes ................................. 26

8.C# Nível 1 ........................................................278.1.O que é .NET? ..........................................27

8.2.O que é C#? ..............................................27

“Main” é o ponto de partida

................................................................... 27Comentários ..............................................28

While-loop

................................................................... 29Variáveis ....................................................30

Assemblies

................................................................... 32

Quais Assemblies adicionar ?

................................................................... 37

Threading .................................................. 389.Entradas e saídas digitais .................................41

9.1.Saídas Digitais ......................................... 41

Piscando um LED ..................................... 439.2.Entradas Digitais ......................................45

9.3.Porta de Interrupção .................................46

9.4.Porta Tristate ............................................ 4710.C# Nível 2 ......................................................50

10.1.Variáveis Booleanas ...............................50

10.2.Comando if .............................................52

10.3.Comando if-else ..................................... 53

10.4.Métodos e Argumentos .......................... 5510.5.Classes ....................................................56

10.6.Publico e Privado ................................... 5710.7.Estático e não estático ............................57

10.8.Constantes .............................................. 58

10.9.Enumeration (Enumeração) ............... ....5811.Assembly/Firmware Correspondente ....... ... ..61

Mensagens durante o Boot-up ...................61

12.Modulação por largura de Pulso(PWM) ........63Simulando um sinal PWM ........................ 65

Controlando Servo Motor e ajustando PWM

................................................................... 6512.1.Piezo .......................................................67

13.Filtro de Glitch (Ruído) .................................68

14.Entradas e saídas analógicas ..........................69

14.1.Entradas analógicas ................................6914.2.Sáidas Analógicas .................................. 70

15.Coletor de Lixo .............................................. 72

15.1.Perdendo Recursos .................................7315.2.Dispose ...................................................74

15.3.Mensagens de saída do coletor de lixo . .75

16.C# Nível 3 ......................................................76

16.1.Byte ........................................................ 7616.2.Char ........................................................76

16.3.Array (Vetor/Matriz) ..............................77

16.4.String ......................................................7816.5.Laço - For ...............................................79

16.6.Comando Switch ....................................81

17.Interfaces Seriais ............................................84

Copyright © 2010 GHI Electronics, LLC Page 2/183




17.1.UART .....................................................84

17.2.SPI ..........................................................8817.3.I2C ..........................................................90

17.4.One Wire ................................................91

17.5.CAN .......................................................9218.Output Compare ............................................ 95

19.Carregando recursos ......................................98

20.Displays ....................................................... 10220.1.Display de caracteres ........................... 102

20.2.Display gráficos ...................................103

Suporte Nativo ........................................ 103

Suporte não Nativo ..................................109Suporte Nativo para displays não padrões

................................................................. 109

21.Serviços de Tempo .......................................113

21.1.Relógio em tempo real (RTC) ..............11321.2.Timers ...................................................114

22.USB Host .....................................................11622.1.Dispositivos HID ..................................117

22.2.Dispositivos Seriais ..............................119

22.3.Dispositivo de Armazenamento ..........12123.Sistema de Arquivos ....................................123

23.1.Cartões SD ...........................................123

23.2.Discos USB (Disco de Armazenamento

em Massa) ....................................................12623.3.Considerações nos arquivos de sistemas

......................................................................12824.Criando Redes (Networking) .......................129

24.1.Suporte a rede com USBizi (FEZ) ......129

24.2.TCP/IP bruto ou Sockets .....................130

24.3.Sockets padrões .NET ..........................13124.4.Wi-Fi (802.11) ......................................132

24.5.Redes móveis com GPRS e 3G ............133

25.Criptografia ..................................................134

25.1.XTEA ...................................................134XTEA nos PCs ........................................ 135

25.2.RSA ......................................................135

26.XML ............................................................ 13826.1.Teoria de XML .....................................138

26.2.Criando um arquivo XML ............ .......139

26.3.Lendo XML ......................................... 14227.Expandindo as E/S .......................................144

27.1.Digital .................................................. 144

Matriz de botões ......................................144

27.2.Analógico .............................................146

Botões Analógicos ................................... 14628.Cliente USB ................................................. 147

28.1.Serial (COM) Debugging ..................... 147

28.2.A configuração (SETUP) ..................... 14828.3.Mouse, o plano perfeito ..................... .. 149

28.4.Teclado .................................................150

28.5.CDC -Virtual Serial ..............................15228.6.Armazenamento em Massa (MSC) .... ..153

28.7.Dispositivo customizados .................. .. 154

29.Baixo Consumo ........................................... 156

30.Watchdog ..................................................... 162Recuperação do Sistema de Execução

................................................................. 162

Limitando tarefas críticas ao tempo ................................................................. 163

Detectando o porque da atuação do WatchDog ..........................................................164

31.Wireless (Conexão sem Fio) ........................ 166

31.1.Zigbee (802.15.4) .................................16631.2.Bluetooth .............................................. 167

31.3.Nordic .................................................. 169

32.Objetos em uma pilha customizada .............170

32.1.Administrando a “Custom Heap” ........17032.2.Grandes bitmaps ...................................172

32.3.Buffers grandes .................................... 17233.Pensando “pequeno” .................................... 174

33.1.Utilização da memória ......................... 174

33.2.Alocação de Objetos ............................ 174

34.Tópicos faltantes .......................................... 17934.1.WPF ..................................................... 179

34.2.DPWS .................................................. 179

34.3.Extended Weak Reference ................. .. 179

34.4.Serialização .......................................... 17934.5.Runtime Loadable Procedures ............180

34.6.Banco de Dados ................................... 180

34.7.Touch Screen (Tela sensíveis ao toque) ......................................................................180

34.8.Eventos ................................................. 180

34.9.USB Host Raw .....................................18135.Palavras finais .............................................. 182

35.1.Leituras complementares ..................... 182

35.2.Notas .................................................... 182





35.3.Placa Brasileira (BABUINO) ............ ..183




Guia para iniciantes em C# e .NET Micro Histórico de mudanças Framework

1. Histórico de mudançasVersão 1.04

• Corrigidos mais alguns erros de digitação

• Trocado texto VS2008 para VS2010

• Adicionada uma nota sobre uma expansão de I/O chamada IO40

• Atualizada a seção do watchdog, desabilitação não é permitido

Versão 1.03

• Corrigido mais erros de digitação• Revisada as fontes dos exemplos

• Revisado o parágrafo 16.1, Byte

• Reescrito “tópicos faltantes”

• Adicionada seção de Watch Dog

• Adicionada seção de Baixo Consumo

• Adicionada nota importantes sobre Coletor de Lixo

•

Adicionada subseção do Coletor de Lixo, sobre mensagens de saída• Adicionado outros dispositivos na seção Selecionando um Dispositivo

• Trocada a seção Display gráficos para para apontar para novos displays SPI nawww.TinyCLR.com

• O índice agora tem 2 colunas

Versão 1.02

• Corrigidos erros de digitação

• Atualizado o uso do VS2010 em vez do VS2008. Atualizado 4.0 para 4.1 e colocandonovo link para para download da versão 4.1

• Adicionado nota sobre filtros de Glitch com pinos capazes de gerar interrupção

• Reescrita seção sobre relógio em tempo real

• Adicionada seção sobre cliente USB






Guia para iniciantes em C# e .NET Micro Histórico de mudanças Framework

Versão 1.01

• Adicionada seção para tradução do livro

• Consertado um pequeno bug no exemplo de matriz de botões

Version 1.00

• Primeira versão oficial




Guia para iniciantes em C# e .NET Micro Sobre o livro Framework

2. Sobre o livro

2.1. Público AlvoEste livro é para iniciantes que querem aprender .NET Micro Framework. Nenhumconhecimento prévio é necessário. O livro cobre .NET Micro Framework, Visual C# e C#!

Se você é um programador, um hobbista ou um engenheiro, você encontrará uma boaquantidade de informações neste livro. Este livro não faz nenhuma suposição sobre o quevocê, leitor sabe, é explicado detalhadamente.

Eu usei o meu tempo livre pessoal (se é que já está disponível!) para escrever este livro.

Esperamos um grande número de erros ortográficos e gramaticais, mas por favor informenos pelo fórum para que eu possa melhorar este livro.

2.2. Traduzindo o livroEste livro é dado para a comunidade em um esforço para fazer NETMF mais fácil para todosos usuários. Se você acha que pode traduzir o livro para outros idiomas, então nósadoraríamos ver sua contribuição. As fontes originais do livro e as regras estão nesta página:

http://www.microframeworkprojects.com/index.php?title=Free_eBook






Guia para iniciantes em C# e .NET Micro Introdução Framework

3. IntroduçãoAlguma vez você já pensou em alguma grande idéia para um produto, mas você não podetrazê-lo para o mundo real porque a tecnologia não estava do seu lado? Ou talvez pensou:"tem que ser uma maneira mais fácil de fazer!". Talvez você seja um programador quequeria fazer um sistema de segurança, mas depois pensou que utilizar os PCs é muito caropara executar um sistema simples? A resposta é : Microsoft .NET Micro Framework!

Aqui está um cenário, você quer fazer um data logger de GPS de bolso, que salve asposições, aceleração e temperatura em um cartão de memória e os exiba em uma telapequena, dispositivos GPS pode enviar dados de posição através de uma porta serial paraque você possa escrever algum código em um PC para ler os dados de GPS e salvá-lo emum arquivo. Mas um PC não pode caber no seu bolso! Outro problema é como você vai

medir a temperatura e aceleração em um PC? Se você fizer este projeto usandomicrocontroladores clássicos, como AVR, PIC, tudo isso pode ser feito, mas então vocêprecisa de um compilador para o micro que você escolher (provavelmente não livre), umasemana para aprender o processador, uma semana para escrever o driver da serial, um mêsou mais para descobrir o sistema de arquivos FAT e mais tempo para cartões de memória,etc ... Basicamente, isso pode ser feito em poucas semanas de trabalho.

Outra opção é utilizar métodos mais simples (Basic Stamp, PICAXE, Arduino, etc). Todosestes produtos simplificam um projeto, mas cada um tem a sua limitação. Somente algunsdeles têm capacidade de depuração. Finalmente, esses dispositivos não são normalmenteadequados para produção em massa.

3.1. VantagensSe você está utilizando o .NET Micro Framework, então há muitas vantagens:

1. Ele roda no Microsoft Visual C# express que é grátis e tem uma IDE de altaperformance.

2. .NET Micro Framework é gratuíto e open-source.

3. Seu código irá rodar em todos os dispositivos com poucas modificações.

4. Capacidade de debug completo (Breakpoints, execução passo a passo,variáveis...etc.).

5. Tem sido testado em muitos produtos comerciais de forma que a qualidade foigarantida.

6. Inclui muitos drivers (SPI, UART , I2C...etc.).

7. Não há necessidade de datasheets do processador porque graças ao padrão doFramework.




Guia para iniciantes em C# e .NET Micro Introdução Framework

8. Se você já é um programador C# para PC, então você esta pronto para ser umdesenvolvedor de sistemas embarcados com NETMF!

Ao longo deste documento, NET Micro Framework será referenciado como NETMF.




Guia para iniciantes em C# e .NET Micro Portabilidade Framework

4. PortabilidadeExistem duas faces de trabalhar com NETMF, portando e usando. Por exemplo, escrevendoum jogo JAVA em um celular é muito mais fácil do que colocar a máquina virtual Java (JVM)em um telefone. O fabricante já fez fez todo o trabalho de portar JAVA para o seu telefonepara que programadores de jogos possa usá-lo com menos esforço. NETMF funciona damesma maneira, portar não é muito fácil mas usá-lo é muito fácil.

NETMF pode ser dividida em dois componentes principais: o núcleo e HAL (HardwareAccess Layer). As principais bibliotecas do nucleo são feitos para que sejam independentesdo hardware. Normalmente não são necessárias modificações nas bibliotecas do núcleo. Osdesenvolvedores precisam para fazer seu próprio HAL para que o NETMF funcione em um

dispositivo.

4.1. Ofertas do padrão GHI

Nós trabalhamos muito próximos de nossos clientes para se certificar que tudo está correndoconforme o necessário. GHI oferece muitos recursos exclusivos que são padrões e grátiscom os nossos produtos (USB host, database, PPP, RLP, Wi-Fi, OneWIRE, etc...).

Suporte dedicado está disponível gratuitamente através de e-mail, telefone e fórum.




Guia para iniciantes em C# e .NET Micro Selecionando um Dispositivo Framework

5. Selecionando um DispositivoGHI Electronics oferece uma variedade de produtos do básico ao avançado.

• Família X

• Família EMX

• USBizi

• Família FEZ

• FEZ Domino e FEZ Mini

•

FEZ Cobra

5. 1 ChipworkXSe o poder de processamento e customizacação são necessários, então este é a escolhacerta.ChipworkX roda um processador ARM de 200Mhz com 64MB dememória SDRAM de 32 bits e 8MB para aplicações do usuário.Também contém 256MB de flash interna para armazenamento dosistema. Ele inclui todas os grandes benifícios e também exclusivosbenefícios como WiFi e suporte a USB host.

ChipworkX também adiciona suporte de banco de dados SQLitee permite aos usuários carregar o seu próprio código nativo (C /assembly) no dispositivo usando RLP (Runtime LoadableProcedures). RLP permite a programação de aplicaçõesintensivas e em tempo real.





5.2 EMXEste pequeno módulo inclui todas as grandes funcionalidades doNETMF e adiciona muitas características exclusivas da GHI. Nolado do software: o sistema de arquivos, TCP / IP, SSL, gráficos,depuração e mais recursos NETMF estão incluídos. GHI tambémacrescenta: WiFi, PPP, USB host, construtor de dispositivo USB,CAN, entrada / saída analógica, PWM e muito mais. Quanto aohardware: É um processador de ARM de com 8MB SDRAM eFLASH 4.5MB.

O processador de EMX contém nativamente o Ethernet MAC comtransferências via DMA, que lhe dá um grande impulso quandocomparado com o chipset Ethernet clássica baseado no SPI,utilizado por outros.

5.3USBizi ChipsetUSBizi é o menor e único single-chip NETMF emexecução no mundo. O software é executado em umaversão reduzida do Embedded Master. Ele inclui todos osrecursos, exceto em rede (TCP / IP e PPP) e gráficosnativa. Mesmo que esses recursos estão faltando, USBizipode ser conectado a uma rede usando TCP / IP comochipsets WIZnet e pode ser executado com algunsdisplays gráficos simples. Há exemplos de projetos jáprovidos demonstrando como USBizi pode ser colocadoem rede e pode exibir gráficos em displays.





5.4 Família FEZ

FEZ Domino e FEZ MiniFEZ FEZ Domino e Mini são placas muito pequenos (open source) específicas parainiciantes. Eles são baseados no chipset USBizi. FEZ oferece vários periféricos, como USBhost e interface SD, não está disponível em muitas placas destinadas a hobbista. MesmoFEZ sendo direcionado para iniciantes, é também ponto de partidade de baixo custoprofissionais que querem explorar NETMF.

FEZ significa “Freakin' Easy!”





FEZ oferece muitas características não encontradas em Arduino, Basic Stamp e outros:

• Baseado no .NET Framework da Microsoft.

• Executa em um processador ARM da NXP de 72Mhz.

• Suporte a debug em tempo real (breakpoints, inspeção de variáveis, execução passoa passo, etc.).

• Utiliza Visual Studio 2008 C# Express Edition para desenvolvimento.

• Capacidades avançadas como FAT, dispositivo USB e USB host.

• Fácil upgrade para Hardware como o Embedded Master.

• Arquivos de Design de Hardware grátis.

• Compatível com shields existentes.

•

Baseado no chipset USBizi(ideal para uso comercial).• Pinagem do FEZ Mini compatível com BS2.

• Pinagem do FEZ Domino compatível com Arduino.

Quando usando FEZ, as possibilidades são infinitas...

Há uma quantidade numerosa de sensores que estão prontos para ligar diretamente noskits . De simples LEDs e botões, bem como sensores de temperatura ou distância.

Estes exemplos do livro são feitos para dispositivos FEZ. Em geral, os exemplos sãoainda para. NET Micro Framework, para modificá-lo para rodar em qualquer sistema NETMFdeve ser uma tarefa fácil.





FEZ Cobra

FEZ Cobra é uma placa de circuito open source baseada em módulos EMX. Com múltiplos

opcionais mostradores, gabinete opcional, suporte nativo de gráficos, suporte a Ethernetnativo com SSL, e megabytes de memória, FEZ Cobra é ideal para aqueles projetos high-end. Não esquecer que este ainda é FEZ, ou seja, fácil de usar!

Uma expansão LCD é disponível para prender tanto displays de 3.5” (320x240) ou 4.3”

(480x272)

Outros dispositivos





GHI trabalha para oferecer as mais recentes tecnologias de forma dinâmica para o que seucliente necessita. Há sempre algo de novo no GHI, por favor visite www.GHIElectronics.com e www.TinyCLR.com para as últimas ofertas.








Guia para iniciantes em C# e .NET Micro Primeiros Passos Framework

6. Primeiros PassosNota Importante 1: Se você recebeu o seu equipamento ou se você não tiver certeza dofirmware carregado nele, você deve atualizar o firmware. A documentação (manual oututorial) de seu equipamento mostra como a atualização. Este é um passo necessário.Além disso, verifique se você leu o título "Coerência Firmware / Assembly" deste livro.

6.1. Configuração do SistemaAntes de tentar qualquer coisa, temos de assegurar que o PC está configurado com osoftware necessário. Para isso, devemos primeiro fazer o download e instalar o Visual C#Express 2010 ( VS2008 ou mais antigo não irá funcionar)

http://www.microsoft.com/express/vcsharp/

Então faça o download e instale NET Micro Framework 4.1 SDK (não o kit de portabilidade).

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=cff5a7b7-c21c-4127-ac65-5516384da3a0

Se o link acima não funcionar, procurar ".NET Micro Framework 4.1 SDK"

Por fim, instale o SDK GHI NETMF. Você pode obtê-lo aqui:

http://www.tinyclr.com/dl/

6.2. O emulador NETMF inclui um emulador que permite a execução de aplicação NETMF diretamente noPC. Para o nosso primeiro projeto, vamos usar um emulador para rodar uma aplicaçãosimples.













Criando um Projeto

Abra o Visual C# Express, e, no menu, escolha File -> New Project. O assistente devemencionar "Micro Framework" no menu à esquerda. Clique nele e, nos modelos, escolha

"Console Application".

Clique no botão "OK" e você terá um novo projeto que está pronto para executar. O projetotem somente o arquivo C#, chamado Program.cs, que contém poucas linhas de código. Oarquivo é mostrado na janela "Solution Explorer". Se o Windows não está mostrando isso,então você pode abri-lo clicando em "View> Solution Explorer" no menu.

using System;using Microsoft.SPOT;

namespace MFConsoleApplication1{ public class Program

{ public static void Main(){

Debug.Print( Resources.GetString(Resources.StringResources.String1));

}

}





}

Para simplificar, altere o código, deve ser idêntico ao abaixo:



{ public static void Main()

{ Debug.Print("Amazing!");

}

}

}

Selecionando Transporte

Não se desespere se você não entender o código. Vou explicar mais tarde. Por agora,queremos executar no emulador. Vamos garantir que temos tudo configurado corretamente.Clique em "Project-> Properties" no menu. Na janela que aparecer, você irá selecionar oemulador. Na esquerda, selecione “.NET Microframework" e certifique-se da janela parecidacom a abaixo.

Transport: emulator





Device: emulador Microsoft

Certifique-se a janela de saída está visível, clique em "View->Output"

Executando

Estamos finalmente prontos para rodar a nossa primeira aplicação. Pressione a tecla F5. Éum atalho muito útil e você vai usá-lo muitas vezes para executar seus aplicativos. Depois depressionar F5, o aplicativo será compilado e carregado no emulador e alguns segundosdepois pára, tudo! Porque o nosso programa terminou tão rápido que não vimos muito.

Nós queremos depurar o código agora. Depurar significa que você pode ver o passo-a-passoatravés do código do programa. Esta é uma das principais características do NETMF.

Desta vez, utilizando a tecla F11 em vez de F5, que vai acompanhar as instruções, ao invésde apenas executar o programa. Isto irá disparar o aplicativo no emulador e parar na primeiralinha de código. Isto é indicado pela seta amarela.

Aplicações C# começam sempre a partir de um método chamado Main e este é o lugar ondea seta tem parado. Pressione F11 novamente e o depurador irá executar a seguinte linha decódigo que você modificou anteriormente. Você provavelmente já adivinhou, esta linha vaiescrever "Amazing!" na janela de depuração. A janela de depuração é a janela de saída doVisual C# Express. Certifique-se a janela de saída é visível, como explicado acima epressione F11 novamente. Quando você passar desta linha, a palavra "Amazing" aparecerána janela de saída.





Se você pressionar F11 novamente, o programa irá terminar e emulador também.

Breakpoints

Breakpoints é outra característica útil quando a depuração de código. Enquanto o aplicativo éexecutado, o depurador verifica se a execução chegou a um ponto de interrupção. Se assimfor, a execução será interrompida. Clique na barra esquerda, à direita da linha que imprime"Amazing!". Isto irá mostrar um ponto vermelho que é o ponto de interrupção.





Agora pressione F5 para executar o software e quando o aplicativo chega ao ponto deinterrupção do depurador, ele pausa mostrando como na imagem abaixo

Neste momento, você pode executar o passo-a-passo com F11, ou F5 para continuar aexecução

6.3. Executando no HardwareExecutando aplicações em equipamentos NETMF é muito simples. Instruções podem diferir dependendo do hardware. Este livro utiliza FEZ para demonstração, mas qualquer outrohardware pode funcionar similarmente

MFDeploy pode enviar um ping!

Antes de utilizar o Hardware, podemos garantir que esteja conectado corretamente. O SDKNETMF vem com um programa chamado Microsoft MFDeploy. Existem diversas maneirasde usar MFDeploy mas por agora só precisamos "pingar" com o Hardware. Para simplificar,MFDeploy vai dizer "Hi!" para verificar se ele também irá responder com "Hi!". Isso é útil paraverificar se o Hardware está ligado e não há problemas de comunicação.

Abra o MFDeploy e conecte o FEZ ao PC através do cabo USB fornecido. Se esta foi aprimeira vez que você conectou o FEZ, o Windows irá pedir por drivers. Aponte para odiretório de instalação do SDK e aguarde até que o Windows conclua a sua instalação.

Na lista, selecione USB. Na lista de equipamentos, você deve ver USBizi. Você verá USBizi

porque FEZ é baseado no chipset USBizi. Escolha USBizi e clique no botão "Ping". Vocêdeve ver agora de volta "TinyCLR”.









Implantação ao Hardware

Agora sabemos que o equipamento é conectado através de MFDeploy, devemos voltar noVisual C# Express. Nas propriedades do projeto, selecione USB para o Transport e USBizipara o Hardware. Verifique se o seu setup parece com que está na tela abaixo.





Pressionando F5 irá enviar nossa pequena aplicação para o FEZ e executar em Hardwarereal. Mudar do emulador para hardware real é tão simples!

Tente os passos que nós seguimos com o emulador, como a definição de breakpoints e usar

F11 para execucação passo-a-passo. Note-se que "Debug.Print" continuará a enviar mensagens de depuração do equipamento para a janela de saída do Visual C# Express.




Guia para iniciantes em C# e .NET Micro Drivers de Componentes Framework

7. Drivers de ComponentesOs componentes FEZ (LEDs, botões, sensores de temperatura, relés, controladores de servo... etc.) e interfaces shield (Ethernet, controladores de motores de LCD ... etc.) são fornecidoscom exemplos com seus drivers. Esses drivers supoe que você não conhece nada sobremHardware. Por exemplo, para piscar um LED, basta pedir para o driver para fazê-lo. Não hámenção de pinos do processador e como alterar o status do pino,etc …Por outro lado, estelivro ensina os princípios. Use os drivers dos componentes para começar a utilizar este livropara entender o que realmente esses drivers fazem.




Guia para iniciantes em C# e .NET Micro C# Nível 1 Framework

8. C# Nível 1Este livro não se destina a ensinar C#, mas irá abranger a maioria das bases necessáriaspara começar.

Para a aprendizagem de C# não ser tediosa, eu vou dividir em vários níveis, para quepossamos fazer coisas mais interessantes com NETMF e voltar ao C#, quando necessário.

8.1. O que é .NET?Microsoft desenvolveu .NET Framework para padronizar programação. (Note que eu estoufalando sobre NET Framework e não o Micro Framework.) Há um conjunto de bibliotecas que

desenvolvedores podem usar de muitas linguagens de programação. O .NET Frameworkroda em PCs e não em dispositivos menores, porque é um é um framework muito amplo.Além disso, a estrutura completa tem muitas coisas que seriam muito úteis em dispositivosmenores. Para isto NET Compact Framework nasceu. O compact framework removeubibliotecas desnecessárias para diminuir o tamanho. Esta versão menor roda no WindowsCE e smart phones. O compact framework menor que o framework completo mas ainda édemasiado grande para rodar pequenos dispositivos por causa do tamanho e porque exigemum sistema operacional para rodá-lo.

. NET Micro Framework é a versão menor desses frameworks. Removeu mais bibliotecas etornou-se um sistema operacional independente. Devido à semelhança entre estes 3frameworks, quase todo código rodar em Pcs, pode rodar em dispositivos pequenos, com

pouca ou nenhuma modificação.Por exemplo, usando a porta serial de um PC, dispositivo WinCE ou FEZ (USBizi) funcionada mesma maneira, quando se utiliza. NET.

8.2. O que é C#?C e C++ são linguagens de programação mais populares. C# é uma melhoria e maismoderno que C e C++. Ele inclui tudo que você esperaria de uma linguagem moderna, comocoleta de lixo e validação em tempo de execução. Ele também é orientado a objeto, o quetorna os programas portáteis e mais fáceis de depuração. C# usa um monte de regras deprogramação para reduzir a possibilidade de erros, provê da maioria dos recursos do C/C++.

“Main” é o ponto de partida

Como vimos antes, os programas sempre iniciam em um método chamado Main.Um métodoé um pequeno pedaço de código que executa uma tarefa específica. Os métodos começam e





terminar com chaves “{“ e “}”. Em nosso primeiro programa, tínhamos apenas uma linha decódigo entre as chaves.

A linha foi Debug.Print ("Amazing!");

Pode ver que a linha termina com um ponto e vírgula. Todas as linhas terminam assim.Esta linha chama o método Print que existe no objeto Debug. Chama ele passando oparâmetro "Amazing".

Confuso? Vamos esclarecer um pouco. Suponha que você é um objeto. Você terá váriosmétodos para controlá-lo. Um método pode ser "sente" e outro seria "Corra”. Agora, comovocê faria para "dizer" Amazing? Vai chamar o seu método "dizer" com a frase (string)"Amazing!!". E o código seria o seguinte:

Voce.diz(“Amazing!”);

Por que precisamos de aspas de depois da palavra “Amazing!!” ? Porque C# não sabe que o

texto que você está escrevendo é um comando ou apenas um texto real. Você pode ver queestá colorido em vermelho quando adiciona aspas, o que faz a a leitura do código muito maisfácil.

Comentários

Como adicionar notas, comentários, avisos em seu código? Estas opiniões vão ajudá-lo aentender o que o código. C# ignora completamente estes comentários. Há duas maneiraspara postar comentários: linha ou bloco. Os comentários são escritos em verde.Para comentar uma linha ou uma parte da linha, adicione / / antes que o texto do comentário.A cor do texto fica verde, indicando que o texto é um comentário e é ignorado pelo C#.




{ // Isto é um comentário Debug.Print("Amazing!");//Isto é um comentário também!

}

}}

Você pode comentar um bloco completo. Começe o comentário com o símbolo /* e terminecom o símbolo */ .








{ /* Isto é um comentário

isto ainda é um comentárioo bloco de comentário termina aqui*/

Debug.Print("Amazing!");}

}

}

While-loop

Este é o momento de nossa primeira palavra-chave "while”. Um while começa e termina comchaves com o código entre os dois. Tudo entre as chaves será executado enquanto umacondição é verdadeira. Por exemplo, eu peço que você continue a ler este livro, enquantovocê está acordado!

Por isso, vamos garantir que o programa exibe continuamente "Amazing!!". Este ciclo é semfim, a condição será sempre "true" (verdadeiro).




{ while(true)

{ Debug.Print("Amazing!");

}}

}}

No código acima, a execução terá início no método “Main”, como de costume, em seguida,








{ int MyVar;

MyVar = 3; while(MyVar>0)

{MyVar--;

Debug.Print("Amazing!");}

}

}}

Note-se que o loop While não é verdade o tempo todo, mas enquanto MyVar> 0. Isso quer

dizer, continua a loop até o valor de myVar é maior que 0.No primeiro ciclo, MyVar é igual a 3. Em cada ciclo é aplicado um descescimo de 1 emMyvar. O laço será executado exatamente três vezes e em seguida, exibir três vezes apalavra "Amazing!"

Vamos fazer algo mais interessante. Eu quero mostrar os números de 1 a 10. Ok, sabemoscomo criar uma variável e como o incremento, mas como mostrar a janela de saída?Fornecer MyVar para Debug.Print vai dar um erro porque só aceita strings, não númerosinteiros. Como converter um inteiro para uma string? Muito simples: use MyVar.ToString().Fácil!




{ int MyVar;

MyVar = 0; while(MyVar<10)

{MyVar++;

Debug.Print(MyVar.ToString());}

}

}}





A última coisa que vamos acrescentar: queremos que o programa escreva:

Count:: 1

Count: 2

...

...

Count: 9

Count:10

Isto pode ser facilmente feito adicionando strings. Strings são adicionadas usando o símbolo+ como se adicionasse qualquer número.

Tente o código seguinte




{ int MyVar;

MyVar = 0;

while(MyVar<10){

MyVar++; Debug.Print("Count: " + MyVar.ToString());

}}

}}

Assemblies

São arquivos que contém o código compilado (montados). Isto permite ao desenvolvedor usar o código embora não tenha acesso ao código fonte. Nós já usamos Debug.Print, por exemplo. Mas quem criou a classe de depuração e escreveu o método de impressão nointerior? Estes foram criados pela equipe NETMF Microsoft. Eles compilam o código efornecem-no com um conjunto para o uso. Assim você não precisa se preocupar comdetalhes internos para utilizá-lo.





No início do código usado anteriormente, podemos ver "using Microsoft.SPOT";

Isso diz a C# que queremos usar o namespace Microsoft.SPOT. Uh ... afinal o que é umnamespace ? Os programas são divididos em regiões "espaços". É muito importante quandoos programas se tornam mais longos. Cada pedaço de código ou a biblioteca é atribuído um"nome" no seu "espaço". Os programas com o mesmo namespace podem ver um ao outro,mas se for diferente, podemos dizer para o C# para usar (use) o espaço de outros.

O nome para o espaço do nosso programa é namespace MFConsoleApplication1Para usar um espaço de nomes diferentes como "Microsoft.SPOT você deve adicionar “usingMicrosoft.SPOT”;





O que é o SPOT, afinal? Aqui está a história: alguns anos atrás, a Microsoft iniciou um projetochamado internamente SPOT. Eles perceberam que este projeto foi uma boa idéia e queriaoferecer a outros desenvolvedores. Eles então decidiram mudar o nome do produto para.NET Micro Framework, mas mantiveram o mesmo código para compatibilidade com

sistemas existentes. Então, basicamente, é NETMF SPOT!Volte para o código. Tente apagar (ou comentar) “using Microsoft.SPOT”e seu código não vaifuncionar.

Aqui está a mensagem de erro recebida após comentar linha “using Microsoft.SPOT”;





Nós usamos “assemblies”, mas para onde eles foram adicionados?

Remova o comentário e certifique-se o programa funciona de novo. Agora olhe para a janela"Solution Explorer" e clique no sinal de adição antes da palavra "References". Você deveráver dois “assemblies”.

Agora, faça um clique com o botão direito em "Microsoft.SPOT.Native" e "Remove”

Nosso programa é rigorosamente a mesma de antes, exceto que agora esta faltando umassembly muito importante. Tente lançá-lo e você terá algo como isto:





Volte a adicioná-lo e verifique se o programa ainda funciona. Clock com o botão direito domouse sobre a palavra "Reference" e selecione "Add Reference ..."

Na nova janela, selecione o guia. NET e escolha "Microsoft.SPOT.Native" e clique em OK.





Experimente o programa, ele deve funcionar. Se você receber erros, volte leia mais e tenhacerteza de que seguiu corretamente os passos mencionados antes de prosseguir

Quais Assemblies adicionar ?

Neste livro, ofereço vários exemplos, mas eu não lhe disse que assemblies eu estouutilizando. É realmente fácil de resolver através da documentação mas pode ter dificuldadesalgumas vezes. Por que não juntar tudo de uma vez? Como iniciante, sua aplicação é aindamuito pequena e você vai ter muita memória, se você pode adicionar todos os assemblies,mesmo que você não usar todos eles.

Os assemblies abaixo são os mais utilizados. Adicione em todos os seus projetos para omomento. Depois de saber o que vai realmente necessitar, pode apagar o que não

interessa.

GHIElectronics.NETMF.Hardware

GHIElectronics.NETMF.IO

GHIElectronics.NETMF.System





Microsoft.SPOT.Hardware

Microsoft.SPOT.Native

Microsoft.SPOT.Hardware.SeriaPort

Microsoft.SPOT.IO

mscorlib

System

System.IO

Lembre-se de utilizar um dos seguintes assemblies, dependendo do que hardware você tem.Eles contêm as atribuições dos pinos do processador.

FEZMini_GHIElectronics.NETMF.FEZFEZDomino_GHIElectronics.NETMF.FEZ.

Threading

É um assunto muito difícil. Somente as informações básicas serão abordados aqui.

Processadores / programas executam uma instrução por vez. Lembre-se de como nósestávamos indo passo a passo através do código? Uma única instrução foi executada e ofluxo de então passou para a próxima. Então, como é possível que seu computador poderodar vários programas ao mesmo tempo? Na verdade, o PC não estão executando aomesmo tempo.! Ele executa cada programa em um curto período de tempo, pára e executaum outro programa após um curto período de tempo.

Em geral, o multi-tasking não é recomendado para iniciantes, mas algumas coisas são mais

fáceis utilizando threads. Por exemplo, você quer um flash LED. Seria bom fazer isso emuma thread e você não precisa se preocupar em seu programa principal.

Além disso, para adicionar atrasos no seu programa você precisa do “namespace threading.Você entenderá melhor nos exemplos a seguir.

Aliás, LED significa Light Emitting Diodes. Há LEDs em torno de você. Pegue qualquer TV,DVD ou dispositivo eletrônico e você verá uma pequena luz vermelha (ou outras). Eles sãoLEDs.

FEZ fornece uma biblioteca dedicada LED para simplificar ao máximo. Este livroexplica como controlar diretamente os pinos e hardware.

Adicione "using System.Threading" em seu programa:

Isso é tudo que nós precisamos usar threads! É importante saber que o nosso programa emsi é uma thread. No início da execução, C# busca por “Main” e executá-lo em uma thread.Nós vamos adicionar um delay em nossa thread (o nosso programa) para escrever





"Amazing!" a cada segundo. Para dar um delay na “thread” nós a colocamos em “Sleep”.Note que o “Sleep” não é para todo o sistema, mas apenas para o “Sleep” na “thread” emquestão.

Adicione "Thread.Sleep (1000);

O método "Sleep" usa o tempo em milissegundos. Assim, por um segundo, teremos em 1000milissegundos.

using System;using Microsoft.SPOT;using System.Threading;


{ public static void Main(){

while (true){

Debug.Print("Amazing!"); Thread.Sleep(1000);

}}

}}

Inicie o programa e olhe a janela de saída. Se você já tentou o emulador e que não deuexatamente 1 segundo o intervalo, não se preocupe. Tente em hardware real (FEZ) e vocêestará muito próximo de 1 seg.

Vamos criar uma segunda thread (o primeiro foi criado automaticamente, lembra?) Vamos ter que criar um novo handler para a thread e dar-lhe um nome de fantasia comoMyThreadHandler, em seguida, criar um novo método local e o chame de MyThread, entãorode a nova thread.

Nós não estamos usando a thread "main" (principal) nunca mais, então vamos deixá-la numloop infinito.

Aqui está a listagem do código. Se você não entender tudo, não se preocupe. O objetivo aquié saber como por em “Sleep” uma thread.







{ public static void MyThread()

{ while (true)

{ Debug.Print("Amazing!"); // Pause esta thread durante 1 segundo Thread.Sleep(1000);

}}

public static void Main(){

// Cria um tratador de Thread Thread MyThreadHandler; // Cria um novo objeto thread

// e atribua para meu HandlerMyThreadHandler = new Thread(MyThread);

// Inicia minha nova ThreadMyThreadHandler.Start();

///////////////////////////////// // Faça alguma coisa que você gostaria aqui Thread.Sleep(Timeout.Infinite);

}

}}




Guia para iniciantes em C# e .NET Micro Entradas e saídas digitais Framework

9. Entradas e saídas digitaisNos processadores há vários pinos 'digitais' que pode ser usados como entrada ou saída.Quando dizemos "digital", isso significa que o estado do pino pode ser 0 ou 1.

Nota Importante: A eletricidade estática (mesmo que do corpo humano) pode danificar oprocessador. Você já experimentou um choque ao tocar em alguém, às vezes. Este pequenochoque é poderoso e suficiente para queimar circuitos eletrônicos. Os profissionais utilizamequipamentos especiais e adaptados para previnir este problema (aterramento). Você podenão ter este equipamento, de modo que tem que evitar tocar no circuito. Você também podeusar no pulso uma pulseira anti estática.

NETMF suporta E/S digitais através do assembly e namespace "Microsoft.SPOT.Hardware”.

Vá em frente e acrescente o assembly e namespace como aprendido anteriormente.

Nós estamos agora prontos para use E/S digitais.

9.1. Saídas DigitaisSabemos que uma saída digital pode ser definido como 0 ou 1. Note que este não é um volt

mas indica que o pino esta suprindo tensão. Se o processador é alimentado por 3.3V, assim,o estado em um pino indica uma tensão de 3,3 V neste pino. Não será exatamente 3,3 V,mas muito perto. Quando o estado do pino é definido como 0, a tensão será muito próximode 0V.

A corrente de saída destes pinos é muito baixa! Eles não podem alimentar dispositivos que





requerem muita corrente. Por exemplo, um motor pode também alimentado por 3,3V, masvocê não pode conectar diretamente a saída digital do processador. Como o processador fornece 3,3 V, mas com muito pouca corrente. O melhor que você pode fazer é alimentar umLED ou sinalizar "1" ou "0" para outro pino.

Todos as placas FEZ têm um LED conectado a uma saída digital. Estamos vamos querer fazer este LED piscar.

As saídas digitais são controladas por um objeto OutputPort. Primeiro criamos umareferência ao objeto (handler) e então criamos um novo objeto OutputPort e o atribuimospara o nosso handler. Quando você cria um novo objeto OutputPort, você deve especificar oestado inicial do pino: 0 ou 1. Zero e um podem ser referidos respectivamente como alto ebaixo and tambem pode ser True para alto e False para baixo. Nós vamos colocar o pinono estado (true alta) neste exemplo para ligar o LED na inicialização.

Aqui está o código que usa o pino 4 ligado ao LED no mapa FEZ Domino.

using System;using Microsoft.SPOT;using System.Threading;using Microsoft.SPOT.Hardware;



{ OutputPort LED;

LED = new OutputPort((Cpu.Pin)4, true);

Thread.Sleep(Timeout.Infinite);}

}}

O SDK FEZ é fornecido com os assemblies "FEZMini_GHIElectronics.NETMF.FEZ" e"FEZDomino_GHIElectronics.NETMF.FEZ”. Adicione o assembly apropriado para seuprograma e tambem adicione "FEZ_GHIElectronics.NETMF.System”.

Agora, modifique o código adicionando "using GHIElectronics.NETMF.FEZ" no início do seucódigo.

Aqui está o código, desta vez usando a lista de pinos presentes no assembly (pinenumeration class).






using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.FEZ;



{ OutputPort LED;

LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);


}}

Viu como é muito fácil ? Nós não temos que se preocupar com o pino onde o LED estáligado.

Inicie o programa e observe o LED. Deve estar aceso agora. Agora as coisas estão ficandointeressantes!!!

Piscando um LED

Para fazer um flash no LED, temos que colocar o pino como alto, forçar um delay e colocar opino para baixo e repetir o delay. É importante incluir um delay ? Por quê? Porque nossosolhos não são rápidos o suficiente para detectar a mudança se o LED é aceso e apagadoimediatamente.O que necessitamos para piscar um LED ? ... aprendemos while, como inserir um atraso,resta-nos saber como colocar o pino no estado Alto/Baixo. Isso é feito chamando o métodoWrite do objeto OutputPort. Observe que você não pode usar diretamente "OutputPort.Write".Isto é errado, que porta de saída você está se referenciando ? Em vez disso, use LED.Write,que faz mais sentido.

Aqui está o código para o flash LED para a placa FEZ Domino / Mini

using System;using Microsoft.SPOT;using System.Threading;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.FEZ;







{ OutputPort LED;

LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true); while (true)

{LED.Write(!LED.Read());

Thread.Sleep(200);}

}}

}

Aqui tem outra forma, e simples, de se fazer um LED piscar.


namespace MFConsoleApplication1{

public class Program{ public static void Main()

{ OutputPort LED;

LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true); while (true)

{LED.Write(true);

Thread.Sleep(200);

LED.Write(false); Thread.Sleep(200);

}}}

}

Tente mudar o valor do Sleep para fazer o LED piscar mais rápido ou mais lento. Tentevalores diferentes.





Nota Importante: Nunca ligue duas saídas juntos. Se eles estão ligados e se um está emestado de alta e o outro para o estado baixo, você irá danificar o processador. Sempreligar uma saída para uma entrada, jogando um sinal ou ligue num LED.

9.2. Entradas DigitaisAs entradas digitais detectam se o estado de um pino está alto ou baixo. Há algumaslimitações nestes pinos de entradas. Por exemplo, a tensão mínima é de 0V. A tensãonegativa pode danificar os pinos do processador. Além disso, a tensão máxima deve ser menor do que a alimentação do processador. Todas as placas da GHI Electronics trabalhamcom 3.3V, logo a tensão máxima em um pino deve ser 3.3V. Isso é verdade para ChipworkX,mas para Embedded Master e USBizi, são processadores tolerantes a 5V. Isto significa quemesmo se o processador é alimentado por 3,3 V, é capaz de receber entradas de 5V emsuas entradas. A maioria dos circuitos digitais são de 5V, logo você pode usar para se

comunicar com o processador.Nota: FEZ baseia-se no chip USBizi e que, portanto, tolera os 5V nas entradas.

Nota Importante: Compatível com 5V, não significa que o processador pode ser alimentadopor 5V.

Sempre alimente o processador com 3,3 V. Apenas pinos são tolerantes a 5V.

O objeto InputPort é usado para gerenciar a entrada digital. Todos os pinos do processador GHI podem ser entradas ou saídas, mas, obviamente, não ao mesmo tempo! Entradas quenão estão ligadas são chamados de "flutuante". Você poderia pensar que uma entrada quenão está ligada equivale ao estado baixo, mas este não é o caso. Quando uma entrada nãoestiver conectado, ele está aberto a qualquer ruído que possa representar alto/baixo. Parasuperar isso, os processadores modernos incluem internamente resistores pull-up ou pull-down que geralmente são controladas pelo software. Resistor de pull-up vai puxar o pinopara o estado alto. Note que isso não coloca o pino no estado alto, mas sim a força de umestado perto do topo. Se não estiver conectado, o estado irá ler sinal alto.

Há uma abundância de utilizações de portas de entrada, mas o clássico é para ligar umbotão ou switch. FEZ já inclui um botão ligado ao pino "Loader". Este pino é usado paraativar o download, mas podemos usar esse pino livremente então. O botão chamado "LDR"ou "Loader".

O botão liga ao terra o pino de entrada. Também vamos conectar o resistor de pull-up. Issosignifica que o pino é "alto" (pull up) quando o botão é liberado e "low" (ligados à terra)

quando o botão for pressionado.Vamos ler o estado do botão e encaminhar para o LED. O LED será desligado quando obotão for pressionado.

Código:








{ OutputPort LED; InputPort Button;

LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);Button = new InputPort((Cpu.Pin)FEZ_Pin.Digital.LDR, false,

Port.ResistorMode.PullUp); while (true)

{LED.Write(Button.Read());

Thread.Sleep(10);}

}}

}

Criar um objeto InputPort requer um parâmetro adicional para filtro “Glitch”. Isso seráexplicado mais tarde. Além disso, a forma como passamos o status de uma porta de entradapara setar uma porta como saída pode parecer confuso. Voltaremos na próxima seção.

9.3. Porta de InterrupçãoSe quisermos saber o status de um pino, é preciso verificar seu status periodicamente. Essedesperdício de tempo de CPU para uma tarefa não é interessante. Você estará checando opino, talvez um milhão de vezes antes que o botão seja pressionado! Porta de interrupçãopermitem-nos escrever um método que será chamado apenas quando o botão for pressionado (pino nível baixo, por exemplo).

Podemos provocar a interrupção na mudanças de estado do pino, de “alto” ou "baixo", por exemplo. O uso comum é "na troca de estado" (cada alteração). A mudança de alto para

baixo ou alto par baixo cria um sinal de borda. A borda para alta quando o sinal muda debaixo para alto e a borda de descida quando o sinal muda de alto para baixo.

No exemplo abaixo, eu uso ambas bordas, por isso o nosso método "IntButton_OnInterrupt"será chamado sempre que o estado das mudanças pino.







{ static OutputPort LED; // Isto foi movido fora daqui para que podeser utilizado por outros métodos


LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true); // Este pino vai gerar uma interrupção na borda de subida edescida

InterruptPort IntButton = newInterruptPort((Cpu.Pin)FEZ_Pin.Interrupt.LDR, true, Port.ResistorMode.PullUp,Port.InterruptMode.InterruptEdgeBoth);

// Adiciona um tratador de interrupção para o pinoIntButton.OnInterrupt += new

NativeEventHandler(IntButton_OnInterrupt);

//Faça alguma coisa que você gostaria aqui Thread.Sleep(Timeout.Infinite);

}

static void IntButton_OnInterrupt(uint port, uint state, DateTimetime)

{ // Muda o estado do led

LED.Write(state == 0);}

}}

Nota: Nem todos os pinos do processador suportar interrupções, mas a maioria deles sim.Para uma melhor identificação dos pinos de interrupção, use a lista (enumeração) para

"interrupt" em vez de "Digital", como consta nos códigos acima.

9.4. Porta TristateE se quisermos que um um pino seja entrada e saída, o que podemos fazer? Um pino nuncapode ser ambos simultaneamente, mas nós podemos fazê-lo como saida para escrever alguma coisa e fazê-lo como entrada para ler a resposta de volta.





Uma maneira de fazer seria "Dispor" o pino. Nós fazemos ele como porta de saída, usamosele e então “dispose” (libere) ele, então fazemos como entrada para lê-lo.

NETMF oferece as melhores opções para isto, através dos portas Tristate. Tristate significatrês pinos de estados possíveis: entrada, saída baixa e alta saída. O único problema comestes três pinos de estado é que se um pino está setado como saida e você nomeá-lonovamente como saída, então você receberá uma exceção. A possibilidade de evitar isso épara verificar a direção do pino antes da mudança. A direção do pino é de sua propriedade"Active" onde falso significa entrada e verdadeiro significa saída. Pessoalmente, eu nãorecomendo o uso de portas tristate, a não ser que seja absolutamente necessário.

using System;using Microsoft.SPOT;using System.Threading;using Microsoft.SPOT.Hardware;

using GHIElectronics.NETMF.FEZ;


{ static void MakePinOutput(TristatePort port)

{ if (port.Active == false)

port.Active = true;}

static void MakePinInput(TristatePort port){

if (port.Active == true)port.Active = false;}


TristatePort TriPin = newTristatePort((Cpu.Pin)FEZ_Pin.Interrupt.LDR, false, false,Port.ResistorMode.PullUp);

MakePinOutput(TriPin);// faça o pino como saídaTriPin.Write(true);MakePinInput(TriPin);// faça o pino como entrada

Debug.Print(TriPin.Read().ToString());}

}}

Nota: Por padrão, TristatePort só funcionam com o pinos que podem gerar interrupções.

Nota Importante: Tenha cuidado para não ter um pino ligado a uma chave e a porta estiver configurada para saida. Isso irá danificar o processador. Eu diria para iniciantes em





aplicações, você não precisa da porta tristate, portanto, não a use se você se senteconfortável com circuitos digitais.





10. C# Nível 2

10.1. Variáveis BooleanasNós aprendemos como variáveis inteiras podem conter números. Em contraste, as variáveisBoolean podem somente ser true ou false (verdadeiro ou falso). A luz pode ser estar acesaou apagada, representando isto com um tipo inteiro não faz sentido, mas usando boolean é oestado verdadeiro para ligado e estado falso para desligado. Nós já usamos esta variávelpara alterar o estado do pino de saída digital como alto ou baixo, LED.Write(true);

Para armazenar o valor de um botão em uma variável, usamos:

bool button_state;button_state = Button.Read();

Nós também usamos o laço while e solicitamos que entrasse em um loop infinito, quando nósusamos True no parâmetro.

while (true){ //código aqui}

Veja as últimas linhas de código que escrevi e modifique-o para usar um boolean para torná-lo mais fácil de ler. Ao invés de passar o estado do botão diretamente para o LED, nós lemoso estado de botão em button_state (boolean) então nós passamos essa variável para o LED.




{ OutputPort LED; InputPort Button;





bool button_state;LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);Button = new InputPort((Cpu.Pin)FEZ_Pin.Digital.LDR, false,


{button_state = Button.Read();LED.Write(button_state);

Thread.Sleep(10);}

}}

}

Pode você fazer um LED piscar no momento que uma tecla é pressionada ?




{ OutputPort LED;

InputPort Button; LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);Button = new InputPort((Cpu.Pin)FEZ_Pin.Digital.LDR, false,


{ while (Button.Read() == false) //Botão é falso quandopressionado

{LED.Write(true);

Thread.Sleep(300);LED.Write(false);

Thread.Sleep(300);}}

}}

}





Nota Importante: O símbolo "==" é usado em C# para testar igualdade, enquanto o sinal "="é usado para atribuir um valor.

10.2. Comando if Uma parte importante do programa é verificar algum estado e tomar uma ação de acordo.Por exemplo, "se a temperatura ultrapassar 35 graus, ligue o ventilador”.

Para testar o If com nosso programa, vamos ligar o LED "If" o botão for pressionado. Noteque, ao contrário do que nós tinhamos antes. No programa, o estado do botão é low quandopressionado. Então, para isso, vamos inverter o estado do LED em comparação com oestado do botão. Se o botão for pressionado (baixo), então a luz do LED acende (alta). Istodeve ser verificado regularmente, por isso vamos fazê-lo cada 10ms.




{ OutputPort LED;

InputPort Button; bool button_state;



{button_state = Button.Read();

if (button_state == true){

LED.Write(false);}

if (button_state == false){

LED.Write(true);}

Thread.Sleep(10);}





} }}

10.3. Comando if-elseNos vimos como o "if" funciona. Agora vamos usar a palavra chave "else". Simplesmente, seum "if" é verdade, então o código associado é executado ou "else" (caso contrário) o códigodo "else" é executada. Com esta nova palavra-chave, podemos otimizar nosso código:




{ OutputPort LED; InputPort Button; bool button_state;



{button_state = Button.Read();

if (button_state == true){

LED.Write(false);}

else{

LED.Write(true);}

Thread.Sleep(10);}

}}

}

Vou lhe contar um segredo! Foram utilizados os comandos if e if-else neste exemplo para







while (true){

LED.Write(!Button.Read()); Thread.Sleep(10);

}}

}}

Em geral, existem várias maneiras de escrever código. Use o que você acha que é mais fácilde começar, e com a experiência você aprenderá a otimizar seu código..

10.4. Métodos e ArgumentosOs métodos são as ações executadas por um objeto. Eles também são chamados de

"funções" de um objeto. Nós já vimos e utilizamos. Lembre-se o objeto Debug com o seumétodo Print. Temos usado frequentemente Debug.Print, a qual temos dado uma string paraele mostrar. Esta "cadeia" passada é chamado de "argumento"

Os métodos podem ter um ou mais argumentos opcionais, mas podem retornar apenas umvalor opcional.

O método Print do objeto Debug recebe um único argumento. Outros métodos nãonecessitam de argumentos ou tem vários. Por exemplo, um método que poderia desenhar um círculo poderia ter quatro argumentos: Circle (X , Y, Diâmetro, Cor). Um exemplo de ummétodo que retorna um valor é um método retorna uma temperatura.

Até agora, nós aprendemos três tipos de variáveis: int, string e boolen. Veremos outros tiposmais tarde, mas lembre-se que tudo o que dizemos aqui também se aplica aos outros tipos.

O valor de retorno é opcional. Se nenhum valor é retornado quando você usa o tipo "void". Apalavra-chave "return" é usado para retornar valores no fim de um método.

Aqui está um método simples que retorna a soma de dois números inteiros:

int Add(int var1, int var2){ int var3;

var3 = var1 + var2; return var3;}

Nós começamos o método indicando o tipo do valor de retorno (int), seguido do nome dométodo. Então nós temos a lista de argumentos. Os argumentos são agrupadas entreparênteses e separados por vírgula.





Dentro do método Add, uma variável inteira local foi declarado: var3. As variáveis locais sóexistem no método no qual eles são declarados. Em seguida, some os nossos doisargumentos e, finalmente, retorne o resultado.

Como retornar uma string representando a soma de dois números? Lembre-se que umastring contendo "123" não é o mesmo como um inteiro 123. Um número inteiro é um númeroe string é uma seqüência representa um texto. Para os seres humanos é a mesma de umcomputador são duas coisas totalmente diferentes

Aqui está o código para retornar uma string:

string Add(int var1, int var2){ int var3;

var3 = var1 + var2;

string MyString;MyString = var3.ToString();

return MyString;

}

Podemos ver como o tipo retornado troca para string. Nós não podemos retornar var3 porqueé uma variável inteira e então tivemos de converter para uma string. Para isso, criamos umanova variável objeto chamada MyString. Então converte var3 “ToString()” e ponha a novastring em MyString.

A pergunta agora é como é possível chamar um método "ToString()" em uma variável inteira?Na verdade, em C#, tudo é representado por um objeto, mesmo os tipos de variáveis. Estelivro não entrará nesses detalhes porque é destinado para os iniciantes.

Tudo o que foi escrito antes foi detalhado para melhor poder explicar, mas você podeescrever do seu jeito e compactar.

string Add(int var1, int var2){

return (var1+var2).ToString();}

Eu não aconselho você a escrever código de forma compacta se você não está familiarizado

com a linguagem. E mesmo que haja certos limites devem ser respeitados, se queremos queo código permaneça legível ou é re-utilizado por outra pessoa facilmente.

10.5. ClassesTodas as coisas que nós discutimos até agora são feitos de "classes" em C #. Em modernas





linguagens orientadas a objetos, tudo é um objeto e os métodos pertencem a um objeto. Istopermite ter métodos com nomes idênticos, mas cujas acções são totalmente diferentes. Ohomem pode "andar" e um gato também pode "andar", só que não da mesma maneira. Sevocê escreve um método “ande" em C#, então não é muito claro se o homem ou gato. A

menos que você está usando: homem.ande ou gato.ande.A criação de classes não é o propósito deste livro, mas aqui é uma classe simples paracomeçar.

class MyClass{ int Add(int a, int b)

{ return a + b;

}}

10.6. Publico e PrivadoOs métodos podem ser privados a uma classe ou publicamente acessível. Isso é útilsimplesmente para forçar os objetos mais robustos. Se você criar um objeto (classe) que temmétodos que você não quer que o programador use externamente, basta adicionar a palavra"private" antes do tipo de retorno do método. Caso contrário, coloque a palavra "public".

Aqui está um exemplo:

class MyClass{ public int Add(int a, int b)

{ // Este objeto pode usar métodos privados // somente dentro da classe

DoSomething(); return a + b;

} private void DoSomething()

{}

}

10.7. Estático e não estáticoAlguns objetos na vida têm várias instâncias, enquanto outros existem apenas uma vez. Por





exemplo, um objeto que represente um ser humano não significa muito. Você precisa criar uma "instância" do objeto para representar um ser humano. Você terá algo como

humano Mike;

Agora temos uma referência chamado Mike, do tipo humano. É importante notar que estareferência neste momento não está refenciando objeto algum (sem instancia atribuida), entãoa referência é NULL

Para realmente criar o exemplo, usando a palavra "new" na referência especificando a classedo objeto:

Mike = new humano();

Podemos agora usar qualquer um dos métodos "humano" da instancia de Mike

Mike.Corra (distancia);

Mike.Coma();

Hungry bool Mike.EstaFaminto();

Nós já usamos esses métodos não estáticos quando verificamos os pinos de E/S.

Quando criamos um novo objeto não estático, a palavra "new" é usado para chamar oconstrutor do objeto. O construtor é um tipo especial de método que não retorna nenhumvalor e exclusivamente durante a construção /criação de novos objetos.

Os métodos estáticos são mais fáceis de gerir, porque se referem a um único objeto sem acriação de uma instância. Um exemplo típico é o nosso objeto Debug: não há um únicoobjeto no Debug NETMF, assim, para utilizar os seus métodos são chamados diretamente do

objeto:Debug.Print ("string");

Eu talvez não usei as definições exatas para "estático" e "instância", mas eu queriadescrever a mais simples possível.

10.8. ConstantesAlgumas variáveis podem ter valores que nunca mudam. Para se protegerem de um possívelerro de programação que iria mudar esses valores, basta adicionar a palavra-chave "const"

para o tipo da variável na sua declaração:

const int hours_in_one_day = 24;

10.9. Enumeration (Enumeração)





Listas são similares às constantes. Suponha que temos um dispositivo que aceita quatrocomandos: MOVE, STOP, LEFT e RIGHT. Este dispositivo não é um ser humano, portanto,esses comandos são realmente números. Nós podemos criar constantes (variáveis) paraestes quatro comandos:

const int MOVE = 1;const int STOP = 2;const int RIGHT = 3;const int LEFT = 4;//Agora nós podemos enviar um comandoSendCommand(MOVE);SendCommand(STOP);

Os nomes de constantes são maiúsculas por convenção. Qualquer programador vendo uma

variável maiúscula sabe que se trata de uma constante.O código acima esta OK e irá funcionar, mas seria ainda melhor se nós agrupassemos estescomandos:

enum Command{

MOVE = 1,STOP = 2,RIGHT = 3,LEFT = 4,

}

//Agora nós podemos enviar um comandoSendCommand(Command.LEFT);SendCommand(Command.STOP);

Com esta nova abordagem, não há necessidade de lembrar quais comandos existem e quaisos números dos comandos. Uma vez a palavra “Command” é digitado, Visual Studio dará avocê uma lista de comandos disponíveis.

C# também é esperto suficiente para incrementar os números das enumerações a cada novaordem. Assim, o código abaixo funciona exatamente da mesma maneira.

enum Command{

MOVE = 1,STOP ,RIGHT,LEFT ,

}





//Agora nós podemos enviar um comandoSendCommand(Command.LEFT);SendCommand(Command.STOP);




Guia para iniciantes em C# e .NET Micro Assembly/Firmware Correspondente Framework

11. Assembly/Firmware

CorrespondenteOs dispositivos NETMF incluem funções geralmente extendidas. Essas funções extendidasexigem assembly/biblioteca adicional para que um projeto de C# possa usá-los. Por exemplo,NETMF não suporta pinos analógicos, mas FEZ e outros dispositivos da GHI suportam autilização dos pinos analógicos, de modo que você deve adicionar um assembly/libraryfornecido pelo GHI e ter acesso a essas novas oportunidades.

Nota Importante: O firmware não vai funcionar se o assembly/library não coincide com aversão do firmware instalada.

É um problema muito comum que os usuários encontram quando ele não atualiza o firmwaree o aplicativo não está funcionando.

Veja o que acontece:

Cenário # 1: Um desenvolvedor recebe novos dispositivo. Tem a versão do firmware 1.0.Então o desenvolvedor baixa do site da GHI a ultima versão doSDK, que é a versão 1.1.Quando você tenta carregar o programa, VS2010 não consegue conectar-se ao dispositivo enão diz porquê! O desenvolvedor então acha que seu equipamento não funciona. Naverdade, o produto funciona bem, mas neste caso, o firmware 1.0 e o conjunto é 1.1, entãonão vai. Para resolver esse problema, é preciso atualizar o firmware.

Cenário # 2: Um desenvolvedor tem um material que funciona bem com o firmware 2.1. Um

novo SDK 2.2 liberado, então o usuário faz a atualizações deste SDK e instala a nova versãodo Firmware na placa FEZ. Quando ele reinicia a sua máquina, ele não funciona! Porque oprograma no processador ainda está na versão 2.1. Para resolver esse problema, abra oprojeto e retire os assembly/library específicos do Hardware e adicioná-los novamente.Assim, os novos arquivos serão buscamos do SDK.

Mensagens durante o Boot-up

Nós podemos facilmente ver porque o sistema não está rodando usando o MFDeploy.NETMF apresenta uma série de mensagens úteis durante a inicialização do sistema. Pode osistema travar, falhar na execução ou no debug, nós podemos usar MFDeploy para mostrar

estas mensagens durante a inicialização. Também todas mensagens “Debug.Print” que sãonormalmente vistas na janela de saida, podem ser vistos no MFDeploy

Para ver estas mensagens, clique em "Target-> Connect" do menu e pressione o botão resetdo Hardware. Imediatamente click em "ping". MFDeploy vai travar por um momento e mostrar uma longa lista de mensagens.








Guia para iniciantes em C# e .NET Micro Modulação por largura de Pulso(PWM) Framework

Na listagem abaixo mostra que o LED da placa é conectada a um pino PWM. E se em vezde fazer flash no LED, que tal aumentar e diminuir o brilho ? Seria muito bom! Aqui está ocódigo:


using System.Threading;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.FEZ;



{ sbyte dirr = 1; byte duty = 40;

PWM pwm = new PWM((PWM.Pin)FEZ_Pin.PWM.LED); while (true)

{pwm.Set(10000, duty);duty = (byte)(duty + dirr);

if (duty > 90 || duty < 10){

dirr *= -1;}

Thread.Sleep(10);}

}}

}

Este código aumenta a potência fornecida ao LED até 90% e diminui para 10%, e novamenteem direção oposta.





Importante: Um sinal PWM é perfeito para controlar a velocidade do movimento de um robôou um ventilador girando. Um pino de PWM pode facilmente alimentar um LED. Este não é ocaso quando se quer controlar um dispositivo que necessite de corrente, como um motor ouuma lâmpada normal. Neste caso, use o sinal de PWM para controlar outro circuito, que vai

gerar a potência fornecida ao dispositivo. Por exemplo, ponte H é frequentemente utilizadopara controlar a direção e velocidade dos motores.

Importante: Todos os sinais PWM material compartilham o mesmo clock. A mudança nafreqüência em um pino vai mudar a freqüência em todos os outros. Mas o “duty cicle” éindependente.

Simulando um sinal PWM

Os pinos PWM são controlados dentro do processador através de circuitos dedicados. Issosignifica que esses circuitos irão chavear os pinos, não você. O processador requer apenassetar alguns registros de modo que nenhuma interação é necessária para gerar o sinal PWM.

As placas da GHI oferecem classe NETMF OutputCompare. Através desta classe, o usuáriopode gerar praticamente qualquer sinal, incluind PWM. Note que isto é feito em software, por isso é melhor usar a classe PWM, se possível. Por quê? Quando usamos a classe PWM, osinal é gerado pelo hardware do processador e não tem nada a fazer. Por outro lado, quandovocê usa OutputCompare para gerar o PWM, o processador deve manter o controle dopassado e alterar o estado dos pinos em intervalos constantes.

O exemplo de servo motor fornecido no www.TinyCLR.com usa OutputCompare. Avantagem aqui é que você pode usar qualquer pino de controle do servo. É melhor usar PWM para controlar o servo, mas neste caso você está limitado a especificar opino que tenha PWM.

Controlando Servo Motor e ajustando PWM

Vimos como controlar a potência com PWM. Há outros bons usos para PWM, como controlar servos. A classe PWM fornece dois métodos, Set e SetPulse. Antes, nós usamos PWM.Set oqual é bom para especificar a energia (potência). Para controlar os servos, SetPulse é maisadequado.

Como o servos funcionam? Veja aqui: www.pc-control.co.uk


http://www.pc-control.co.uk/

http://www.pc-control.co.uk/




Você pode então controlar a posição de um servo através do envio de um pulso. Se o pulsodura 1,25 ms, então o servo vai a 0°. Se este for aumentada para 1,50 ms o servo vai para90° (posição neutra). Um pulso de 1,75 ms vai enviá-lo para 180°. Bem, é fácil gerar o sinalPWM, mas ainda precisamos de uma informação: a imagem mostra a duração de um pulso"alto" mas sobre o pulso "baixo"? Os servos estão à espera de um pulso a cada 20 a 30ms.Agora nós temos tudo que precisamos. Antes de começar, vou explicar o que o "período": é asoma to tempo alto com o tempo baixo. Agora estamos prontos para codificação.

O método PWM.SetPulse necessita do tempo alto e o período do sinal. Desde que este

período low no servo não é crítico (entre 20 e 30ms), vou setar para 20ms. O importante éque o pulso alto deve estar entre 1,25 ms e 1,75 ms.Uma última coisa:

SetPulse aceita valores em nanossegundos, mas temos tempo em milissegundos. 1 ms =1000000 ns.

Finalmente, aqui está o código:





using System;using System.Threading;using Microsoft.SPOT;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.FEZ;class Program{ public static void Main()

{ PWM servo = new PWM((PWM.Pin)FEZ_Pin.PWM.Di5); while (true)

{ // 0 graus. Período de 20ms e 1.25ms de pulso alto

servo.SetPulse(20 * 1000 * 1000, 1250 * 1000); Thread.Sleep(1000);//wait for a second

// 90 graus. Período de 20ms e 1.50ms de pulso altoservo.SetPulse(20 * 1000 * 1000, 1500 * 1000);

Thread.Sleep(1000);//wait for a second

// 180 graus. Período de 20ms e 1.75ms de pulso altoservo.SetPulse(20 * 1000 * 1000, 1750 * 1000);

Thread.Sleep(1000);//Espera por um segundo}

Thread.Sleep(-1);}

}

12.1. PiezoOs alto-falantes piezo elétricos são uma maneira barata de adicionar um som para o seuequipamento. Eles emitem um som quando estão aplicando uma determinada frequência.Um sinal PWM é perfeito para gerar essa frequência e pode facilmente ativar um piezo.Usaremos um ciclo de trabalho de 50%, mas vamos mudar a freqüência para ter diferentestons.

Quando você conectar um piezo, preste atenção à polaridade: + vai PWM e - para terra.

Olhe para o componente FEZ PIEZO em www.TinyCLR.com

Este é um projeto que decodifica um arquivo MIDI de um cartão SD e toca no Piezo

http://www.microframeworkprojects.com/index.php?title=PWM_MIDI_Player








Guia para iniciantes em C# e .NET Micro Filtro de Glitch (Ruído) Framework

13. Filtro de Glitch (Ruído)Quando usamos o botão tempo atrás, nós confirguramos de tal modo que quandopressionado , o pino vai a nível baixo, caso contrário vai a alto. Quando você pressionar obotão, ele pode dar “picos”,em outras palavras, o botão gera alguns estados alto/baixo sãogerados antes de se estabilizar. Parece, portanto, que o botão foi pressionado várias vezes.Estes saltos em um tempo muito curto. Para eliminá-los em nível de hardware, podemoscolocar um capacitor entre o pino eo terra. Para gerenciar isto por software, podemos medir otempo entre estes pulsos e se for muito curto, podemos descartar. Um usuário podepressionar um botão aproximadamente a cada 200ms. Portanto, se a diferença é de 10msentre pressionadas, sabemos que este não é um ser humano quem fez isso e portanto,podem ser filtrados.

Felizmente, NETMF inclui um filtro interno, então não se preocupe com isso. Quando criamosum pino de entrada, temos a possibilidade de ativar o filtro de Glitch. O segundo argumentoda criação de um pino de entrada é um booleano que indica se o filtro deve ser ativado (true)ou não (false). Ao usar os pinos com botões / switches, é melhor ativar.

Button = new InputPort((Cpu.Pin)FEZ_Pin.Digital.LDR, true,Port.ResistorMode.PullUp);

Você pode alterar a sensibilidade do filtro de retorno da seguinte forma:

TimeSpan ts = new TimeSpan(0, 0, 0, 0, 200);//200msMicrosoft.SPOT.Hardware.Cpu.GlitchFilterTime = ts;

Nota importante: Filtro de Glitch funciona somente nos pinos capazes de gerar interrupção.Se você tentar usar InputPort com filtro setado para true e você ver uma exceção, entãomuito provavelmente você está usando um pino que não é capaz de gerar interrupção.




Guia para iniciantes em C# e .NET Micro Entradas e saídas analógicas Framework

14. Entradas e saídas

analógicasOs pinos analógicos são multiplexadas com pinos digitais. Alguns pinos do processador podem ser digitais e analógicos mas não ao mesmo tempo.

14.1. Entradas analógicasAs entradas digitais só podem ler valores baixo ou alto (0 ou 1), mas os pinos analógicospodem medir a tensão analógica. Existem limitações quanto ao tensões aplicadas às

entradas analógicas. Por exemplo, as entradas analógicas FEZ pode ler uma tensão entre 0e 3,3V. Quando ao pino digital, ele tolera 5V, mas se ele estiver configurado como analógico,3,3V é o máximo. Esta limitação não é realmente um problema porque a maioria dos sinaisanalógicos são condicionados para trabalhar com esta entrada analógica. Um divisor detensão ou circuito opamp pode ser usado para obter uma parcela do sinal. Por exemplo, sequisermos medir a tensão da bateria, 6V, ou seja, então vamos cortar pela metade a tensãocom resistências por exemplo, para o pino só pega metade da tensão que é 3V. No software,sabemos que a leitura da tensão é dividida por dois, basta multiplicar por 2 para obter a realmedida.

Felizmente, a implementação da GHI para entradas analógicas manuseia condicionamentodo sinal (escala). Ao criar um novo objeto Analog Input, você pode especificar a opção deescala.

A referência interna é 0V a 3.3V, assim que qualquer medida tem que considerar isto.

A maneira mais fácil é colocar a escala de 0-3300. Podemos, portanto, pensar em milivolts.Se nós lermos 1000, então a tensão de entrada é de 1V.

AnalogIn BatteryVoltage = new AnalogIn((AnalogIn.Pin)FEZ_Pin.AnalogIn.An0);BatteryVoltage.SetLinearScale(0, 3300);int voltage = BatteryVoltage.Read();

Considere usar a lista para ver quais os pinos podem ser analógicos.

Para mostrar a leitura da tensão em volts, converter para Volts e depois converter para umastring.




Guia para iniciantes em C# e .NET Micro Entradas e saídas analógicas Framework

AnalogIn BatteryVoltage = new AnalogIn((AnalogIn.Pin) FEZ_Pin.AnalogIn.An0);BatteryVoltage.SetLinearScale(0, 3300);int voltage = BatteryVoltage.Read();Debug.Print("Voltage = " + (voltage / 1000).ToString() + "." + (voltage %1000).ToString());

Nos dividimos por 1000 para obter a tensão e então nos usamos os módulo para obter afração.

14.2. Sáidas AnalógicasAs saídas analógicas são semelhantes às saídas digitais visto que elas também têm limitesde quanta potência pode proporcionar e ainda são menores do que as saídas digitais. Elessão capazes de fornecer um pequeno sinal para controlar outro circuito ou possivelmente um

amplificador de potência.As saídas digitais podem ser alto ou baixo estado, enquanto as saídas analógicas podemfornecer uma tensão entre 0 e 3,3V. A implementação da GHI para saídas analógicas permiteo dimensionamento automático: você dá o mínimo, máximo e o valor da tensão.

Um teste simples seria colocar o mínimo para 0 e máximo para 330V (3,3 x 100) e o valor de100 (1Vx100). Isto vai dar 1V no pino. Vamos ligar este pino em uma outra uma entradaanalógica para verificar se realmente tem 1V. Pode não ser exatamente 1V, mas muito perto.

A saída analógica é multiplexado com a entrada analógica 3. Ao utilizar a saída analógica, aentrada analógica não pode ser utilizada neste mesmo pino, mas nós podemos utilizar outrasentradas analógicas.

using System;using Microsoft.SPOT;using System.Threading;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.FEZ;


{


AnalogOut VoltLevel = newAnalogOut((AnalogOut.Pin)FEZ_Pin.AnalogOut.An3);

VoltLevel.SetLinearScale(0, 3300);VoltLevel.Set(1000);

AnalogIn PinVoltage = new






Guia para iniciantes em C# e .NET Micro Coletor de Lixo Framework

15. Coletor de LixoQuando se programa com linguagens mais antigas, como C ou C++, programadores devemmanter o controle dos objetos que eles criam e liberam quando necessário. Se um objeto écriado e não liberado, está usando os recursos do sistema que nunca serão liberados. Osintoma mais comum é o estouro de vazamento de memória (memory leak). Um programaque tem um vazamento de memória vai usar mais e mais memória e mais até que dê estourode memória. Estes erros são muito difíceis de localizar em um código.

As línguagens modernas têm uma coletor de lixo (Garbage Collector), que se mantéminformado dos objetos usados. Quando o sistema ficar sem memória, o coletor de lixo éativado e procura entre todos os objetos e libera aqueles que não são mais referenciados.

Lembra quando nós criamos objetos com a palavra "new", então temos uma referênciaatribuído ao objeto? Um objeto pode ser referenciado várias vezes o coletor de lixo irá excluir o objeto que não tem referência (NULL).

// Novo ObjetoOutputPort Ref1 = new OutputPort(FEZ_Pin.Digital.LED, true);// Segunda referência para o mesmo objetoOutputPort Ref2 = Ref1;// Loose a primeira referênciaRef1 = null;// Nosso objeto está ainda sendo referencia

// Não será removido ainda// Agora remova a segunda referênciaRef2 = null;// A partir deste ponto o objeto está pronto para ser// removido pelo coletor de lixo

Observe que o objeto não for removido imediatamente. Se necessário, o coletor de lixo iráexecutar e excluí-lo. Isso pode ser inconveniente às vezes, porque o coletor de lixo necessitade um tempo para pesquisar e excluir objetos. Isso só vai durar alguns milisegundos, mas sesua aplicação poder permitir isso? Neste caso, você pode forçar a execução do coletor delixo quando você quiser.

//Força o coletor de lixoDebug.GC(true);







}}

Para superar isso, precisamos de uma referência que está sempre acessível. Aqui está ocódigo correto:

using System;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;

namespace Test{ public class Program

{ static OutputPort LED; static void TurnLEDOn()

{ // Ligue o LED

LED = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, true);}


TurnLEDOn(); // Execute o GC Debug.GC(true); // O LED está ligado ?

}

}}

Outro bom exemplo refere-se a temporizadores. NETMF oferece um modo de criar timersque manuseia um serviço após um determinado tempo. Se a referência para o timer éperdido e que o coletor de lixo tenha rodado em seguida, o timer é perdido e não funcionarácomo esperado. Timers serão explandados mais tarde.

15.2. DisposeO coletor de lixo irá liberar objetos em determinado ponto, mas se você quiser liberar um

objeto em particular imediatamente ? A maioria dos objetos tem um método Dispose. Se umobjeto tem de ser liberada a qualquer momento, você pode "Dispose" (liberar) ele.

Organizar os objetos é muito importante com NETMF. Quando criamos um objeto InputPort,o pino é reservado. E se alguém quiser usá-las como saída ? Ou até mesmo como umaentrada analógica? Temos que libertar o pino e, em seguida, basta criar o novo objeto:





OutputPort OutPin = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.Di5, true);

OutPin.Dispose();InputPort InPort = new InputPort((Cpu.Pin)FEZ_Pin.Digital.Di5, true,Port.ResistorMode.PullUp);

15.3. Mensagens de saída do coletor delixoQuando o coletor de lixo é executado, ele exibe uma série de informações úteis para a janelade saída. Essas mensagens lhe dão uma idéia de que recursos do sistema está usando.

Embora não seja recomendado, você pode querer desativar essas mensagens para liberar a janela de saída para o seu próprio uso. Isso é facilmente alcançável com esta linha de código

Debug.EnableGCMessages(false);





16. C# Nível 3Esta seção irá cobrir todo material C# que nós queremos incluir neste livro. Um bom e livrográtis para continuar aprendendo sobre C# está disponível em

http://www.programmersheaven.com/2/CSharpBook

16.1. ByteAprendemos como int são úteis para armazenar números. Eles podem armazenar umnúmero muito grande, mas cada inteiro consome 4 bytes de memória. Você pode pensar no

byte como uma simples célula de memória. Um byte pode conter um valor entre 0 e 255.Parece pouco mas é suficiente para muitas coisas. Em C#, bytes são declaradas usando apalavra "byte"

byte b = 10;byte bb = 1000;// Isto não vai funcionar

O valor em um byte pode ser no máximo 255 [0.255], então o que acontece nele quando oincremento em 1? O valor ultrapassa a capacidade de armazenamento, retornando a 0.

Você provavelmente vai querer usar inteiros para a maioria das variáveis, mas nósaprendemos mais tarde que os bytes são muito importantes quando você começar a usar arrays (array).

16.2. Char Para representar uma língua como o Inglês, precisamos de 26 valores para letras minúsculase 26 para maiúsculas e talvez outros 10 para símbolos. Somando tudo, fica abaixo de 255,então um byte é suficiente. Se criarmos uma tabela que contém letras, números e símbolos,todos podem ser representados por um valor numérico. Na verdade, essa tabela já existe e é

chamado tabela ASCII.Um byte é suficiente para armazenar todos os "caracteres" que usamos em Inglês. Oscomputadores modernos têm sido extendido para incluir outros idiomas, alguns caracterescomplexos "não-latino". Esses novos caracteres são chamados de Unicode. Estes podemassumir valores maiores do que 255, então um byte não é suficiente. Mas um número inteiro(4 bytes) é muito longo. Precisamos de um tipo que utilize dois bytes de memória. 2 bytes







são para armazenar valores entre 0 e 65535. Este tipo é chamado de "short", mas nãovamos usá-lo neste livro.

Os sistemas podem representar caracteres usando um ou dois bytes. Os programadoresdecidiram criar um novo tipo chamado de "char" que pode ser 1 ou 2 bytes, dependendo dosistema. Como NETMF é feito para sistemas pequenos, um caractere é 1 byte. Este não é ocaso em um PC onde tem dois bytes!

Não se preocupe muito com isso: Não use char, se você não precisa e se você usá-lo,lembre-se que ele ocupa no NETMF 1 byte.

16.3. Array (Vetor/Matriz)Se lermos 100 vezes uma entrada analógica e queremos passar para as leituras de ummétodo, não é prático usar 100 variáveis em 100 argumentos! Em vez disso, ele cria umarray do tipo da nossa variável. Você pode criar array de qualquer objeto. Vamos utilizar principalmente array de bytes. Quando iniciar uma interface de hardware ou acessar arquivos, você irá sempre utilizar array de bytes.A declaração é semelhante ao de objetos:

byte[] MyArray;

O código acima cria uma “referência"para um objeto do tipo"byte array”. Isto é apenas umareferência mas ainda não inclui qualquer objeto, ele é nulo. Se você esqueceu o que é umareferência por isso volte para o capítulo "C # Nível 2”.

Para criar o objeto, nós utillizamos a palavra reservada "new" e então devemos especificar otamanho de nosso array. O tamanho é o número de itens que temos em nosso array. Aqui, éo tipo "byte" e, portanto, o número representa a quantidade de bytes alocados na memória.

byte[] MyArray;MyArray = new byte[10];

Nós criamos um array de bytes com 10 elementos na mesma. Esta tabela é referenciada por "MyArray".Agora podemos ler / escrever qualquer um dos 10 valores na tabela simplesmente

especificando o índice do valor desejado.

byte[] MyArray;MyArray = new byte[10];MyArray[0] = 123;// primeiro índiceMyArray[9] = 99;// último índiceMyArray[10] = 1;// isto é ruim...ERRO!!!!







aspas (texto em vermelho), mas é considerado simplesmente como uma string.

Você pode ainda estar preocupado com a diferença entre uma variável inteira que contém ovalor 5 e uma seqüência que contém o número 5. Está aqui um exemplo:

string MyString = "5" + "5";int MyInteger = 5 + 5;

Quais são os valores das variáveis? Para o inteiro é 10, porque 5 +5 = 10. Mas para stringisto não é verdadeiro. Strings não conhece nada sobre o que há dentro, seja texto ounúmeros, não importa. Quando adicionando 2 strings, uma nova string é construída paracombinar ambas. Então "5" + "5" + = "55" e não 10 como inteiros

Quase todos os objetos têm um método toString que converte a informação do objeto paraum texto imprimível. Está aqui um exemplo:

int MyInteger = 5 + 5;string MyString = "The value of MyInteger is: " + MyInteger.ToString();Debug.Print(MyString);

Este código irá imprimir

The value of my myInteger is: 10

Strings podem ser convertidos para array de bytes, se necessário. Isto é importante se nósusamos um método que aceita apenas bytes e queremos passar nossa string para ele. Aofazer isso, todos os caracteres na string serão convertidos em seu valor equivalente em bytee armazenado na array.

using System.Text;..........byte[] buffer = Encoding.UTF8.GetBytes("Example String");

16.5. Laço - For Usar laço while é suficiente para os nossas necessidades de loops, mas laço for pode ser mais fácil de se utilizar. O exemplo mais simples é faze um programa que conte de 1 até 10.Similarmente nós podemos faze um LED piscar 10 vezes. O laço for tem três argumentosem uma variável. Necessita o valor inicial, como para terminar o ciclo e o que fazer em cadaloop.





int i;for (i = 0; i < 10; i++){ //faça alguma coisa}

Inicialmente, devemos declarar a variável que vamos utilizar. Em seguida, no loop for, temosque passar os três argumentos (inicial, regra, ação). No primeiro ciclo de loop, nos setamosa variável i para 0. Em seguida, o loop continuará correndo enquanto a variável i for inferior a10. Finalmente, o loop for irá incrementar a variável i em cada iteração. Vamos tentar isso:

using System.Threading;using Microsoft.SPOT;using System;



{ int i; for (i = 0; i < 10; i++)

{ Debug.Print("i= " + i.ToString());

}}

}

}

Se executar o programa, vemos que ela apresenta os valores 0-9, mas não o 10. Mas nósqueríamos 1-10, 0-9, não! Para começar de 1, não 0, precisamos inicializar i com 1 i noinício do loop. Além disso, para rodar até 10, temos de dizer o loop for para executar até 10 enão menos que 10, então vamos mudar a condição de "<" para "<="




{ int i;





for (i = 1; i <= 10; i++){

Debug.Print("i= " + i.ToString());}

}

}}

Podemos fazer o loop somente com números pares ?




{ int i; for (i = 2; i <= 10; i = 1 + 2)

{ Debug.Print("i= " + i.ToString());

}}

}

}

O melhor meio de se entender o loop for é executando passo a passo o código e vendocomo o C# executa ele.

16.6. Comando SwitchVocê provavelmente não usou o comando “swtich” em aplicações, mas você verá que ele émuito útil para programas grandes, especialmente quando você tem que trabalhar commáquinas de estados. O comando switch compara uma variável para uma lista de constantes

(apenas constantes) e executa uma ação conforme o caso. Neste exemplo, lemos o dia atual("DayOfWeek") e partir deste se escreve por extenso (string) o dia da semanacorrespondente. Nós poderíamos fazer isto com o if, mas veja como simplificam as coisascom a opção Switch:

using System.Threading;





using Microsoft.SPOT;using System;



{ DateTime currentTime = DateTime.Now; int day = (int)currentTime.DayOfWeek; switch (day)

{ case 0: Debug.Print("Sunday"); break; case 1: Debug.Print("Monday");

break; case 2: Debug.Print("Tuesday"); break; case 3: Debug.Print("Wednsday"); break; case 4: Debug.Print("Thursday"); break; case 5: Debug.Print("Friday"); break;

case 6: Debug.Print("Saturday"); break; default: Debug.Print("We should never see this"); break;

}}

}}

O ponto importante é que a variável é comparado com uma lista de constantes. Depois decada ("case") nós temos uma constante e não uma variável.

Podemos modificar esse código para trocar para enumeração como segue.

using System.Threading;using Microsoft.SPOT;





using System;



{ DateTime currentTime = DateTime.Now; switch (currentTime.DayOfWeek)

{ case DayOfWeek.Sunday: Debug.Print("Sunday"); break; case DayOfWeek.Monday: Debug.Print("Monday"); break; case DayOfWeek.Tuesday:

Debug.Print("Tuesday"); break; case DayOfWeek.Wednesday: Debug.Print("Wednsday"); break; case DayOfWeek.Thursday: Debug.Print("Thursday"); break; case DayOfWeek.Friday: Debug.Print("Friday"); break; case DayOfWeek.Saturday: Debug.Print("Saturday");

break; default: Debug.Print("We should never see this"); break;

}}

}}

Tente ir Ir passo-a-passo no código e veja a operação em detalhes






Guia para iniciantes em C# e .NET Micro Interfaces Seriais Framework

http://www.nkcelectronics.com/rs232-to-ttl-converter-board-33v232335.html

No mundo do PC, a porta USB é mais comum que as portas seriais. Os novoscomputadores, especialmente laptops, não têm porta serial, mas tem uma porta USB. Por este motivo, os fabricantes criaram conversores USB-RS232. Um produto interessante écabo USB com interface UART. Note que este é TTL UART, não RS232, o que significa quevocê pode ligar diretamente na UART do processador. A referência para este cabo é "TTL-232R-3V3”.

Para resumir tudo, você pode ligar dois processadores pelos pinos de conexão UARTdiretamente. Para a interface do processador com um computador, você precisará de umconversor UART/RS232 ou USB ou utilizando um dos circutos prontos, como MAX232 paraRS232 e FT232 para USB.

NETMF suporta portas série UART da mesma maneira que Framework do PC. Para usar uma porta serial, adicione o conjunto "Microsoft.SPOT.Hardware.SerialPort" e "usingSystem.IO.Ports" no início do seu código.

As portas seriais em computadores e NETMF são chamados de COM e começam com aCOM1. Não há COM0 em computadores. Isso pode ser irritante quando você quer mapear uma porta COM para uma porta UART no processador, que normalmente começa emUART0 e não UART1. Então COM1 é UART0, COM2 = UART1 etc ....

PCs têm, frequentemente, um programa "Terminal" que abre a porta serial para enviar ereceber dados. O que você digitar no terminal é enviado pela serial e o que vir pela serial éimpresso. Um exemplo desse tipo de programa é: TeraTerm.

O programa a seguir envia o valor de um contador de 10 vezes por segundo. Os dados sãoenviados a um taxa de 115.200 baud, portanto, tenha certeza de que o terminal estáconfigurado com esta velocidade. O programa envia os dados no dispositivo COM1 doNETMF. A porta COM não tem nada a ver com a de seu PC. Por exemplo, você pode ter umaconversor USB / Serial que foi mapeado na COM8. Então você deve abrir a porta do seu PCde identificação COM8 e não COM1.

using System.Threading;using System.IO.Ports;using System.Text;



{ SerialPort UART = new SerialPort("COM1", 115200); int counter=0;

UART.Open(); while (true)

{







// cria uma String string counter_string = "Count: " + counter.ToString() +"\r\n"; // converte string para bytes byte[] buffer = Encoding.UTF8.GetBytes(counter_string); // manda os bytes para a porta serial

UART.Write(buffer, 0, buffer.Length); // incrementa o contador

counter++; //aguarde Thread.Sleep(100);

}}

}}

Note que nós terminamos nossa string com "\n\r". The “\r” no código diz ao terminal paravoltar ao início da linha e "\n" significa adicionar uma nova linha (pular a linha).

Quando os dados são recebidos na UART, elas são infileirados de forma a não perder qualque dado. Note que há limites para a quantidade de dados que podem ser armazenados,por isso, se você está depurando ou você não está lendo os dados recebidos, feche a portaserial, senão o sistema irá desacelerar significativamente e o debug/execução será instável elenta. Idealmente, eventos serão utilizados para nós recebermos automaticamente os dados.Eventos serão vistos mais tarde.

Este exemplo irá esperar até receber um byte e mostrar o que você digitou (transmitida, naverdade), pelo terminal.

using System.Threading;using System.IO.Ports;using System.Text;



{ SerialPort UART = new SerialPort("COM1", 115200); int read_count = 0; byte[] rx_byte = new byte[1];

UART.Open(); while (true)

{

// Leia um byteread_count = UART.Read(rx_byte, 0, 1);





if (read_count > 0)// temos dados?{

// cria uma string string counter_string = "You typted: " +rx_byte[0].ToString() + "\r\n"; // converte string para bytes byte[] buffer = Encoding.UTF8.GetBytes(counter_string); // manda os bytes para serial

UART.Write(buffer, 0, buffer.Length); //aguarde Thread.Sleep(10);

}}

}}

}

O último exemplo é um loop-back. Ligue um fio do pino TX ao RX na sua placa e envie dadose esteja certo que está recebendo corretamente.

using System.Threading;using System.IO.Ports;using System.Text;using Microsoft.SPOT;



{ SerialPort UART = new SerialPort("COM1", 115200); int read_count = 0; byte[] tx_data; byte[] rx_data = new byte[10];

tx_data = Encoding.UTF8.GetBytes("FEZ");UART.Open();

while (true){

// flush todos os dadosUART.Flush();

// Envia algum dadoUART.Write(tx_data, 0, tx_data.Length);

// Espere para ter certeza que o dado é transmitido Thread.Sleep(100); // leia do dado

read_count = UART.Read(rx_data, 0, rx_data.Length); if (read_count != 3)

{





// Nós enviamos 3 então devemos ter 3 de volta Debug.Print("Wrong size: " + read_count.ToString());

} else

{ // O contador está correto, então check os valores //Eu estou fazendo de uma maneira mais clara if (tx_data[0] == rx_data[0])

{ if (tx_data[1] == rx_data[1])

{ if (tx_data[1] == rx_data[1])

{ Debug.Print("Perfect data!");

}}

}}

Thread.Sleep(100);}

}}

}

17.2. SPISPI usa 3 a 4 fios para transmitir dados. Em UART, ambos os lados devem usar umavelocidade pré-definidas. Para SPI, é diferente, porque um nó envia um sinal de clock para ooutro, ao mesmo tempo que os dados. Este sinal de clock é para determinar o quanto o

receptor deve ser rápido para ler os dados. Se você tiver algum conhecimento de eletrônica,há um registrador de deslocamento. O sinal de clock é sempre transmitida a partir dodispositivo mestre. O outro dispositivo é um escravo que não envia, mas recebem sinal declock do mestre.

Então, o mestre transmite o sinal de clock SCK pino (clock serial) e simultaneamente,transmite os dados no pino MOSI (Master Slave Out In). O escravo lê o sinal de clock em seupino SCK e, simultaneamente, lê os dados em seu pino MOSI. Até então, ele é umacomunicação em uma direção. Enquanto os dados são transmitidos em uma direção usandoMOSI, outro pacote de dados são transmitidos de volta no pino MISO (Master In Slave Out).Tudo isso é feito simultâneamente , enviando e recebendo. Com o SPI, não é possívelapenas enviar ou receber. Você sempre receberá um byte para cada byte enviado.Tamanhos diferentes de dados são possíveis, mas o mais comum é o octeto. NETMF suportatransferências de 8 (byte) e 16 bits (short).

Devido a este esquema de mestre/escravo, você pode adicionar mais escravos no mesmobus e escolhe com quem quer trocar dados. Eu uso o termo de troca, porque você não pode“enviar” ou “receber”, mas “enviar e receber” dados (trocar) . O mestre seleciona o escravousando seu pino SSEL(slave select) ou CS (Chip Select). Em teoria, um mestre pode ter um





número ilimitado de escravos, mas não pode selecionar mais de um em um única vez. Omestre precisa de apenas três ligações (SCK, MISO, MOSI) para se conectar a todos osescravos, mas precisa de um pino SSEL dedicados a cada escravo.

Alguns hardwares SPI (escravo) pode ter mais de um pino CS como o decodificador MP3VS1053 que usa um pino para dados e outro para comandos, mas ambos compartilham omesmo 3 pinos de transferência (SCK, MOSI, MISO) .

SPI exige mais fios que outros “bus” similares, mas permite transferências muito rápidas. Umclock de 50MHz é possível em um barramento SPI, ou seja, 50 milhões de bits por segundo.

Os dispositivos NETMF são sempre mestres SPI. Antes de criar um objeto SPI, precisamoscriar um objeto SPI “configuration”. O objeto de configuração é usado para definir o estado depinos e alguns parâmetros de tempo. Na maioria dos casos, você quer que esteja em repolso(false) com clock na borda de subida (true) e com zero para selecionar o setup e terá otempo para o estado de baixo com um pulso sobre o estado de alta e de 0 para selecionar o

“Setup” e "Hold Time". A única coisa que você deveria setar é o clock do relógio. Algunsdispositivos podem aceitar uma alta freqüência, mas não todos. Ao colocar em 1000KHz(1MHz), deve funcionar para a maioria dos dispositivos escravos.

O exemplo está enviando e recebendo (troca) 10 bytes de pelo SPI, canal 1. Note que noNETMF começa numerando os canais SPI a partir de 1, mas nos processadores, os canaiscomeçam a partir de 0. SPI1 no código é o SPI0 no processador.

using System.Threading;using System.Text;using Microsoft.SPOT;

using Microsoft.SPOT.Hardware;



{ SPI.Configuration MyConfig = newSPI.Configuration((Cpu.Pin)FEZmini.Pin.Di2x,false,0,0,false,true,1000,SPI.SPI_module.SPI1); SPI MySPI = new SPI(MyConfig);

byte[] tx_data= new byte[10]; byte[] rx_data = new byte[10];

MySPI.WriteRead(tx_data, rx_data);

Thread.Sleep(100);}

}









temperatura

while (ow.ReadByte() == 0) ; // aguarde enquantoocupado

ow.Reset();ow.WriteByte(0xCC); // Pula ROMow.WriteByte(0xBE); // Leia Scratchpad

temperature = ow.ReadByte(); // LSBtemperature |= (ushort)(ow.ReadByte() << 8); // MSB

Debug.Print("Temperature: " + temperature / 16); Thread.Sleep(1000);

} else

{ Debug.Print("Device is not detected.");

}

Thread.Sleep(1000);}

}}

}

17.5. CANInterface CAN (Controller Area Network) é muito comum na indústria e automação. CAN é

muito robusto e funciona muito bem em ambientes com ruídos e em altas velocidades. Todosos tratamentos e os metodos de recuperação são feitos no hardware. TD (Transmit Data) eRD (Receive Data) são os únicos dois pinos necessários. Estes pinos transportar o sinaldigital para ser convertido para analógico antes de ser enviado sobre a linha usando acamada física. As camadas físicas são às vezes chamados de trasncievers.

Existem vários tipos de camadas físicas, mas a maioria usa HSDW (High Speed Dual-Wire),que utiliza um par trançado para a sua imunidade ao ruído. Esta camada pode se comunicar até 1 Mbps e fazer upload de dados a longas distâncias, se a a taxa de transferência é baixa.Os dados podem ser transferidos entre nós no bus, onde cada nós podem trasnferir aqualquer momento para os outros nós,e todos os outros nós devem ser capazes de receber dados. Com o CAN, não existe master / slave. Além disso, todos “nós” devem ter um critério

de sincronização predefinido. Isso é muito mais complicado do que calcular um simplesbaud rate para UART. Por esta razão, existem muitas calculos de taxa de bits para a CAN.

O dispositivo CAN da placa Embedded Master é idêntico ao popular SJA1000. Um pouco depesquisa na internet para SJA1000 deve dar-lhe vários opções de cálculo.

Aqui está um exemplo de calculadora dedicado:

http://www.esacademy.com/en/library/calculators/sja1000-timing-calculator.html







Aqui está um exemplo de calcular o “timming”

1.Divida o clock do sistema (72MHz) para obter um clock apropriado para o periférico CAN(isto não é BAUD RATE) Este é a chamado de BRP.

2.Defina quandtos clocks você necessetia para definir um 1. Normalmente, este é de 24 ou16. Isso é chamado TQ.

3.Atribua os valores para T1 e T2 onde T1 + T2 + 1 = TQ

Vamos supor que precisemos de 250Kbps.

1. A partir de clock 72MHz sistema, eu quero que clock do CAN seja de 6Mhz, então eupreciso dividir por 12 (BRP = 12).

2. 6Mhz/250kbps = 24 TQ (nós queremos geralmente 16 ou 24).

3. T1 = 15, T2 = 8 nos dá 15 + 8 + 1 = 24 e isso é o que precisamos.

Eu obtive os valores de T1 e T2 em http://www.kvaser.com/can/protocol/index.htm

Eu obtive o primeiro valor e subtraí 1 de T1, pois a calculadora incluiu o bit de sincronismo

GHI Electronics está atualizando os driver para o CAN NETMF 4.0 e assim a interface podemudar. Verifique a documentação para obter mais ajuda.


Aqui está o código com comentários detalhados:


using System;using GHIElectronics.Hardware;



{ // Estes números foram calculados usando a calculadora deste link // http://www.kvaser.com/can/protocol/index.htm // Nós usamos o primeiro valor da saída da calculadora /////////////////////////////////////////////////////////////////

//////////////////////////// // Bitrate 250Kbps // CLK = 72 Mhz, with BRP = 12 -> 6Mhz CAN clock // 6Mhz/250Kbps = 24 TQ // T1 = 16 menus 1 para sync = 15 // T2 = 8 // 15 + 1 + 8 = 24 TQs que é o que queremos /////////////////////////////////////////////////////////////////


http://www.kvaser.com/can/protocol/index.htm

http://www.kvaser.com/can/protocol/index.htm




//////////////////////////// const int BRP = 12; const int T1 = 15; const int T2 = 8; // Para 500Kbps você pode usar BRP=6 e para 1Mbps você pode usarBRP=3 e para 125Kbps use BRP=24...e assim por diante // Mantenha T1 e T2 o mesmo para manter o sampling do pino omesmo (entre 70% e 80%)

// Inicializa o canal CAN, set o bit rate CAN canChannel = new CAN(CAN.CANChannel.Channel_1,

((T2 - 1) << 20)| ((T1 - 1) << 16) | ((BRP - 1) << 0)); // Faça uma nova mensagem CAN CAN.CANMessage message = new CAN.CANMessage(); // Faça uma mensagem de 8 bytes for (int i = 0; i < 8; i++)

message.data[i] = (byte)i;

message.DLC = 8; // 8 bytesmessage.ArbID = 0xAB; // IDmessage.isEID = false; // ID não extendidomessage.isRTR = false; // não remoto

// Envia a mensagemcanChannel.PostMessage(message);

// Espera por uma mensagem e a pegue while (canChannel.GetRxQueueCount() == 0) ; // Pegue a mensagem usando o mesmo objeto message

canChannel.GetMessage(message); // Agora "message" contém o dado, ID, flags da mensagem recebida

}}

}




Guia para iniciantes em C# e .NET Micro Output Compare Framework

18. Output CompareEste recurso exclusivo da GHI permite que o desenvolvedor GHI gere um sinal em qualquer pino. Por exemplo, OutputCompare pode ser usado para gerar um sinal UART ou um sinalpara controlar um controle remoto infravermelho em 38Khz para simular um controle remotoda TV.

Um bom exemplo é o driver o display serial de 2x16 encontrador em www.TinyCLR.com. Odisplay é controlada pela UART. Ele não retorna dados. Tudo que você precisa é enviar alguns códigos de controle serial. Assim, podemos ligar o LCD em um dos pinos seriais.Então perderemos a porta serial para fazer uma coisa muito simples, além da UARTnecesssitar de um pino para transmitir e receber cados. Mas, o LCD não manda dados devolta, logo, vamos “perder” um pino. A maneira apropriada de controle deste LCD serial é

utilizando o método OutputCompare: você só precisa de um pino e você pode usar qualquer um dos pinos digitais.

Como OutputCompare funciona? Basicamente, você fornece ao método um array de valoresde tempos entre cada inversão do pino. OutputCompare vai procurar essa tabela e gerar osinal no pino selecionado. Portanto, se queremos gerar o UART, devemos primeiro pré-calcular os valores que representam

os dados a transmitir e dar a ele como um parâmetro para o objeto OutputCompare.

Este driver de exemplo mostra para você. É uma cópia do driver do LCD serial encontradono site da www.TinyCLR.com

using System;using System.Threading;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;namespace GHIElectronics.NETMF.FEZ{ public static partial class FEZ_Components

{ public class SerialLCD : IDisposable

{ const byte DISP_ON = 0xC; //Torna o LCD visível const byte CLR_DISP = 0x01; //Apaga display const byte CUR_HOME = 2; //Move cursor para home e a apagaa memória de vídeo const byte SET_CURSOR = 0x80; //SET_CURSOR + X : Seta o cursorpara posição X const byte Move_CURSOR_LEFT = 0x10;

OutputCompare oc;









const int MAX_TIMINGS_BUFFER_SIZE = 10; uint[] buffer = new uint[MAX_TIMINGS_BUFFER_SIZE]; const int BAUD_RATE = 2400; const int BIT_TIME_US = 1 * 1000 * 1000 / BAUD_RATE; readonly int BYTE_TIME_MS; public void Dispose()

{oc.Dispose();buffer = null;

} private void SendByte(byte b)

{ bool currentPinState; int currentBufferIndex = 0; uint currentStateTiming; // bit de start

currentPinState = false;currentStateTiming = BIT_TIME_US;

// bit de dados for (int i = 0; i < 8; i++)

{ bool neededState = (b & (1 << i)) != 0;

if (neededState != currentPinState){

buffer[currentBufferIndex] = currentStateTiming;currentStateTiming = BIT_TIME_US;currentPinState = neededState;currentBufferIndex++;

} else

{currentStateTiming += BIT_TIME_US;

}}

// bit de parada if (currentPinState != true)

{buffer[currentBufferIndex] = currentStateTiming;currentBufferIndex++;

}oc.Set(false, buffer, 0, currentBufferIndex, false);\

// espera dado ser enviado Thread.Sleep(BYTE_TIME_MS);

} public void PutC(char c)

{SendByte((byte)c);

}

private void SendCommand(byte cmd){





SendByte(0xFE);SendByte(cmd);

} public void Print(string str)

{ for (int i = 0; i < str.Length; i++)

PutC(str[i]);}

public void ClearScreen(){

SendCommand(CLR_DISP);}

public void CursorHome(){

SendCommand(CUR_HOME);}

public void SetCursor(byte row, byte col){

SendCommand((byte)(SET_CURSOR | row << 6 | col));}

public void MoveLeft(){

SendCommand(Move_CURSOR_LEFT);}

public SerialLCD(FEZ_Pin.Digital pin){

BYTE_TIME_MS = (int)Math.Ceiling((double)BIT_TIME_US *MAX_TIMINGS_BUFFER_SIZE / 1000);

oc = new OutputCompare((Cpu.Pin)pin, true,MAX_TIMINGS_BUFFER_SIZE); // Inicializa LCD

SendCommand(DISP_ON);SendCommand(CLR_DISP);

}}

}}




Guia para iniciantes em C# e .NET Micro Carregando recursos Framework

19. Carregando recursosUm recurso é um arquivo que foi incluído com a imagem da aplicação. Se a sua aplicaçãodepende de um determinado arquivo (imagem, ícone, de som) então nós podemos adicionar este arquivo para a aplicação dos recursos. Um aplicativo pode ler este arquivo do sistemade arquivos, mas se tornaria dependente do sistema de arquivos usado.

Recursos também podem se strings, como um aviso de direitos autorais. Assim, senecessitamos mudar o texto de copyright, nós deveriamos atualizar os recursos e não fazer nada no código.

Sempre conheça quanto de memória é reservado para espaço de aplicação. Adicionandoarquivos muito grandes resultará em erros e o VS2010 não vai lhe dizer porque os arquivos

são muito grandes.Olhando pela janela "Solution Explorer", você pode ver "Resource.resx” e se nós expandí-lopodemos ver "Resources.Designer.cs".

Visual Studio cria automaticamente um arquivo “resources designer”. Nunca modifique essearquivo manualmente. Em vez disso, clique duas vezes em "Resources.resx" para abrir umacaixa de ferramentas específica.







Debug.Print(Resources.GetString(Resources.StringResources.String1)); Debug.Print(Resources.GetString(Resources.StringResources.String2));

}}

}

Tente alterar o texto do recurso e veja como a saída muda.

Agora adicione um arquivo. Crie um arquivo de texto no desktop e escrever algumaspalavras nele. Escolha "files" do menu drop-down então click no “"Add Resource"

Como um arquivo de texto, o Visual Studio foi experto suficiente para adicionar isto no modosimilar as strings. Então para usar este recurso, é da mesma forma como string.



{


Debug.Print(Resources.GetString(Resources.StringResources.SomeFile));

}}

}





Neste exemplo, eu adicionei um arquivo midi. Mais tarde, neste livro vemos como adicionar um decodificador e reproduzir o arquivo. Escolha um arquivo midi e adicione-no.

Neste exemplo, o tamanho do arquivo é de cerca de 33Kb. Este é pequeno para o mundoPC, mas não é pequeno para um um sistema embarcado. O exemplo a seguir funcionará emdispositivos com muita memória, como o ChipworkX e Embedded e Master. No USBizi eFEZ, ele pode não funcionar. Nós podemos ainda acessar arquivos grandes com USBIZI eFEZ, mas ao invés de lê-lo de uma única vez (na íntegra), vamos lê-lo em pedaços,decodificar e assim por diante. Vemos isso em detalhes mais tarde.




{ byte [] file_data =Resources.GetBytes(Resources.BinaryResources.labamba); Debug.Print("File Size is " + file_data.Length.ToString());

}}

}




Guia para iniciantes em C# e .NET Micro Displays Framework

20. Displays

20.1. Display de caracteresA maioria dos LCDs usa a mesma interface. Em geral, existem duas linhas de 16 caracteres,comumente chamado de 2x16 LCD. O display é controlado com uma interface de 8 bits ou 4bits. Opção de 4 bits é melhor, porque requer menos pinos.

A interface utiliza RS (dados / instruções), RW (Read / Write), E (Enable) e 4 bits de dados. Adocumentação do LCD é a melhor fonte de informação, mas aqui está um exemplo paracomeçar rapidamente.

GHI oferece uma alternativa a este LCD. O LCD serial oferecido no site www.TinyCLR.com utiliza um único pino no FEZ. Os drivers incluídos fazem os LCD mais fáceis de usar

Utilizando o driver do LCD




{ FEZ_Components.SerialLCD LCD =

new FEZ_Components.SerialLCD(FEZ_Pin.Digital.Di5);

LCD.ClearScreen();LCD.CursorHome();LCD.Print("FEZ Rocks!");

}}

}







20.2. Display gráficos

Suporte Nativo

NETMF, com sua classe bitmap, pode manipilar gráficos muito bem. Essa classe suportaimagens do tipo BMP, JPG e GIF. As imagens podem ser obtidos através do sistema dearquivos ou rede, mas é mais fácil a opção de incluir a imagem como um recurso.

O objeto bitmap pode ser usado para desenhar imagens, formas ou texto (usando umafonte). NETMF suporta criação de fontes usando a ferramenta TFConvert.

Quando nós desenhamos usando o objeto Bitmap, na verdade estamos desenhando noobjeto (na memória) e nada é visível na tela. Para transferir a imagem da memória para atela, devemos usar o método flush(). Um ponto importante aqui é que flush() só funciona se otamanho do bitmap é idêntico ao da tela.

Se temos uma imagem 128x128 e quero mostrar na tela, é preciso primeiro criar um bitmapdo tamanho da tela e uma segunda dimensão da imagem. Desenhe a imagem bitmap na telae use flush () na tela. Para evitar confusão, eu sempre tenho um objeto bitmap chamado LCDe tudo é desenhado para este bitmap.

Vamos fazer os nossos testes no emulador, porque pode seu hardware não suportar nativamente os gráficos.


using Microsoft.SPOT.Presentation;using Microsoft.SPOT.Presentation.Media;



{ Bitmap LCD = new Bitmap(SystemMetrics.ScreenWidth,SystemMetrics.ScreenHeight);

//Apaga a memória e não o LCD

LCD.Clear(); //Desenha na memória

LCD.DrawLine(Colors.Green, 1, 10, 10, 40, 40); //transfere a memória bitmap para o display atual

LCD.Flush();}

}}





Devemos acrescentar o assembly “Microsoft.SPOT.TinyCore” para rodar. Então nósnecessitamos usar o programa e fazer uma referência ao namespace "Presentation" demodo que nós possamos ter o "SystemMetrics”.

Execute o código e você terá uma linha verde na tela do emulador.









Tente usar o que nós aprendemos sobre o o loop for para criar várias linhas.

using System.Threading;using Microsoft.SPOT;using System;using Microsoft.SPOT.Presentation;using Microsoft.SPOT.Presentation.Media;


{

public static void Main(){ Bitmap LCD = new Bitmap(SystemMetrics.ScreenWidth,SystemMetrics.ScreenHeight);

//Apaga a memória e não o displayLCD.Clear();

int i; for (i = 10; i < 200; i += 4)

{ //Desenha na memória

LCD.DrawLine(Colors.Green, 1, 10, i, i, 200);}

//transfere a memória bitmap para o display atualLCD.Flush();

}}

}





Para escrever um texto, devemos primeiro ter o “recurso de fonte". Adicionar um novorecurso para o projeto. Você pode usar qualquer um dos recursos de arquivos enviados comos exemplos do SDK NETMF.

Os exemplos em \Documents\Microsoft. Micro Framework NET 4.0\Samples\

Eu uso o arquivo de fontes "NinaB.tinyfnt. Adicione o arquivo para os recursos comoexplanado no capítulo anterior. Nós podemos agora executar este programa para escrever no LCD.


using System;using Microsoft.SPOT.Presentation;using Microsoft.SPOT.Presentation.Media;



{ Bitmap LCD = new Bitmap(SystemMetrics.ScreenWidth,SystemMetrics.ScreenHeight); Font MyFont = Resources.GetFont(Resources.FontResources.NinaB);

//apaga a memória e não o displayLCD.Clear();

int i; for (i = 10; i < 200; i += 4)

{ //desenha na memória

LCD.DrawLine(Colors.Green, 1, 10, i, i, 200);





} // imprime algum texto no bitmap

LCD.DrawText("Still Amazing!", MyFont, Colors.Red, 100, 20); //transfere do bitmap para o display atual

LCD.Flush();}

}}





Suporte não Nativo

Muitas pequenas telas gráficas usam o bus SPI para receber imagens do host. DispositivosNETMF normalemente suportam grandes displays TFT que usam um bus especial, comoEmbedded Master e ChipworkX. Mas mesmo que o sistema não suporte aqueles displays,como USBizi e Fez, o usuário pode conectar um display baseado no SPI e mostrar osgráficos desta forma. É também possível ter 2 displays no sistema que suporte interface TFTnativa. Um grande display rodará na interface TFT e pequenos displays rodarão no bus SPI.

Embora SPI é muito rápido, as telas contêm milhões de pixels, é preferível escolher modeloscom um acelerador gráfico. Www.TinyCLR.com tem muitos displays, SPI ou TFT que sãoideais para trabalhar com o que a GHI oferece. Abaixo está um exemplo. Além disso,verifique o display padrão baseado no SPI para o FEZ Rhino no site acima mencionado.

Suporte Nativo para displays não padrões

A better option is to use the bitmap class to draw text, draw shapes and then transfer thebitmap to your display. You can only use this if Bitmap (graphics) is supported on your device,USBizi doesn't support graphics.

This code will display some data on the F-51852 128x64 pixel display found on the old non-TFT Embedded Master development system.

using System;using System.Text;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Presentation;using Microsoft.SPOT.Presentation.Media;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.System;







public class Program{

static SPI.Configuration conf = new SPI.Configuration((Cpu.Pin)33, false, 0, 0, false, true, 1000, SPI.SPI_module.SPI2); static SPI SPI_port = new SPI(conf); static OutputPort RST = new OutputPort((Cpu.Pin)9, true); static OutputPort DC = new OutputPort((Cpu.Pin)15, true); static byte[] _ba = new byte[1]; static void OPTREX_SSD_WriteCmdByte(byte b)

{DC.Write(false);

Thread.Sleep(1);

_ba[0] = b;SPI_port.Write(_ba);

}

static void OPTREX_SSD_WriteByte(byte b){

DC.Write(true);

Thread.Sleep(1);

_ba[0] = b;SPI_port.Write(_ba);

} static void OPTREX_Locate(int x, int y)

{ if (y > 7)

y = 7;

if (x > 127)x = 127;

OPTREX_SSD_WriteCmdByte((byte)(0X10 | (x >> 4)));//col upOPTREX_SSD_WriteCmdByte((byte)(0X00 | (x & 0xF)));//col down

OPTREX_SSD_WriteCmdByte((byte)(0XB0 | y));//page addr

} public static void Main()

{

OPTREX_SSD_WriteCmdByte(0XA2);//biasOPTREX_SSD_WriteCmdByte(0XA1);//adc inverseOPTREX_SSD_WriteCmdByte(0Xc0);//common dir...normalOPTREX_SSD_WriteCmdByte(0X40);//initial lineOPTREX_SSD_WriteCmdByte(0X81);//evr setOPTREX_SSD_WriteCmdByte(0X20);OPTREX_SSD_WriteCmdByte(0X29);//2B we have -10V........wait for







Thread.Sleep(1);}

}}






Guia para iniciantes em C# e .NET Micro Serviços de Tempo Framework

}

Para usar o hardware RTC, precisamos primeiro verificar se o hardware RTC tem uma horaválida ou não. Talvez isto acontece porque foi colocada uma nova bateria ou um novosistema e o RTC não tenha sido configurado. Se a RTC tem uma hora válido, então podemosler o RTC (hardware) e usar esse tempo para definir a hora do sistema NETMF (software).Se a hora não é válido, então você precisa definir o RTC para a hora correta.

using System;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;


public static void Main(){ // To keep track of time, set it at the beginning of your applicationfrom the RTC.

// If it was NOT set before and currently running using the battery(not exhausted), set it to a fixed time. if (RealTimeClock.IsTimeValid == false)

RealTimeClock.SetTime(new DateTime(2010, 03, 01, 12, 0, 0, 0));

Utility.SetLocalTime(RealTimeClock.GetTime());}

}

21.2. TimersO Micro Framework inclui duas classes de temporizadores: Timer e ExtendedTimer. A classeTimer é idêntica à que está presente full framework onde ExtendedTimer é específico doNETMF com funcionalidade extra. Para aplicações de iniciantes, eu sugiro que você continueutilizando threads antes de partir para os Timers. Eu vou mostrar um exemplo aqui nestelivro. Este programa irá criar um timer que vai começar depois de 5 segundos e, então,ativado a cada segundo.



{




Guia para iniciantes em C# e .NET Micro Serviços de Tempo Framework

static void RunMe(object o){

Debug.Print("From timer!");}


Timer MyTimer = new Timer(new TimerCallback(RunMe), null, 5000,1000); Debug.Print("The timer will fire in 5 seconds and then firepriodically every 1 second"); Thread.Sleep(Timeout.Infinite);

}}

}




Guia para iniciantes em C# e .NET Micro USB Host Framework

22. USB HostHá muitas vezes uma confusão entre o "host USB" e "dispositivo USB". O host USB é ohardware que se conecta a vários outros dispositivos USB. Por exemplo, o PC tem um hostUSB, porque pode conectar diversos dispositivos USB, como mouses, teclados e discosrígidos. A implementação de um dispositivo USB é relativamente simples, então implémenter um hospedeiro é muito mais complicado.

O host USB é uma característica exclusiva da GHI Electronics. Com ele, você pode conectar praticamente qualquer dispositivo USB nos produtos NETMF da GHI (UsBizi, EmbeddedMaster ChipworkX). Ele abre novos horizontes para um sistema embarcado. O produto jápode se conectar a um teclado USB padrão, ou mesmo o acesso a um pendrive USB!

USB é um sistema plugável, o que significa que os dispositivos podem ser conectados edesconectados a qualquer momento. Eventos são gerados quando há conexões/desconexões. O desenvolvedor deve registrar estes eventos para gerenciar os dispositivosconectados. Como este é um livro para iniciantes, vou assumir que o dispositivo já estáconectado ao sistema.

Com hub USB, vários dispositivos podem ser conectados diretamente. Hub usb não pode ser conectado em Hub usb.

Em primeiro lugar, deixe nos detectar quais os dispositivos estão conectados. A primeiracoisa a fazer é iniciar o administrador do sistema para nos fornecer a lista de dispositivosdisponíveis. Não se esqueça de adicionar o assembly correspondente ao seu projeto.

using System;using System.Threading;using Microsoft.SPOT;

using GHIElectronics.NETMF.USBHost;

namespace Test{ class Program


{ // Inscreve eventos para USBH USBHostController.DeviceConnectedEvent += DeviceConnectedEvent; USBHostController.DeviceDisconnectedEvent +=DeviceDisconnectedEvent;

// Loop para sempre Thread.Sleep(Timeout.Infinite);





}

static void DeviceConnectedEvent(USBH_Device device){

Debug.Print("Device connected..."); Debug.Print("ID: " + device.ID + ", Interface: " +device.INTERFACE_INDEX + ", Type: " + device.TYPE);

}

static void DeviceDisconnectedEvent(USBH_Device device){

Debug.Print("Device disconnected..."); Debug.Print("ID: " + device.ID + ", Interface: " +device.INTERFACE_INDEX + ", Type: " + device.TYPE);

}}

}

Quando nós detectamos um dispositivo, nós podemos comunicar com ele diretamente. Istorequer um monte de conhecimento sobre dispositivos USB. Felizmente, a maioria dosdispositivos abrangidos por classes padrão e GHI já oferecem drivers para eles.

22.1. Dispositivos HIDHID significa Human Interface Devices (dispositivo de interface humana), mouses, teclados e

joysticks são suportados diretamente. O uso da HID é através de eventos. Os eventos sãométodos que você cria e que você inscreve para certo evento. Quando esse evento ocorre,

seu método é executado automaticamente.

using System;using System.Threading;using Microsoft.SPOT;using GHIElectronics.NETMF.USBHost;

namespace Test{ public class Program

{ static USBH_Mouse mouse;


// Inscreve eventos para USBH USBHostController.DeviceConnectedEvent += DeviceConnectedEvent;


}






if (device.TYPE == USBH_DeviceType.Mouse){

Debug.Print("Mouse Connected");mouse = new USBH_Mouse(device);mouse.MouseMove += MouseMove;mouse.MouseDown += MouseDown;

}}

static void MouseMove(USBH_Mouse sender, USBH_MouseEventArgs args){

Debug.Print("(x, y) = (" + sender.Cursor.X + ", " +sender.Cursor.Y + ")");

}

static void MouseDown(USBH_Mouse sender, USBH_MouseEventArgs args){

Debug.Print("Button down number: " + args.ChangedButton);}

}}

Acessar o joysticks é muito similar. Aqui o mesmo exemplo, mas modificado para funcionar com um joystick.

using System;using System.Threading;using Microsoft.SPOT;using GHIElectronics.NETMF.USBHost;namespace Test{ public class Program

{ static USBH_Joystick j; public static void Main()

{ // Inscreve eventos para USBH USBHostController.DeviceConnectedEvent += DeviceConnectedEvent;


}


if (device.TYPE == USBH_DeviceType.Joystick){







class Program{

static USBH_SerialUSB serialUSB; static Thread serialUSBThread; // Imprime dados a cada segundo


// Inscreve eventos para USBH USBHostController.DeviceConnectedEvent += DeviceConnectedEvent;


}


Debug.Print("Device connected");

switch (device.TYPE){

case USBH_DeviceType.Serial_FTDI: // FTDI conectadoserialUSB = new USBH_SerialUSB(device, 9600,

System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One);serialUSB.Open();serialUSBThread = new Thread(SerialUSBThread);serialUSBThread.Start();

break;

case USBH_DeviceType.Unknown: // SiLabs não pode serreconhecido

// força SiLabs USBH_Device silabs = new USBH_Device(device.ID,device.INTERFACE_INDEX, USBH_DeviceType.Serial_SiLabs, device.VENDOR_ID,device.PRODUCT_ID, device.PORT_NUMBER);

serialUSB = new USBH_SerialUSB(silabs, 9600,System.IO.Ports.Parity.None, 8, System.IO.Ports.StopBits.One);

serialUSB.Open();serialUSBThread = new Thread(SerialUSBThread);serialUSBThread.Start();

break;}

}

static void SerialUSBThread(){

// Imprime "Hello World!" a cada segundo byte[] data = Encoding.UTF8.GetBytes("Hello World!\r\n"); while (true)

{ Thread.Sleep(1000);





serialUSB.Write(data, 0, data.Length);}

}}

}

22.3. Dispositivo de ArmazenamentoOs dispositivos de armazenamento como hard drives USB e drives de memória USB usammesma classe MSC (Mass Storage Class). A biblioteca da GHI suporta diretamente essesdispositivos. USB apenas define como ler / escrever setores na mídia. O sistemaoperacional lida com o sistema de arquivos. NETMF suporta sistema de arquivos FAT32 eFA16. Para acessar os arquivos em uma mídia USB, precisamos primeiro detectá-lo, então

precisamos para montar a mídia.

using System;using System.IO;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.IO;using GHIElectronics.NETMF.IO;using GHIElectronics.NETMF.USBHost;

namespace Test

{ class Program{


// Inscreve eventos para RemovableMedia RemovableMedia.Insert += RemovableMedia_Insert; RemovableMedia.Eject += RemovableMedia_Eject;

// Inscreve para eventos USB USBHostController.DeviceConnectedEvent += DeviceConnectedEvent;

// loop para sempre Thread.Sleep(Timeout.Infinite);

}


if (device.TYPE == USBH_DeviceType.MassStorage){

Debug.Print("USB Mass Storage detected...");





//.... //....

}}

}}

A próxima seção explana como acessar arquivos na memória USB.




Guia para iniciantes em C# e .NET Micro Sistema de Arquivos Framework

23. Sistema de ArquivosO sistema de arquivos suportado pelo NETMF 4.0 adiciona vários recursos para o suportepadrão. Por exemplo, um cartão SD pode ser montado no sistema de arquivos ou serviçoMSC do dispositivo USB. Quando ele está montado no sistema de arquivos, osdesenvolvedores podem acessar os arquivos. Se ele é montado sobre um dispositivo MSCUSB, um PC conectado à porta USB irá ver um leitor de cartões USB com cartão SDinserido. Isso é útil para a criação de um data logger. O dispositivo irá logar dados no cartãoSD e quando o dispositivo for plugado no PC, o dispositivo será um leitor de cartão for omesmo cartão de memória SD. A classe de armazenamento persistente da GHI é usadopara gerenciar a instalação do sistema de arquivos no sistema.

Esta seção irá cobrir somente o uso de dispositivos de armazenamento no sistema de

arquivos.

23.1. Cartões SDPrimeiro, precisamos detectar a inserção do cartão SD. Conectores de cartões SDgeralmente tem switch interno pequeno, que fecha quando o cartão é inserido. Nesteexemplo, vou assumir que o cartão está inserido e que não há necessidade de detectá-lo. Oprograma irá listar todos os arquivos no diretório raiz.

using System;using System.IO;using System.Threading;

using Microsoft.SPOT;using Microsoft.SPOT.IO;

using GHIElectronics.NETMF.IO;


{

public static void Main(){ // ... // Cartão SD é inserido // Cria um novo dispositivo de armazenamento PersistentStorage sdPS = new PersistentStorage("SD");

// Monta o arquivo de sistemas





sdPS.MountFileSystem();

//Assume que um dispositivo de armazenamento é disponível, acesseo através do Micro Framework e mostre no display os arquivos e foldersdisponíveis Debug.Print("Getting files and folders:"); if (VolumeInfo.GetVolumes()[0].IsFormatted)

{ string rootDirectory = VolumeInfo.GetVolumes()[0].RootDirectory; string[] files = Directory.GetFiles(rootDirectory); string[] folders = Directory.GetDirectories(rootDirectory);

Debug.Print("Files available on " + rootDirectory + ":"); for (int i = 0; i < files.Length; i++) Debug.Print(files[i]);

Debug.Print("Folders available on " + rootDirectory + ":");

for (int i = 0; i < folders.Length; i++) Debug.Print(folders[i]);

} else

{ Debug.Print("Storage is not formatted. Format on PC withFAT32/FAT16 first.");

}

// DesmontesdPS.UnmountFileSystem();

}}

}

Há várias maneiras de se abrir arquivos. Vou tratar aqui de objetos FilteStream. Esteexemplo abre um arquivo para escrever uma string dentro. Como FileStream aceita apenasarrays de bytes, teremos que converter a nossa string em um array de bytes.

using System.Threading;using System.Text;using Microsoft.SPOT;using System.IO;

using Microsoft.SPOT.IO;using GHIElectronics.NETMF.IO;


{ static void Main()







// SD Card está inserido // Cria um dispositivo de armazenamento PersistentStorage sdPS = new PersistentStorage("SD");

// Monte o sistema de arquivossdPS.MountFileSystem();

// Assume que um dispositivo de armazenameno está disponivelacesse ele pelo NETMF string rootDirectory = VolumeInfo.GetVolumes()[0].RootDirectory; FileStream FileHandle = new FileStream(rootDirectory +@"\hello.txt", FileMode.Open, FileAccess.Read); byte[] data = new byte[100]; // Escreva dados e feche o arquivo int read_count = FileHandle.Read(data, 0, data.Length);

FileHandle.Close(); Debug.Print("The size of data we read is: " +read_count.ToString());

Debug.Print("Data from file:"); Debug.Print(data.ToString());

// se nós necessitamos desmontarsdPS.UnmountFileSystem();

// ... Thread.Sleep(Timeout.Infinite);

}}

}

23.2. Discos USB (Disco deArmazenamento em Massa)Os arquivos são tratados no USB exatamente da mesma maneira que é feito em cartões SD.A única diferença é como vamos detectar e como montá-lo. Para SD, você pode usar umaentrada para o pino detectá-los. Com um drive USB, usamos eventos para detectar umanova mídia.

using System;using System.IO;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.IO;using GHIElectronics.NETMF.IO;using GHIElectronics.NETMF.USBHost;






{ // Mantém uma referência no caso que o GC cai fora e libere-oautomaticamente, note que somente temos suporte neste exemplo static PersistentStorage ps;


// Inscreva para eventos RemovableMedia RemovableMedia.Insert += RemovableMedia_Insert; RemovableMedia.Eject += RemovableMedia_Eject;

// Inscreva para eventos USB USBHostController.DeviceConnectedEvent += DeviceConnectedEvent;

// Loop para sempre



if (device.TYPE == USBH_DeviceType.MassStorage){

Debug.Print("USB Mass Storage detected...");ps = new PersistentStorage(device);ps.MountFileSystem();

}}

static void RemovableMedia_Insert(object sender, MediaEventArgs e){

Debug.Print("Storage \"" + e.Volume.RootDirectory + "\" isinserted."); Debug.Print("Getting files and folders:"); if (e.Volume.IsFormatted)

{ string[] files = Directory.GetFiles(e.Volume.RootDirectory); string[] folders =Directory.GetDirectories(e.Volume.RootDirectory);

Debug.Print("Files available on " + e.Volume.RootDirectory +":");

for (int i = 0; i < files.Length; i++) Debug.Print(files[i]);

Debug.Print("Folders available on " + e.Volume.RootDirectory+ ":"); for (int i = 0; i < folders.Length; i++) Debug.Print(folders[i]);

}





else{

Debug.Print("Storage is not formatted. Format on PC withFAT32/FAT16 first.");

}}

static void RemovableMedia_Eject(object sender, MediaEventArgs e){

Debug.Print("Storage \"" + e.Volume.RootDirectory + "\" isejected.");

}}

}

Podemos ver com o código acima com montar um drive USB para o arquivo de sistemas,

tudo funciona exatamente como os cartões SD.

23.3. Considerações nos arquivos desistemasNETMF 4.0 suporta sistema de arquivos FAT32 e FAT16. A mídia formatado para FAT12 nãoirá funcionar.

O sistema de arquivos tem internamente um monte de bufferização para acelerar o acesso aarquivos e aumentar o tempo de vida da mídia. Quando você gravar dados em um arquivo,

não está claro se os dados são gravados no cartão. Eles serão gravados, provavelmente, emalgum lugar na memória, no buffer interno. Para garantir que os dados sejam gravados namídia, você deve limpar os buffers usando o método flush(). Fazendo o flush ou fechando oarquivo arquivo é a única maneira de garantir que os dados são realmente gravados namídia.

Isso é no nível de arquivo. No nível de mídia, há também outras informações que podemnão ter efeito imediato. Por exemplo, se você excluir um arquivo e remover o cartão, nadaindica que o arquivo é realmente apagado. Para ter certeza, você deve usar o métodoVolumeInfo.FlushALL.

Idealmente, você desmontar (Unmount) a midia que é removido do sistema. Isto pode nemsempre ser possível, portanto, um Flush ou FlushAll na mídia irá garantir que seus dadostenham sido salvos e sem perda de dados se a mídia for removida em algum momento.




Guia para iniciantes em C# e .NET Micro Criando Redes (Networking) Framework

24. Criando Redes (Networking)A rede é uma parte essencial do nosso trabalho e vida. Quase todas casas está conectadasa rede que tenha Internet e a maioria das empresas pode não funcionar sem uma redeinterna (LAN ou WIFI) que é conectado com uma rede externa. Todas as redes tem umaforma de comunicação, eles todos usam o protocolo TCP/IP. Há atualmente vários protocolosque manuseiam diferentes atividades na rede, como DNS, DHCP, IP, ICMP, TCP, UDP, PPP emuito mais.

NETMF suporta redes TCP/IP através dos sockets padrões do .NET. Um socket é umaconexão virtual entre 2 dispositivos em uma rede.

GHI extendeu o suporte TCP/IP para PPP e WIFI. Através do PPP, 2 dispositivos podem se

conectar através de uma conexão serial. A conexão serial pode ser um modem de linhatelefônica ou um modem 3G/GPRS ou modem analógico. Com PPP, dispositivos NETMFpodem conectar a internet usando telefones celulares 3G/GPRS. É Também possívelconectar 2 dispositivos NETMF através de fios ou conexão serial sem fio (Xbee / Bluetooth /outros).

Além disso, com suporte a WIFI, dispositivos NETMF podem conectar para redes wirelessseguras. NETMF tambem também suporta conexão segura para SSL.

O suporte para rede é padrão e completa ( HTTP, SSL, Sockets,etc) no dispositivoEMX, Embedded Master e ChipworkX.

24.1. Suporte a rede com USBizi (FEZ)Para gerenciar uma rede maior e que ocupa mais memória, USBizi precisa de um apoioexterno. Por exemplo, o USBizi gerencia a rede através do chipset Wiznet W5100. QuandoUSBizi quer criar uma conexão de rede, a única coisa a fazer é enviar a solicitação paraWiznet 5100 e que o chip vai fazer o resto.

O chip Wiznet W5100 funciona com o barramento SPI. Há o driver da GHI que gerencia omódulo W5100 pelo C# . Este driver é uma versão beta, ou seja, o driver ainda esta emdesenvolvimento. O código está disponível para os usuários optimizarem e torná-lo maiseficiente.





24.2. TCP/IP bruto ou SocketsEsta é uma área onde a maioria dos designers podem cometer erros. Ao selecionar um

módulo WiFi ou GPRS/3G, existem duas categorias de módulos para escolher. Módulo com"Sockets" ou "módulos com TCP/IP bruto". Módulos com sockets TCP/IP gerenciam todo otrabalho TCP/IP internamente e dá-lhe o acesso a bases de alto nível. Isso significa que otrabalho mais difícil é feito internamente no módulo. Depois de ter atribuído um endereço euma porta, você só precisa enviar/receber dados a partir do módulo. Problema: ele é muitolimitado. Por exemplo, número de soquetes. Mesmo se seu sistema é muito poderoso, temmuitos MB de RAM, você está limitado pela funcionalidade do módulo. Por esta razão, noentanto, o uso de tais módulos "alto nível" é ideal para pequenos sistemas.

Tomemos um exemplo: Roving Networks oferece um módulo chamado WiFly. Este módulocontém uma rede TCP/IP e um único soquete. Usando este módulo é muito simples, já que

você conecta a uma placa de porta serial, em seguida, através de simples comandos emsérie, você pode ler/escrever dados de um socket disponível. Isso é suficiente para fazer umpequeno servidor web, uma conexão telnet ou transferência de dados. É perfeito parapequenos sistemas e recursos limitados, tais como a memória USBizi (FEZ). O módulo faztudo para você, basta enviar e receber dados seriais

Se você implementar um servidor web que fornece certos valores,tais como temperatura ou umidade, por isso é tudo que vocêprecisa e pode ser implementado de forma fácil e mais baratocom USBizi (FEZ). Um simples protótipo pode ser feito ligando oSHIELD WiFly ao FEZ Domino. Na imagem à direita, veja oSHIELD Wifly da SparkFun.

A desvantagem destes módulos simples é que são em númeromuito limitado de sockets. E se você precisa de mais? Ou que sepretende implementar uma conexão SSL? Para isso, você teráum módulo que não suporta TCP/IP internamente. O Trabalho doTCP/IP deve ser feito fora do módulo. Aqui que entram osmódulos EMX e ChipworkX. Estes módulos são potentes, com muitos recursos. Eles têmuma pilha TCP/IP interrna de SSL / HTTP / DHCP, etc. Conectando o módulo ZEROG aoEMX ou ChipworkX vai aumentar o poder do TCP/IP e permitir também conexões seguras.





Que tal modems GPRS e 3G? É a mesma coisa. Alguns têmsocket nativo, como SM5100B enquanto outros trabalham comPPP como um modem de PC (o módulo da Telit, por exemplo).Se você precisar de uma conexão de rede com TCP/IP

completo, vá direto para EMX ou ChipworkX com modemspadrões PPP, assim como um PC que se conecta à internet comum modem.

Se você precisa de uma conexão barata e fácil, então USBizi(FEZ) pode ser usado com SM5100B. O SHIELD da SparkFunCelular mostrada à direita é montado diretamente sobre o FEZ/Domino.

24.3. Sockets padrões .NETO suporte a Socket no NETMF é muito semelhante ao .NET Framework. O NETMF SDK temmuitos exemplos para uso de sockets, cliente e servidor. Também muitos projetos estãodisponíveis exibindo as diferentes possibilidades.

Cliente Twitter:

http://www.microframeworkprojects.com/index.php?title=MFTwitter

Google maps:

http://www.microframeworkprojects.com/index.php?title=GoogleMaps

Cliente RSS: http://www.microframeworkprojects.com/index.php?title=RSS_n_Weather

Rádio Internet MP3:

http://www.microframeworkprojects.com/index.php?title=ShoutcastClient

Servidor Web:

http://www.microframeworkprojects.com/index.php?title=WebServer





http://www.microframeworkprojects.com/index.php?title=RSS_n_Weather





http://www.microframeworkprojects.com/index.php?title=RSS_n_Weather






24.4. Wi-Fi (802.11)WiFi é muito comum em redes. Ele permite transferências seguras de dados a velocidades

altas entre várias conexões. Ele também permite a comunicação entre dois nós (Ad-Hoc). Amaneira mais fácil é conectar vários computadores a um ponto de acesso (access point). Oacesso não é simples e certamente, não se destina a ser incorporado facilmente. GHIElectronics é a única empresa que oferece a opção de WiFi NETMF em seus dispositivos.

WiFi é projetado para funcionar com pilha TCP/IP (sockets em rede NETMF) e pode ser utilizado em sistemas que já suportam TCP/IP como EMX e ChipworkX.

Wi-Fi apoiado pela GHI usa os chips e ZG2100 (comantena interna e externa respecitivamente) da ZeroG.Para o protótipo, a placa WiFi é um bom começo.

Como observado anteriormente, USBizi (FEZ) pode ser usadocom módulos que contêm suporte TCP/IP e socket interno comoo Shield Sparkfun que contêm o módulo WiFly da RovingNetworks.





24.5. Redes móveis com GPRS e 3G

EMX e ChipworkX tem o stack TCP/IP interno e suporte a PPP internamente. Você podeconectar um modem padrão e usá-lo em alguns passos.

No USBizi, uma conexão a uma rede móvel pode ser estabelecida através de um modemcom TCP / IP interno como o SM5100B. Abaixo o Shield com o SM5100B da Sparkfun.




Guia para iniciantes em C# e .NET Micro Criptografia Framework

25. CriptografiaA criptografia tem sido uma parte importante da tecnologia por muitos anos. Modernosalgoritmos de criptografia podem necessitar de muitos recursos. Já que os cartões NETMFsão destinados para dispositivos pequenos, a equipe NETMF teve que escolher quaisalgoritmos eles devem suportar. Esses algoritmos são XTEA e RSA.

25.1. XTEAXTEA, com a sua chave de 16 bytes (128 bits) é considerado muito seguro e não requer muito poder de processamento. Originalmente XTEA foi projetado para trabalhar em"pedaços" de 8 bytes apenas. Isto pode ser problemático para a criptografia de dados cujotamanho não é um múltiplo de 8. A implementação de XTEA em NETMF permite acriptografia de dados de qualquer tamanho.

A criptografia e descriptografia são fáceis de fazer. Está aqui um exemplo:

using System;using System.Text;using Microsoft.SPOT;using Microsoft.SPOT.Cryptography;public class Program{ public static void Main()

{

// 16-byte 128-bit key (chave) byte[] XTEA_key = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,13, 14, 15, 16 };

Key_TinyEncryptionAlgorithm xtea = newKey_TinyEncryptionAlgorithm(XTEA_key); // Dado que nós queremos incriptart string original_string = "FEZ is so easy!";//must be more than 8bytes //Converte para array de bytes byte[] original_data = UTF8Encoding.UTF8.GetBytes(original_string);

//Encripte o dado byte[] encrypted_bytes = xtea.Encrypt(original_data, 0,

original_data.Length, null); //descripte o dado byte[] decrypted_bytes = xtea.Decrypt(encrypted_bytes, 0,encrypted_bytes.Length, null); //imprima o dado descriptado string decrypted_string = newstring(Encoding.UTF8.GetChars(decrypted_bytes)); Debug.Print(original_string);





Debug.Print(decrypted_string);}

}

Os dados criptografados têm o mesmo tamanho que os dados brutos.

XTEA nos PCs

Agora você pode compartilhar dados entre dispositivos NETMF de modo seguro usandoXTEA, mas como a troca de dados com um PC ou outro sistema? O livro "expert. NET MicroFramework Second Edition" de Jens Kuhner fornece o código fonte que mostra comoimplementar XTEA em um PC. Usando o código de Jens, você pode criptografar os dados e

enviar-lhes a um dispositvo NETMF e vice-versa. Se você não tiver o livro, o código-fonte éonline, capítulo 8:

Você pode baixá-lo aqui: http://apress.com/book/view/9781590599730

25.2. RSAXTEA é seguro, mas tem uma limitação: a chave deve ser compartilhada. Para compartilhar dados criptografados, os dois sistemas devem primeiro conhecer a chave usada. Se umsistema tenta enviar a chave para o outro, alguém poderia espiar a linha e pegar a chave e,assim, descriptografar os dados. Isto é francamente não mais seguro!

RSA contorna este problema oferecendo uma combinação de chave pública / chave privada.Isso pode parecer absurdo, mas a chave usada para criptografar não pode ser usado paradescriptografar. A outra chave deve ser utilizada para descriptografar os dados. Suponha queo sistema de 'A' deve ler sistema de dados seguro 'B'. A primeira coisa que 'A' deve fazer éenviar uma chave pública ao sistema 'B'. O sitema 'B', então irá encriptar os dados com achave pública e enviar os dados para o PC. Um hacker pode ver os dados codificados e achave pública, mas sem a chave privada de descriptografia é praticamente impossível.Finalmente, o sistema de 'A' pode descriptografar os dados usando sua chave privada.A propósito, é assim que os sites seguros funcionam.

Os dispositivos NETMF não podem gerar chaves. Estes são gerados em um PC com um

programa chamado MetaDataProcessor. Abra uma linha de comando e digite as instruçõesabaixo

cd “C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.0\Tools”

Isso depende do seu diretório de instalação do NET Micro Framework.

Gere as chaves, fazendo isso:


http://apress.com/book/view/9781590599730

http://apress.com/book/view/9781590599730




MetadataProcessor.exe create_key_pair-c: \private.bin \c: public.bin

As teclas são codificadas em binário, mas esta ferramenta pode convertê-los em textolegível:

MetadataProcessor.exe dump_key c:\public.bin >> c:\public.txtMetadataProcessor.exe dump_key c:\private.bin >> c:\private.txt

Agora copie a chave do nosso programa de exemplo. Note que a chave pública semprecomeça com 1,0,1 e o resto são 0. Permite-nos optimizar o nosso código um pouco,conforme visto abaixo:

using System;using System.Text;using Microsoft.SPOT;using Microsoft.SPOT.Cryptography;


{ //isto é compartilhado entre keys publicas e privadas (chaves) byte[] module = new byte[] { 0x17, 0xe5, 0x27, 0x40, 0xa9, 0x15,0xbd, 0xfa, 0xac, 0x45, 0xb1, 0xb8, 0xe1, 0x7d, 0xf7, 0x8b, 0x6c, 0xbd, 0xd5,0xe3, 0xf4, 0x08, 0x83, 0xde, 0xd6, 0x4b, 0xd0, 0x6c, 0x76, 0x65, 0x17, 0x52,0xaf, 0x1c, 0x50, 0xff, 0x10, 0xe8, 0x4f, 0x4f, 0x96, 0x99, 0x5e, 0x24, 0x4c,0xfd, 0x60, 0xbe, 0x00, 0xdc, 0x07, 0x50, 0x6d, 0xfd, 0xcb, 0x70, 0x9c, 0xe6,0xb1, 0xaf, 0xdb, 0xca, 0x7e, 0x91, 0x36, 0xd4, 0x2b, 0xf9, 0x51, 0x6c, 0x33,0xcf, 0xbf, 0xdd, 0x69, 0xfc, 0x49, 0x87, 0x3e, 0x1f, 0x76, 0x20, 0x53, 0xc6,0x2e, 0x37, 0xfa, 0x83, 0x3d, 0xf0, 0xdc, 0x16, 0x3f, 0x16, 0xe8, 0x0e, 0xa4,

0xcf, 0xcf, 0x2f, 0x77, 0x6c, 0x1b, 0xe1, 0x88, 0xbd, 0x32, 0xbf, 0x95, 0x2f,0x86, 0xbb, 0xf9, 0xb4, 0x42, 0xcd, 0xae, 0x0b, 0x92, 0x6a, 0x74, 0xa0, 0xaf,0x5a, 0xf9, 0xb3, 0x75, 0xa3 }; //A chave privada...para descriptar byte[] private_key = new byte[] { 0xb9, 0x1c, 0x24, 0xca, 0xc8, 0xe8,0x3d, 0x35, 0x60, 0xfc, 0x76, 0xb5, 0x71, 0x49, 0xa5, 0x0e, 0xdd, 0xc8, 0x6b,0x34, 0x23, 0x94, 0x78, 0x65, 0x48, 0x5a, 0x54, 0x71, 0xd4, 0x1a, 0x35, 0x20,0x00, 0xc6, 0x0c, 0x04, 0x7e, 0xf0, 0x34, 0x8f, 0x66, 0x7f, 0x8a, 0x29, 0x02,0x5e, 0xe5, 0x39, 0x60, 0x15, 0x01, 0x58, 0x2b, 0xc0, 0x92, 0xcd, 0x41, 0x75,0x1b, 0x33, 0x49, 0x78, 0x20, 0x51, 0x19, 0x3b, 0x26, 0xaf, 0x98, 0xa5, 0x4d,0x14, 0xe7, 0x2f, 0x95, 0x36, 0xd4, 0x0a, 0x3b, 0xcf, 0x95, 0x25, 0xbb, 0x23,0x43, 0x8f, 0x99, 0xed, 0xb8, 0x35, 0xe4, 0x86, 0x52, 0x95, 0x3a, 0xf5, 0x36,0xba, 0x48, 0x3c, 0x35, 0x93, 0xac, 0xa8, 0xb0, 0xba, 0xb7, 0x93, 0xf2, 0xfd,

0x7b, 0xfa, 0xa5, 0x72, 0x57, 0x45, 0xc8, 0x45, 0xe7, 0x96, 0x55, 0xf9, 0x56,0x4f, 0x1a, 0xea, 0x8f, 0x55 }; //A chave pública sempre começa com 0x01, 0x00, 0x01,... e o resto étudo zero byte[] public_key = new byte[128];

public_key[0] = public_key[2] = 1;

Key_RSA rsa_encrypt = new Key_RSA(module, public_key);


http://c/public.txt

http://c/private.txt

http://c/public.txt

http://c/private.txt




Key_RSA rsa_decrypt = new Key_RSA(module, private_key);

// O dado que queremos incriptar string original_string = "FEZ is so easy!"; //Converte para array de bytes byte[] original_data = UTF8Encoding.UTF8.GetBytes(original_string); //Encrypt the data byte[] encrypted_bytes = rsa_encrypt.Encrypt(original_data, 0,original_data.Length, null); //Descripte os dados byte[] decrypted_bytes = rsa_decrypt.Decrypt(encrypted_bytes, 0,encrypted_bytes.Length, null); //Imprima o dado descriptado string decrypted_string = newstring(Encoding.UTF8.GetChars(decrypted_bytes)); Debug.Print("Data Size= " + original_string.Length + " Data= " +original_string); Debug.Print("Encrypted Data size= " + encrypted_bytes.Length + "

Decrypted Data= " + decrypted_string);}

}

O tamanho dos dados criptografados com a RSA não é o mesmo que os dados originais.Tenha isso em mente quando você planeja carregar ou armazenar dados criptografados.RSA requer muito mais poder de processamento que XTEA, que pode causar problemas emsistemas de pequeno porte. Eu sugiro que você inicie uma sessão RSA para trocar a chaveXTEA e alguma informação de segurança e então depois continue com XTEA.




Guia para iniciantes em C# e .NET Micro XML Framework

26. XML

26.1. Teoria de XMLeXtensible Markup Language (XML) é uma linguagem padrão para uma organização dedados de computador. Quando você quiser transferir dados entre dois dispositivos, vocêpode definir regras como os dados podem ser empacotados enviados a partir do dispositivoA. Por outro lado, o dispositivo B recebe e sabe como eles estão organizados. Antes de XML,tinham-se alguns problemas. O que acontece quando você quer enviar dados para umsistema desenvolvido por outra pessoa? Você precisa explicar como você organizou seusregistros para que ele possa lê-los corretamente. Agora os desenvolvedores podem usar

XML para uma organização comum de dados.XML é usado diariamente de muitas formas. Por exemplo, se um proprietário de um site devendas quer saber o custo do transporte de um pacote, ele formata os detalhes de custo emXML e o envia para a FedEx (por exemplo). O site da FedEx irá interpretar o conteúdo eenviar informações sobre a expedição, sempre em formato XML.

A eficácia do XML também pode ser útil em outros casos. Suponha que você tenhaprogramado um conjunto de dados de log. Imagine também que o usuário final podeconfigurar o data logger para cobrir suas necessidades, então ele precisa salvar ainformação em algum lugar. Você pode usar o seu próprio formato, mas exigiria mais códigoe depuração. A melhor maneira é usar o XML, que é um padrão.Todos os cartões NETMF

GHI Electronics ter suporte para leitura / escrita de XML.Aqui está um exemplo de arquivo XML que será útil para o nosso data logger.

<?xml version="1.0" encoding="utf-8" ?><NETMF_DataLogger><FileName>Data</FileName><FileExt>txt</FileExt><SampleFreq>10</SampleFreq>

</NETMF_DataLogger>

Este exemplo mostra um elemento raíz e 3 filhos. Eu escolhi essa estrutura, mas vocêpoderia muito bem ter colocado apenas elementos pai. XML é muito flexível, às vezes flexívelaté demais. Voltamos ao nosso exemplo. O elemento raiz "NETMF_DataLogger" contémtrês elementos de informação que são importantes para o nosso logger. Contém o nome doarquivo, sua extensão e freqüência de backup. Neste exemplo o logger irá criar um arquivodata.txt e preenchê-lo 10 vezes a cada segundo.





Outro uso importante para nós "Desenvolvedores de Aplicações Embarcadas" é a partilha deinformação com o sistema maior, como o PC. Como todos os sistemas operacionais de PCssuportam XML, você pode enoyer / receber dados do PC usando XML.

Espaços e layout não são significativas em XML. Estas coisas só são úteis aos sereshumanos, por razões de legibilidade. O mesmo exemplo acima poderia muito bem ter sidoescritos desta forma:

<?xml version="1.0" encoding="utf-8" ?><NETMF_DataLogger><FileName>Data</FileName><FileExt>txt</FileExt><SampleFreq>10</SampleFreq></NETMF_DataLogger>

Você entende porque a apresentação é importante para os seres humanos?

Você também pode adicionar comentários em um arquivo XML. Os comentários nãorepresentam nada para o XML, apenas facilita a leitura do arquivo por um ser humano.

<?xml version="1.0" encoding="utf-8" ?><NETMF_DataLogger><FileName>Data</FileName><FileExt>txt</FileExt><SampleFreq>10</SampleFreq>

</NETMF_DataLogger>

Finalmente, XML suporta atributo. Um atributo é uma informação adicional de um item. Maspor que usar um atributo se você pode adicionar um novo elemento que descreve estainformação extra ? Você não precisa usar estes atributos e eu diria que se você não tiver uma boa razão para usá-los então não use. Eu não estarei explanando sobre atributos nestelivro.

26.2. Criando um arquivo XMLOs dispositivos NETMF da GHI Electronics permitem ler e escrever XML. Isto é feito atravésde "streams", o que significa que qualquer stream que você tenha ou implementou, pode

trabalhar com XML. Vamos utilizar os “streams” FileStream e MemoryStream, mas vocêpoderia usar o seu próprio stream, o que não é descrita neste livro.

Este código mostra como criar um documento XML na memória. Esta código representa oexemplo XML recente.





using System.IO;using System.Xml;using System.Ext.Xml;using Microsoft.SPOT;


{ MemoryStream ms = new MemoryStream();

XmlWriter xmlwrite = XmlWriter.Create(ms);

xmlwrite.WriteProcessingInstruction("xml", "version=\"1.0\"encoding=\"utf-8\"");

xmlwrite.WriteComment("This is just a comment");xmlwrite.WriteStartElement("NETMF_DataLogger");//root elementxmlwrite.WriteStartElement("FileName");//child element

xmlwrite.WriteString("Data");xmlwrite.WriteEndElement();xmlwrite.WriteStartElement("FileExt");xmlwrite.WriteString("txt");xmlwrite.WriteEndElement();xmlwrite.WriteStartElement("SampleFeq");xmlwrite.WriteString("10");xmlwrite.WriteEndElement();xmlwrite.WriteEndElement();//end the root element

xmlwrite.Flush();xmlwrite.Close();

//////// mostra o dado XML ///////////

byte[] byteArray = ms.ToArray(); char[] cc = System.Text.UTF8Encoding.UTF8.GetChars(byteArray); string str = new string(cc); Debug.Print(str);

}}

Nota importante: com NETMF, bibliotecas de leitura e escrita XML são distintas. O leitura deXML provém do assembly "System.Xml" e a escrita provém do "MFDpwsExtensions"! Parasua comodidade, inclua os assembly quando você for trabalhar com XML.

Nota: Quando você adicionar o assembly, você verá que existem duas assemblies para XML,"System.Xml" e "System.Xml.Legacy”. Nunca utilize o driver "legacy", pois é muito lento econsome muita memória. Ele existe apenas para sistemas que não conseguem suportar opadrão XML. Todos os dispositivos NETMF da GHI Electronics tem suporte XML nativo(muito rápido), então você pode sempre utilizar "System.Xml".

Ao executar o programa acima, você verá os dados XML na saída aparecem no final. Estesdados estão corretos, mas não necessariamente legível. Note que nós estamos





escrevendo/lendo arquivos XML em um sistema muito pequeno e, portanto, quanto menosinformação (espaços, formato) melhor. Então é melhor não ter a formatação ou espaços,mas, tornam as coisas ainda mais divertidas quando nós adicionamos algumas linhas paramelhorar a exibição






xmlwrite.WriteComment("This is just a comment");xmlwrite.WriteRaw("\r\n");xmlwrite.WriteStartElement("NETMF_DataLogger");//elemento raizxmlwrite.WriteString("\r\n\t");xmlwrite.WriteStartElement("FileName");//elemento filhoxmlwrite.WriteString("Data");xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n\t");xmlwrite.WriteStartElement("FileExt");

xmlwrite.WriteString("txt");xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n\t");xmlwrite.WriteStartElement("SampleFeq");xmlwrite.WriteString("10");xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n");xmlwrite.WriteEndElement();//fim do elemento raiz

xmlwrite.Flush();xmlwrite.Close();

//////// mostra o dado XML /////////// byte[] byteArray = ms.ToArray();

char[] cc = System.Text.UTF8Encoding.UTF8.GetChars(byteArray); string str = new string(cc); Debug.Print(str);

}}





26.3. Lendo XMLCriar um arquivo XML que é mais fácil do que ler (analisar). Existem várias maneiras de ler um arquivo XML, mas você pode simplesmente ler em pedaços até ao final do arquivo. Esteexemplo cria um dado XML e o lê de volta.






xmlwrite.WriteComment("This is just a comment");xmlwrite.WriteRaw("\r\n");xmlwrite.WriteStartElement("NETMF_DataLogger");//elemento raizxmlwrite.WriteString("\r\n\t");xmlwrite.WriteStartElement("FileName");//elemento filhoxmlwrite.WriteString("Data");

xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n\t");xmlwrite.WriteStartElement("FileExt");xmlwrite.WriteString("txt");xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n\t");xmlwrite.WriteStartElement("SampleFeq");xmlwrite.WriteString("10");xmlwrite.WriteEndElement();xmlwrite.WriteRaw("\r\n");xmlwrite.WriteEndElement();//fim do elemento raiz

xmlwrite.Flush();

xmlwrite.Close(); //////// mostra o dado XML /////////// byte[] byteArray = ms.ToArray(); char[] cc = System.Text.UTF8Encoding.UTF8.GetChars(byteArray); string str = new string(cc); Debug.Print(str);

///////////Leia XML





MemoryStream rms = new MemoryStream(byteArray);

XmlReaderSettings ss = new XmlReaderSettings();ss.IgnoreWhitespace = true;ss.IgnoreComments = false;

//XmlException.XmlExceptionErrorCode. XmlReader xmlr = XmlReader.Create(rms,ss); while (!xmlr.EOF)

{xmlr.Read();

switch (xmlr.NodeType){

case XmlNodeType.Element: Debug.Print("element: " + xmlr.Name); break; case XmlNodeType.Text: Debug.Print("text: " + xmlr.Value); break;

case XmlNodeType.XmlDeclaration: Debug.Print("decl: " + xmlr.Name + ", " + xmlr.Value); break; case XmlNodeType.Comment: Debug.Print("comment " +xmlr.Value); break; case XmlNodeType.EndElement: Debug.Print("end element"); break; case XmlNodeType.Whitespace: Debug.Print("white space"); break; case XmlNodeType.None:

Debug.Print("none"); break; default: Debug.Print(xmlr.NodeType.ToString()); break;

}}

}}






Guia para iniciantes em C# e .NET Micro Expandindo as E/S Framework

colunas conectado aos pinos (4,5,6)


using System;using Microsoft.SPOT.Hardware;using Microsoft.SPOT;


{ static OutputPort[] Rows = new OutputPort[3]; static InputPort[] Colms = new InputPort[3];

static bool ReadMatrix(int row, int column){

bool col_state;

//selecione uma linhaRows[row].Write(true);

//selecione uma colunacol_state = Colms[column].Read();

// deselecione uma linhaRows[row].Write(false);

return col_state;}

static void Main()

{ // inicialize linha como saída e jogue valor baixoRows[0] = new OutputPort((Cpu.Pin)1, false);Rows[1] = new OutputPort((Cpu.Pin)2, false);Rows[2] = new OutputPort((Cpu.Pin)3, false);

//Inicialize entradas com PULL DOWNColms[0] = new InputPort((Cpu.Pin)4, true,

Port.ResistorMode.PullDown);Colms[1] = new InputPort((Cpu.Pin)5, true,

Port.ResistorMode.PullDown);Colms[2] = new InputPort((Cpu.Pin)6, true,

Port.ResistorMode.PullDown);

while (true){

bool state;

// Leia o botão na primeira linha e primeira colunastate = ReadMatrix(0, 0);//nós contamos do zero

Debug.Print("Buton state is: " + state.ToString());




Guia para iniciantes em C# e .NET Micro Expandindo as E/S Framework

//Leia o botão da terceira linha e segunda coluna columnstate = ReadMatrix(2, 1);//nós contaomos do zero

Debug.Print("Buton state is: " + state.ToString());

Thread.Sleep(100);}

}}

}

27.2. AnalógicoExistem dezenas (centenas) de chipsets analógicos disponíveis para o barramento SPI, I2Cou 1-Wire. Alguns lêem a partir de 0 a 5V e outros-10V a +10 V. Na verdade, existem muitasmaneiras de adicionar entradas analógicas para o circuito! Alguns chips têm funçôes

específicos. Se precisarmos de uma medida de temperatura, podemos conectar um sensor de temperatura para um pino analógico e ler o valor que será convertido em temperatura. Éuma possibilidade, mas a melhor solução é usar um sensor de temperatura digital queoperam em I2C, 1-Wire ou SPI. Isto lhe dará uma precisão melhor medição e vai salvar opino analógico para outros usos.

Botões Analógicos

Uma dica para ligar um monte de botões para um único pino é usar uma entrada analógica.Cada botão está ligado a uma resistência diferente e, assim, a tensão na entrada do pinoanalógico será diferente dependendo do botão pressionado.




Guia para iniciantes em C# e .NET Micro Cliente USB Framework

28. Cliente USBEu quero começar esta seção, salientando que este é um tema pouco avançada. Salve paraler mais tarde.

28.1. Serial (COM) DebuggingPor padrão, todos os dispositivos NETMF da GHI usam USB para a implantação (deploy) edepuração. Opcionalmente, um desenvolvedor pode querer utilizar o USB cliente (não oHost) para alguma coisa diferente do que a depuração. Isto é atualmente suportado peloNETMF e GHI acrescentou recursos ficando muito fácil de configurar.

Nota importante: Você não pode usar a porta USB do cliente para ambas depuração e outracoisa. Uma vez que você decidir que quer usar a porta USB do cliente para seu próprio uso,então você não pode usar a porta USB para depuração. A propósito, GHI adcionou suporte adepuração e personalizar da interface USB simultaneamente através da utilização de váriasinterfaces na mesma interface USB, mas isso causou uma enorme carga de processo desuporte e assim a utilização simultânea foi descartada.

Deixe-me dar um exemplo sobre o uso do cliente USB.Digamos que você está fazendo um dispositivo que lê atemperatura e a umidade, etc ... e registra todos osdados em um cartão SD. Além disso, este dispositivopode ser configurado, como configurar o tempo ou dar

nomes de arquivo etc ... Você deseja que o dispositivo aser configurado através de USB. Então, quando é ligadoo dispositivo a uma porta USB, você quer mostrar comouma porta serial virtual. Desta forma, qualquer um podeabrir um software de terminal (como TeraTerm) paraconectar o dispositivo para configurá-lo. Este é o lugar onde cliente USB torna-se muito útil. Não hánecessidade de acrescentar custos adicionais ao projeto, mas acrescentando mais portasseriais RS232 ou USB <-> chipsets série. A Porta USB do cliente pode ser configurado paraagir como um dispositivo do CDC, a porta COM virtual. Mas, existe uma batalha! Você aindaprecisa conectar o PC para o dispositivo serial de depuração e implantação de aplicativos já

que a porta cliente USB é usado por sua aplicação final. A boa notícia é que você só precisada interface serial em fase de desenvolvimento, mas, quando você implanta no produto, aporta serial não é mais necessária. Por exemplo, você pode usar o shield RS232 FEZDomino em fase de desenvolvimento, mas então você não vai mais necessitar dele quandoterminar de depuração.





Agora, você tem COM1 contectado ao seu dispositivo e deseja usá-la para a depuração emvez de USB. O próximo passo é configurar o dispositivo para uso serial de depuração. Este éum dispositivo específico que você precisa verificar no manual do usuário do dispostiivo. Por exemplo, se você estiver usando FEZ Domino, há jumper rotulado MODE que você podecolocar para selecionar a depuração serial. Se você estiver usando FEZ Cobra, então o pinoLMODE precisa estar conectado para 3.3V para seleccionar a depuração serial. Lembre-seque uma vez que você ligar o pino em alto ou baixo, então você não pode mais usá-lo emsua aplicação. Por exemplo, o pino MODE no FEZ Domino é o mesmo utilizado para o LED eé também um pino PWM. Uma vez que você curto circuitou o pino terra (através do jumper),você nunca deve tentar usar esse pino, nunca tente usar o LED ou poderá danificar o seuaparelho!

28.2. A configuração (SETUP)Ok, chega de conversa e vamos iniciar a configuração. Estou usando o shield RS232 FEZDomino, mas você pode usar qualquer dispositivo de sua escolha. Eu tenho o shield RS232conectado ao FEZ Domino e também ligado ao meu PC usando um cabo RS232<->USB(sem porta serial no meu PC). Eu também fiz coloquei o jumper no pino MODE e conectei ocabo USB do Domino ao PC. Depois de colocar o jumper MODE, conectando o cabo USB doFEZ Domino a um PC não irá carregar todos os drivers do Windows (você não vai ouvir osom de USB conectado).

Finalmente, queremos ter certeza que podemos ping o dispositivo usando a ferramentaMFDeploy. Nós fizemos isso antes deusar o USB e agora queremos utilizar a serial. Note que apesar de eu ter FEZ Domino + shield RS232conectado à porta USB do meu PCatravés do cabo RS232 <-> USBcaboUSB, este é a COM e não USB, é umaCOM virtual para ser exato.

Então, abra o MFDeploy e selecioneCOM e então você terá uma lista dasportas seriais disponíveis. Selecione oseu dispositivo conectado e clique em

Ping. Você deverá ver "TinyCLR ". Senão, então volte e verifique suaconfiguração.





28.3. Mouse, o plano perfeitoAqui está o plano de mestre! Você quer fazer uma brincadeira com, gravar um vídeo eenviar ? Aqui está como você pode fazer isto. Configurar seu FEZ para emular um mouseUSB, em seguida, fazer o movimento do mouse em um círculo cada poucos minutos. Apostoque ele vai se sentir como se houvesse um fantasma na sua máquina. A boa notícia é que oWindows pode ter vários dispositivos de mouse, logo o FEZ será escondido atrás do PC.

using System;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.USBClient;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.FEZ;

public class Program


{ FEZ_Components.LED led = new FEZ_Components.LED(FEZ_Pin.Digital.Di3);

led.StartBlinking(100, 200);

// Checa interface de depuração if (Configuration.DebugInterface.GetCurrent() ==Configuration.DebugInterface.Port.USB1) throw new InvalidOperationException("Current debug interface is USB.It must be changed to something else before proceeding. Refer to your platformuser manual to change the debug interface.");

// Inicia o Mouse USBC_Mouse mouse = USBClientController.StandardDevices.StartMouse();

// Move ponteiro const int ANGLE_STEP_SIZE = 15; const int MIN_CIRCLE_DIAMETER = 50; const int MAX_CIRCLE_DIAMETER = 200; const int CIRCLE_DIAMETER_STEP_SIZE = 1;

int diameter = MIN_CIRCLE_DIAMETER; int diameterIncrease = CIRCLE_DIAMETER_STEP_SIZE; int angle = 0; int factor;

Random rnd = new Random(); int i = 0;

while (true){

// Nos queremos fazer isto randomicamentei = rnd.Next(5000) + 5000;//entre 5 e 10 segundos

Debug.Print("Delaying for " + i + " ms"); Thread.Sleep(i);





i = rnd.Next(200) + 100;//faz isto por um curto espaço de tempo Debug.Print("Looping " + i + " times!"); while (i-- > 0)

{ // Checa se conectado ao PC

if (USBClientController.GetState() ==USBClientController.State.Running)

{ // Nota X, Y são reportados como deslocamentos, não valorabsoluto

factor = diameter * ANGLE_STEP_SIZE * (int)System.Math.PI /180 / 2; int dx = (-1 * factor * (int)Microsoft.SPOT.Math.Sin(angle) /1000); int dy = (factor * (int)Microsoft.SPOT.Math.Cos(angle) /1000);

angle += ANGLE_STEP_SIZE;diameter += diameterIncrease;

if (diameter >= MAX_CIRCLE_DIAMETER ||diameter <= MIN_CIRCLE_DIAMETER)diameterIncrease *= -1;

// reporta a posição do mousemouse.SendData(dx, dy, 0, USBC_Mouse.Buttons.BUTTON_NONE);

}

Thread.Sleep(10);}

}

}}

28.4. TecladoEmulando um teclado é tão fácil como emular um mouse. O exemplo a seguir criará umteclado USB e enviar "Olá mundo!" para um PC a cada segundo.

using System;

using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;

using GHIElectronics.NETMF.USBClient;using GHIElectronics.NETMF.Hardware;

public class Program






{ // Checa interface de debug if (Configuration.DebugInterface.GetCurrent() ==

Configuration.DebugInterface.Port.USB1) throw new InvalidOperationException("Current debug interface is USB.It must be changed to something else before proceeding. Refer to your platformuser manual to change the debug interface."); // Start keyboard USBC_Keyboard kb = USBClientController.StandardDevices.StartKeyboard(); Debug.Print("Waiting to connect to PC..."); // Envie "Hello world!" a cada segundo while (true)

{ // Checa se está conectado ao PC if (USBClientController.GetState() ==USBClientController.State.Running)

{ // Temos que pressionar SHIFT para sair o “H” maiúsculo

kb.KeyDown(USBC_Key.LeftShift);kb.KeyTap(USBC_Key.H);kb.KeyUp(USBC_Key.LeftShift);

// Agora "Hello world"kb.KeyTap(USBC_Key.E);kb.KeyTap(USBC_Key.L);kb.KeyTap(USBC_Key.L);kb.KeyTap(USBC_Key.O);kb.KeyTap(USBC_Key.Space);kb.KeyTap(USBC_Key.W);kb.KeyTap(USBC_Key.O);kb.KeyTap(USBC_Key.R);

kb.KeyTap(USBC_Key.L);kb.KeyTap(USBC_Key.D); // Agora "!"

kb.KeyDown(USBC_Key.LeftShift);kb.KeyTap(USBC_Key.D1);kb.KeyUp(USBC_Key.LeftShift);

// Envie um enter (CR)kb.KeyTap(USBC_Key.Enter);

} Thread.Sleep(1000);

}}

}





28.5. CDC -Virtual SerialAs portas seriais são a interface mais comuns no mundo dos sistemas embarcados, É umasolução ideal para dispositivos para transferir dados entre PCs e dispositivos FEZ. Paracombinar a popularidade e utilidade da USB com a facilidade da serial, temos dispositivosUSB virtuais. Para aplicações para o Windows ou para dispositivos, uma porta serial virtualfunciona como uma porta serial, mas na realidade, é realmente uma porta USB.

Uma coisa importante que eu quero mencionar aqui é que, normalmente, os drivers CDCmanuseia uma transação em cada frame. O tamanho máximo do EP no USB é de 64 bytes ehá 1000 frames/segundo em uma USB full-speed. Isto significa, a taxa de transferênciamáxima para os drivers CDC é de 64KB/sec. Eu acho que, a Microsoft percebeu anecessidade de CDC e maior taxa de transferência e realçou esta limitação. A última vez quetestei a velocidade de transferência em minha máquina win7, eu era capaz de contastatar 500KB/sec.

O exempo a seguir irá criar um USB CDC e enviar "Olá mundo!" para o PC a cada segundo.

using System;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;

using GHIElectronics.NETMF.USBClient;using GHIElectronics.NETMF.Hardware;



// Checa a interface de debug if (Configuration.DebugInterface.GetCurrent() ==Configuration.DebugInterface.Port.USB1) throw new InvalidOperationException("Current debug interface is USB.It must be changed to something else before proceeding. Refer to your platformuser manual to change the debug interface.");

// Incie CDC USBC_CDC cdc = USBClientController.StandardDevices.StartCDC();

// Envie "Hello world!" para o PC a cada segundo (com cr/lf) byte[] bytes = System.Text.Encoding.UTF8.GetBytes("Hello world!\r\n"); while (true)

{ // Checa se conectado ao PC if (USBClientController.GetState() !=USBClientController.State.Running)

{ Debug.Print("Waiting to connect to PC...");

}








{ // Checa interface de debug if (Configuration.DebugInterface.GetCurrent() ==

Configuration.DebugInterface.Port.USB1) throw new InvalidOperationException("Current debug interface isUSB. It must be changed to something else before proceeding. Refer to yourplatform user manual to change the debug interface.");

// Inicia MS USBC_MassStorage ms =USBClientController.StandardDevices.StartMassStorage();

// Assume que o cartão SD está conectado PersistentStorage sd; try

{sd = new PersistentStorage("SD");

} catch

{ throw new Exception("SD card not detected");

}ms.AttachLun(0, sd, " ", " ");

// Habilita acesso ao hostms.EnableLun(0);


}}

28.7. Dispositivo customizadosO suporte de cliente USB da GHI permite-lhe controlar o cliente USB de qualquer maneiraque você gosta. Esta funcionalidade exige um bom conhecimento de USB. Se você não sabeo que é terminal e Pipe então não tente criar dispositivos personalizados. Além disso, é muitoimportante que você tenha dispositivo configurado corretamente na primeira vez ele estáconectado no Windows. Isto é importante porque o Windows armazena um monte deinformações no seu registro. Então, se você alterar a configuração do seu aparelho depois

que você tinha se conectado no Windows pela primeira vez o Windows pode não pode ver asmudanças, uma vez que estará usando a configuração antiga do seu registo.

Basicamente, ficar longe de USB Client Custom Devices, a menos que você realmente temuma boa razão para usá-los e você tem um bom conhecimento de USB e os drivers doWindows.

Eu não vou explicar Custom Devices posteriormente, mas só queria deixar claro porque eu





decidi não fazê-lo. O padrão construído em classes, explicado anteriormente, deve ser suficiente para cobrir a maior parte de suas necessidades.




Guia para iniciantes em C# e .NET Micro Baixo Consumo Framework

29. Baixo ConsumoDispositivos alimentados por pilhas deveriam limitar o uso de corrente elétrica, o máximopossível.Os dispositivos podem reduzir o consumo de corrente de muitas maneiras:

1. Reduza o clock do processador

2. “Paralize” processador quando estive ocioso (mantenha os periféricos e interrupçõesativos)3. “Paralize” alguns periféricos

4. Hiberne o sistema

Um dispositivo NETMF pode opcionalmente suportar qualquer um destes métodos. Consulteo manual do usuário do seu dispositivo para saber mais sobre o que é suportadodiretamente. Em geral, todos os dispositivos GHI NETMF “paralizam” o processador quandoem estado ocioso. Por exemplo, isto reduzirá o consumo do FEZ Rhino para cerca de 45mA.Você realmente não precisa fazer nada de especial, logo que o sistema estiver ocioso, oprocessador é “paralizado” automaticamente enquanto as interrupções e periféricos aindaestão ativos.

Além disso, todos os periféricos (ADC, DAC, PWM, SPI, UART ...) estão desativados por padrão, para menor consumo de corrente. Eles são ativados automaticamente quando elessão usados.

Se tudo isso não é suficiente, você pode hibernar completamente o sistema. Basta lembrar que quando o sistema está hibernando, não está executando e periféricos não estãofuncionais. Por exemplo, quando dados vindo para a UART não irá acordar o sistema. Vocêsimplesmente vai perder os dados recebidos. Acordando da hibernação é uma característicado sistema depende, mas geralmente o pino específico (s) pode ser alternado para acordar osistema.

Nota: GHI percebeu que o modo padrão NETMF de alimentação não é adequado parahibernar, assim um método específico da GHI é executado para lidar com a hibernação dosistema.

Nota Importante: Quando o dispositivo está no modo de hibernação, USB para de funcionar.

Você não pode ir nó código ou acessar o dispositivo. Se o seu programa sempre coloca odispositivo em Sleep, então você não será capaz de carregar um novo programa.Basicamente, bloqueia o dispositivo. Você precisa entrar no gerenciador de boot para apagar tudo para desbloquear o aparelho da hibernação!

Nota Importante: Quando você hibernar, o relógio do sistema pára (não RTC) por isso otempo do NETMF será desativado. Você vai precisar de ler o tempo da RTC e definir o tempodo sistema NETMF depois de acordar da hibernação.





Acordando da hibernação só é possível em alguns eventos. Verifique o manual do usuário dodispositivo ou a documentação da biblioteca para obter mais detalhes. Uma maneira fácil deacordar da hibernação é utilizando o recurso de alarme (quando disponível). Por exemplo,FEZ Rhino inclui o clock de 32KHz necessário para o RTC / alarme, mas o FEZ Mini não.

Veja este link para mais detalhes http://www.tinyclr.com/compare

Neste exemplo, eu ajustei o RTC alguma hora aleatória válida e então eu fiz piscar um LED.A cada três segundos, o dispositivo define o alarme para despertar em 10 segundos e depoiscoloca o dispositivo em modo de hibernação. O dispositivo estará completamente morto(novamente, sem depuração pela USB) mas você deve ser capaz de ver isso no LED.Quando o dispositivo acorda, ele continua a piscar o LED. No final, o LED irá piscar por 3segundos e depois pára por 10 segundos.

using System;using System.Threading;using Microsoft.SPOT;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;

using GHIElectronics.NETMF.FEZ;public class Program{ public static void Main()

{ //Pisca Led FEZ_Components.LED led = new FEZ_Components.LED(FEZ_Pin.Digital.LED);


//Seta uma hora válida randomica RealTimeClock.SetTime( new DateTime(2010, 1, 1, 1, 1, 1)); while (true)

{ Thread.Sleep(3000);//pisca led por 3 segundos RealTimeClock.SetAlarm(RealTimeClock.GetTime().AddSeconds(10)); Debug.Print("Going to sleep for 10 seonds!"); // Dorme por 10 segundos Power.Hibernate(Power.WakeUpInterrupt.RTCAlarm);

Debug.Print("Good Morning!");}

}}

Outra opção é acordar na porta de interrupção. Você tem que ter cuidado com isso porquequalquer interrupção em qualquer pino fará com que este acorde. Por exemplo, o módulo Wi-Fi no FEZ Cobra usa internamente um dos pinos de interrupção e de modo que este vaiacordar o sistema. Você precisa desativar WiFi antes da hibernação. Este não é o únicotruque que você precisa estar ciente! Olhe para a código seguinte e tente. Não vai funcionar!


http://www.tinyclr.com/compare

http://www.tinyclr.com/compare




using System;using System.Threading;using Microsoft.SPOT;

using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;


{ //Pisca led FEZ_Components.LED led = new FEZ_Components.LED(FEZ_Pin.Digital.LED);

led.StartBlinking(100, 100); //Configura o pino de interrupção InterruptPort LDR = new InterruptPort((Cpu.Pin)0,false,

Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow); while (true)

{ Thread.Sleep(3000);//Pisca led por 3 segundos // dorme Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs); //chegamos aqui quando sai da hibernação

}}

}

Por que o exemplo acima não funciona? Quando você cria uma interrupção (ou entrada) do

pino, as interrupções são habilitados somente se o filtro glitch é usado ou se um manipulador de eventos está instalado. Então, para fazer o exemplo acima funcionar, você só precisaativar o filtro. Aqui está o código que funciona.

using System;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;


{ //pisca led FEZ_Components.LED led = new FEZ_Components.LED(FEZ_Pin.Digital.LED);

led.StartBlinking(100, 100); //Seta o pino de interrupção com Glitch habilitado





InterruptPort LDR = new InterruptPort((Cpu.Pin)0,true,Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow); while (true)

{ Thread.Sleep(3000);//pisca led por 3 segundos

// Durma Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs); //hegamos aqui quando sai da hibernação

}}

}

Outra opção é instalar um manipulador de eventos para o botão como segue:

using System;using System.Threading;

using Microsoft.SPOT;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;



led.StartBlinking(100, 100); //configura o pino de interrupção InterruptPort LDR = new InterruptPort((Cpu.Pin)0,false,Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);

LDR.OnInterrupt += new NativeEventHandler(LDR_OnInterrupt); while (true)

{ Thread.Sleep(3000);//pisca leds por 3 segundos // durma Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs); //chegamos aqui quando sai da hibernação

}}

static void LDR_OnInterrupt(uint data1, uint data2, DateTime time)

{ // vazio no momento}

}

Por favor, note que o uso InputPort é tão bom quanto usar o InterruptPort uma vez que,internamente, as interrupções são utilizados quando o filtro de Glitech está habilitado. Aqui é





o exemplo, utilizando InputPort em vez de InterruptPort.

using System;

using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;




//Configura pino de interrupçÃo InterruptPort LDR = new InterruptPort((Cpu.Pin)0,false,Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);

LDR.OnInterrupt += new NativeEventHandler(LDR_OnInterrupt); while (true)

{ Thread.Sleep(3000);//pisca led por 3 segundos // durma Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs); //chegamos aqui quando sai da hibernação

}}

static void LDR_OnInterrupt(uint data1, uint data2, DateTime time)

{ // vazio no momento

}}

Este exemplo irá piscar um LED, quando acordar ou quando o botão LDR botão for pressionado, o sistema vai entrar em sono profundo por 10 segundos.

Este é um exemplo para FEZ Domino (USBizi) que vai entrar em sono profundo e acordar quando eu pressionar um botão ??????????

using System;using System.Threading;using Microsoft.SPOT;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;using GHIElectronics.NETMF.Hardware.LowLevel;







{ //pisca led

FEZ_Components.LED led = new FEZ_Components.LED(FEZ_Pin.Digital.LED);led.StartBlinking(100, 100);

//configura pino de interrupção InputPort LDR = new InputPort((Cpu.Pin)0,true,Port.ResistorMode.PullUp); while (true)

{ Thread.Sleep(3000);//blink LED for 3 seconds // durma Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs); //chegamos aqui quando sai da hibernação

}}

}

Finalmente, você pode acordar em mais um eventos. Por exemplo, você pode acordar se umbotão for pressionado ou o alarme é acionado.

Power.Hibernate(Power.WakeUpInterrupt.InterruptInputs |Power.WakeUpInterrupt.RTCAlarm);




Guia para iniciantes em C# e .NET Micro Watchdog Framework

30. WatchdogNo mundo de sistemas embarcados, os dispositivos são geralmente sempre rodando e seminteração do usuário. Portanto, se algo der errado, seria muito benéfico se tivermos um botãode reset automático. Watchdog é o botão de reset!

Recuperação do Sistema de Execução

Suponha que você está fazendo uma máquina de venda automática inteligente que reportaos relatórios de inventário sobre a rede. Se o seu código gera uma exceção que não foitratado adequadamente, em seguida, seu programa vai finalizar. Programa terminandosignifica que a máquina de vendas não funcionam mais. Alguém terá de conduzir atémáquina de vendas e dar um reset, ou melhor, é só usar watchdog.

Quando você habilita o cão de guarda (watch dog), você configura o tempo limite pararesetar. Em seguida, você manter a redefinição do watchdog timer periodicamente. Se osistema trava, em seguida, watch dog chega ao limite, então irá resetar o sistema.

Importante: GHI percebeu que o watch dog interno não é o que os consumidores querem,então a GHI implementou a sua própria versão de watch dog. Não use o watch dog daMicrosoft.SPOT.Hardware, em vez disso, use o cão de guardaGHIElectronics.NETMF.Hardware.LowLevel.

Se ambos os namespaces forem ser usados, então você terá erros de ambigüidade e por isso é necessário chamar especificamente o caminho completo do cão de guarda que vocêprecisa. Por exemplo, em vez de usar o tempo limite (Watchdog.Enable), useGHIElectronics.NETMF.Hardware.LowLevel.Watchdog.Enable (timeout).

Este exemplo mostra como definir o timeout do watchdog para 5 segundos e criar umathread para reinicializar o cão de guarda a cada 3 segundos. Se algo der errado, o dispositivoirá reiniciar em 5 segundos.

Nota Importante: Uma vez você ter habilitado o Watchdog, não pode ser mais desabilitado.Então you deve ficar resetando o timeout. Isto é feito para garantir que o corrompimento dosistema não desabilite o watchdog acidentalmente.

using System;using System.Threading;using GHIElectronics.NETMF.Hardware.LowLevel;


{





// Timeout por 5 segundos uint timeout = 1000 * 5;

// Habilita Watchdog Watchdog.Enable(timeout);

// Da início ao contador do tempo de reset (thread)WDTCounterReset = new Thread(WDTCounterResetLoop);WDTCounterReset.Start();

// .... // seu programa começa aqui

// Se nós terminamos o programa, a thread vai parar de trabalhar e osistema irá resetar Thread.Sleep(Timeout.Infinite);

}

static Thread WDTCounterReset; static void WDTCounterResetLoop()

{ while (true)

{ // Conador o tempo de reseet a cada 3 segundos Thread.Sleep(3000);

Watchdog.ResetCounter();}

}}

Está pensando talvez, se o software trava, como seria o código que manipula o watchdog ?Em baixo nível, o watchdog é suportada pelo hardware, não pelo software. Isso significa queo contador e o mecanismo de reset e é feito dentro do processador, sem necessidade dequalquer software.

Limitando tarefas críticas ao tempo

De volta ao nosso exemplo da máquina de venda automática, mas desta vez queremos lidar com um problema diferente. Como NETMF não é em tempo real, as tarefas podem levar

mais tempo do que o esperado. Se uma pessoa se aproximou da máquina e selecionou oque eles querem comprar, a máquina vai ligar um motor que, por sua vez irá expulsar o itempara o usuário. Digamos que isso foi programada de modo que o motor tem que estar ligadopor um segundo. Agora, o que se sucedeu que, ao mesmo tempo o motor está funcionandooutro segmento começou a usar o cartão SD. Vamos supor também que o cartão tinha algumproblema que causou três segundo atraso na leitura do cartão SD. O atraso de 3 segundos,enquanto o motor estiver funcionando irá resultar em três itens que estão sendo empurrados





para o comprador, mas nós só queriamos um item.

Se utilizado o watch dog e configurá-lo para um segundo, então o usuário terá um item equando o tempo é superior a um segundo, a máquina de vendas irá resetar, o qual vai parar o motor de mandar outros items para fora.

Aqui um simples exemplo:

// ....// ....// Timeout de segundouint timeout = 1000;

//....usuário compra alguma coisa

// Habilita Watch DogWatchdog.Enable(timeout);

//Liga moto//...//Desliga motor//...Watchdog.Disable();

// ....// Se programa começa aqui// ....// ....

Detectando o porque da atuação do Watch Dog

Em alguns casos, você precisa saber se o sistema resetou por causa do watch dog paralogar estas informação ou executar algum procedimento de recuperação. Aqui é comofunciona:

using System;using System.Threading;using Microsoft.SPOT;using GHIElectronics.NETMF.Hardware.LowLevel;


{ // você pode ler este flag ***UMA única VEZ*** quando alimentar if (Watchdog.LastResetCause == Watchdog.ResetCause.WatchdogReset)





{ Debug.Print("Watchdog did Reset");

} else

{

Debug.Print("Reset switch or system power");}

}}




Guia para iniciantes em C# e .NET Micro Wireless (Conexão sem Fio) Framework

31. Wireless (Conexão sem Fio)As conexões sem fio estão se tornando muito importante em nossas vidas. Alguns aplicaçõesrequerem altas velocidades de transferência, outros de consumo muito baixo. Algunsoferecem ponto-a-ponto, enquanto outros exigem uma rede mesh.O maior problema quando você cria um dispositivo sem fio é a certificação. Não só isso, deveser feito de maneira diferente em diferentes países, mas também é muito caro. Isto podecustar cerca de US$ 50.000 para uma certificação. Felizmente, algumas empresas oferecemmódulos certificados. Usando esses módulos, você não precisa de certificação.

31.1. Zigbee (802.15.4)Zigbee foi concebido para uso em sistemas de baixa potência.Vários sensores podem ser conectados a uma rede Zigbee. Eleconsome muito pouca corrente, no entando não é muito rápido.

Uma aplicação muito comum do Zigbee é são os módulos Xbeefornecida pela Digi. Existem vários tipos de módulos: de baixoconsumo e alta potência de transmissão para cobrir grandesdistâncias (20 km!). Estes módulos estão disponíveis comantenas internas ou externas.

A interface com esses módulos é uma UART simples.

Com UART, pode ser conectado com qualquer cartãoNETMF. Se você criar uma conexão entre dois módulos,é feito automaticamente. Se você deseja se conectar amúltiplos nodos, então você precisa enviar algunscomandos adicionais para configurar a rede. Eurecomendo que você comece com o conexão ponto aponto.

Conectando-se a Xbee ao FEZ Mini ou FEZ Domino podeser facílmente utilizando o componente de expansãoXbee





31.2. BluetoothQuase todos os telefones celulares têm como se conectar a dispositivos Bluetooth. A

tecnologia Bluetooth define vários perfis para conexões. O perfil de áudio é útil para conectar fones de ouvido. Profile (SPP Serial Port Profile) é útil para estabelecer uma comunicação,simulando uma conexão serial. É realmente muito parecido com a conexão Xbee. Enquantoa maioria dos telefones têm Bluetooth, muitos não suportam o perfil SPP e, portanto, aconexão serial com o seu laptop é provavelmente impossível.

No Windows, você pode criar uma conexão Bluetooth em alguns cliques:

1.No painel de controle, procure "Dispositivos Bluetooth"

2.Clique em "Configurações do Bluetooth"

3 Veja o tab “COM ports”

4.Se você tem COMs bluetooth instaladas então você já tem SPP habilitado no seu PC

5.Para adicionar novas portas, clique em "Add …"

6.Crie uma porta pra recebimento de dados e outra para envio de dados

Windows cria duas portas, uma entrada e uma saída. Isso pode confundir o usuário, porqueele não pode usar a mesma porta para enviar ou receber dados.





No lado de Hardware, existem muitos módulos seriaisBluetooth que já que incluem Hardware e software. Istopermite facilmente se conectar a uma porta serial dodispositivo NETMF.

A conexão do módulo Bluetooth na placa FEZ ou FEZ

Dominio pode facilmente ser realizada utilizando ocomponente de interface Bluetooth.





31.3. NordicNordic Semiconductor criou seus próprios chips digitais sem fio, nRF24L01. Estes chips debaixa potência, utilizam a banda de 2.4Ghz que é livre em muitos países. Os chips wirelessda Nordic permitem conexão ponto a ponto ou multipontos.

Olimex oferece placas com o nRF24L01. Essasplacas podem se conectar a maioria das placasNETMF da GHI electronics.

Este é um projeto (e vídeo) exibindo como conectar 2 dispositivos NETMF por meio do NRF24L01

http://www.microframeworkprojects.com/index.php?title=SimpleWireless









Guia para iniciantes em C# e .NET Micro Objetos em uma pilha customizada Framework

32. Objetos em uma pilha customizadaEsta seção aborda sobre alocações de memória grandes e não se aplica ao USBizi.

Sistemas gestores como o NETMF necessitam de um sistema complexo de administração dememória. Para reduzir a sobrecarga em sistemas pequenos, a pilha somente suportaalocação de objetos de até 700KBs. Não é possível usar objetos maiores. A partir do NETMF4.0, no entanto, grandes buffers podem ser atribuídos usando outra pilha, separada,chamada "Custom Heap”. Agora, você pode criar buffers ou imagens grandes. Internamente,esses objetos não estão na pilha padrão, mas no “Custom Heap”. Isso levanta umaimportante questão: quanto de memória é reservada para “Custom Heap” e quanto éreservado para a a pilha ?

GHI oferece uma API que permite que você ajuste o tamanho de cada pilha, “custom heap” e

do sistema.

using System;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;class Program{


// Seta o tamanho da pilha para 4MB

if (Configuration.Heap.SetCustomHeapSize(4 * 1024 * 1024)){ // Isto terá efeito após resetar o sistema PowerState.RebootDevice(false);

} // ...

// você pode agora usar objetos acima de 4MB}

}

32.1. Administrando a “Custom Heap”Ao contrário da pilha normal, que é totalmente gerenciado, a “Custom Heap” é gerenciada,mas há vários pontos a considerar com o uso dela. Para que objetos na pilha sejamapagados automaticamente, você deve preencher 3 requerimentos:

• A referência para o objeto deve ser perdida (isto é tudo que você necessita paraobjetos regulares)

• O coletor de lixo deve ser executado. Você provavelmente tem que forçá-lo





• O sistema deve estar em repouso que forma que finalize() a execução e “Dispose” oobjeto

Não vou detalhar o coletor de lixo, “dispose” ou “finalize”. A única coisa que você precisasaber é que os objetos grandes que estão na “custom heap” não são facilmente apagáveisdo sistema de modo que você sempre tem que “dispose” objeto quando tiver terminadode usá-lo.

Aqui está o comentário do “dispose” para objetos grandes.

using System;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;class Program{


// aloca um buffer de 1MB LargeBuffer lb = new LargeBuffer(1024 * 1024); // use o buffer

lb.Bytes[5] = 123; // .... // Quando pronto, libere (dispose) o objeto para esvaziar a memória

lb.Dispose();}

}

A melhor solução é usar a palavra-chave "using". Ela palavra-chave irá automaticamentechamar “dispose” uma vez a execução está deixando as chaves do “using”

using System;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;class Program{ public static void Main()

{

// aloca um buffer de 1MB using (LargeBuffer lb = new LargeBuffer(1024 * 1024)){

// use o bufferlb.Bytes[5] = 123;

// ... }

// Dispose foi chamado automaticamente





// ...}

}

32.2. Grandes bitmapsAs imagens maiores que 750KB/2 são automaticamente alocados na pilha do usuário(custom heap). Por exemplo, uma imagem de 800x480 vai exigir 800x480x4 bytes, 1.5 MBEsta imagem vai estar na “custom heap” e você tem que “dispose" (eliminar) ela no final dasua utilização ou utilizar a palavra-chave “using".

using System;using Microsoft.SPOT;using Microsoft.SPOT.Presentation.Media;

class Program{ public static void Main()

{ using(Bitmap largeBitmap = new Bitmap(800,480))

{ // assuma que temos um display de 800x480 // desenhe um circulo

largeBitmap.DrawEllipse(Colors.Green, 100, 100, 10, 10); // desenhe outras coisas // ...

largeBitmap.Flush();//flush o objeto Bitmap para o display}

// uma vez aqui, o Dispose para largeBitmap é chamado automaticamente // ...}

}

32.3. Buffers grandesNós já usamos LargeBuffer no exemplo mais recente. Só use se você realmente precisaalocar um buffer que seja maior que 750KB. Em sistemas embarcados, você pode nãonecessitar usar buffers grandes. Embora não seja recomendado, você pode usá-lo senecessário.

using System;using Microsoft.SPOT.Hardware;using GHIElectronics.NETMF.Hardware;class Program{ public static void Main()





{ // aloca 1 Mb de memória using (LargeBuffer lb = new LargeBuffer(1024 * 1024))

{ // use o buffer

lb.Bytes[5] = 123; byte b = lb.Bytes[5];

} // Dispose foi chamado automaticamente // ...

}}




Guia para iniciantes em C# e .NET Micro Pensando “pequeno” Framework

33. Pensando “pequeno”Muitos desenvolvedores NETMF vem do mundo do PC. Eles estão acostumados a escrever um código que funciona bem em um PC, mas este mesmo código não será executado deforma ótima para software embarcado. Um PC pode rodar em 4GHz e tem 4GB de memória.cartões NETMF têm menos de 1% dos recursos disponíveis em um PC. Vou falar sobrediferentes áreas onde você tem que pensar "pequeno".

33.1. Utilização da memóriaCom uma quantidade limitada de memória, você deve usar apenas o que você realmenteprecisa. Programadores PC tendem a criar buffers maiores para tratar até mesmo coisas

pequenas. Desenvolvedores "embedded" devem estudar suas necessidades e atribuir apenas a memória necessária. Se eu ler dados de um UART, eu posso muito bem usar umbuffer de 100 bytes para leitura e 1000 bytes de buffer tambem vai funcionar bem. Mas se euanalisar o meu código, eu percebi que na verdade eu só receberei 40 bytes no meu loop.Então, por que usar um buffer com de mais de 40 bytes?

Em alguns drivers, o NETMF faz uma série de bufferizações internamente. Por exemplo, osistema de arquivos, UART ou drivers USB têm buffers internos, prontos para seremutilizados no código gerenciado do usuário. Se temos de gerir um arquivo de 1 MB, ele criauma reserva menor e são enviados em várias partes. Para reproduzir um arquivo MP3 de5MB, um buffer único byte 100 lerá pequenos pedaços do arquivo para o decodificador MP3.

33.2. Alocação de ObjetosAlocação e liberação de objetos é muito caro. Somente faça alocação de objetos quandovocê realmente necessita deles. Não se esqueça que você está programando um sistemaembarcado e, portanto, os objetos que você esta utilizando sempre são utilizados. Por exemplo, você sempre irá sempre utilizar o LCD ou o SPI.

Tomemos por exemplo o código


using System;using Microsoft.SPOT.Hardware;using Microsoft.SPOT;


{





static void WriteRegister(byte register_num, byte value){

SPI _spi = new SPI(newSPI.Configuration(Cpu.Pin.GPIO_NONE,false,0,0,false, true,1000,SPI.SPI_module.SPI1)); byte[] buffer = new byte[2];

buffer[0] = register_num;buffer[1] = value;_spi.Write(buffer);


{WriteRegister(5, 100);

}}

}

Para escrever um byte em um chip SPI, eu tinha alocado um objeto SPI tenho atribuído umobjeto SPI.Configuration e um array de bytes. Três objetos para enviar um único byte! Isso épossível se você fazer algumas vezes no início do programa, mas se você chamar o métodoWriteRegister então isto não é um bom caminho. Para iniciantes, este método rodará muitolento então não poderá se utilizado continuamente para enviar dados MP3 para um decoder.E o pior, esta função será chamada centenas de vezes por segundo. Um segundo problemaé que esses objetos são criados, usados e abandonados para o coletor de lixo remove-los.O coletor de lixo vai ter que disparar e remover todos os objetos não usados da memória oqual fará a CPU parar por alguns milisegundos.

Aqui é uma versão modificada do código para testar o método quando chamado 1000 vezes.

using System.Threading;using System;using Microsoft.SPOT.Hardware;using Microsoft.SPOT;


{


SPI _spi = new SPI(newSPI.Configuration(Cpu.Pin.GPIO_NONE,false,0,0,false, true,1000,SPI.SPI_module.SPI1)); byte[] buffer = new byte[2];

buffer[0] = register_num;





buffer[1] = value;_spi.Write(buffer);_spi.Dispose();


{ long ms; long ticks = DateTime.Now.Ticks; for (int i = 0; i < 1000; i++)

WriteRegister(5, 100);ticks = DateTime.Now.Ticks - ticks;ms = ticks / TimeSpan.TicksPerMillisecond;

Debug.Print("Time = " + ms.ToString());}

}}

Ao executar este código no dispositivo FEZ (USBizi), notamos que o coletor de lixo foichamado 10 vezes. Ele exibe a sua atividade na janela de saída. O tempo necessário para aexecução completa do programa é de 1911ms, quase dois segundos! Agora modifique ocódigo conforme abaixo. Nós criamos o objeto SPI globalmente, e estará sempre disponível.Nós ainda estamos alocando o buffer em cada loop.



{ static SPI _spi = new SPI(new SPI.Configuration( Cpu.Pin.GPIO_NONE, false, 0, 0, false, true, 1000, SPI.SPI_module.SPI1));


byte[] buffer = new byte[2];buffer[0] = register_num;buffer[1] = value;_spi.Write(buffer);_spi.Dispose();


{ long ms; long ticks = DateTime.Now.Ticks;





for (int i = 0; i < 1000; i++)WriteRegister(5, 100);

ticks = DateTime.Now.Ticks - ticks;ms = ticks / TimeSpan.TicksPerMillisecond;


}}

Neste exemplo, o coletor de lixo tem sido disparado apenas duas vezes e o código durou 448milissegundos, menos de meio segundo. Nós apenas movemos uma única linha de código eagora é 4 vezes mais rápido!

Deixe nos mover o buffer globalmente e ver



{ static SPI _spi = new SPI(new SPI.Configuration( Cpu.Pin.GPIO_NONE, false, 0, 0, false,

true, 1000, SPI.SPI_module.SPI1)); static byte[] buffer = new byte[2]; static void WriteRegister(byte register_num, byte value)

{buffer[0] = register_num;buffer[1] = value;_spi.Write(buffer);_spi.Dispose();


{ long ms; long ticks = DateTime.Now.Ticks; for (int i = 0; i < 1000; i++)

WriteRegister(5, 100);ticks = DateTime.Now.Ticks - ticks;ms = ticks / TimeSpan.TicksPerMillisecond;


}}





Nós temos agora 368ms e o coletor de lixo nem sequer foi chamado!

Um teste rápido que você pode fazer no seu dispositivo é checar a saída para ver o quanto

frequênte o coletor de lixo é disparado. Nos sistemas como muita memória como ChipworkXnão vai ajudar muito, então você deve ainda verificar o seu código manualmente.




Guia para iniciantes em C# e .NET Micro Tópicos faltantes Framework

34. Tópicos faltantesAlguns temas não foram abordados neste livro. Aqui está uma pequena lista com um resumosobre a questão. Talvez eu adicione capítulos destes tópicos posteriormente.

34.1. WPFWindows Presentation Foundation é uma nova maneira flexível para criar aplicações cominterface gráfica. Embedded Master e ChipworkX pode usar WPF, mas não USBizi e FEZ.

34.2. DPWS

Device Profile for Web Services permite que os dispositivos sejam automaticamentedetectados e utilizados em uma rede. DPWS requer soquetes. NET para operar e, portanto,pode ser usado com Embedded Master ou ChipworkX.

34.3. Extended Weak Reference

Extensão Weak Reference (EWR) permite que os desenvolvedores possar salvar algunsdados na memória não-volátil. EWR foi utilizado principalmente antes da introdução dosistema de arquivos em NETMF

34.4. SerializaçãoSerialização é uma maneira de converter um objeto para uma série de bytes que representaum objeto. Um objeto Mike criado como tipo humano pode ser serializado em um array debyte e então estes dados transferidos para outro dispositivo. O outro dispositivo sabe o que éum tipo humano mas não sabe nada sobre Mike Ele vai então pegar este dado para construir um novo objeto baseado nele e vai ter uma cópia do objeto Mike.




Guia para iniciantes em C# e .NET Micro Tópicos faltantes Framework

34.5. Runtime Loadable ProceduresRuntime Loadable Procedures (PRP) é uma característica exclusiva que permite aosusuários GHI escrever código nativo C/Assembly e usá-lo por meio de código gerenciado(C#). O código nativo é centenas de vezes mais rápido, mas é menos fácil de admnistrar.Tarefas específicas, como cálculos de CRC tem uso intensivo de CPU, são particularmenteadequados para tais características. A aplicação é feita usando código gerenciado (C#) masapenas o método de cálculo do CRC é feito em código nativo (C/Assembly).Atualmente, ChipworkX e EMX são as únicas dispositiivos que dão apoio à RPL.

34.6. Banco de DadosUm banco de dados armazena os dados em um lugar onde é fácil e rápido para recuperar mais tarde.

Procurar por um item de produto é muito rápido porque tem internamente indexadores dobanco de dados.

Atualmente, ChipworkX e EMX são os únicos dispositivos do mundo que tem suporte abancos de dados usando o SQLite.

34.7. Touch Screen (Tela sensíveis aotoque)

NETMF suporta telas sensíveis ao toque. Estas telas são uma boa combinação com displayTFT. Um desenvolvedor pode criar uma aplicação gráfica com o WPF e o usuário podecontrolá-lo usando a tela sensível ao toque.

34.8. EventosSe você tem um programa que recebe dados de uma porta serial, você deve verificar continuamente essa porta. Pode não ter dados para receber, mas como saber disto sem ficar testando ?Isso seria mais conveniente se pudéssemos ser notificado de que tem dadosrecebidos. Esta notificação pode vir de um "evento" (Event), que ocorre quando o driver recebeu os dados.

O mesmo raciocínio se aplica para portas de interrupção já relatado antes. Este livro nãoabrange a criação de eventos, mas nós já vimos como eram utilizados nas portas deinterrupções e no mouse com suporte a USB host.






Guia para iniciantes em C# e .NET Micro Palavras finais Framework

35. Palavras finaisSe você achou este livro interessante e poupou-llhe tempo de pesquisa, então eu realizei oque eu tinha em mente. Eu te agredeço muito por baixar este livro e lê-lo.

35.1. Leituras complementaresEste livro cobriu as base do C# e .NET Micro Framework. Aqui temos uma lista de algunsrecursos para aprender mais:

• Meu blog é sempre um bom lugar para visitar.

http://tinyclr.blogspot.com/

•

O site de projetos do Micro Framework Project é um ótimo recursohttp://www.microframeworkprojects.com/

• Um bom e livro grátis para continuar aprendendo sobre C# está disponível emhttp://www.programmersheaven.com/2/CSharpBook

• Excelente livro de sobre .NET Micro Framework de Jens Kuhner http://www.apress.com/book/view/9781430223870

• USB complete é um excelente livro sobre USBhttp://www.lvr.com/usbc.htm

• Wikipedia é meu lugar favorito para por informação para todo mundohttp://en.wikipedia.org/wiki/.NET_Micro_Framework

• Website da Microsoft sobre .NET Micro Frameworkhttp://www.microsoft.com/netmf

35.2. NotasEste livro é grátis somente se você fizer o download direto da GHI Electtronics. Use para seupróprio conhecimento e é seu risco. Nem o escritor ou GHI electronics é responsável for algum dano ou perda causado por este livro ou pela informação suprida por ele. Não hágarantia que qualquer informação neste livro é válida.

USBizi, Embedded Master, EMX, ChipworkX, RLP and FEZ são marcas da GHI Electronics,LLC

Visual Studio and .NET Micro Framework são marcas registradas da Microsoft corporation.



http://www.microframeworkprojects.com/



http://www.apress.com/book/view/9781430223870

http://www.lvr.com/usbc.htm

http://en.wikipedia.org/wiki/.NET_Micro_Framework

http://www.microsoft.com/netmf




http://www.apress.com/book/view/9781430223870

http://www.lvr.com/usbc.htm

http://en.wikipedia.org/wiki/.NET_Micro_Framework

http://www.microsoft.com/netmf



Guia para iniciantes em C# e .NET Micro Palavras finais Framework

35.3. Placa Brasileira (BABUINO)Miguel Alexandre Wisintainer desenvolveu uma placa baseada no USBizi. Quem tiver interesse em comprá-la no Brasil, entre em contato com ele pelo [email protected]

mailto:[email protected]

mailto:[email protected]