arduino, eletrônica, robotica...

Arduino + Raspberry Pi em tempo real

Li muito a respeito do Arduino e do Raspberry Pi e criei uma forma do Arduino mandar os valores de todas suas entradas (6 analógicas e 14 digitais) para o Raspberry Pi que disponibiliza para qualquer usuário da rede via navegador de internet.

O problema é que os valores que o Raspberry Pi mostra no navegador são valores que estavam em seu buffer, ou seja, não está mostrando a leitura do Arduino em tempo real :(

Já tentei apagar o buffer antes de enviar a leitura para o HTML com o comando "serialFromArduino.flushInput()" e também já tentei usar "serialFromArduino.readline(1)", mas quando faço isso não dá tempo de gravar todas as variáveis e mandar pro HTML pra serem exibidas o que gera erro no browser. Tentei usar o "time.sleep(1)" para dar tempo de carregar os dados, mas parece que esse comando impede que o RaspberryPi grave os valores nesse espaço de tempo. Não sei o que fazer para resolver esse problema,se alguém consegui me ajudar ficarei muito grato.

Segue os programas:

ARDUINO

void setup() {

  // inicializa comunicacao serial a 9600 bps:

  Serial.begin(9600);

  // configura os 14 canais digitais como entrada:

  for (int canalDigital = 0; canalDigital < 14; canalDigital++) {

    pinMode(canalDigital, INPUT);

// leitura das entradas em loop:

void loop() {

  // le todas entradas analogicas:

  for (int canalAnalogico = 0; canalAnalogico < 6; canalAnalogico++) {

    int leituraSensor = analogRead(canalAnalogico);

    // envia todas leituras analogicas:

    Serial.print(leituraSensor);

    Serial.print(",");

  // le todas entradas digitais:

  for (int canalDigital = 0; canalDigital < 13; canalDigital++) {

    int leituraSensor = digitalRead(canalDigital);

    // envia todas leituras digitais:

    Serial.print(leituraSensor);

    Serial.print(",");

  // ultima leitura separado para dizer ao raspberry e a string terminou:

  Serial.print(digitalRead(13));

  Serial.println(",");

  delay(1);        // atraso entre as leituras para dar estabilidade

PROGRAMA EM PYTHON

# configuracao para receber do arduino e mandar para HTML

from flask import Flask, render_template, request

import serial

app = Flask(__name__)

port = "/dev/ttyACM0"

serialFromArduino = serial.Serial(port,9600)

serialFromArduino.flushInput()

# inicio do programa

@app.route("/")

def main():

      # salva a string q o arduino mandou e entrada

      entrada = serialFromArduino.readline()

      # divide a string usando a virgula como referencia

      dados = entrada.split(',')

      # salva os 6 valores analogicos e 14 digitais em 20 variaveis

      A0 = int(dados[0])

      A1 = int(dados[1])

      A2 = int(dados[2])

      A3 = int(dados[3])

      A4 = int(dados[4])

      A5 = int(dados[5])

      D0 = int(dados[6])

      D1 = int(dados[7])

      D2 = int(dados[8])

      D3 = int(dados[9])

      D4 = int(dados[10])

      D5 = int(dados[11])

      D6 = int(dados[12])

      D7 = int(dados[13])

      D8 = int(dados[14])

      D9 = int(dados[15])

      D10 = int(dados[16])

      D11 = int(dados[17])

      D12 = int(dados[18])

      D13 = int(dados[19])

      # manda os valores salvos para o template HTML

      templateData = {

              'A0' : A0,

              'A1' : A1,

              'A2' : A2,

              'A3' : A3,

              'A4' : A4,

              'A5' : A5,

              'D0' : D0,

              'D1' : D1,

              'D2' : D2,

              'D3' : D3,

              'D4' : D4,

              'D5' : D5,

              'D6' : D6,

              'D7' : D7,

              'D8' : D8,

              'D9' : D9,

              'D10' : D10,

              'D11' : D11,

              'D12' : D12,

              'D13' : D13,

      return render_template('main.html', **templateData)

if __name__ == "__main__":

      app.run(host='0.0.0.0', port=80, debug=True)

HTML

<!DOCTYPE html>

      <head>

              <title>TITULO</title>

      </head>

      <body>

              <p>Valor analógico A0: {{ A0 }}</p>

              <p>Valor analógico A1: {{ A1 }}</p>

              <p>Valor analógico A2: {{ A2 }}</p>

              <p>Valor analógico A3: {{ A3 }}</p>

              <p>Valor analógico A4: {{ A4 }}</p>

              <p>Valor analógico A5: {{ A5 }}</p>

              <p>Valor digital 0: {{ D0 }}</p>

              <p>Valor digital 1: {{ D1 }}</p>

              <p>Valor digital 2: {{ D2 }}</p>

              <p>Valor digital 3: {{ D3 }}</p>

              <p>Valor digital 4: {{ D4 }}</p>

              <p>Valor digital 5: {{ D5 }}</p>

              <p>Valor digital 6: {{ D6 }}</p>

              <p>Valor digital 7: {{ D7 }}</p>

              <p>Valor digital 8: {{ D8 }}</p>

              <p>Valor digital 9: {{ D9 }}</p>

              <p>Valor digital 10: {{ D10 }}</p>

              <p>Valor digital 11: {{ D11 }}</p>

              <p>Valor digital 12: {{ D12 }}</p>

              <p>Valor digital 13: {{ D13 }}</p>

      </body>

</html>

Curtir

0 membros curtem isto

Exibições: 1362

▶ Responder esta

Respostas a este tópico

Permalink Responder até Mauro Assis em 12 janeiro 2015 at 19:16

Odail,

Acontece que o Arduino é um processador "tempo real", ou seja, ele não tem um sistema operacional para "distraí-lo" das funções de I/O. No caso do RPi o SO consome recursos do processador que impedem esse processe informações que cheguem muito rapidamente a ele. O RPi, por exemplo, é incapaz de controlar com precisão dois servos ao mesmo tempo.

Você pode tentar acelerar a velocidade comunicação para 115200 bps, para ver se a coisa melhora.

▶ Responder

Permalink Responder até Odail Cardoso em 12 janeiro 2015 at 19:35

o problema não é a velocidade de leitura pq toda vez que dou refresh no browser é atualizado os valores. O problema é q aparece muitos valores antes de aparecer o status que acabei d setar no Arduino.

A impressão q tenho é q o Raspberry está enviando o final da fila do seu buffer enquanto q eu qro o primeiro valor da fila.

▶ Responder

Permalink Responder até Rogerio A. Filho em 12 janeiro 2015 at 20:34

Eu fiz realtime usando serialport, nodejs, socket.io.. ai sim fica realtime :)

▶ Responder

Permalink Responder até Mauro Assis em 12 janeiro 2015 at 21:13

Realtime, realtime, fica não. Façamos umas continhas:

Supondo que vc esteja se comunicando a 115 kpbs. Isso significa uma velocidade de comunicação de 14,4 kbytes/s.

O Arduino tem um clock de 16 MHz, ou seja, em teses ele pode processar eventos nesse clock. Vamos supor que os eventos nas portas aconteçam a uma velocidade de 10% disso, ou seja, 1,6 MHz. Esses eventos aconteceriam mais de 100 vezes mais rápido que a porta serial do Arduino tivesse capacidade de transmitir.

E isso sem contar com as questões que eu levantei na outra resposta.

▶ Responder

Permalink Responder até Odail Cardoso em 13 janeiro 2015 at 19:42

Cara, vc tem razão em uma coisa: o Arduino é um monstro d rápido.

Fiquei pensando no q vc disse e a princípio havia discordado, mas depois revisei aqui e vi q o Arduino tava com um delay d 1 ms e por conta disso sobrecarregava o buffer do RaspberryPi.

Havia usado 1 ms pq é o msm utilizado no exemplo q vem no próprio Arduino. Mudei pra 1000 ms (1 s) e utilizei no html um refresh d 1 s tb e obtive um resultado bem melhor do que tinha antes.