sábado, 28 de julho de 2012

Utilizando o PWM no Netduino


Agora que eu tranquei o mestrado to tento alguns meses para escrever mais no blog e utilizar a placa do Netduino direito e uma das coisas que me deixaram bem feliz foi a permanência de PWM em hardware que, a pesar do Netduino não conseguir temporizar em microsegundos, o PWM do hardware vai nesse nível, o que é bem interessante dependendo da aplicação.

O PWM (Pulse-Width Modulation) que siginifica em português modulação por largura de pulso (MLP) trata-se de um sinal modulado em função de sua razão cíclica (duty cycle) para transportar qualquer informação sobre um canal de comunicação ou controlar o valor da alimentação entregue a carga.
Do site http://aquaticus.info

É comum encontrar comunicação entre dispositivos feita por PWM. Nestes casos a largura dos pulsos corresponde a valores de dados específicos codificados a um fim e decodificou ao outro.  Pulsos de largura variadas será enviada em intervalos regulares, isso acontece especialmente quando o sinal é analógico como um sinal de um controlador.

Outra aplicação muito comum - e uma das minhas preferidas -  é a construção de ondas senoidais para  transferência de potência entregue a uma carga, ou seja, conversores estáticos senoidais. Em um sistema controlado a disparo o pulso PWM atua sobre chaves de estado sólido (normalmente IGBT, MOSFET, GTO, transistor bipolar) tendo como efeito final o controle do fluxo de corrente dentro dos estados de corte e condução da chave. Com uma frequência elevada, filtros passivos RLC são podem ser utilizados para suavizar o trem de pulsos das chaves e prover o aspecto final - processo de integração passiva do sinal de potência. Esse método é normalmente empregado no controle de velocidade de motores de corrente contínua, e esse é uma aplicação que pretendo demonstrar controlado um carrinho autônomo.

Outras aplicações mais modestas como dimmers de luz comuns também podem ser feitos utilizando essa técnica onde a modulação é feita sobre a própria corrente alternada (CA) através dos convencionais TRAIC's . Um simples ajuste na quantidade de luminosidade pode ser implementado estabelecendo-se a que tensão do ciclo CA o dimmer começa a conduzir a eletricidade à lâmpada, claro que isso está ficando mais raro porque as lâmpadas fluorecentes, que hoje dominam o mercado, não aceitam bem esse tipo de técnica de dimerização. Como o ciclo ativo da modulação é o mesmo que a frequência de 60Hz (no Brasil), o olho humano percebe apenas a intensidade média.

Agora vamos ao código n

o Netduino. Diferente de um microcontrolador convencional onde dezenas de registros devem ser configurados ao estilo Indiana Jones o Netduino isso pode ser feito com apenas 2 linhas de comando, criando o objeto e depois setando o PWM.


__________________________________________________________________________________
using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

namespace MotorControl_01
{
    public class Program
    {

        public const UInt32  PWMSTEP  = 200 ;

        public static void Main()
        {
            // As portas PWM disponíves são os pinos digitas
            PWM motor1 = new PWM(Pins.GPIO_PIN_D5);
            //PWM motor1 = new PWM(Pins.GPIO_PIN_D6);
            //PWM motor1 = new PWM(Pins.GPIO_PIN_D9);
            //PWM motor1 = new PWM(Pins.GPIO_PIN_D10);

            //Fazendo uma Inicialização da placa (para saber se está funcionando ok!)
            OutputPort board_led = new OutputPort(Pins.ONBOARD_LED, false);

            for (uint j = 0; j < 10; j++)
            {
                //Pisca o Led da placa para dar um sinal
                //que está vivo!
                board_led.Write(!board_led.Read());
                Thread.Sleep(200);
             }


            //Fazendo o PWM aumentar e diminuir em
            //Zig-e-zag
            while (true)
            {
                uint i = 0;
                for (i = 0; i < PWMSTEP; i++)
                {
                    //a função: SetPulse( tempo_pulso [us], tempo_ativo [us])
                    motor1.SetPulse(2000, i * 10);
                    //Espera 50 [ms]
                    Thread.Sleep(50);
                }

                for (i = 0; i < PWMSTEP; i++)
                {
                    motor1.SetPulse(2000, (PWMSTEP - i) * 10);
                    Thread.Sleep(50);
                }
            }
           
        }

    }
}
__________________________________________________________________________________
Tive duas dificuldade porque não estava encontrado informação e documentação como sempre... A primeira foi descobrir qual a unidade dos tempos que devem ser colocados no SetPulse(period ,duration) porque não diz em lugar nenhum - mas como sempre alguém já teve o mesmo problema - não foi difícil descobrir no fórum do Netduino. As duas unidades estão em microssegundos.


