Ämne: Någon som köpt MODBUS 40

[Bergen77]

Noen som har sett noe mer på modbus til Nibe? Må man ha denne modbus-40 eller klarer man å lese ut modbus uten?

[Andybaa]

Hei,

Jeg har jobba en del med dette for noen måneder siden. Jeg har fått til å lese ut sykliske data ved bruk av en Arduino og nibegw programmet (søk på Google). Videre har jeg fått til å skrive og lese spesifikke parametre fra en VVM320. Alt er gjort uten Modbus-40.

[944_Driver]

Jag har lyckats läsa och skriva till register på min F1155 med en Arduino och en RS485 omvandlare nu.
Protokollet bygger på att VP:n inleder all kommunikation och den anslutna enheten svarar med NAK, ACK eller med sitt eget meddelande.

Exempel, skicka -50 till register 47206:
Allt i HEX.
Detta kanske först framstår som ett meddelande men är tre stycken.
5C 00 20 6B 00 4B C0 6B 06 66 B8 CE FF 00 00 42 06

VP skickar
5C 00 20 6B 00 4B
nedbrutet:
5C= start på kommunikation
00= alltid 00?
20= adress till modbus40
6B= kommando, fråga från VP till modbus40 om den vill skriva till något register i VP
00= längd på data, 0 bytes i detta fall eftersom VP inte skickar någon data, bara en fråga.
4B= checksum

...och arduino/modbus svarar:
C0 6B 06 66 B8 CE FF 00 00 42
nedbrutet:
C0= meddelande inleds med C0
6B= kommando, skriva till register i VP
06= 6 bytes data i meddelandet, adress*2 + data*4, i detta exempel är det en 16-bitars int så två bytes används.
66 B8 CE FF 00 00= addressLSB addressMSB dataLSB dataMSB 0 0
10= checksum XOR

VP svarar
06 (ack)

Vill man läsa av samma register ser det ut så här:
Invänta att VP skickar meddelande med kommando 69, skicka C0 69 02 66 B8 [checksum] och VP skickar svaret i nästa meddelande.

// Magnus

[944_Driver]

Här är lite kod jag knåpat ihop för att testa det hela med. I grunden är det NibeGW som jag utgått från och lagt till funktioner för att skriva till VP i. Troligen inte nått vidare optimal kod men det kan kanske hjälpa någon att förstå och utveckla det vidare.

OBS!! testa på egen risk, du skriver data rakt in i maskin och det kan bli väldigt fel.

// Magnus

/* ----------------------------------------------------------------------------
 *  Arduino Mega used.
 *  Serial1 used for RS485, settings: 9600 baud, 8 bits, Parity: none, Stop bits 1
 *  Modbus40 must be selected in heat pump.
 *
 *  Message:
 *  +----+----+----+-----+-----+----+-...---+-----+
 *  | 5C | 00 | 20 | CMD | LEN |  DATA...   | CHK |
 *  +----+----+----+-----+-----+----+-...---+-----+
 *
 *   ACK = 0x06
 *   NAK = 0x15
 */


// ######### CONFIGURATION #######################

// enable debug printouts, put '//' before to disable
#define ENABLE_DEBUG

// ######### VARIABLES #######################

// direction change pin for RS-485 port
#define directionPin  22

#ifdef ENABLE_DEBUG
char verbose = 9; 
char debug_buf[50];
#endif

const byte numChars = 16;
char receivedChars[numChars]; // an array to store the received data

boolean newData = false;
String addrString = "";     // string to hold input
byte bytesBuff[5];
byte addrBuff[2];   // addr should be in 40000-49999 range
byte dataBuff[4];   // data can 1 to 4 bytes depending on address, look in Nibe documentation
long dataLong;

// state machine states
enum e_state {
  STATE_WAIT_START,
  STATE_WAIT_DATA,
  STATE_OK_MESSAGE_RECEIVED,
  STATE_CRC_FAILURE,
  STATE_SEND_MESSAGE,
};

e_state state = STATE_WAIT_START;


// message buffers for RS-485 communication 
#define MAX_DATA_LEN 127
byte rx_buffer[MAX_DATA_LEN];
byte tx_buffer[30];     // just a guesss... needs to be checked up.

byte index = 0;
byte LastMessageCommand;
boolean WantToTx, PrintNextMess;
byte TxCommand = 0;
byte BytesToSend = 0;

// ######### SETUP #######################

void setup()  {
//  wdt_enable (WDTO_1S);
 
  pinMode(directionPin, OUTPUT);
  digitalWrite(directionPin, LOW);

  Serial.begin(115200, SERIAL_8N1);
  Serial1.begin(9600, SERIAL_8N1);
 
//  Ethernet.begin(mac,ip);
 // udp.begin(udp_port);
 
  #ifdef ENABLE_DEBUG
  if (verbose) {
    debugPrint("\nStarted...\n");
  }
  #endif
}

