Erreur :variable or field 'calcCRC' declared void

International Français
1

je veut faire passer un tableau en argument d'une fonction mais j'obtient cette erreur lors de la compilation

variable or field 'calcCRC' declared void

comm_modbus.cpp:

#include <Crc16.h>
Crc16 crc; 

#include "Arduino_MachineControl.h"
using namespace machinecontrol;

#include "comm_modbus.h"

byte SlaveID = 0x01;
byte FunctionID;
byte addressHI;
byte addressLO;
byte quantityHI = 0x00;
byte quantityLO = 0x02;
byte totalByteWrite = 0x04;
byte Value24;
byte Value16;
byte Value8;
byte Value0;
byte crcHI;
byte crcLO;

int trameRecus[9];
int trameTraiter [9];
byte check[2];


void initModbus(){
    Serial.begin(9600);
    // Wait for Serial or start after 2.5s
    for (auto const timeout = millis() + 2500; !Serial && timeout < millis(); delay(500))
        ;

    delay(2500);
    Serial.println("Start RS485 initialization");

    // Set the PMC Communication Protocols to default config
    comm_protocols.init();

    // RS485/RS232 default config is:
    // - RS485 mode
    // - Half Duplex
    // - No A/B and Y/Z 120 Ohm termination enabled

    // Enable the RS485/RS232 system
    comm_protocols.rs485Enable(true);

    // Specify baudrate, and preamble and postamble times for RS485 communication
    comm_protocols.rs485.begin(19200,SERIAL_8E1 ,0, 500);
    // Start in receive mode
    comm_protocols.rs485.receive();

    Serial.println("Initialization done!");
}

long ModbusRead(unsigned int addrMB){
      FunctionID = 0x03;
      addrModbus(addrMB);
      
      byte trame [] = {SlaveID,FunctionID,addressHI,addressLO,quantityHI,quantityLO};
      
      calcCRC();
      
      byte trameReadComplet []={SlaveID,FunctionID,addressHI,addressLO,quantityHI,quantityLO,crcHI,crcLO};
      
        // Disable receive mode before transmission
        comm_protocols.rs485.noReceive();

        comm_protocols.rs485.beginTransmission();

        comm_protocols.rs485.write(trameReadComplet[0]);
        comm_protocols.rs485.write(trameReadComplet[1]);
        comm_protocols.rs485.write(trameReadComplet[2]);
        comm_protocols.rs485.write(trameReadComplet[3]);
        comm_protocols.rs485.write(trameReadComplet[4]);
        comm_protocols.rs485.write(trameReadComplet[5]);
        comm_protocols.rs485.write(trameReadComplet[6]);
        comm_protocols.rs485.write(trameReadComplet[7]);

        comm_protocols.rs485.endTransmission();

        // Re-enable receive mode after transmission
        comm_protocols.rs485.receive();
        
    auto const timeout = millis() + 500;
    while (comm_protocols.rs485.available() < 9){
        if (millis()> timeout){
          Serial.println("communication timeout!");
          Serial.println("erreur : ");
          while(comm_protocols.rs485.available()){
            Serial.println(comm_protocols.rs485.read());
          }
          break;
        }
      }
    if (comm_protocols.rs485.available()==9){
    
      long value;
      reception();
      value = VARvalue();
      return value;
    }
}

void ModbusWrite(unsigned int addrMB, long ValueMB){
  
  FunctionID = 0x10;
  addrModbus(addrMB);
  ValueModbus(ValueMB);
  
  byte trame [] = {SlaveID,FunctionID,addressHI,addressLO,quantityHI,quantityLO,totalByteWrite,Value24,Value16,Value8,Value0};
  
  calcCRC(trame);

   byte trameComplet []={SlaveID,FunctionID,addressHI,addressLO,quantityHI,quantityLO,totalByteWrite,Value24,Value16,Value8,Value0,crcHI,crcLO};

   comm_protocols.rs485.noReceive();

        comm_protocols.rs485.beginTransmission();

        comm_protocols.rs485.write(trameWriteComplet[0]);
        comm_protocols.rs485.write(trameWriteComplet[1]);
        comm_protocols.rs485.write(trameWriteComplet[2]);
        comm_protocols.rs485.write(trameWriteComplet[3]);
        comm_protocols.rs485.write(trameWriteComplet[4]);
        comm_protocols.rs485.write(trameWriteComplet[5]);
        comm_protocols.rs485.write(trameWriteComplet[6]);
        comm_protocols.rs485.write(trameWriteComplet[7]);
        comm_protocols.rs485.write(trameWriteComplet[8]);
        comm_protocols.rs485.write(trameWriteComplet[9]);
        comm_protocols.rs485.write(trameWriteComplet[10]);

        comm_protocols.rs485.endTransmission();

        // Re-enable receive mode after transmission
        comm_protocols.rs485.receive();
}