A segunda dificuldade que eu tive foi em descobrir porque eu não podia setar o pino D0 como PWM. a partir daí eu comecei a investigar pelo datasheet do AT91SMA7X512, mas o que salvou mesmo foi o esquemático. Observe que os pinos I/O/PWM são apenas os pinos D5, D6, D9 e D10.



Tratei de fazer um vídeo (house made) mostrando como foi que funcionou.




O circuito que eu fiz para ligar a lâmpada foi bem simples: um transistor que tinha aqui NPN com 10k na base e um resistor de 10k no coletor com um N-MOSFET em cascata com o gate ligado no coletor do transistor. A lâmpada foi uma lampada simples de carro mesmo.


Espero que o post tenha ajudado - se quiser o código pode fazer download do projeto aqui!

sexta-feira, 27 de julho de 2012

Atualização do Netduino Plus (Completo)


Como tinha sido discutido em uns post's anteriores a respeito da atualização do Firmware do Netduino Plus, ficou um pouco obscuro essa parte então tratei de fazerum post mais completo sobre isso. Na época havia mencionado as vantagens de se atualizar mesmo sendo uma versão RC (RELEASE CANDIDATE), por isso não entrarei nesses detalhes mas sim no processo em si.

Etapa 1 - Instalação do Novo Firmware na Flesh ( Flashing new firmware )
  1. Baixe o SAM-BA 2.11 da Atmel através do link. Instale o programa no computador;
  2. Ligue o Netduino (Alimentação externa ou USB) e com um fio  faça um jumper entre o pino 3,3V e um pequeno leed dourado perto do pino I/O 0 (Veja a figura!)
  3. leed para efetuar o reset da placa


           
    3.  Desconecte o Netduino do PC (Se você estava alimentando-o pelo PC) e reconecte outra vez. Nesse momento, se é a primeira vez que você está fazendo esse procedimento um driver será solicitado. Geralmente o Windows 7 têm o driver, mas como geralmente não é sempre, segue o link do driver para instalação manual (até porque todas as vezes eu tive que fazer isso).

    3.1. Com o driver já descompactado, clique com o botão direito no "Meu Computador" e selecione "Propriedades" e aparecerá a seguinte tela:
    3.3 Abra o "Gerenciamento de Dispositivos"  ou  "Device Manager"
   3.4 Se o driver não foi instalado corretamente algum dispositivo desconhecido deve estar em destaque no painel. Clique com o botão direito e selecione a primeira opção "Atualizar Driver"
   3.5 Escolha o caminho onde você salvou o driver e clique em avançar.

    3.6 Se tudo ocorreu de maneira esperada, ao final você terá um novo dispositivo em Portas (COM e LPT) com o nome de "GPS Camera Detect (COMx)" - Guarde o valor da porta na memória, você vai usar isso no passo 4.




   4.  Com o driver já instalado basta saber o numero da porta COM que o dispositivo ficou listado. Agora abra o SAM-BA - executando como Administrador - e configure para a porta COM que a placa subiu no seu computador, no meu caso é COM6 e o dispositivo da sua placa "at91sam7x512-ek"
   4.1 Depois clique em "Conectar".
