C++ Arduino - expressão primária esperada

Gustavo Henrique Barros · 9 de julho de 2022

Erro : In function 'void loop()':
ultrassonico:48:29: error: expected primary-expression before '.' token
ultrassonico:48:52: error: expected primary-expression before '.' token
exit status 1
expected primary-expression before '.' token

código utilizado :

 #include <Ultrasonic.h>
Ultrasonic SensorUltrassonico1(5, 4);

long Microsegundos = 0;
float DistanciaemCM = 0;
#define MotorLadoEsquerdo1 11
#define MotorLadoEsquerdo2  12

#define MotorLadoDireito1  9
#define MotorLadoDireito2 10

#define VelocidadeMotorLadoEsquerdo 13
#define VelocidadeMotorLadoDireito 8


//============================================================ Escolhe a velocidade dos motores ==================================================================//
int ValorVelocidadeMotorLadoEsquerdo = 120;
int ValorVelocidadeMotorLadoDireito = 80;

void setup() {

  //============================================================== Definições de entrada e saída ===================================================================//

  pinMode(MotorLadoEsquerdo1, OUTPUT);
  pinMode(MotorLadoEsquerdo2, OUTPUT);
  pinMode(MotorLadoDireito1, OUTPUT);
  pinMode(MotorLadoDireito2, OUTPUT);

  Serial.begin(115200);

  delay(3000);
}
void loop() {
  
  DistanciaemCM = Ultrasonic.convert(Ultrasonic.timing(), Ultrasonic::CM);

  Serial.print(DistanciaemCM);
  Serial.println(" cm");

  if (DistanciaemCM <= 40) 
  
    analogWrite( VelocidadeMotorLadoEsquerdo, ValorVelocidadeMotorLadoEsquerdo);

    analogWrite( VelocidadeMotorLadoDireito, ValorVelocidadeMotorLadoDireito);

    digitalWrite(MotorLadoEsquerdo1, HIGH);
    digitalWrite(MotorLadoEsquerdo2, LOW);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(700);

    digitalWrite(MotorLadoEsquerdo1, LOW);
    digitalWrite(MotorLadoEsquerdo2, HIGH);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(400);
  }

  else {
    analogWrite( VelocidadeMotorLadoEsquerdo, ValorVelocidadeMotorLadoEsquerdo);

    analogWrite( VelocidadeMotorLadoDireito, ValorVelocidadeMotorLadoDireito);
    
    digitalWrite(MotorLadoEsquerdo1, LOW);
    digitalWrite(MotorLadoEsquerdo2, HIGH);

    digitalWrite(MotorLadoDireito1, LOW);
    digitalWrite(MotorLadoDireito2, HIGH);
  }
}

arfneto · 9 de julho de 2022

1 hora atrás, Gustavo Henrique Barros disse:
void loop()

Nunca use isso. void f(void) é um desastre.

Só vai operar com dados globais e isso é proibido em toda parte, escolas e empresas.

Onde está o código do header?

Gustavo Henrique Barros · 9 de julho de 2022

@arfneto como assim código do header? sou iniciante no arduino.
se for o código base, é esse mesmo que estou utilizando.

arfneto · 9 de julho de 2022

1 hora atrás, Gustavo Henrique Barros disse:
#include <Ultrasonic.h>

Simples assim: onde está o header?

Econsidere o que escrevi:

Nunca use isso. void f(void) é um desastre.

Só vai operar com dados globais e isso é proibido em toda parte, escolas e empresas.

Gustavo Henrique Barros · 10 de julho de 2022

23 horas atrás, arfneto disse:

Simples assim: onde está o header?

Econsidere o que escrevi:

Nunca use isso. void f(void) é um desastre.

Só vai operar com dados globais e isso é proibido em toda parte, escolas e empresas.