// ######### MAIN LOOP #######################

void loop() {

  recvWithEndMarker();    // read user input on serial

  // Read data from register x, syntax: r4xxxx
  if ((receivedChars[0] == 'r') && (receivedChars[1] == '4') && (receivedChars[7] == '\0') && (newData == true))  // look for r4xxxx data...
  {
    // create string for address
    addrString = "";    // clear before using
    addrString += receivedChars[1];
    addrString += receivedChars[2];
    addrString += receivedChars[3];
    addrString += receivedChars[4];
    addrString += receivedChars[5];
 
    dataLong = addrString.toInt();
    addrBuff[0] = (dataLong >> 0x08 )& 0xFF;   // high byte
    addrBuff[1] = dataLong & 0xFF;             // low byte
 
   // create buffer to send
    tx_buffer[0] = 0xC0;  // start?
    tx_buffer[1] = 0x69;  // Request data command 69
    tx_buffer[2] = 0x02;  // lenght
    tx_buffer[3] = addrBuff[1];
    tx_buffer[4] = addrBuff[0]; 
    tx_buffer[5] = CalcChecksum(tx_buffer, (2+3));
    // set some control variables
    TxCommand = tx_buffer[1];
    WantToTx = true;
    newData = false;    //true for test, false for live
    BytesToSend = tx_buffer[2];
  }

// Write data y to register x, syntax: w4xxxx=yyyyy
// test with room temp setpoint 47398=200 => 20,0C
// test with GM between elec. add on steps 47209=300

  if ((receivedChars[0] == 'w') && (receivedChars[1] == '4') && (receivedChars[6] == '=') && (receivedChars[14] == '\0') && (newData == true))  // look for w4xxxx:yyyyy...
  {
    // create string for address
    addrString = "";    // clear before using
    addrString += receivedChars[1];
    addrString += receivedChars[2];
    addrString += receivedChars[3];
    addrString += receivedChars[4];
    addrString += receivedChars[5];
 
    dataLong = addrString.toInt();
    addrBuff[0] = (dataLong >> 0x08 )& 0xFF;   // high byte
    addrBuff[1] = dataLong & 0xFF;             // low byte

    // create string for data
    addrString = "";    // clear before using
    addrString += receivedChars[7];
    addrString += receivedChars[8];
    addrString += receivedChars[9];
    addrString += receivedChars[10];
    addrString += receivedChars[11];

    dataLong = addrString.toInt();
    dataBuff[0] = (dataLong >> 0x08 )& 0xFF;   // high byte
    dataBuff[1] = dataLong & 0xFF;             // low byte

   // create buffer to send
    tx_buffer[0] = 0xC0;  // start?
    tx_buffer[1] = 0x6B;  // Write data command 6B (from modbus40)
    tx_buffer[2] = 0x06;  // lenght, need to check if last 0x00 bytes can be omitted and use length 4 instead?
    tx_buffer[3] = addrBuff[1];
    tx_buffer[4] = addrBuff[0]; 
    tx_buffer[5] = dataBuff[1];
    tx_buffer[6] = dataBuff[0];
    tx_buffer[7] = 0x00;
    tx_buffer[8] = 0x00;
    tx_buffer[9] = CalcChecksum(tx_buffer, (6+3));
    // set some control variables
    TxCommand = tx_buffer[1];
    WantToTx = true;
    newData = false;   //true for test, false for live
    BytesToSend = tx_buffer[2];
  }

 
  #ifdef ENABLE_DEBUG
 
  #endif
 
  switch(state) {
 
    case STATE_WAIT_START:
      if (Serial1.available() > 0) {
        byte b = Serial1.read();
 
        #ifdef ENABLE_DEBUG
        if (verbose > 2) {
          sprintf(debug_buf,"%02x", b);
        }
        #endif
       
        if (b == 0x5C) {
          rx_buffer[0] = b;
          index = 1;
          state = STATE_WAIT_DATA;
         
          #ifdef ENABLE_DEBUG
          if (verbose > 1) {
            debugPrint("Frame start found\n");
          }
          #endif
        }
      }
      break;
     
    case STATE_WAIT_DATA:
      if (Serial1.available() > 0) {
        byte b = Serial1.read();
 
        #ifdef ENABLE_DEBUG
        if (verbose > 2) {
          sprintf(debug_buf, "%02x", b);
        }
        #endif
     
        if (index >= MAX_DATA_LEN)
        {
          // too long message
          state = STATE_WAIT_START;
        }
        else
        {
          rx_buffer[index++] = b;
         
          int msglen = checkNibeMessage(rx_buffer, index);
         
          #ifdef ENABLE_DEBUG
          if (verbose > 1) {
            sprintf(debug_buf,"\ncheckMsg=%d\n", msglen);
          }
          #endif
             
          switch (msglen)
          {
            case 0:   break; // Ok, but not ready
            case -1:  state = STATE_WAIT_START; break; // Invalid message
            case -2:  state = STATE_CRC_FAILURE; break; // Checksum error
            default:  state = STATE_OK_MESSAGE_RECEIVED; break;
          }
        }
      }
      break;

    case STATE_CRC_FAILURE:
      #ifdef ENABLE_DEBUG
      if (verbose) {
        debugPrint("CRC failure\n");
      }
      #endif
     
      sendNak();
      state = STATE_WAIT_START;
      break;
   
    case STATE_OK_MESSAGE_RECEIVED:
      #ifdef ENABLE_DEBUG
      if (verbose) {
        debugPrint("Message received\n");
      }
      #endif

      LastMessageCommand = rx_buffer[3];

      // ****************** time to transmitt some data **********************
      if (WantToTx && (TxCommand == LastMessageCommand))
      {
        sendDataBytes(tx_buffer, (BytesToSend+4));
        PrintNextMess = true; // print respons for debug..
        WantToTx = false;
      }
      else
      {
        sendAck();
      }
     
      // print packet if....
      // if data contains 0x5C (start character)
      if (rx_buffer[0] == 0x5C)
        sendUdpPacket(rx_buffer, index);

      if (PrintNextMess && rx_buffer[3] == 0x6A)  // print for debug purpose...
      {
        PrintNextMess = false;
        for (int i=0 ; i<index ; i++)
        {
          Serial.print(rx_buffer,HEX);
          Serial.print(" ");
        }
        Serial.print('\n');
      }
     
      state = STATE_WAIT_START;
      break;
  }
}