5. Se tudo deu certo então você está no caminho certo! Agora na tela que abriu, vá na caixa "script" e selecione primeiramente "Boot from Flash (GPNVM2)" e clique em "Execute". Uma mensagem do tipo deve aparecer na caixa de logo abaixo:
-I- GPNVM2 set
(sam-ba_2.11) 1 % 


   6. Agora, ainda na caixa "script" e selecione "Enable Flash access" e clique em "Execute".

  7. Estamos chegando lá! Agora precisamos instalar o driver para o AT91SAM7X entender-se como Netduino e aceitar subir o .NET MF. O arquivo binário é o "TinyBooterDecompressor.bin" que encontra-se junto aos arquivos de Firmware disponibilizados pelo Chris Walker. Faça o download em função da sua placa: Netduino ou Netduino Plus ou ainda veja a páquina com todos os Firmwares disponíveis.
      Baixando a versão certa para sua placa, decompacte  o arquivo e selecione o arquivo "TinyBooterDecompressor.bin" em "Send File Name" como mostra na figura.

   8. Aparecerá uma mensagem igual a da figura baixo, clique em "No". Feito isso tudo está pronto nessa primeira fase! e você pode fechar o SAM-BA e desconectar o Netduino do PC.


  9.  Torne a conectar o Netduino no PC. Indo no Gerenciador de dispositivos você poderá encontrá-lo entre os "Controladores USB"

  10. Essas etapas vamos colocar para dentro a camada do .NET MF. Então, vamos abrir o famos MFDeploy indo em:  Menu Iniciar >Microsoft .NET Micro Framework 4.2>Tools. Um diretório será aberto chamado "Tools". Nesse diretório selecione "MFDeploy" - Como Adiministrador!



  11. Agora configure o "Device" para "USB", no campo do lado direito aparecerá escrito automaticamente "NetduinoPlus_NetduinoPlus" (ou "Netduino_Netduino" depende da placa). Agora clique em "Ping". Se na caixa inferior aparecer 

Pinging... TinyBooter
Bootloader build info: Netduino Plus (v4.2.0.0 RC5) by Secret Labs LLC
É sinal que está tudo certo até aqui.




12. Agora vá em image file e selecione os dois arquivos que estão no *.zip que você baixou em algumas etapas atrás com o Firmware do Netduino. Os nomes dos arquivos são: "ER_FLASH.hex" e "ER_CONFIG.hex". Feito isso clique em "Deploy". O processo pode demorar um pouco dependendo do computador.
13. Pronto! Seu Netduino já está atualizado. Agora reconecte a placa no PC e você já pode executar os seus testes!

domingo, 22 de julho de 2012

NeonMika.Webserver: páginas de internet no Netduino+

Uma das coisas que mais atraem no Netduindo+ é a porta de Ethernet na própria placa. Isso porque certamente todos vocês leitores do blog tem interesse em fazer algum projeto que se conecte a internet, eu em especial, tenho vários projetos e interesses com isso, mas antes de tudo tenho que começar a realizar testes.

Pesquisando no fórum do Netduino achei um tópico do Markus  VV. que falava sobre o NeonMika, um projeto a parte para aplicações envolvendo internet, nesse post pretendo realizar uma não breve explanação do que está disponível na página do projeto NeonMika.Webserver.

Eu fiz aqui no blog meio que uma tradução comentada do que está em algumas páginas do projeto.

Introdução:
 O NeonMika.Webserver trata de uma plataforma fácil de configurar e fácil de estender que através de um código otimizado com o mínimo necessário pretende atingir grandes resultados controlar e acessar o Netduino+.

Desenvolvido utilizando a tecnologia .NET MF, consegue se adaptar para qualquer dispositivo que já esteja rodando o .NET MF, assim pode funcionar bem até mesmo para o Netduino Go e a Fez Panda.