/*
 * Ultrasonic.cpp - Library for HC-SR04 Ultrasonic Sensing Module.
 *
 * With ideas from:
 *   Created by ITead studio. Apr 20, 2010.
 *   iteadstudio.com
 *
 * SVN Keywords
 * ----------------------------------
 * $Author: cnobile $
 * $Date: 2011-10-08 21:07:42 -0400 (Sat, 08 Oct 2011) $
 * $Revision: 35 $
 * ----------------------------------
 *
 * Centimeters Divisor
 * =========== =======
 *  15.875     26.9029
 *  46.355     27.6233
 *  92.075     28.1949
 * 137.795     28.4717
 * 183.515     28.5584
 * 229.235     28.5936
 * 274.955     28.7194
 *
 * Inches      Divisor
 * ======      =======
 *   6.25      68.3333
 *  18.25      70.1633
 *  36.25      71.6152
 *  54.25      72.3182
 *  72.25      72.5384
 *  90.25      72.6277
 * 108.25      72.9473
 */

#include <stdlib.h>
#include <string.h>
#include <Ultrasonic.h>


Ultrasonic::Ultrasonic(int tp, int ep)
    {
    pinMode(tp, OUTPUT);
    pinMode(ep, INPUT);
    _trigPin = tp;
    _echoPin = ep;
    _cmDivisor = 27.6233;
    _inDivisor = 70.1633;
    }

