RS01毫米波雷达测距传感器

/*!
 * @file  getModuleInfo.ino
 * @brief  Read all the register data from the sensor
 * @details  Experimental phenomenon: serial print sensor basic information, measurement parameters and measured data
 * @copyright  Copyright (c) 2010 DFRobot Co.Ltd (http://www.dfrobot.com)
 * @license  The MIT License (MIT)
 * @author   [qsjhyy](yihuan.huang@dfrobot.com)
 * @version  V1.0
 * @date  2021-07-06
 * @url   https://github.com/DFRobot/DFRobot_RS01
 */
#include <DFRobot_RS01.h>
#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
  #include <SoftwareSerial.h>
#endif

#define DEFAULT_DEVICE_ADDRESS 0x000E
/**
 * DFRobot_RS01 constructor
 * addr: modbus slave address(range1~247)or broadcast address(0x00)
 * If it's configured a broadcast address, send a broadcast packet, and all slaves on bus will process it but not respond
 */
DFRobot_RS01 sensor(/*addr =*/DEFAULT_DEVICE_ADDRESS);

#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
  SoftwareSerial mySerial(/*rx =*/4, /*tx =*/5);
#endif


/* Print measured data */
void print_measure_data(int number, uint16_t distance, uint16_t intensity)
{
  Serial.print("target ");
  Serial.print((number + 1) / 2);
  Serial.print(" distance: ");
  Serial.print(distance);
  Serial.print("  ");
  for(uint16_t i=distance/10; i>0; i--)
    Serial.print("-");
  Serial.println();

  Serial.print("target ");
  Serial.print((number + 1) / 2);
  Serial.print(" intensity: ");
  Serial.print(intensity);
  Serial.print("  ");
  for(uint16_t i=intensity/10; i>0; i--)
    Serial.print("+");
  Serial.println();
}


void setup(void)
{
  Serial.begin(115200);
  Stream *_serial;
#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
  mySerial.begin(115200);   // Excessive baud rate of UNO soft serial port will makes communication unstable, 9600 is recommended
  _serial = &mySerial;
#elif defined(ESP32)
  Serial1.begin(115200, SERIAL_8N1, /*rx =*/D3, /*tx =*/D2);
  _serial = &Serial1;
#else
  Serial1.begin(115200);
  _serial = &Serial1;
#endif

  /**
   * Init function
   * _serial Serial ports for communication, supporting hard and soft serial ports
   * returning 0 means reading succeeds
   */
  while( NO_ERROR != sensor.begin(/*s =*/_serial) ){
    Serial.println("Communication with device failed, please check connection");
    delay(3000);
  }
  Serial.println("Begin ok!");
  Serial.println();
}