Entre as grandes vantagens apontadas para utilizá-lo são:
  • Respostas a requisições por XML. Basta criar uma instância do XML e atribuir uma URI para ouvir e preencher um Hashtable com as teclas de resposta e de valores; 
  • Funciona diretamente como um túnel entre uma requisição feita pela prota de internet e uma página HTML hospedade no sistema de arquivos do cartão SD. Além disso, segundo a página do projeto, o NeonMika permite ainda funcionar como uma espécie de "ftp" deixando colocar no cartão microSD arquivos diversos. 
  • Resposta a requisições personalizadas, o projeto visa permitir ainda ciar respostas personalizadas para a troca de informações com outros dispositivos em algum protocolo louco que você deseje criar.
O objetivo é simplificar para tornar "utilizável". Para quem vem do limbo que nem eu, e está acostumado com  os complexos códigos de TCP/IP da MICROCHIP em C com máquinas de estado infinitas etc e tal... isso é bastante interessante porque reduz muito o trabalho, especialmente quando pretende-se construir aplicativos mais comerciais (universal/confiável).

Estrutura:

O esquema da figura mostra como funciona o NeonMika. Os métodos do projeto manipulam tudo exceto a "ação" que trata efetivamente do que se deseja realizar e depende da aplicação em atividade.

Funcionamento do NeonMika.Webserver
Dessa forma a passagem das informações para sua camada de código denominada no esquema como camada de ação pode ser feita de três maneiras distintas:
  1. Respostas por XML;
  2. Respostas Complexas; e
  3. Respostas por arquivo. 

De modo mais específico a versão atual do NeonMika permite algumas coisas interessantes:
  1. Processamento de arquivos - envio e recebimento de arquivos colocados no cartão SD;
  2. Echo (xml) - Pode enviar informações do tipo variável = valor por xml ex.:ipnetduino/echo?value=toEcho;
  3. SwitchPin (xml) - mudar o estado da IO - ex.:ipnetduino/switchPin?pin=0-13
  4. SetPin (xml) - setar o estado da IO - ex.:ipnetduino/setPin?pin=0-13&value=true
  5. IndexPage (complex) -manipulação de páginas de html escritas em código. - ex.:ipnetduino/
A ideia do funcionamento sem cartão, segundo o autor é permitir a manipulação do Netduino+ via o navegador de Internet, o que é bem legal e útil mas limita muito o projeto,  lembre-se que um dos problemas do Netduino+ é a quantidade de memória disponível para aplicações porque dos 512Kb uma boa parte é ocupada pelo .NET MF e agora pelo NeonMika.

Outra vantagem útil é que o NeonMika permite que você deixe-o funcionando de modo independente sendo um túnel de código entre uma requisição feita pela rede a arquivos HTML devidamente dispostos no cartão microSD

O codeplex é bem organizado tem a documentação do código escrita em na parte de Documentação, não é muita coisa, mas ajuda um pouco. Como eu estou começando também nisso de servidor web com o Netduino+ to tendo que estudar tudo que está disponível.

Se você baixar o arquivo mais atual do NeonMika você vai ver disponível três pastas: Executeable, Framework  e Pictures.

Na pasta Framework está disponível o código básico para um novo projeto baseado em NeonMika.Webserver. Confira esta pasta se você quiser uma versão "virgem" do NeonMika.Webserver.

Na outra pasta, Executeable, tem contem pequenos projetos criados pelo próprio Markus que são baseados no NeonMika.Webserver, ou seja, é a referência do que funciona com o NeonMika.Webserver.


Então, finalmente vamos ao primeiro teste com  programa do Markus!  Seguindo os passos dados pelo mestre:
  1. Baixar o NeonMika.Webserver e abrir o projeto contido em "Executeable\NeonMikaWebserver" 
  2. Debugar o projeto no Netduino; Como ele entra no DHCP teoricamente funciona, para mim ficou na teoria mesmo porque não entendi nada.
  3. Fique atendo no Output do Debug que ele vai dizer o IP que o dispositivo subui, no meu foi http://192.168.1.153/
  4. Joga o valor no navegador que você verá uma página como da figura.