long Ultrasonic::timing()
    {
    digitalWrite(_trigPin, LOW);
    delayMicroseconds(2);
    digitalWrite(_trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(_trigPin, LOW);
    return pulseIn(_echoPin, HIGH);
    }

float Ultrasonic::convert(long microsec, int metric)
    {
    // microsec / 29 / 2;
    if(metric) return microsec / _cmDivisor / 2.0;  // CM
    // microsec / 74 / 2;
    else return microsec / _inDivisor / 2.0;  // IN
    }

void Ultrasonic::setDivisor(float value, int metric)
    {
    if(metric) _cmDivisor = value;
    else _inDivisor = value;
    }

#ifdef COMPILE_STD_DEV
bool Ultrasonic::sampleCreate(size_t numBufs, ...)
    {
    bool result = false;
    va_list ap;
    _numBufs = numBufs;

    if((_pBuffers = (BufCtl *) calloc(numBufs, sizeof(BufCtl))) != NULL)
        {
        va_start(ap, numBufs);
        BufCtl *buf;
        size_t smpSize;

        for(size_t i = 0; i < _numBufs; i++)
            {
            buf = &_pBuffers[i];
            smpSize = va_arg(ap, size_t);

            if((buf->pBegin = (float *) calloc(smpSize, sizeof(float))) != NULL)
                {
                buf->pIndex = buf->pBegin;
                buf->length = smpSize;
                buf->filled = false;
                result = true;
                }
            else
                {
                result = false;
                break;
                }
            }

        va_end(ap);
        }

    if(!result) _freeBuffers();
    return result;
    }

void Ultrasonic::sampleClear()
    {
    if(_pBuffers)
        {
        BufCtl *buf;

        for(size_t i = 0; i < _numBufs; i++)
            {
            buf = &_pBuffers[i];
            memset(buf, '\0', sizeof(float) * buf->length);
            buf->pIndex = buf->pBegin;
            buf->filled = false;
            }
        }
    }

float Ultrasonic::unbiasedStdDev(float value, size_t bufNum)
    {
    float result = 0.0;

    if(_pBuffers)
        {
        BufCtl *buf = &_pBuffers[bufNum];

        if(buf->length > 1)
            {
            _sampleUpdate(buf, float(value));

            if(buf->filled)
                {
                float sum = 0.0, mean, tmp;

                for(size_t i = 0; i < buf->length; i++)
                    sum += buf->pBegin[i];

                mean = sum / buf->length;
                sum = 0.0;

                for(size_t i = 0; i < buf->length; i++)
                    {
                    tmp = buf->pBegin[i] - mean;
                    sum += (tmp * tmp);
                    }

                result = sqrt(sum / (buf->length - 1));
                //Serial.print(bufNum);
                //Serial.print(" : ");
                //Serial.println(result);
                }
            }
        }

    return result;
    }

void Ultrasonic::_sampleUpdate(BufCtl *buf, float msec)
    {
    if(buf->pIndex >= (buf->pBegin + buf->length))
        {
        buf->pIndex = buf->pBegin;
        buf->filled = true;
        }

    *(buf->pIndex++) = msec;
    }

void Ultrasonic::_freeBuffers()
    {
    if(_pBuffers)
        {
        BufCtl *buf;

        for(size_t i = 0; i < _numBufs; i++)
            {
            buf = &_pBuffers[i];
            free(buf->pBegin);
            }

        free(_pBuffers);
        }
    }
#endif // COMPILE_STD_DEV

arfneto · 10 de julho de 2022

Essas coisas nada tem a ver com o arduino. É o modo de montar o código para compilar um programa desses.

O código que postou agora, Ultrasonic.cpp tem o código de implementação da classe.

Ultrasonic.h o header tem as definições da classe. Para entender o código ou compilar A CLASSE precisa do par, .h e .cpp

E qualquer programa que usa a classe precisa dos dois. Para compilar apenas o header. Mas para gerar um programa precisa de um cpp que implemente as funções da classe, a menos que esteja toda a implementação contida no header

devair1010 · 10 de julho de 2022

@Gustavo Henrique Barros parece me Que não existem essa função "Ultrasonic.convert" , e então você pode experimentar usar outros comandos , como esses :

#include <Ultrasonic.h>
Ultrasonic SensorUltrassonico1(5, 4);
#include <LiquidCrystal.h> //Adiciona a biblioteca do display
 
#define trigPin 10 // Declara constante trigPin
#define echoPin 9 // Declara constante echoPin
#define trigger 18
#define echo 19
 
Ultrasonic ultrasonic(trigPin, echoPin); //Define os pinos para o ultrassonico
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Define os pinos para o display

long Microsegundos = 0;
float DistanciaemCM = 0;
#define MotorLadoEsquerdo1 11
#define MotorLadoEsquerdo2  12

#define MotorLadoDireito1  9
#define MotorLadoDireito2 10

#define VelocidadeMotorLadoEsquerdo 13
#define VelocidadeMotorLadoDireito 8


//============================================================ Escolhe a velocidade dos motores ==================================================================//
int ValorVelocidadeMotorLadoEsquerdo = 120;
int ValorVelocidadeMotorLadoDireito = 80;

float time=0,distance=0;

void setup() {

  //============================================================== Definições de entrada e saída ===================================================================//

  pinMode(MotorLadoEsquerdo1, OUTPUT);
  pinMode(MotorLadoEsquerdo2, OUTPUT);
  pinMode(MotorLadoDireito1, OUTPUT);
  pinMode(MotorLadoDireito2, OUTPUT);

  Serial.begin(115200);

  delay(3000);
}
void loop() {
  
//  DistanciaemCM = Ultrasonic.convert(Ultrasonic.timing(), Ultrasonic::CM);
// DistanciaemCM = Ultrasonic.convert(/*microsec*/Ultrasonic.timing(), Ultrasonic::CM);
  time     = pulseIn( echoPin , HIGH );
  DistanciaemCM = time * 340 /   20000;
  Serial.print( DistanciaemCM );
  Serial.println(" cm");

  if (DistanciaemCM <= 40) 
  {
    analogWrite( VelocidadeMotorLadoEsquerdo, ValorVelocidadeMotorLadoEsquerdo);

    analogWrite( VelocidadeMotorLadoDireito, ValorVelocidadeMotorLadoDireito);

    digitalWrite(MotorLadoEsquerdo1, HIGH);
    digitalWrite(MotorLadoEsquerdo2, LOW);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(700);

    digitalWrite(MotorLadoEsquerdo1, LOW);
    digitalWrite(MotorLadoEsquerdo2, HIGH);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(400);
  }

  else {
    analogWrite( VelocidadeMotorLadoEsquerdo, ValorVelocidadeMotorLadoEsquerdo);

    analogWrite( VelocidadeMotorLadoDireito, ValorVelocidadeMotorLadoDireito);
    
    digitalWrite(MotorLadoEsquerdo1, LOW);
    digitalWrite(MotorLadoEsquerdo2, HIGH);

    digitalWrite(MotorLadoDireito1, LOW);
    digitalWrite(MotorLadoDireito2, HIGH);
  }
  // delay(4e44);
}

arfneto · 11 de julho de 2022

6 horas atrás, devair1010 disse:

parece me Que não existem essa função "Ultrasonic.convert" , e então você pode experimentar usar outros comandos

Sem o header não dá pra saber o que existe ou não. Um header é texto. Pode ter qualquer coisa.

E convert pode ser um método declarado e implementado em ultrasonic.h.

Para o caso aqui o arquivo cpp é secundário. Apenas o header importa. Só que o autor da questão inicialmente não postou nenhum dos dois e depois postou o cpp.

C++ não tem interfaces como java, mas é razoável em muitos cenários ter mais de um cpp implementando um header

arfneto · 11 de julho de 2022

De todo modo as bibliotecas para o Arduino estão nesse endereço

Ultrasonic home em Arduino.cc

e lá está Ultrasonic.h:

/*
 * Ultrasonic.h
 *
 * Library for Ultrasonic Ranging Module in a minimalist way
 *
 * created 3 Apr 2014
 * by Erick Simões (github: @ErickSimoes | twitter:
 * @AloErickSimoes) modified 23 Jan 2017 by Erick Simões
 * (github: @ErickSimoes | twitter: @AloErickSimoes)
 * modified 04 Mar 2017
 * by Erick Simões (github: @ErickSimoes | twitter:
 * @AloErickSimoes) modified 15 May 2017 by Eliot Lim
 * (github: @eliotlim) modified 10 Jun 2018 by Erick Simões
 * (github: @ErickSimoes | twitter: @AloErickSimoes)
 *
 * Released into the MIT License.
 */

#ifndef Ultrasonic_h
#define Ultrasonic_h

/*
 * Values of divisors
 */
#define CM 28
#define INC 71

class Ultrasonic
{
   public:
    Ultrasonic(uint8_t sigPin)
        : Ultrasonic(sigPin, sigPin){};
    Ultrasonic(
        uint8_t trigPin, uint8_t echoPin,
        unsigned long timeOut = 20000UL);
    unsigned int read(uint8_t und = CM);
    unsigned int distanceRead(uint8_t und = CM)
        __attribute__((
            deprecated("This method is deprecated, use "
                       "read() instead.")));
    void setTimeout(unsigned long timeOut)
    {
        timeout = timeOut;
    }

   private:
    uint8_t       trig;
    uint8_t       echo;
    boolean       threePins = false;
    unsigned long previousMicros;
    unsigned long timeout;
    unsigned int  timing();
};

#endif  // Ultrasonic_h

E o correspondente cpp para a versão 3

/*
 * Ultrasonic.cpp
 *
 * Library for Ultrasonic Ranging Module in a minimalist way
 *
 * created 3 Apr 2014
 * by Erick Simões (github: @ErickSimoes | twitter:
 * @AloErickSimoes) modified 23 Jan 2017 by Erick Simões
 * (github: @ErickSimoes | twitter: @AloErickSimoes)
 * modified 04 Mar 2017
 * by Erick Simões (github: @ErickSimoes | twitter:
 * @AloErickSimoes) modified 15 May 2017 by Eliot Lim
 * (github: @eliotlim) modified 10 Jun 2018 by Erick Simões
 * (github: @ErickSimoes | twitter: @AloErickSimoes)
 * modified 14 Jun 2018
 * by Otacilio Maia (github: @OtacilioN | linkedIn:
 * in/otacilio)
 *
 * Released into the MIT License.
 */

#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif

#include "Ultrasonic.h"

Ultrasonic::Ultrasonic(
    uint8_t trigPin, uint8_t echoPin, unsigned long timeOut)
{
    trig      = trigPin;
    echo      = echoPin;
    threePins = trig == echo ? true : false;
    pinMode(trig, OUTPUT);
    pinMode(echo, INPUT);
    timeout = timeOut;
}

unsigned int Ultrasonic::timing()
{
    if (threePins) pinMode(trig, OUTPUT);

    digitalWrite(trig, LOW);
    delayMicroseconds(2);
    digitalWrite(trig, HIGH);
    delayMicroseconds(10);
    digitalWrite(trig, LOW);

    if (threePins) pinMode(trig, INPUT);

    previousMicros = micros();
    while (!digitalRead(echo) &&
           (micros() - previousMicros) <= timeout)
        ;  // wait for the echo pin HIGH or timeout
    previousMicros = micros();
    while (digitalRead(echo) &&
           (micros() - previousMicros) <= timeout)
        ;  // wait for the echo pin LOW or timeout

    return micros() - previousMicros;  // duration
}

/*
 * If the unit of measure is not passed as a parameter,
 * sby default, it will return the distance in centimeters.
 * To change the default, replace CM by INC.
 */
unsigned int Ultrasonic::read(uint8_t und)
{
    return timing() / und / 2;  // distance by divisor
}

/*
 * This method is too verbal, so, it's deprecated.
 * Use read() instead.
 */
unsigned int Ultrasonic::distanceRead(uint8_t und)
{
    return read(und);
}

E isso é para ser compilado dentro do Arduino IDE. E imagino que lá possa compilar com sucesso já que é a versão 3.0 essa

Mas era pra ser C++ comum e não vejo vantagem em mudar coisas como atributos:

    unsigned int distanceRead(uint8_t und = CM)
        __attribute__((
            deprecated("This method is deprecated, use "
                       "read() instead.")));

O oficial:

    [[deprecated("This method is deprecated, use read() instead."))]]
    unsigned int distanceRead(uint8_t und = CM);