// ######### FUNCTIONS #######################

// read data from serial port
void recvWithEndMarker()
{
 static byte ndx = 0;
 char endMarker = '\n';
 int rc;
 
 // if (Serial.available() > 0) {
  while (Serial.available() > 0 && newData == false)
  {
    rc = Serial.read();
    if (rc != endMarker)
    {
      receivedChars[ndx] = rc;
      ndx++;
      if (ndx >= numChars)
      {
        ndx = numChars - 1;
      }
    }
    else
    {
      receivedChars[ndx] = '\0'; // terminate the string
      ndx = 0;
      newData = true;
    }
  }
}


/*
 * Return:
 *  >0 if valid message received (return message len)
 *   0 if ok, but message not ready
 *  -1 if invalid message
 *  -2 if checksum fails
 */
int checkNibeMessage(const byte* const data, byte len)
{
    #ifdef ENABLE_DEBUG
    if (verbose > 2) {
      sprintf(debug_buf,"\nlen=%u\n", len);
    }
    #endif
   
    if (len <= 0)
        return 0;
   
    if (len >= 1)
    {
        if (data[0] != 0x5C)
            return -1;
       
        if (len >= 3)
        {
            if (data[1] != 0x00 && data[2] != 0x20)
                return -1;
        }
       
        if (len >= 6)
        {
            int datalen = data[4];
           
            if (len < datalen + 6)
                return 0;
           
            byte checksum = 0;
           
            // calculate XOR checksum
            for(int i = 2; i < (datalen + 5); i++)
                checksum ^= data;
           
            byte msg_checksum = data[datalen + 5];
           
            #ifdef ENABLE_DEBUG
            if (verbose > 1) {
              sprintf(debug_buf,"%02x", checksum, msg_checksum);
            }
            #endif
                     
            if (checksum != msg_checksum) {
             
              // check special case, if checksum is 0x5C (start character),
              // heat pump seems to send 0xC5 checksum
              if (checksum != 0x5C && msg_checksum != 0xC5)
                return -2;
            } 
            return datalen + 6;
        }     
    }
   
    return 0;
   
}

byte CalcChecksum(const byte* const data, int len)
{
  // calculate XOR checksum
  byte checksum = 0;
  for(int i = 0; i < len; i++)
    checksum ^= data;

    // check special case, if checksum is 0x5C (start character),
    // heat pump seems to want 0xC5 checksum back
  if (checksum == 0x5C)
    checksum = 0xC5;
  return checksum;
}

void sendAck()
{
  #ifdef ENABLE_DEBUG
  if (verbose) {
    debugPrint("Sending ACK\n");
  }
  #endif
 
  digitalWrite(directionPin, HIGH);
  delay(1);             // 1ms
  Serial1.write(0x06);
  Serial1.flush();       // Wait for tx to finish
  delay(1);
  digitalWrite(directionPin, LOW);
}