Tela do teste do NeonMika
 Pronto. Agora já fiz um webserver com o Netduino+. só falta todo o resto que vou deixar para um próximo post, especialmente porque não ficou todo colorido como mostra no site do Markus,
 



sexta-feira, 20 de julho de 2012

Aplicações Comerciais com Netduino

Essa semana tive a surpresa de receber no escritório da empresa uma cópia da Revista da FAPERJ (Fundação de Amparo à Pesquisa do Estado do Rio de Janeiro) desde mês ( Rio Pesquisa - Ano 5 - nº 19 - junho de 2012) onde foi publicado um artigo sobre medição de Luz e Água.

O artigo fala sobre um dos projetos desenvolvidos por mim na empresa onde trabalho, a ENELTEC. O projeto de um sistema de medição descentralizada de água e energia elétrica que financiado pela FAPERJ através do edital Prioridade Rio tem se mostrado com um grande potencial inovador por tratar de um tema tão em voga no Brasil e no Mundo que são os selos de eficiência energética.

Não é para menos, mais de 1000 prédios em todo o mundo estão em fase de  homologação para receber alguma categoria de selo verde e para isso todos estão investindo em sistemas de medição de energia.

A ideia do projeto surgiu de um serviço que a ENELTEC vem fazendo para a Petrobrás de retrofit de algumas poucas instalações comerciais para certificação verde - A ENELTEC ficou a cargo de realizar dois serviços: primeiro de levantamento individualizado do consumo e o segundo de reprojeto das instalações para aumentar a eficiência. Nos dois serviços a parte de medição se aplica.

A fase de levantamento encontramos muitas dificuldades ao buscar medidores de vazão de água e medidores de energia simples que pudessem ser facilmente instalados e removidos - por um preço aceitável naturalmente - mais ainda no Brasil.

Quando aos medidores de energia a serem instalados durante o retrofit  as opções ficaram ainda menores. Digo isso porque procuramos dezenas de soluções para apresentar como medição mas nenhuma se encaixava no perfil que desejávamos: um sistema de medição integrado por internet, com instalação dentro das normas de segurança apresentada pela Petrobrás e que pudesse ser gerenciado pela própria equipe de manutenção da Petrobrás que não possui atribuições de manipulação de bancos de dados. As soluções disponíveis no mercado internacional, devido as padrões brasileiros de tomadas e painéis, se tornam incompatíveis por conexão além de nos deixar vítimas dos serviços de suporte em inglês e plataformas em euro e libras. As soluções nacionais, prefiro nem entrar nesse mérito, só o preço da instalação inviabiliza qualquer tipo de solução nacional.

Com isso, a solução foi desenvolver uma solução "house made" ao  melhor estilo de engenheiro e desenvolver uma solução própria de medição. No inicio tínhamos muitas dívidas, preteia fazer toda a solução com o PIC's, a final, tratava-se de uma solução simples e que a microchip fornecia todo o aporte para fazê-lo desde a medição propriamente dita até as camadas mais altas do protocolo IEEE 802.11, mas as dificuldades surgiram.

As soluções da MICROCHIP são excelentes em nível de hardware  para a medição e também para controle, é o que eu acho, mas o problema mesmo é quando as camadas começam a subir e foi nesse ponto que surgiram as primeiras dificuldades na questão do armazenamento. Os códigos exemplo eram simplificados, evidentemente, e as implementações dos protocolos TCP/IP e IEEE 802.11 eram desenvolvidos na forma de uma máquina de estados infinita que não só deixava o intervalo entre as medições complicado de ser estipulado e mais ainda a introdução de uma interrupção de tempo desmontava a pilha e criava problemas.

 O que foi decisivo para procurar uma nova solução foi mesmo o problema da página de html. A solução exemplo não tratava de modificar as configurações do TCP/IP por uma página hospedada no próprio chip, a falta de memória interna para hospedagem de uma página simples e a solução apresenta pela microchip seria colocar uma memoria SPI de míseros 256kb, lamentável, ou colocava a página ou armazenava as medições.

