Desenvolvendo Aplicações Analógicas Para Dragonboard 410c Com Linker Sprite Mezzanine

Essa publicação tem como objetivo mostrar os passos necessários para desenvolver aplicações analógicas usando Dragonboard 410c e Linker Sprite Mezzanine.

Step 1: Pré Requisitos:

Os pré requisitos são:

Plataforma de desenvolvimento (Target):

Step 2: Como Funciona a Comunicação Analógica Entre Dragonboard 410c E Linker Sprite Mezzanine

O Linker Sprite Mezzanine tem um chip ADC integrado para que módulos analógicos possam ser usados através da Dragonboard 410c.

O chip ADC usado é o MCP3004 e comunica com a Dragonboard 410c através da interface SPI.

Step 3: Habilitando Interface SPI Na Dragonboard 410c

Você pode gerar um novo boot image para Dragonboard 410c com SPI habilitado, ou usar esse boot image já compilado e com SPI habilitado.

Como fleshar o boot image na Dragonboard 410c?

Após obter o boot image com SPI habilitado, o próximo passo é fleshar esse boot image na Dragonboard 410c.

Step 4: Biblioteca Libsoc

libsoc é a biblioteca que vamos usar para desenvolver aplicações analógicas na Dragonboard 410c com Linker Sprite Mezzanine.

As dependências da biblioteca libsoc são:

build-essential
autoconf
automake
libtool-bin
pkg-config
python-dev

sudo apt-get install build-essential autoconf automake libtool-bin pkg-config python-dev

Pronto! Feito isso, temos o ambiente preparado para instalar a biblioteca libsoc.

Step 5: Instalando Libsoc Na Dragonboard 410c

Seguem as etapas para instalar a biblioteca libsoc:

wget -c https://github.com/jackmitch/libsoc/archive/0.8.2.zip
unzip 0.8.2.zip
cd libsoc-0.8.2
autoreconf -i
./configure --enable-python=2 --enable-board=dragonboard410c --with-board-configs
make
sudo make install
sudo ldconfig /usr/local/lib
sudo reboot

Step 6: Exemplo: Sliding Rheostat

Considerando que o módulo Sliding Rheostat esteja plugado na porta ADC1 do Linker Sprite Mezzanine, siga os próximos passos para executar o código.

Código:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <linux/spi/spidev.h>
#include <linux/types.h>
#include <inttypes.h>
 
#include "libsoc_spi.h"
#include "libsoc_gpio.h"
#include "libsoc_debug.h"
 
#define GPIO_CS 18
 
static uint8_t tx[3],rx[3];
 
int main() {
    int adc_value;
    gpio *gpio_cs;
    libsoc_set_debug(0);

    gpio_cs = libsoc_gpio_request(GPIO_CS,LS_SHARED);

    if(gpio_cs == NULL) {
    goto fail;
    }

    libsoc_gpio_set_direction(gpio_cs,OUTPUT);

    if(libsoc_gpio_get_direction(gpio_cs) != OUTPUT){
    printf("Failed to set direction to OUTPUT!\n");
    goto fail;  
    }
    
   spi *spi_dev = libsoc_spi_init(0,0);   
     
   if(!spi_dev){
    printf("Failed to get spidev device!\n");
    return EXIT_FAILURE;
   }


   libsoc_spi_set_mode(spi_dev,MODE_0);
   libsoc_spi_get_mode(spi_dev);
   libsoc_spi_set_speed(spi_dev,10000);
   libsoc_spi_get_speed(spi_dev);
   libsoc_spi_set_bits_per_word(spi_dev,BITS_8);
   libsoc_spi_get_bits_per_word(spi_dev);
 
   tx[0] = 0x01;
   tx[1] = 0x80;
   tx[2] = 0x00;
   while(1) {
    libsoc_gpio_set_level(gpio_cs,HIGH);
    usleep(10);
    libsoc_gpio_set_level(gpio_cs,LOW);
    libsoc_spi_rw(spi_dev,tx,rx,3);
    libsoc_gpio_set_level(gpio_cs,HIGH);
 
    adc_value = (rx[1]<<8)&0b1100000000;
    adc_value |= (rx[2]&0xff);
 
    printf("adc_value:%d\n",adc_value);
    sleep(1);
   }

   free:
   libsoc_spi_free(spi_dev);
   fail:
   if(gpio_cs) {
    libsoc_gpio_free(gpio_cs);
   }

   return EXIT_SUCCESS;
}

Salve o código como: slide.c

Compile o código:

gcc slide.c -o slide -lsoc

Execute o projeto:

sudo ./slide