Mova um carrinho com sua mente

A telecinética ou a capacidade de mover um objeto com seus pensamentos não é mais uma realidade distante. Usando o Muse™, um dispositivo usável que coleta sinais de onda cerebral, um dispositivo Arduino e um programa Python, este artigo demonstra como é possível mover um carrinho usando o poder da sua mente. Na realidade, o carrinho não é movido analisando seus pensamentos, mas, na verdade, determinando o tipo de ondas cerebrais que estão sendo mais ativas em um determinado momento.

Mover um carrinho pode não ser um aplicativo significativo. Entretanto, imagine as possibilidades para pessoas com deficiência que não podem andar ou falar — usando suas ondas cerebrais, agora elas podem mover potencialmente um objeto. Além disso, graças à Internet, você pode ser capaz de mover um objeto com suas ondas cerebrais em outro país ou continente! Siga as etapas descritas neste tutorial para fazer seu primeiro objeto (um carrinho) se mover. Esse tutorial também descreve como um aplicativo da web Node.js em execução no IBM Cloud foi desenvolvido para armazenar e mostrar a atividade cerebral coletada usando o Muse.

O que será necessário para desenvolver o aplicativo

  • Um carrinho com controle remoto (o modelo New Bright 1:24 Scale Radio Control Sports Car é usado neste tutorial).
  • Um dispositivo Arduino.
  • Um headband Muse.
  • Uma conta do IBM Cloud, para que possa usar o Node.js runtime, o método serviço de banco de dados Cloudant NoSQL e o serviço dashDB.
  • Uma conta do DevOps Services para obter e bifurcar o código de amostra abaixo.
  • Familiaridade com a linguagem de programação Python.
  • Familiaridade com Cloudant (banco de dados noSQL).

Computador conectado a Arduino com carrinho de controle remoto

O Muse conecta-se ao laptop usando Bluetooth. O laptop é conectado a um dispositivo Arduino Uno, que é conectado ao controle remoto que vem com o carrinho.

O laptop executa um aplicativo local Python com a lógica que analisa o tipo de onda cerebral recebida pelo Muse. Quando ele determinar que essas ondas ‘alfa’ são as mais fortes (associadas ao relaxamento), ele executará um programa pequeno no dispositivo Arduino Uno para mover o carro para a frente.

Ao mesmo tempo, um aplicativo IBM Cloud usando o Node.js, o banco de dados Cloudant NoSQL e o dashDB está em execução. Este é um aplicativo da web que exibirá em tempo real a atividade do sensor do Muse, a atividade cerebral e os dados que estão sendo passados e armazenados em um banco de dados do Cloudant NoSQL. Os serviços do IBM Cloud Cloudant e dashDB são configurados para que os dados sejam sincronizados do Cloudant para o dashDB. Usando R no dashDB, mostramos uma visualização simples dos dados coletados.

NoneNone

Parte I. Hardware – Carrinho remoto e Arduino

Etapa 1.Desmonte o carrinho remoto

Primeiro, você precisa configurar todo o hardware. Para este tutorial, usamos um modelo de carro específico (New Bright 1:24 Scale Radio Control Sports Car) que nos permitiu soldar alguns fios em pontos específicos e ter o controle total do carro. Embora não seja necessário, recomendamos que você use um modelo semelhante para facilitar as coisas.

Carrinho e controle remoto

Controle remoto desmontado

Este carro específico possui botões para frente/trás e esquerda/direita no controle remoto. Após abrir o controle remoto, é possível procurar locais de pontos de teste (TP) correspondentes na placa do circuito que leva aos respectivos botões. Esses locais na placa de circuito são usados para teste no processo de manufatura. Podemos usá-los para enviar sinais ALTOS e BAIXOS para controlar o carro sem remover os botões. Além disso, uma vez que o controle remoto é aliemntado com duas baterias AA (3V total), podemos ligar a placa de circuito usando a saída 3.3V no Arduino.

Locais de TP para soldar fios:

  • Traseira – TP80
  • Frente – TP81
  • Esquerda – TP82
  • Direita – TP83