Partir para uma nova solução era necessário, assim tratei de perguntar ao meu estagiário o que fazer. Cairo me deu várias soluções entre as quais o Netduino, uma placa pequena muito mais potente que o Arduíno convencional e com um slot microSD embutido e uma porta de Ethernet e com exemplos de código para uma shield wifi.

Compramos os primeiros módulos de Netduino em Setembro de 2011. Fizemos alguns testes e as dificuldades apareceram - depois do simples piscar do led - a final nada é perfeito mas desde então estamos desenvolvendo uma solução de medição utilizando o Nteduino Plus como plataforma para armazenamento integrado a comunicação de conectividade e tem dado certo.

A expectativa é que tenhamos um medidor funcionado em Setembro desse ano ainda, para isso ainda teremos que escovar alguns bits e realizar mais testes para deixar a solução mais confiável.

domingo, 8 de julho de 2012

Escrevedo no Cartão SD - Parte 3

Como Rubens mencionou no comentário , não publiquei nenhum código para transformar o arquivo de texto em uma planilha do excel ou em gráfico. Então, nesse final de semana tratei de fazer algo que nos fosse próximo ao que ele solicitou e que pudesse exportar os gráficos para Excel e também construir um gráfico.


De maneira conveniente, o gráfico seria simples com dois step's apenas (Verdadeiro ou Falso), por isso, mudei o código um pouco tratando de conectar o LDR na porta analógica. O LDR é analógico por natureza e pouco linear por isso pode-se estimar o nível de iluminamento utilizando o simples LDR conectado na porta analógica. Atendo-se ao objetivo do software não me preocupei muito em realizar a interpolação matemática dos pontos pelo software - que deixo para outro post mais oportuno - e sim  conversão dos dados para excel.

Para apresentar os dados usei uma estrutura muito conhecida dos programadores em .NET, o DataSet. Proveniente do ADO.NET o DataSet é uma estrutura de conexão com banco de dado, através do DataSet você pode "importar" um banco de dados para local e manipulá-lo sem necessitar de grandes códigos. Além disso, o que me agrada bastante, é a possibilidade de salvar o arquivo em um *.xml através de um único comando e depois carregá-lo em outro software na mesma estrutura de tabelas. Realmente o que eu uso  código não o DataSet em si, mas sim o DataTable - uma tabela do DataSet - com essa tabela basta associar como fonte da estrutura DataGridView que já se organiza na tela permitindo a visualização dos dados, como foi feito no software.

Além da tabela, fiz no programa uma maneira de implementar de forma gráfica, o que trata de algo bem interessante visto que um gráfico torna o resultado mais palpável e evidente. Para implementação usei a maneira mais simples que encontrei na internet - através do Chart do.NET - que funciona de maneira bem similar a forma utilizada para apresentar os dados na tela do programa. Cria-se uma área gráfica (ChartAreas) atribui a ela uma série de dados (uma série porque só salvamos um dado) e associa a área gráfica delimitada no programa.

Este é o código para apresentar a tabela de valores e o gráfico na tela. Para baixar projeto do Visual Studio clique aqui.


'Abre o arquivo
Dim objReader As StreamReader = New StreamReader(openFileDialog.FileName)
Dim strContents As String = objReader.ReadToEnd()
objReader.Close()


'Cria o gráfico e o eixo onde será colocado os dados
Chart1.ChartAreas(0).Name = "Gráfico"
Chart1.Series.Add("Lux")
Chart1.Series("Lux").ChartType = SeriesChartType.Line
Chart1.Series("Lux").ChartArea = "Gráfico"

'Cria uma tabela de dados para apresentar no DataGridView
myTable = New Data.DataTable
myTable.TableName = "Data"

