Manual MAC

Author: budulinek

README.md

@@ -100,6 +100,9 @@ You can either:
 Connect your Arduino to ethernet and use your web browser to access the web interface on default IP:  http://192.168.1.254
 Enjoy :-)
 # Settings
+  - settings marked \* are only available if ENABLE_DHCP is defined in the sketch
+  - settings marked \*\* are only available if ENABLE_EXTRA_DIAG is defined in the sketch
+
 ## System Info
 <img src="pics/modbus1.png" alt="01" style="zoom:100%;" />
 
@@ -111,7 +114,7 @@ Enjoy :-)
 
 **Ethernet Sockets**. Max number of usable sockets. See Limitations bellow. One socket is reserved for Modbus UDP, remaining sockets are shared between Modbus TCP and WebUI.
 
-**Generate New MAC**. Generate new MAC address. First 3 bytes are fixed 90:A2:DA, remaining 3 bytes are true random.
+**MAC Address**. First 3 bytes are fixed 90:A2:DA, remaining 3 bytes are random. You can also set manual MAC in IP Settings.
 
 ## Modbus Status
 <img src="pics/modbus2.png" alt="02" style="zoom:100%;" />
@@ -159,6 +162,8 @@ Enjoy :-)
 ## IP Settings
 <img src="pics/modbus3.png" alt="03" style="zoom:100%;" />
 
+**MAC Address**. Change MAC address. "Randomize" button will generate new random MAC (first 3 bytes fixed 90:A2:DA, last 3 bytes will be random).
+
 **Auto IP**.\* Once enabled, Arduino will receive IP, gateway, subnet and DNS from the DHCP server.
 
 **Static IP**. Set new static IP address. Gateway automatically redirect the web interface to the new IP.

arduino-modbus-rtu-tcp-gateway/01-interfaces.ino

@@ -55,8 +55,8 @@ void startSerial() {
 }
 
 // number of bits per character (11 in default Modbus RTU settings)