que é bem mais legível

 if (DistanciaemCM <= 40) 
  
    analogWrite( VelocidadeMotorLadoEsquerdo, ValorVelocidadeMotorLadoEsquerdo);

    analogWrite( VelocidadeMotorLadoDireito, ValorVelocidadeMotorLadoDireito);

    digitalWrite(MotorLadoEsquerdo1, HIGH);
    digitalWrite(MotorLadoEsquerdo2, LOW);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(700);

    digitalWrite(MotorLadoEsquerdo1, LOW);
    digitalWrite(MotorLadoEsquerdo2, HIGH);

    digitalWrite(MotorLadoDireito1, HIGH);
    digitalWrite(MotorLadoDireito2, LOW);

    delay(400);
  }

De qualquer forma parece prov[avel que falte uma chave depois do if (DistanciaemCM <= 40) ...

    if (DistanciaemCM <= 40)
    {
        analogWrite(
            VelocidadeMotorLadoEsquerdo,
            ValorVelocidadeMotorLadoEsquerdo);

        analogWrite(
            VelocidadeMotorLadoDireito,
            ValorVelocidadeMotorLadoDireito);

        digitalWrite(MotorLadoEsquerdo1, HIGH);
        digitalWrite(MotorLadoEsquerdo2, LOW);

        digitalWrite(MotorLadoDireito1, HIGH);
        digitalWrite(MotorLadoDireito2, LOW);

        delay(700);

        digitalWrite(MotorLadoEsquerdo1, LOW);
        digitalWrite(MotorLadoEsquerdo2, HIGH);

        digitalWrite(MotorLadoDireito1, HIGH);
        digitalWrite(MotorLadoDireito2, LOW);

        delay(400);
    }
    else
    {
        analogWrite(
            VelocidadeMotorLadoEsquerdo,
            ValorVelocidadeMotorLadoEsquerdo);

        analogWrite(
            VelocidadeMotorLadoDireito,
            ValorVelocidadeMotorLadoDireito);

        digitalWrite(MotorLadoEsquerdo1, LOW);
        digitalWrite(MotorLadoEsquerdo2, HIGH);

        digitalWrite(MotorLadoDireito1, LOW);
        digitalWrite(MotorLadoDireito2, HIGH);
    }

E um ponto aqui provavelmente está errado também:

Em 09/07/2022 às 12:14, Gustavo Henrique Barros disse:
 DistanciaemCM = Ultrasonic.convert(Ultrasonic.timing(), Ultrasonic::CM);

Se Ultrasoninc fosse estática deveria usar :: e se não é deveria usar uma instância e não a classe como prefixo. Isso a menos que o Arduino SDK tenha mudado essa realidade