'Associa a tabela "Data" a coluna de tempo
Dim timeColum As New DataColumn()
timeColum.ColumnName = "Tempo"
timeColum.Namespace = "Tempo"
If Not myTable.Columns.Contains(timeColum.Namespace) Then
    myTable.Columns.Add(timeColum)
End If

'Associa também a tabela "Data" a coluna de dados
Dim valueColum As New DataColumn()
valueColum.Namespace = "Valor"
valueColum.ColumnName = "Valor"
If Not myTable.Columns.Contains(valueColum.Namespace) Then
    myTable.Columns.Add(valueColum)
End If

'Desmonata o arquivo de texto em linhas
Dim arrayContents As String() = strContents.Split(vbLf)

'Para cada Linha processa os dados
For i As Integer = 0 To arrayContents.Length - 2

    'Se a linha é valida, ou seja, tem pelo menos os caracteres da data correta
    ' os 18 primeiros caracteres ex.: 06/17/2012 14:08:10
    If arrayContents(i).Length = 23 Then

        'Cria uma nova linha tipada da tabela
        Dim newRow As DataRow = myTable.NewRow

        'Separa a data de um lado e o dado na outra coluna
        newRow.Item(0) = arrayContents(i).Substring(1, 18)
        newRow.Item(1) = arrayContents(i).Split(vbTab)(1)

        'Adiciona a tabela
        myTable.Rows.Add(newRow)

        'Adiciona o dado ao gráfico convertendo-o para double
        Chart1.Series("Lux").Points.AddXY(arrayContents(i).Substring(1, 18), _
CType(arrayContents(i).Split(vbTab)(1), Double))

    End If
Next

DataGridView1.DataSource = myTable

 Como o Rubens pediu eu construí também uma parte para converter o arquivo para excel usando uma dll do excel mesmo - isso implica que terá que ter o excel instalado para que o programa funcione (presumo eu, não fiz nenhum teste)  no mesmo projeto (Projeto).


  ' various variables
Dim row As Integer
Dim col As Integer
Dim rowCount As Integer
Dim colCount As Integer
Dim cell As String
Dim rowcell As Integer

' Excel Variables
Dim excelApp As New Excel.Application
Dim excelBook As Excel.Workbook = excelApp.Workbooks.Add
Dim excelWorksheet As Excel.Worksheet = _
    CType(excelBook.Worksheets(1), Excel.Worksheet)

' get count of rows and count of columns
rowCount = myTable.Rows.Count()
colCount = myTable.Columns.Count()

' add the column headings
For col = 0 To colCount - 1
    row = 1
    cell = GetExcelColumn(col) & row.ToString
    excelWorksheet.Range(cell).Value = "Data"
    'excelWorksheet.Range(cell).ColumnWidth = "Valor"
Next

' now add the data elements
For row = 0 To rowCount - 1
    rowcell = row + 2
    For col = 0 To colCount - 1
cell = GetExcelColumn(col) & rowcell.ToString
excelWorksheet.Range(cell).Value = myTable.Rows(row).Item(col).ToString
    Next
Next
' turn off wait cursor
Me.Cursor = Cursors.Default

' view the spread sheet
excelApp.Visible = True

excelBook.SaveAs(myStream.ToString(), _
 Excel.XlFileFormat.xlXMLSpreadsheet, _
 AccessMode:=Excel.XlSaveAsAccessMode.xlNoChange)

Para o código funcionar deve-se adicionar o Microsoft.Office.Interop.Excel do .NET. Oc comentários estão em inglês porque encontrei esse código na internet e fiz alguns pequenos ajuste, se desejar encontrar a origem coloque no google algum trecho, realmente esqueci de onde veio o código...

Para salvar pela interface digite o nome do arquivo com extensão xls, por exemplo: teste.xls.

Acredito que o post tenha sido bem útil e tenha ajudado bastante, para finalizar, deixo os link para fazer download dos dois projetos do VS2010, do programa do Netduino Plus e do Código para interpretar os dados do cartão.