-byte bitsPerChar() {
-  byte bits =
+uint8_t bitsPerChar() {
+  uint8_t bits =
     1 +                                                         // start bit
     (((localConfig.serialConfig & 0x06) >> 1) + 5) +            // data bits
     (((localConfig.serialConfig & 0x08) >> 3) + 1);             // stop bits
@@ -65,7 +65,7 @@ byte bitsPerChar() {
 }
 
 // character timeout in micros
-unsigned long charTimeOut() {
+uint32_t charTimeOut() {
   if (localConfig.baud <= 192) {
     return (15000UL * bitsPerChar()) / localConfig.baud;  // inter-character time-out should be 1,5T
   } else {
@@ -74,7 +74,7 @@ unsigned long charTimeOut() {
 }
 
 // minimum frame delay in micros
-unsigned long frameDelay() {
+uint32_t frameDelay() {
   if (localConfig.baud <= 192) {
     return (35000UL * bitsPerChar()) / localConfig.baud;  // inter-frame delay should be 3,5T
   } else {
@@ -90,9 +90,6 @@ void startEthernet() {
     digitalWrite(ETH_RESET_PIN, HIGH);
     delay(ETH_RESET_DELAY);
   }
-  byte mac[6];
-  memcpy(mac, MAC_START, 3);               // set first 3 bytes
-  memcpy(mac + 3, localConfig.macEnd, 3);  // set last 3 bytes
 #ifdef ENABLE_DHCP
   if (localConfig.enableDhcp) {
     dhcpSuccess = Ethernet.begin(mac);
@@ -131,7 +128,7 @@ void maintainDhcp() {
 
 #ifdef ENABLE_EXTRA_DIAG
 void maintainUptime() {
-  unsigned long milliseconds = millis();
+  uint32_t milliseconds = millis();
   if (last_milliseconds > milliseconds) {
     //in case of millis() overflow, store existing passed seconds
     remaining_seconds = seconds;
@@ -147,8 +144,8 @@ void maintainUptime() {
 
 bool rollover() {
   // synchronize roll-over of run time, data counters and modbus stats to zero, at 0xFFFFFF00
-  const unsigned long ROLLOVER = 0xFFFFFF00;
-  for (byte i = 0; i < ERROR_LAST; i++) {
+  const uint32_t ROLLOVER = 0xFFFFFF00;
+  for (uint8_t i = 0; i < ERROR_LAST; i++) {
     if (errorCount[i] > ROLLOVER) {
       return true;
     }
@@ -157,7 +154,7 @@ bool rollover() {
   if (seconds > ROLLOVER) {
     return true;
   }
-  for (byte i = 0; i < DATA_LAST; i++) {
+  for (uint8_t i = 0; i < DATA_LAST; i++) {
     if (rtuCount[i] > ROLLOVER || ethCount[i] > ROLLOVER) {
       return true;
     }
@@ -181,20 +178,23 @@ void generateMac() {
   seed1 = 36969L * (seed1 & 65535L) + (seed1 >> 16);
   seed2 = 18000L * (seed2 & 65535L) + (seed2 >> 16);
   uint32_t randomBuffer = (seed1 << 16) + seed2; /* 32-bit random */
-  for (byte i = 0; i < 3; i++) {
-    localConfig.macEnd[i] = randomBuffer & 0xFF;
+  memcpy(mac, MAC_START, 3);                     // set first 3 bytes
+  for (uint8_t i = 0; i < 3; i++) {
+    mac[i + 3] = randomBuffer & 0xFF;  // random last 3 bytes
     randomBuffer >>= 8;
   }
 }
 
 void updateEeprom() {
   eepromTimer.sleep(EEPROM_INTERVAL * 60UL * 60UL * 1000UL);  // EEPROM_INTERVAL is in hours, sleep is in milliseconds!
   eepromWrites++;                                             // we assume that at least some bytes are written to EEPROM during EEPROM.update or EEPROM.put
-  int address = CONFIG_START;
+  uint16_t address = CONFIG_START;
   EEPROM.put(address, eepromWrites);
   address += sizeof(eepromWrites);
   EEPROM.put(address, VERSION[0]);
   address += 1;
+  EEPROM.put(address, mac);
+  address += 6;
   EEPROM.put(address, localConfig);
   address += sizeof(localConfig);
   EEPROM.put(address, errorCount);
@@ -208,25 +208,25 @@ void updateEeprom() {
 }
 
 #if MAX_SOCK_NUM == 8
-unsigned long lastSocketUse[MAX_SOCK_NUM] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-byte socketInQueue[MAX_SOCK_NUM] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+uint32_t lastSocketUse[MAX_SOCK_NUM] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+uint8_t socketInQueue[MAX_SOCK_NUM] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 #elif MAX_SOCK_NUM == 4
-unsigned long lastSocketUse[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
-byte socketInQueue[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+uint32_t lastSocketUse[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+uint8_t socketInQueue[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
 #endif
 
 // from https://github.com/SapientHetero/Ethernet/blob/master/src/socket.cpp
 void manageSockets() {
   uint32_t maxAge = 0;         // the 'age' of the socket in a 'disconnectable' state that was last used the longest time ago
-  byte oldest = MAX_SOCK_NUM;  // the socket number of the 'oldest' disconnectable socket
-  byte modbusListening = MAX_SOCK_NUM;
-  byte webListening = MAX_SOCK_NUM;
-  byte dataAvailable = MAX_SOCK_NUM;
-  byte socketsAvailable = 0;
+  uint8_t oldest = MAX_SOCK_NUM;  // the socket number of the 'oldest' disconnectable socket
+  uint8_t modbusListening = MAX_SOCK_NUM;
+  uint8_t webListening = MAX_SOCK_NUM;
+  uint8_t dataAvailable = MAX_SOCK_NUM;
+  uint8_t socketsAvailable = 0;
   // SPI.beginTransaction(SPI_ETHERNET_SETTINGS);								// begin SPI transaction
   // look at all the hardware sockets, record and take action based on current states
-  for (byte s = 0; s < maxSockNum; s++) {            // for each hardware socket ...
-    byte status = W5100.readSnSR(s);                 //  get socket status...
+  for (uint8_t s = 0; s < maxSockNum; s++) {            // for each hardware socket ...
+    uint8_t status = W5100.readSnSR(s);                 //  get socket status...
     uint32_t sockAge = millis() - lastSocketUse[s];  // age of the current socket
     if (socketInQueue[s] > 0) {
       lastSocketUse[s] = millis();
@@ -313,7 +313,7 @@ void manageSockets() {
   // we do not need SPI.beginTransaction(SPI_ETHERNET_SETTINGS) or SPI.endTransaction()
 }
 
-void disconSocket(byte s) {
+void disconSocket(uint8_t s) {
   if (W5100.readSnSR(s) == SnSR::ESTABLISHED) {
     W5100.execCmdSn(s, Sock_DISCON);  // Sock_DISCON does not close LISTEN sockets
     lastSocketUse[s] = millis();      //   record time at which it was sent...

arduino-modbus-rtu-tcp-gateway/02-modbus-tcp.ino

@@ -40,25 +40,25 @@ uint8_t masks[8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
 uint16_t crc;
 
 void recvUdp() {
-  unsigned int msgLength = Udp.parsePacket();
+  uint16_t msgLength = Udp.parsePacket();
   if (msgLength) {
 #ifdef ENABLE_EXTRA_DIAG
     ethCount[DATA_RX] += msgLength;
 #endif                               /* ENABLE_EXTRA_DIAG */
-    byte inBuffer[MODBUS_SIZE + 4];  // Modbus TCP frame is 4 bytes longer than Modbus RTU frame
+    uint8_t inBuffer[MODBUS_SIZE + 4];  // Modbus TCP frame is 4 bytes longer than Modbus RTU frame
                                      // Modbus TCP/UDP frame: [0][1] transaction ID, [2][3] protocol ID, [4][5] length and [6] unit ID (address)..... no CRC
                                      // Modbus RTU frame: [0] address.....[n-1][n] CRC
     Udp.read(inBuffer, sizeof(inBuffer));
     while (Udp.available()) Udp.read();
-    byte errorCode = checkRequest(inBuffer, msgLength, (uint32_t)Udp.remoteIP(), Udp.remotePort(), UDP_REQUEST);
+    uint8_t errorCode = checkRequest(inBuffer, msgLength, (uint32_t)Udp.remoteIP(), Udp.remotePort(), UDP_REQUEST);
     if (errorCode) {
       // send back message with error code
       Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
       if (!localConfig.enableRtuOverTcp) {
         Udp.write(inBuffer, 5);
         Udp.write(0x03);
       }
-      byte addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
+      uint8_t addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
       Udp.write(inBuffer[addressPos]);                      // address
       Udp.write(inBuffer[addressPos + 1] + 0x80);           // function + 0x80
       Udp.write(errorCode);
@@ -80,26 +80,26 @@ void recvUdp() {
 }
 
 void recvTcp(EthernetClient &client) {
-  unsigned int msgLength = client.available();
+  uint16_t msgLength = client.available();
 #ifdef ENABLE_EXTRA_DIAG
   ethCount[DATA_RX] += msgLength;
 #endif                             /* ENABLE_EXTRA_DIAG */
-  byte inBuffer[MODBUS_SIZE + 4];  // Modbus TCP frame is 4 bytes longer than Modbus RTU frame
+  uint8_t inBuffer[MODBUS_SIZE + 4];  // Modbus TCP frame is 4 bytes longer than Modbus RTU frame
   // Modbus TCP/UDP frame: [0][1] transaction ID, [2][3] protocol ID, [4][5] length and [6] unit ID (address).....
   // Modbus RTU frame: [0] address.....
   client.read(inBuffer, sizeof(inBuffer));
   while (client.available()) client.read();
-  byte errorCode = checkRequest(inBuffer, msgLength, {}, client.remotePort(), TCP_REQUEST | client.getSocketNumber());
+  uint8_t errorCode = checkRequest(inBuffer, msgLength, {}, client.remotePort(), TCP_REQUEST | client.getSocketNumber());
   if (errorCode) {
     // send back message with error code
-    byte i = 0;
-    byte outBuffer[9];
+    uint8_t i = 0;
+    uint8_t outBuffer[9];
     if (!localConfig.enableRtuOverTcp) {
       memcpy(outBuffer, inBuffer, 5);
       outBuffer[5] = 0x03;
       i = 6;
     }
-    byte addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
+    uint8_t addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
     outBuffer[i++] = inBuffer[addressPos];                // address
     outBuffer[i++] = inBuffer[addressPos + 1] + 0x80;     // function + 0x80
     outBuffer[i++] = errorCode;
@@ -122,7 +122,7 @@ void recvTcp(EthernetClient &client) {
 
 void scanRequest() {
   // Insert scan request into queue, allow only one scan request in a queue
-  static byte scanCommand[] = { SCAN_FUNCTION_FIRST, 0x00, SCAN_DATA_ADDRESS, 0x00, 0x01 };
+  static uint8_t scanCommand[] = { SCAN_FUNCTION_FIRST, 0x00, SCAN_DATA_ADDRESS, 0x00, 0x01 };
   if (scanCounter != 0 && queueHeaders.available() > 1 && queueData.available() > sizeof(scanCommand) + 1 && scanReqInQueue == false) {
     scanReqInQueue = true;
     // Store scan request in request queue
@@ -135,7 +135,7 @@ void scanRequest() {
       0,                        // atts
     });
     queueData.push(scanCounter);  // address of the scanned slave
-    for (byte i = 0; i < sizeof(scanCommand); i++) {
+    for (uint8_t i = 0; i < sizeof(scanCommand); i++) {
       queueData.push(scanCommand[i]);
     }
     if (scanCommand[0] == SCAN_FUNCTION_FIRST) {
@@ -148,8 +148,8 @@ void scanRequest() {
   }
 }
 
-byte checkRequest(byte inBuffer[], unsigned int msgLength, const uint32_t remoteIP, const unsigned int remotePort, byte requestType) {
-  byte addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
+uint8_t checkRequest(uint8_t inBuffer[], uint16_t msgLength, const uint32_t remoteIP, const uint16_t remotePort, uint8_t requestType) {
+  uint8_t addressPos = 6 * !localConfig.enableRtuOverTcp;  // position of slave address in the incoming TCP/UDP message (0 for Modbus RTU over TCP/UDP and 6 for Modbus RTU over TCP/UDP)
   if (localConfig.enableRtuOverTcp) {                   // check CRC for Modbus RTU over TCP/UDP
     if (checkCRC(inBuffer, msgLength) == false) {
       errorCount[ERROR_TCP]++;
@@ -194,7 +194,7 @@ byte checkRequest(byte inBuffer[], unsigned int msgLength, const uint32_t remote
     byte(requestType),             // requestType
     0,                             // atts
   });
-  for (byte i = 0; i < msgLength; i++) {
+  for (uint8_t i = 0; i < msgLength; i++) {
     queueData.push(inBuffer[i + addressPos]);
   }
   if (queueData.size() > queueDataSize) queueDataSize = queueData.size();
@@ -208,7 +208,7 @@ void deleteRequest()  // delete request from queue
   if (myHeader.requestType & SCAN_REQUEST) scanReqInQueue = false;
   if (myHeader.requestType & TCP_REQUEST) socketInQueue[myHeader.requestType & TCP_REQUEST_MASK]--;
   if (myHeader.requestType & PRIORITY_REQUEST) priorityReqInQueue--;
-  for (byte i = 0; i < myHeader.msgLen; i++) {
+  for (uint8_t i = 0; i < myHeader.msgLen; i++) {
     queueData.shift();
   }
   queueHeaders.shift();
@@ -224,17 +224,17 @@ void clearQueue() {
   sendMicroTimer.sleep(0);
 }
 
-bool getSlaveStatus(const uint8_t slave, const byte status) {
+bool getSlaveStatus(const uint8_t slave, const uint8_t status) {
   if (slave >= MAX_SLAVES) return false;  // error
   return (slaveStatus[status][slave / 8] & masks[slave & 7]) > 0;
 }
 
-void setSlaveStatus(const uint8_t slave, byte status, const bool value, const bool isScan) {
+void setSlaveStatus(const uint8_t slave, uint8_t status, const bool value, const bool isScan) {
   if (slave >= MAX_SLAVES || status > SLAVE_ERROR_0B_QUEUE) return;  // error
   if (value == 0) {
     slaveStatus[status][slave / 8] &= ~masks[slave & 7];
   } else {
-    for (byte i = 0; i <= SLAVE_ERROR_0B_QUEUE; i++) {
+    for (uint8_t i = 0; i <= SLAVE_ERROR_0B_QUEUE; i++) {
       slaveStatus[i][slave / 8] &= ~masks[slave & 7];  // set all other flags to false, SLAVE_ERROR_0B_QUEUE is the last slave status
     }
     slaveStatus[status][slave / 8] |= masks[slave & 7];