void loop()
{
  Serial.println("-----------------read module basic information---------------------");
  /**
   * retrieve the basic information from the sensor and buffer it into the basicInfo structure that stores information:
   * basicInfo structure members:
   *     PID: module PID
   *     VID: module VID
   *     modbusAddr: module communication address
   *     baudrate: module baud rate
   *     checkbit: check bit
   *     stopbit: stop bit
   *     versions: firmware version number
   * returning 0 means reading succeeds
   */
  if(0 == sensor.refreshBasicInfo()){
    /* Module PID, the default value is 0x01E9 (The highest two of 16-bit data are used to determine SKU type: 00: SEN, 01: DFR, 10: TEL, the next 14 are numbers.)(SEN0489) */
    Serial.print("PID: 0x");
    Serial.println(sensor.basicInfo.PID, HEX);

    /* Module VID, the default value is 0x3343(represent manufacturer is DFRobot) */
    Serial.print("VID: 0x");
    Serial.println(sensor.basicInfo.VID, HEX);

    /* Module communication address, the default value is 0x000E, module device address(1~247) */
    Serial.print("mailing address: ");
    Serial.println(sensor.basicInfo.modbusAddr);

    /* Module baud rate, the default value is 0x0009:
     * 0x0001---2400  0x0002---4800  0x0003---9600  0x0004---14400  0x0005---19200
     * 0x0006---38400  0x0007---57600  0x0008---115200  0x0009---1000000 */
    Serial.print("baudrate: 0x");
    Serial.println(sensor.basicInfo.baudrate, HEX);

    /* Module check bit and stop bit, the default value is 0x0001
     * check bit: 0 is none; 1 is even; 2 is odd
     * stop bit: 1bit; 2bit */
    Serial.print("check bit: ");
    Serial.println(sensor.basicInfo.checkbit);
    Serial.print("stop bit: ");
    Serial.println(((sensor.basicInfo.stopbit & 0x00FF) + 1)/2);

    /* Firmware version number: 0x1000 represents V1.0.0.0 */
    Serial.print("versions: 0x");
    Serial.println(sensor.basicInfo.versions, HEX);

  }else{
    Serial.println("Failed to read basic information!!!");
  }
  Serial.println();

  Serial.println("-----------------read module measurement config--------------------");
  /**
   * Retrieve the currently configured parameters from the sensor and buffer it into the structure measurementConfig that stores information:
   * measurementConfig structure members:
   *     startPosition: current measurement start position set value
   *     stopPosition: current measurement stop position set value
   *     initialThreshold: current initial threshold set value
   *     endThreshold: current end threshold set value
   *     moduleSensitivity: current module sensitivity set value
   *     comparisonOffset: current comparison offset set value
   * returning 0 means reading succeeds
   */
  if(0 == sensor.refreshMeasurementConfig()){
    /* current measurement start position set value, 0x0046~0x19C8, can't be greater than the stop position set value */
    Serial.print("start position :  ");
    Serial.println(sensor.measurementConfig.startPosition);

    /* current measurement stop position set value, 0x0046~0x19C8, can't be less than the start position set value */
    Serial.print("stop position :  ");
    Serial.println(sensor.measurementConfig.stopPosition);

    /* current initial threshold set value */
    Serial.print("initial threshold : ");
    Serial.println(sensor.measurementConfig.initialThreshold);

    /* current end threshold set value */
    Serial.print("end threshold : ");
    Serial.println(sensor.measurementConfig.endThreshold);

    /* current module sensitivity set value */
    Serial.print("module sensitivity : ");
    Serial.println(sensor.measurementConfig.moduleSensitivity);

    /* current comparison offset set value */
    Serial.print("comparison offset : ");
    Serial.println(sensor.measurementConfig.comparisonOffset);

  }else{
    Serial.println("Failed to read measurement config!!!");
  }
  Serial.println();

  Serial.println("------------------Read module measurement data---------------------");
  /**
   * re-read the measured data from the sensor and buffer it into the array dataBuf[11] that stores information:
   *    dataBuf[0]: the number of objects currently detected
   *    dataBuf[1]: measured distance to the first object; dataBuf[2]: measured intensity of the first object
   *    dataBuf[3]: measured distance to the second object; dataBuf[4]: measured intensity of the second object
   *    dataBuf[5]: measured distance to the third object; dataBuf[6]: measured intensity of the third object
   *    dataBuf[7]: measured distance to the fourth object; dataBuf[8]: measured intensity of the fourth object
   *    dataBuf[9]: measured distance to the fifth object; dataBuf[10]: measured intensity of the fifth object
   * returning 0 means reading succeeds
   */
  if(0 == sensor.refreshMeasurementData()){
    /*the number of objects currently detected*/
    Serial.print("target amount:  ");
    Serial.println(sensor.dataBuf[0]);
    Serial.println();

    /*measured data*/
    for(int i=1; i<11; i+=2){
      print_measure_data(i, sensor.dataBuf[i], sensor.dataBuf[i+1]);
    }

  }else{
    Serial.println("Failed to read measurement data!!!");
  }

  Serial.println("\n");
  delay(3000);
}

#include "DFRobot_RTU.h"
#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
#include <SoftwareSerial.h>
#endif

#define   SLAVE_ADDR_DEFAULT                ((uint16_t)0x0E)
#define   SLAVE_BAUDRATE_DEFAULT              ((uint32_t)115200)

typedef enum{ 
  ePid,
  eVid,
  eAddr,
  eComCtlL,
  eComCtlH,
  eVersion,
  eNbTargets,
  eDist1,
  eSignalIntensity1,
  eDist2,
  eSignalIntensity2,
  eDist3,
  eSignalIntensity3,
  eDist4,
  eSignalIntensity4,
  eDist5,
  eSignalIntensity5,
  eDetectionStartPos,
  eDetectionStopPos,
  eStartThreshold,
  eStopThreshold,
  eSensitivity,
  eComparisonOffset,
  eRestoreFactorySetting,
  eNbOfReg
}eRegIndex_t;//Sensor register index

#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
  SoftwareSerial mySerial(/*rx =*/4, /*tx =*/5);
  DFRobot_RTU modbus(/*s =*/&mySerial);
#else
  DFRobot_RTU modbus(/*s =*/&Serial1);
#endif

volatile uint16_t cr = 0;
void setup() {
  Serial.begin(9600);
  while(!Serial){                                                     //Waiting for USB Serial COM port to open.
  }

#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
    mySerial.begin(SLAVE_BAUDRATE_DEFAULT);
#elif defined(ESP32)
  Serial1.begin(SLAVE_BAUDRATE_DEFAULT, SERIAL_8N1, /*rx =*/D3, /*tx =*/D2);
#else
  Serial1.begin(SLAVE_BAUDRATE_DEFAULT);
#endif

  modbus.setTimeoutTimeMs(500);
  delay(1000);
 
}

uint16_t ret;
void loop() {
  ret = modbus.writeHoldingRegister(/*id =*/SLAVE_ADDR_DEFAULT, /*reg =*/ eRestoreFactorySetting, /*val =*/0x00);//Write 0 to the register to restore factory Settings
  if(ret == 0){
    Serial.println("The factory Settings are restored successfully!");
  }else{
    Serial.print("Failed to restore factory Settings. The error code is:");
    Serial.println(ret);
  }
 delay(1000);
}