Observação: Este esquema é específico ao controle remoto que estamos usando. Se você estiver usando outro modelo de carrinho e um controle remoto diferente, será necessário procurar os pontos de teste específicos da placa de circuito.

Após soldar os fios nos locais de TP (traseira/frente e esquerda/direita) e nos pontos de energia, o controle remoto estará pronto para ser conectado ao Arduino.

Circuito de controle remoto

Etapa 2.Conecte o Arduino ao carrinho remoto

Após soldar o controlador nos locais corretos, é hora de conectar o Arduino. Conecte o fio colorido conforme a seguir:

  • Azul (traseira TP80) – Pino 4
  • Branco (frente TP81) – Pino 2
  • Verde (esquerda TP82) – Pino 8
  • Amarelo (direita TP83) – Pino 12
  • Vermelho – 3.3V
  • Laranja – GND

Circuito de controle remoto

Circuito Arduino

Observação: É possível usar quaisquer cores que desejar para os cabos. Apenas lembre-se de ligar os cabos aos pinos corretos.

Vamos ver como fica a instalação completamente montada.

Circuito de controle remoto

Parte II. Software

Etapa 1.Extraia os dados a partir do headband do Muse

O headband do Muse inclui um SDK e aplicativos de amostra. Este primeiro descreve como é possível extrair os diferentes tipos de ondas cerebrais do Muse.

  1. Pareie o Muse ao seu computador usando o Bluetooth (detalhes são descritos no manual do dispositivo).
  2. Instale a SDK do Muse em seu computador.

    Observação: Assegure-se de instalar as bibliotecas pyliblo e liblo (versão 0.27).

  3. Execute muse-io:

    $ ./muse-io
    
  4. Execute o comando a seguir para ver todas as mensagens OSC que chegam do Muse:

    $ oscdump 5000
    

Etapa 2.Desenvolva um aplicativo da web usando Node.js no IBM Cloud para mostrar estados cerebrais

Agora que você extraiu com sucesso alguns dados do Muse, vamos desenvolver o aplicativo da web para mostrar todos estes dados.

