Go com Intel Edison Lendo valor analógico

Como ler valores analógicos com Intel Edison

Este é mais um post da serie falando sobre Go com Intel Edison, e estou usando bastante do que já falei em outros posts como tratamento de sinais por exemplo.

Para gerar o sinal analógico vamos usar um potenciômetro, ou melhor RAS, Rotary Angle Sensor :D. O estilo do código é muito parecido com o que fizemos para gerar sinais PWM, mas agora a operação é de leitura.

Lendo valores analógicos com MRAA.

A biblioteca MRAA resolve bem a leitura de dados analógicos, entretanto dependendo do que estivermos lendo é conveniente usar a UPM simplesmente porque ela já tem algumas funções prontas para conversão que já estão bem testadas.

O arquivo ras.h vai conter as declarações das funções que serão exportadas para o código Go.

#ifndef __RAS_H__
#define __RAS_H__

void config(void);
float readRAS(void);
void removeRAS(void);

#endif

O arquivo ras.c contem as funções que fazer o wrapper para esconder as funções da MRAA.

Um truque que poderíamos usar aqui é na função readRAS ler várias vezes a porta analógica acumulando os valores e depois tirar a média. Isso é uma pratica comum para “estabilizar” a leitura porque sinais analógicos tendem a flutuar. Se estivéssemos usando um microcontrolador que só tem uma tarefa eu certamente eu faria isso mas como estamos usando um SBC (Single Board Computer) com Linux embarcado eu achei melhor ler apenas uma vez.

#include <mraa.h>

#define RAS_PIN       0        // Terminal do potenciometro A0

mraa_aio_context      rasPin;  // guarda o contexto do potenciometro

void config(void) {
    mraa_init();
    rasPin = mraa_aio_init(RAS_PIN);
}

float readRAS(void) {
    return mraa_aio_read(rasPin);
}

void removeRAS(void) {
    mraa_aio_close(rasPin);
}

O arquivo ras.go consome o wrapper em C e faz as outras tarefas com tratar os sinais do SO e converter o valor lido em ângulos para exibir na tela.

package main

/*
#cgo LDFLAGS: -lmraa ras.a
#include "ras.h"
*/
import "C"
import (
	"fmt"
	"os"
	"os/signal"
	"time"
)

func main() {
	const maxAngle = float32(180.0)
	rasValue := float32(0.0)

	keeprunning := true

	go func() {
		sc := make(chan os.Signal, 1)
		signal.Notify(sc, os.Interrupt)
		// espera pelo sinal
		<-sc
		keeprunning = false
	}()

	C.config()

	for keeprunning {
		rasValue = float32(C.readRAS())
		fmt.Printf("Valor: %f angulo: %f\r\n",
			rasValue,
			rasValue*maxAngle/1023.0)

		time.Sleep(50000 * time.Microsecond)
	}

	C.removeRAS()

}

Makefile

Finalmente temos o Makefile que compilar os arquivos na ordem correta gerando um biblioteca “ras.a” para ser consumida no programa em Go e finalmente compilar ras.go.

all:
	gcc -c -Wall -O2 -lmraa ras.c
	ar rvs ras.a ras.o
	go build ras.go

clean:
	rm -f ras.o ras.a pwm

Tudo isso claro compilando direto no Intel Edison bastando executar o comando make.

make

E para executar é só conectar o potenciômetro que vem no Gove Kit na porta A0 e rodar o comando ./ras, e claro que pode ser qualquer potenciômetro, não precisa ser o do Gove Kit :D

./ras
comments powered by Disqus