#include "DFRobot_RTU.h"
#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
#include <SoftwareSerial.h>
#endif

#define   SLAVE_ADDR_DEFAULT                ((uint16_t)0x0E)
#define   SLAVE_BAUDRATE_DEFAULT              ((uint32_t)115200)

typedef enum{ 
  ePid,
  eVid,
  eAddr,
  eComCtlL,
  eComCtlH,
  eVersion,
  eNbTargets,
  eDist1,
  eSignalIntensity1,
  eDist2,
  eSignalIntensity2,
  eDist3,
  eSignalIntensity3,
  eDist4,
  eSignalIntensity4,
  eDist5,
  eSignalIntensity5,
  eDetectionStartPos,
  eDetectionStopPos,
  eStartThreshold,
  eStopThreshold,
  eSensitivity,
  eComparisonOffset,
  eRestoreFactorySetting,
  eNbOfReg
}eRegIndex_t;//Sensor register index

#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
  SoftwareSerial mySerial(/*rx =*/4, /*tx =*/5);
  DFRobot_RTU modbus(/*s =*/&mySerial);
#else
  DFRobot_RTU modbus(/*s =*/&Serial1);
#endif

 uint16_t cr = 0,ret,rcvbuf[eNbOfReg];
void setup() {
  Serial.begin(9600);
  while(!Serial){                                                     //Waiting for USB Serial COM port to open.
  }

#if defined(ARDUINO_AVR_UNO)||defined(ESP8266)
    mySerial.begin(SLAVE_BAUDRATE_DEFAULT);
#elif defined(ESP32)
  Serial1.begin(SLAVE_BAUDRATE_DEFAULT, SERIAL_8N1, /*rx =*/D3, /*tx =*/D2);
#else
  Serial1.begin(SLAVE_BAUDRATE_DEFAULT);
#endif
  modbus.setTimeoutTimeMs(500);
  
  ret = modbus.readHoldingRegister(SLAVE_ADDR_DEFAULT,ePid,rcvbuf,eNbOfReg);
  if(ret == 0){
    Serial.println("-----------------read module basic information---------------------");
     /* module PID, the default value is 0x01E9 (the highest two values are used as class to judge 00: SEN、01: DFR、10: TEL, the next 14 numbers as num)(SEN0489) */
    Serial.print("PID: 0x");
    Serial.println(rcvbuf[ePid], HEX);
    /* module VID, the default value is 0x3343(representative manufacturer is DFRobot) */
    Serial.print("VID: 0x");
    Serial.println(rcvbuf[eVid], HEX);
    /* firmware revision number: 0x1000 represents V1.0.0.0 */
    Serial.print("versions: 0x");
    Serial.println(rcvbuf[eVersion], HEX);
    
    Serial.println("-----------------read module measurement config--------------------");

     /* current set value at measurement start position, 0x0046~0x19C8, the value can't be greater than the set value at stop position */
    Serial.print("start position :0x");
    Serial.println(rcvbuf[eDetectionStartPos],HEX);

    /* current set value at measurement stop position, 0x0046~0x19C8, the value can't be less than the set value at start position */
    Serial.print("stop position :0x");
    Serial.println(rcvbuf[eDetectionStopPos],HEX);

    /* current initial threshold set value */
    Serial.print("initial threshold :0x");
    Serial.println(rcvbuf[eStartThreshold],HEX);

    /* current end threshold set value */
    Serial.print("end threshold :0x");
    Serial.println(rcvbuf[eStopThreshold],HEX);

    /* current module sensitivity set value */
    Serial.print("module sensitivity :0x");
    Serial.println(rcvbuf[eSensitivity],HEX);

    /* current comparison offset set value */
    Serial.print("comparison offset :0x");
    Serial.println(rcvbuf[eComparisonOffset],HEX);
  }else{
    Serial.print("Failed to restore factory Settings. The error code is:");
    Serial.println(ret);
  }
  delay(1000);
}


void loop() {
  ret = modbus.readHoldingRegister(SLAVE_ADDR_DEFAULT,eNbTargets,rcvbuf + eNbTargets,11);
  if(0 == ret){
    Serial.println("----------------------Read data successfully----------------------");
    Serial.print("target amount:  ");
    Serial.println(rcvbuf[eNbTargets]);
    for(int i = 1; i <= rcvbuf[eNbTargets];i++){
      Serial.print("target:");
      Serial.print(i);
      Serial.print("   ");
      
      Serial.print("distance:  ");
      Serial.print( rcvbuf[eNbTargets + 2*i -1]);
      Serial.print("   ");
    
      Serial.print("intensity:  ");
      Serial.println( rcvbuf[eNbTargets + 2*i]);
    }
    Serial.println("------------------------------------------------------------------");
  }else{
    Serial.println("Failed to read measurement data!!!");   
  }
  delay(3000);
}