void sendNak()
{
  #ifdef ENABLE_DEBUG
  if (verbose) {
    debugPrint("Sending NAK\n");
  }
  #endif
 
  digitalWrite(directionPin, HIGH);
  delay(1);
  Serial1.write(0x15);
  Serial1.flush();
  delay(1);
  digitalWrite(directionPin, LOW);
}

void sendDataBytes(const byte* const data, int len)
{
  #ifdef ENABLE_DEBUG
  if (verbose) {
    debugPrint(" **** Sending data ****\n");
  }
  #endif
 
  digitalWrite(directionPin, HIGH);
  delay(1);
  int i;
  for (i=0; i<len; i++)
  {
    Serial1.write(data);
  }
  Serial1.flush();
  delay(1);
  digitalWrite(directionPin, LOW);
}

void sendUdpPacket(const byte* const data, int len) {
 
  #ifdef ENABLE_DEBUG
  if (verbose) {
    sprintf(debug_buf, "Sending UDP packet, len=%d\n", len);
    if (verbose > 2) {
      int i;
      for (i=0; i<len; i++) {
        sprintf(debug_buf,"%02x", data);
      }
      debugPrint("\n");
    }
  }
  #endif
 
}

#ifdef ENABLE_DEBUG

void debugPrint(char* data) {
  Serial.write(data);

}
#endif

[Bergen77]

Jeg sliter med å lese ut verdien fra DMstart heating (47206), jeg får ut verdien -30 uansett hva GMstart står innstillit på. Er det andre her som leser og skriver modbus data her?

[944_Driver]

Jag har legat lågt på VP fronten i väntan på kyla så jag har inte gjort några mer tester.

// Magnus

[Bergen77]

Jag har legat lågt på VP fronten i väntan på kyla så jag har inte gjort några mer tester.

Jeg forstår, jeg sliter fortsatt med å få jevn temperatur på pumpen men har ikke fått testet noe nå før det har begynt å bli kaldt. Nå kan jeg forske mer her. Har du muligheten for å teste ut å hente 47206 fra varmepumpen? Jeg får lest ander verdier fint men ikke akkurat denne.

[944_Driver]

Min utrustning för test är tyvärr inte inkopplad nu, det är lite uppstartstid för att få igång den igen efter ett halvår i malpåse. Jag återkommer när jag tar tag i det men det kan ta sin tid.

// Magnus

[Bergen77]

Nibe Modbus Manager er kommet i en ny versjon nå. Der finner man en rekke nye modbus registre for dere som liker sånt. Jeg får fortsatt ikke lest ut GMstart fra pumpen, noen andre som kan prøve dette?

[944_Driver]

Nu fick jag igång min testutrustning igen. Det gick fint att läsa ut 47206. Fick ut FFBA i hex eller -70 i decimalform vilket är vad jag ställt in just nu.

Hela strängen blev 5C 0 20 6A 6 66 B8 BA FF 0 0 D7

// Magnus

[Bergen77]

Nu fick jag igång min testutrustning igen. Det gick fint att läsa ut 47206. Fick ut FFBA i hex eller -70 i decimalform vilket är vad jag ställt in just nu.
Hela strängen blev 5C 0 20 6A 6 66 B8 BA FF 0 0 D7
// Magnus

Har du noen andre verdier du leser med samme formatet? Hvilken versjon har du på programvaren, siste?

[Bergen77]

Jeg klarer fint å lese ut eksempelvis DM Between add. steps register 47209. Bruker du samme format på 47209 som 47206?

[944_Driver]

Jag får prova på 47209 när jag får tid.
Det som skulle kunna spöka för dig är att 47206 innehåller negativa tal och då måste man ju kunna hantera 2-komplement representation av tal för att kunna tyda det.

// Magnus

[Bergen77]

Det som skulle kunna spöka för dig är att 47206 innehåller negativa tal och då måste man ju kunna hantera 2-komplement representation av tal för att kunna tyda det.

Gradminutt i register 40940 leser jeg fint ut, den er jo som oftest negativ. Hvis jeg leser 47206 på samme måte som 40940 leser jeg alltid ut -30.
Var det slik at du ikke hadde modbus-40 men henter rett fra pumpen? Kunne du oppgitt software versjon så jeg kan sammenligne? Jeg har siste versjonen instalert.

[944_Driver]

Jag ligger lite efter på mjukvaran i pumpen, kör fortfarande 7998R3 då det senare inte verkar innehålla någon förändring jag har nytta av enligt change log. Jag ska uppdatera någon dag när jag får tid.

Jag har tyvärr inte hunnit testa med några fler register nu men jag testade med några olika förra säsongen och såg inga konstigheter. Det är lite omständigt att testa för mig eftersom jag inte skrivit klart koden för att översätta värdena från hex till decimal ännu utan det får jag göra manuellt vid varje test..

// Magnus