void addrModbus(unsigned int addresseMB){
 
  addressHI = (addresseMB >> 8) & 0xFF; //highbyte
  addressLO = (addresseMB & 0xFF);      //lowbyte
}

void ValueModbus(long valMB){
 
    Value24 = (valMB & 0xFF000000) >> 24; 
    Value16 = (valMB & 0x00FF0000) >> 16; 
    Value8  = (valMB & 0x0000FF00) >> 8; 
    Value0  = valMB & 0xFF; 
    
}

void calcCRC(byte trame []){
  
   unsigned short crcTrame;
   int sizeTrame= sizeof(trame);
    
    crc.clearCrc();
    for(int i=0;i< sizeTrame;i++)
    {
      Serial.print("byte ");
      Serial.print(i);
      Serial.print(" = ");
      Serial.println(trame[i],HEX);
     crc.updateCrc(trame[i]);
    }
    
    crcTrame = crc.Modbus(trame,0,sizeTrame);

    check[1] = (crcTrame >> 8) & 0xFF; //highbyte
    check[0] = (crcTrame & 0xFF);      //lowbyte

    crcHI = check[0],HEX;
    crcLO = check[1],HEX;

    Serial.print("Modbus crcHI = 0x");    
    Serial.println(crcHI,HEX);
    Serial.print("Modbus crcLO = 0x");    
    Serial.println(crcLO,HEX);
}

long VARvalue()
{
  long Value = 0;
  int expo = 0;
  int multi = 0;
  for( int i = 3 ;i <= trameRecus[2]+2;i++){
    expo = 6-i;
    multi = pow(256,expo);
    trameRecus[i]= trameRecus[i] * multi;
    Value = Value + trameRecus[i];
  }
  Serial.print("valeur reel = ");
  Serial.println(Value);
  return Value;
}

void reception(){
 
  int compteur = 0;
  byte ValueModbus;
  
  while (comm_protocols.rs485.available()> 0){
      ValueModbus = comm_protocols.rs485.read();
      Serial.println("Reception :");
      Serial.println(ValueModbus);
      trameRecus[compteur] = ValueModbus;
      
      compteur++;
  }
}

comm_modbus.h:

void initModbus();
long ModbusRead(unsigned int);
void ModbusWrite(unsigned int, long);
void addrModbus(unsigned int);
void ValueModbus(long);
void calcCRC(array byte);
long VARvalue();
void reception();

l'erreur se fait sur la ligne

void calcCRC(array byte);

2

Array byte n’est pas un type

Essayez avec byte*

Attention on perd la taille du tableau lors d’un passage de paramètres , ceci ne fonctionne pas.

void calcCRC(byte trame []){
  
   unsigned short crcTrame;
   int sizeTrame= sizeof(trame); // vous allez obtenir la taille d’un pointeur, pas du tableau

donc à moins que le tableau soit de taille connue, on passe aussi souvent le nombre d’éléments à prendre en compte

void calcCRC( byte* tableau, size_t nbElements) {…}

Ou

void calcCRC( byte tableau[], size_t nbElements) {…}

Et vous faites-le sizeof lors de l’appel si le tableau est connu à ce niveau là

3

et dans mon fichier comm_modbus.h je dois lui mettre quoi en type de ma fonction ?
pour le moment je lui ai mit :

void calcCRC(byte[],int);
4

La même chose mais sans le code

Vous pouvez éventuellement omettre les noms de variables

5

Une fonction qui s'appelle calcCRC, on en attend qu'elle calcule un CRC.
Et donc qu'elle renvoie la valeur qu'elle a calculé.
Donc le prototype devrait être:
unsigned long calcCRC ( const byte* tableau, size_t nb_elements );

L'attribut const permet de l'employer sur un tableau déclaré constant.

6

elle me le renvoie bien mas pas en retour de fonction, le CRC calculer elle met directement la valeur dans une variable qui ici est

byte crcHI
byte crcLO
7

Du coup ta fonction n'est pas directement réutilisable dans un autre projet, à moins d'avoir aussi une variable globale du même nom.
Ou, si tu devais un jour calculer 2 CRC sur deux tableaux, il faudrait la retoucher.

Pour de la bonne programmation, solide, réutilisable, une fonction doit renvoyer son résultat par return.

8

Pourquoi passer par des variables global au lieu du retour de la fonction qui serait plus logique ?

9

+1, tout à fait d'accord.

10

ou en passant les paramètres par pointeur ou référence en C++ (pratique quand on en a plusieurs), la fonction retournant alors un message d'erreur (si ça c'est mal passé).

(sinon on peut retourner une structure)