ModBus - primeiros resultados

Olá!

Depois de alguns dias batendo cabeça com libaries dos mais diversos tipos parece que consegui encontrar uma que atendeu minhas necessidades com certa estabilidade.

Estou fazendo os testes simulando a aceleração do motor visando o controle de temperatura e tudo tem rodado tranquilamente sem travamentos como estavam ocorrendo.

Um detalhe importante é a proibição da utilização do delay() dentro do loop quando rodando em modbus, depois de algumas horas e umas boas cervejas consegui adaptar a millis() em meu código.

Ma qual a necessidade de um delay no código? Simples, evitar a aceleração imediata do motor; basicamente ele acelera um pouco, espera 3 segundos, testa a temperatura desejada com a atual e acelera novamente até atingir seu limite de giros ou a temperatura desejada.

No decorrer da semana irei montar todos os componentes novamente e filmo o resultado.

Fonte da biblioteca ModBus utilizada: https://code.google.com/p/arduino-modbus-slave/

Código preliminar (vou transformar alguns pontos em funções):


#include <modbus.h>
#include <modbusDevice.h>
#include <modbusRegBank.h>
#include <modbusSlave.h>

#include "DHT11.h" // Importa a Biblioteca do sensor de umidade e temperatura
#include <Servo.h>

/*
This example code shows a quick and dirty way to get an
arduino to talk to a modbus master device with a
device ID of 1 at 9600 baud.
*/

//Setup the brewtrollers register bank
//All of the data accumulated will be stored here
modbusDevice regBank;
//Create the modbus slave protocol handler
modbusSlave slave;


//variaveis de controle do sistema
int ConstMotor = 0;
int FimMotor = 1023;
int val = 0;
int Comando = 0;
int TempAtual = 0;


Servo myservo; // crie objeto Servo para controlar o servomotor

int ledPin4 = 4;
#define dht11_pin 4 // Usa o pino digital 4 para receber umidade/temperatura
// Cria Instancia da Classe do sensor de temperatura
DHT11 sensor1(dht11_pin);


void setup()
{   

         myservo.attach(9); // setando o pino do servo 
        
        sensor1.Initialize(); //inicializando o sensor de temperatura e umidade
  
//Assign the modbus device ID.  
  regBank.setId(1);

/*
modbus registers follow the following format
00001-09999  Digital Outputs, A master device can read and write to these registers
10001-19999  Digital Inputs, A master device can only read the values from these registers
30001-39999  Analog Inputs, A master device can only read the values from these registers
40001-49999  Analog Outputs, A master device can read and write to these registers 

Analog values are 16 bit unsigned words stored with a range of 0-32767
Digital values are stored as bytes, a zero value is OFF and any nonzer value is ON

It is best to configure registers of like type into contiguous blocks.  this
allows for more efficient register lookup and and reduces the number of messages
required by the master to retrieve the data
*/

//Add Analog Output registers 40001-40020 to the register bank
  regBank.add(40001);  
  regBank.add(40002);  
  regBank.add(40003);  
  regBank.add(40004);  
  regBank.add(40005);  
  regBank.add(40006);  
  regBank.add(40007);  
  regBank.add(40008);  
  regBank.add(40009);  
  regBank.add(40010);  
  regBank.add(40011);  
  regBank.add(40012);  
  regBank.add(40013);  
  regBank.add(40014);  
  regBank.add(40015);  
  regBank.add(40016);  
  regBank.add(40017);  
  regBank.add(40018);  
  regBank.add(40019);  
  regBank.add(40020);  

/*
Assign the modbus device object to the protocol handler
This is where the protocol handler will look to read and write
register data.  Currently, a modbus slave protocol handler may
only have one device assigned to it.
*/
  slave._device = &regBank;  

// Initialize the serial port for coms at 9600 baud  
  slave.setBaud(9600);   
}

long previousMillis = 0; // previousMillis irá armazenar o ultimo número da função millis()
long interval = 1000; // intervalo em que o motor irá esperar

void loop()
{
  
 while(1)
 {
    
  //************** SENSOR DE TEMPERATURA E UMIDADE ***********************
  double sensorData[2];
  int result;
  result = sensor1.Read(sensorData);                
  //*************** FIM DE SENSOR *****************************************  
          
 /*Escrevendo no ModBus = regBank.SET */
    regBank.set(40001, (int) 27 + sensorData[0]); //umidade
    regBank.set(40002, (int) sensorData[1]); //temperatura
    regBank.set(40003, (int) ConstMotor); //velocidade moto


 /*Lendo do ModBus = regBank.GET */
    int Comando = regBank.get(40004); //Lendo o valor do Set-Point da temperatura
    int TempAtual =  regBank.get(40002); //Lendo o valor da temperatura

//Na impossibilidade de usar o Delay(0 por truncar a execução do script, vamos partir para um millis().

    unsigned long currentMillis = millis(); //variável currentMillis irá armazenar o tempo
    if(currentMillis - previousMillis > interval) {
        previousMillis = currentMillis; //armazena a variável currentMillis para previousMillis
    
        //verifico a existencia de comando e solto as rotinas...
        if (Comando > 0){
              if (ConstMotor < FimMotor){ 
                if (Comando < TempAtual){ //se o set-point é menor que a temp atual eu acelero o motor
                  ConstMotor = ConstMotor + 10;  
                  val = map(ConstMotor, 0, 1023, 0, 179); 
                  myservo.write(val); 
                  regBank.set(40003, (int) ConstMotor);
                }  
              }

         if (Comando > TempAtual){ //se o set-point é maior que a temp atual eu reduzo o motor
             if (ConstMotor > 10) {
               ConstMotor = ConstMotor - 10;  
               val = map(ConstMotor, 0, 1023, 0, 179); 
               myservo.write(val); 
               regBank.set(40003, (int) ConstMotor);
             }else {
               ConstMotor = 0;  //se já for menor que 10 eu paro o motor de vez
               val = map(ConstMotor, 0, 1023, 0, 179); 
               myservo.write(val); 
               regBank.set(40003, (int) ConstMotor);                
             }
         }

         if (Comando == 0){
            ConstMotor = 0;  
            val = map(ConstMotor, 0, 1023, 0, 179); 
            myservo.write(val); 
            regBank.set(40003, (int) ConstMotor);
          }
        }  
    }
     slave.run(); 
  }
}