Sugerimos que você bifurque nosso repositório e obtenha o código !–(https://hub.jazz.net/project/lucaslsl/bluemix-move-toycar/overview)–para o aplicativo.

  1. Altere o código para enviar dados a um banco de dados Cloudant.

    1. Navegue até nodejs-app/app.js.

      Aplicativo no Cloudant

    2. Procure o código a seguir e altere as variáveis com as informações para seu banco de dados Cloudant:

         /*
             CLOUDANT DATABASE SETTINGS
         */
      
         var cradle = require('cradle'); //Must have Cradle library installed
         var account = new(cradle.Connection)({
             host: 'username.cloudant.com', //Cloudant URL
             port: 443,
             secure: true,
             auth:{
                 username: "username", //Cloudant username
                 password: "password" //Cloudant password
             }
         });
         var db = account.database('databasename'); //database name
      
    3. Procure e remova o comentário das linhas a seguir, que enviam os dados coletados ao banco de dados especificado:

         arrayJson.push(dataCloudantSave);
             if(arrayJson.length==100){
                 db.save(arrayJson,function(err,res){
                     console.log(err);
                     console.log(res);
                 });
                 arrayJson = [];
             }
      
  2. Configure a variação de cor do gráfico de barras.

    1. Navegue até nodejs-app/public/javascript/ws.js.
    2. Altere o último atributo no método drawChartCanvas (variação 0-1).

         if (startSession){
                     //Change the variation in which the chart should change color, e.g 0.2, 0.35...
                 drawChartCanvas(att["C0"],att["C1"],att["C2"],att["C3"],0.1);
                     //The last attribute is the "VARIATION" in which the chart should change the color
                     $(function(){
                         $("#datasent").html("<p>"+event.data+"</p>");
                     });
             }
      
  3. Prepare o aplicativo para implementação.

    1. Navegue até nodejs-app/manifest.yml.

      Aplicativo no Cloudant

    2. Altere o arquivo com informações sobre seu aplicativo.

    Observação: É possível criar um aplicativo Node.js no painel do IBM Cloud e altere o manifest.yml com as informações do aplicativo (fornecidas quando o aplicativo é criado).

  4. Implemente o aplicativo no IBM Cloud.

    Observação: Antes de implementar o aplicativo, você deve ter instalado a interface da linha de comandos (CLI) do Cloud Foundry.

    1. Abra um prompt de comandos.
    2. Acesse o diretório do aplicativo (nodejs-app).
    3. Execute os comandos cf a seguir:

      • Conecte-se ao IBM Cloud:

             ```
             $ cf api https://api.ng.bluemix.net
             ```
        
      • Efetue login no IBM Cloud (insira o email e a senha quando solicitado):

             ```
             $ cf login
             ```
        
      • Realize push do aplicativo:

             ```
             $ cf push <appname>
             ```
        

        Dica: Ao implementar um aplicativo usando a ferramenta cf, abra outro prompt de comandos e rastreie os logs usando $ cf logs <appname>.

Etapa 3.Desenvolva o código para controlar seu carrinho de controle remoto do Arduino

  1. Se você não tiver o IDE do Arduino instalado, faça download dele.
  2. Abra o arquivo chamado serialArduino.ino no repositório.
  3. Faça upload do código para o seu Arduino.

É isso. Seu Arduino está configurado.

Agora, vamos dar uma olhada no código:

Aqui, configuramos os pinos que enviarão comandos ao controlador:

#define FORWARD 2
#define BACKWARD 4
#define LEFT 8
#define RIGHT 12
#define LED 13

String inputString = ""; // a string to hold incoming data
boolean stringComplete = false, goodString = false; // whether the string is complete
int forward=HIGH, backward=HIGH, left=HIGH, right=HIGH;

void setup() {
 // initialize serial:
 Serial.begin(115200);
 // reserve 10 bytes for the inputString:
 inputString.reserve(10);
 pinMode(FORWARD, OUTPUT);
 pinMode(BACKWARD, OUTPUT);
 pinMode(LEFT, OUTPUT);
 pinMode(RIGHT, OUTPUT);
 pinMode(LED, OUTPUT);

 digitalWrite(FORWARD, HIGH);
 digitalWrite(BACKWARD, HIGH);
 digitalWrite(LEFT, HIGH);
 digitalWrite(RIGHT, HIGH);

}

No loop principal, verificamos a entrada serial e configuramos os pinos de acordo:

void loop() {
 if (stringComplete) {
 //     Serial.println(inputString);

   goodString = false;

   if(inputString == "F\n"){
     digitalWrite(LED, HIGH);
     forward = LOW;
     backward = HIGH;
     goodString = true;
   }
   else if(inputString == "B\n"){
     forward = HIGH;
     backward = LOW;
     goodString = true;
   }
   else if(inputString == "L\n"){
     left = LOW;
     right = HIGH;
     goodString = true;
   }
   else if(inputString == "R\n"){
     left = HIGH;
     right = LOW;
     goodString = true;
   }
   else if(inputString == "S\n"){
     digitalWrite(LED, LOW);
     left = HIGH;
     right = HIGH;
     forward = HIGH;
     backward = HIGH;
     goodString = true;
   }
   else{
     goodString = false;
   }

   if(goodString){
     digitalWrite(FORWARD, forward);
     digitalWrite(BACKWARD, backward);
     digitalWrite(LEFT, left);
     digitalWrite(RIGHT, right);
   Serial.print('!');
   }

   // clear the string:
   inputString = "";
   stringComplete = false;
 }
}

Etapa 4.Redirecione os dados do Muse usando um programa Python

A última etapa é ler os dados do Muse e enviar, ao mesmo tempo, o comando correto ao Arduino e corrigir os dados a serem exibidos em seu aplicativo da web.

  1. Antes de executar o aplicativo Python, é necessário conectar-se ao Muse usando o software fornecido. Esse software receberá os dados por meio do Bluetooth e os redirecionará a uma porta OSC.

    1. Acesse a pasta SDK.
    2. Execute o comando a seguir:

         $ ./muse-io --dsp --osc osc.udp://localhost:5000
      
    3. Altere o script Python (moveRCToyCar.py) para usar sua URL customizada fornecida pelo IBM Cloud (altere a variável chamada webAppURL) e a porta à qual seu Arduino está conectado (arduinoPort).

      Se você não souber à qual porta seu Arduino está conectado, apenas abra o IDE do Arduino, clique no menu Tools e procure a opção marcada Serial Port.

  2. Assim que terminar de alterar o código, será hora de executá-lo!

    $ python moveRCToyCar.py -t 0.12
    

    Observação: É possível usar a sinalização -t para configurar o nível de “relaxamento” que você tem de realizar para mover o carro. Também é possível omiti-la e será padronizada para 0.35. (Também é possível alterar isto no código.)

    Se tudo ocorreu bem, você deve esperar para ver algo como o seguinte:

    Setting threshold to 0.12
    Connecting to arduino on /dev/ttyACM0 at 115200 baud
    Connected!
    Message to Arduino: <STOP> 0
    Message to Arduino: <STOP> 0
    Message to Arduino: <STOP> 0
    Message to Arduino: <STOP> 0
    Message to Arduino: <STOP> 0
    
  3. Quando desejar parar, pressione Enter antes de desconectar o Muse ou Arduino. Você verá o seguinte:

    Closing everything...
    Waiting for threads to close...
    Message to Arduino: <STOP> 0
    Arduino thread closed!
    Local server thread closed!
    Waiting for OSC server to close...
    OSC server closed!
    

    Observação: Se você esqueceu de pressionar Enter antes de desconectar o Muse ou o Arduino, provavelmente terá de encerrar o processo Python. Se você estiver usando um sistema semelhante ao Unix (como OSX ou Ubuntu), apenas execute o comando a seguir e ele fechará quaisquer aplicativos Python em execução no momento:

    $ sudo killall python
    

Etapa 5.Use R para analisar os dados armazenados no Cloudant e dashDB

Observação: Para esta parte, é necessário uma conta do Cloudant e o serviço dashDB no IBM Cloud.

  1. Sincronize os dados a partir do Cloudant.

    1. Insira as informações para sua conta e seu banco de dados do Cloudant.
    2. Escolha um nome para a tabela a ser criada.
    3. Selecione Start Sync.

      Sincronização de tabela no Cloudant

  2. Para executar o script do R, acesse Analyze/Develop R Scripts no menu do dashDB, em que você tem as opções para criar e importar o script.

    O script R a seguir, que pode ser localizado no repositório, busca os dados de uma tabela chamada SAMPLES e plota um gráfico de linhas usando um dos campos.

    library(bluR)
    mycon <- bluConnect("BLUDB", "", "")
    bluAnalyticsInit(mycon)
    
    datamuse <- as.data.frame(blu.data.frame('"BLU11196"."SAMPLES"')[ ,
    c("C0","C1","C2","C3","F","S0","S1","S2","S3","TIMESTAMP","_ID","_REV")])
    
    plot(datamuse[1:nrow(datamuse),1],type="l")
    

    Para este cenário, BLU11196 é o usuário do banco de dados e SAMPLES é o nome da tabela.

    Criação de tabelas

    Dê uma olhada no gráfico plotado dos dados do Muse usando R:

    Gráfico do Muse

Conclusão

Neste tutorial, você aprendeu a extrair os sinais de onda cerebral do headband do Muse. Você também aprendeu a interpretar esses dados usando um programa Python, que possui a lógica de fazer um carrinho se mover para frente ou não. O tutorial também mostrou como é possível criar um aplicativo da web no Node.js no IBM Cloud para exibir em tempo real a atividade de onda cerebral, bem como o limite que foi codificado para fazer o carrinho se mover. É possível argumentar que isto não é realmente uma demonstração de telecinésia, uma vez que você não está realmente fazendo o carrinho se mover apenas ao pensar nisto. Em vez disto, o carrinho está sendo movido pelo seu nível de relaxamento, porque estamos detectando suas ondas cerebrais alfa. Apesar deste argumento, uma coisa é fato — suas ondas cerebrais estão fazendo o carrinho se mover!