Writing a Berry Driver for RD-03D Radar Sensor

[jkwim]

I am attempting to write a driver for RD-03D mmwave Radar Sensor in Berry.
https://en.ai-thinker.com/pro_view-140.html

The sensor gives out a 30byte data stream periodically.

I used an ESP32-C6 with GPIO0 (Rx) and GPIO1(Tx) for the setup.

My script below probably needs lot of cleanup as this is the first time that I am trying to write a driver for such a device.

import string
import math
import webserver


class HexPacketParser
  var ser
  var buffer
  var x1
  var y1
  var speed1
  var distance_res1
  var distance1
  var angle1
  
  var x2
  var y2
  var speed2
  var distance_res2
  var distance2
  var angle2
  
  var x3
  var y3
  var speed3
  var distance_res3
  var distance3
  var angle3


  # Configure the RD-03D
  def RD03D_config()

    # 1. Define the little-endian hex sequences as bytes objects
    var open_config  = bytes('FDFCFBFA0400FF00010004030201')
    var multi_target = bytes('FDFCFBFA0200900004030201')
    var close_config = bytes('FDFCFBFA0200FE0004030201')

    print("RD-03D: Starting configuration sequence...")

        # 2. Flush any leftover tracking data from the buffer
    self.ser.flush()
    tasmota.delay(100)

    # 3. Send: Open Configuration Mode
    print("RD-03D: Opening configuration mode...")
    self.ser.write(open_config)
    tasmota.delay(200) # Give the radar time to process and change state
    
    # Optional: Read back the ACK response if needed
    var ack1 = self.ser.read()
    print("RD-03D: ACK Received:", ack1.tohex())

    # 4. Send: Switch to Multi-Target Detection Mode
    print("RD-03D: Setting to Multi-Target tracking...")
    self.ser.write(multi_target)
    tasmota.delay(200)

    var ack2 = self.ser.read()
    print("RD-03D: ACK Received:", ack2.tohex())

    # 5. Send: Close Configuration Mode (Resumes active radar streaming)
    print("RD-03D: Closing configuration mode and resuming radar...")
    self.ser.write(close_config)
    tasmota.delay(100)

    var ack3 = self.ser.read()
    print("RD-03D: ACK Received:", ack3.tohex())
    print("RD-03D: Configuration complete!")
  end #RD03D_config

  def init(rx_pin, tx_pin)
    self.ser = serial(rx_pin, tx_pin, 256000, serial.SERIAL_8N1)
    self.buffer = bytes() # Initialize empty persistent buffer
    # initial configuration of the sensor
    self.RD03D_config()

    # Add a console command to reload the driver (revisit the need of this later)
    tasmota.add_cmd('reload',
      def()
        tasmota.remove_driver(self)
        tasmota.remove_cmd('reload')
      end
    )

  end # init


  # This loops continuously every 50ms
  def every_50ms() # originally 50ms. increasing to 250ms caused buffer to get 2,3 frames 
    #print("Running every 50ms!")
    #print(self.buffer.size())
    #print("ser available", self.ser.available())

    if self.ser.available() > 0
      #print("ser available", self.ser.available())
      # sensor sends 30bytes 
      # Read the available bytes
	  # need to add logic to check first 4 bytes and then read 30byte frame
      var bytes_obj = self.ser.read(self.ser.available())

      #print("ser read", bytes_obj.size())
      #print("Read bytes: ", string.format("%02X", bytes_obj[0]))
	  tasmota.log("Read bytes: " + bytes_obj.tohex(),3) # default Weblog Level is 2. To reduce noise shifted this long to level 3

	  #----------------------------
	  Read Target 1
	  -----------------------------#
      # pick the values as signed 16bit little-endean
	  # pcik from offset 4 ans size of 2 bytes. (For big-endean use size as -2,-3,-4)
      var val_le = bytes_obj.get(4,2)
  	  self.x1 = ((val_le & 0x8000) ? val_le - 32768 : 0 - val_le) # mm
	  #print("self.x1", self.x1)

	  val_le = bytes_obj.get(6,2)
	  self.y1 = ((val_le & 0x8000) ? val_le - 32768 : 0 - val_le) # mm
	  #print("self.y1", self.y1)

	  val_le = bytes_obj.get(8,2)
	  self.speed1 = ((val_le & 0x8000) ? val_le - 32768 : 0 - val_le) # cm/s
	  #print("self.speed1", self.speed1)

	  val_le = bytes_obj.get(10,2)
	  self.distance_res1 = val_le
	  #print("self.distance_res1", self.distance_res1) # mm

      self.distance1 = math.sqrt((self.x1 * self.x1) + (self.y1 * self.y1))
	  
      self.angle1 = math.atan2(self.y1, self.x1) * 180 / math.pi
	  
	  tasmota.log(string.format("1st Target: x1 %i y1 %i speed %i distance_res %i distance %i angle %i", self.x1, self.y1, self.speed1, self.distance_res1,self.distance1, self.angle1),3) # default Weblog Level is 2. To reduce noise shifted this long to level 3
	  
	  #----------------------------
	  Read Target 2
	  -----------------------------#
	  self.x2 = ((bytes_obj.get(12,2) & 0x8000) ? bytes_obj.get(12,2) - 32768 : 0 - bytes_obj.get(12,2))
	  self.y2 = ((bytes_obj.get(14,2) & 0x8000) ? bytes_obj.get(14,2) - 32768 : 0 - bytes_obj.get(14,2))
	  self.speed2 = ((bytes_obj.get(16,2) & 0x8000) ? bytes_obj.get(16,2) - 32768 : 0 - bytes_obj.get(16,2))
	  self.distance_res2 = ((bytes_obj.get(18,2) & 0x8000) ? bytes_obj.get(18,2) - 32768 : 0 - bytes_obj.get(18,2))
      self.distance2 = math.sqrt((self.x2 * self.x2) + (self.y2 * self.y2))
      self.angle2 = math.atan2(self.y2, self.x2) * 180 / math.pi

	  #----------------------------
	  Read Target 3
	  -----------------------------#
	  self.x3 = ((bytes_obj.get(20,2) & 0x8000) ? bytes_obj.get(20,2) - 32768 : 0 - bytes_obj.get(20,2))
	  self.y3 = ((bytes_obj.get(22,2) & 0x8000) ? bytes_obj.get(22,2) - 32768 : 0 - bytes_obj.get(22,2))
	  self.speed3 = ((bytes_obj.get(24,2) & 0x8000) ? bytes_obj.get(24,2) - 32768 : 0 - bytes_obj.get(24,2))
	  self.distance_res3 = ((bytes_obj.get(26,2) & 0x8000) ? bytes_obj.get(26,2) - 32768 : 0 - bytes_obj.get(26,2))
      self.distance3 = math.sqrt((self.x3 * self.x3) + (self.y3 * self.y3))
      self.angle3 = math.atan2(self.y3, self.x3) * 180 / math.pi

	  
     end # self.ser.available()

  end # every_50ms()

  # Display on Tasmota's Web UI
  # The mandatory hook called every time the Web UI refreshes
  def web_sensor()
    # Format the text with Tasmota UI row templates ({s}, {m}, {e})
    # Construct lines using Tasmota UI row layout tags ({s}, {m}, {e})
    var gui_rows = string.format(
      "{s}RD-03D Data<hr>{e}" .. 
      "{s}1st Target X{m}%i mm{e}" ..
      "{s}1st Target Y{m}%i mm{e}" ..
      "{s}1st Target Speed{m}%i cm/sec{e}" ..
      "{s}1st Target Distance Resolution{m}%i mm{e}"..
      "{s}1st Target Distance {m}%i mm{e}"..
      "{s}1st Target Angle{m}%i °{e}" ..
	  "{s}<hr>{e}" ..
      "{s}2nd Target X{m}%i mm{e}" ..
      "{s}2nd Target Y{m}%i mm{e}" ..
      "{s}2nd Target Speed{m}%i cm/sec{e}" ..
      "{s}2nd Target Distance Resolution{m}%i mm{e}"..
      "{s}2nd Target Distance {m}%i mm{e}"..
      "{s}2nd Target Angle{m}%i °{e}" ..
	  "{s}<hr>{e}" ..
      "{s}3rd Target X{m}%i mm{e}" ..
      "{s}3rd Target Y{m}%i mm{e}" ..
      "{s}3rd Target Speed{m}%i cm/sec{e}" ..
      "{s}3rd Target Distance Resolution{m}%i mm{e}"..
      "{s}3rd Target Distance {m}%i mm{e}"..
      "{s}3rd Target Angle{m}%i °{e}" ,
	  
      self.x1, self.y1, self.speed1, self.distance_res1, self.distance1, self.angle1,
	  self.x2, self.y2, self.speed2, self.distance_res2, self.distance2, self.angle2,
	  self.x3, self.y3, self.speed3, self.distance_res3, self.distance3, self.angle3
    )
    # Ship the formatted message safely to the frontend
    tasmota.web_send_decimal(gui_rows)

    # var row_text = string.format("{s}1st Target X{m}%i mm{e}", self.x1)
    # webserver.content_send(row_text)
	self.web_add_main_button()
  end # web_sensor()
  
  
  # Hook to render the canvas element and radar animation loop
  def web_add_main_button()
  
    # Physical Sensor: Measures distance from 10 cm to 800 cm  (upto 8m)
	# Radar Screen max distance is 90px
	# divide the self.distance1 by 10 to make it cm
    var scaled_distance1 = (self.distance1/10 - 10.0) * (90.0 - 0.0) / (800.0 - 10.0) + 0.0
	# Constrain distance bounds so it doesn't bleed off the canvas
    if scaled_distance1 > 90.0  scaled_distance1 = 90.0 end
    if scaled_distance1 < 0.0   scaled_distance1 = 0.0  end
	
    # Scale Angle (Map 0-120 degrees to -150 to -30 degrees)
    #var scaled_angle_deg1 = (self.angle1 - 0.0) * (-30.0 - (-150.0)) / (120.0 - 0.0) + (-150.0)
	

    # Scale Angle (Map 30-150 degrees to -150 to -30 degrees) 
    var scaled_angle_deg1 = self.angle1 - 180
  
    # Convert degrees to Radians for the JavaScript canvas
    var scaled_angle_rad1 = scaled_angle_deg1 * 3.14159 / 180.0
  
  
    var json_data = string.format("[{\"a\":%.2f,\"d\":%.1f,\"a1\":%.2f,\"d1\":%.1f}]", scaled_angle_rad1, scaled_distance1, self.angle1, self.distance1)
    print(json_data)
	
    webserver.content_send(
      "<div style='text-align:center;'><h3>120° Radar Screen</h3>" +
      "<div id='radarDebug' style='font-family:monospace;font-size:12px;color:#00ff00;background:#111;padding:5px;margin:10px auto;width:180px;border:1px solid #333;border-radius:4px;'>Waiting...</div>" +
      "<canvas id='radarCanvas' width='200' height='200' style='background:#252525;border-radius:50%;'></canvas>" +
      "<script>" +

      # Assign the data immediately at the top of the script block
      string.format("window.radarBlips = %s;", json_data) + 

      "let ctx = document.getElementById('radarCanvas').getContext('2d');" +
      "let debugDiv = document.getElementById('radarDebug');" +

#      "console.log(debugDiv);" +
#      "console.log('Script executed');" +
#      "console.log(window.radarBlips);" +

      "let minAngle = -5 * Math.PI / 6;" + # -150 degrees
      "let maxAngle = -1 * Math.PI / 6;" + # -30 degrees
      "let sweepAngle = minAngle;" +
      "let direction = 1;" +                 # 1 for forward, -1 for backward
      "function drawRadar() {" +
      "  ctx.fillStyle = 'rgba(0, 17, 0, 0.20)';" +
      "  ctx.fillRect(0, 0, 200, 200);" +
      "  ctx.strokeStyle = '#00ff00';" +
      "  ctx.lineWidth = 1;" +
      "  ctx.beginPath();" +
      "  ctx.arc(100, 100, 90, minAngle, maxAngle);" +
      "  ctx.moveTo(100, 100);" +
      "  ctx.arc(100, 100, 60, minAngle, maxAngle);" +
      "  ctx.moveTo(100, 100);" +
      "  ctx.arc(100, 100, 30, minAngle, maxAngle);" +
      "  ctx.moveTo(100, 100); ctx.lineTo(100 + 90 * Math.cos(minAngle), 100 + 90 * Math.sin(minAngle));" +
      "  ctx.moveTo(100, 100); ctx.lineTo(100 + 90 * Math.cos(maxAngle), 100 + 90 * Math.sin(maxAngle));" +
      "  ctx.moveTo(100, 100); ctx.lineTo(100, 10);" + # Center index line
      "  ctx.stroke();" +
      "  ctx.strokeStyle = '#00ff0055';" +
      "  ctx.beginPath();" +
      "  ctx.moveTo(100, 100);" +
      "  ctx.lineTo(100 + 90 * Math.cos(sweepAngle), 100 + 90 * Math.sin(sweepAngle));" +
      "  ctx.stroke();" +


      "  if (window.radarBlips && window.radarBlips.length > 0) {" +
      "    let blip = window.radarBlips[0];" +
      "    let deg = Math.round(blip.a * (180 / Math.PI));" + # Convert radians to degrees
      "    debugDiv.innerHTML = 'ANG: ' + deg + '° | DIST: ' + blip.d + 'px'  + ' | angle1: ' + blip.a1 + '°' + ' | distance1: ' + blip.d1;" +
#      "    console.log(window.radarBlips);" +

      "    window.radarBlips.forEach(blip => {" +
      "      if (blip.a >= minAngle && blip.a <= maxAngle) {" + # Boundary safety

      "        let bx = 100 + blip.d * Math.cos(blip.a);" +
      "        let by = 100 + blip.d * Math.sin(blip.a);" +
      "        ctx.fillStyle = '#ff1111';" + # Red Circle
      "        ctx.beginPath();" +
      "        ctx.arc(bx, by, 4, 0, Math.PI * 2);" +
      "        ctx.fill();" +
      "        ctx.strokeStyle = '#ffffff';" + # White outside ring
      "        ctx.lineWidth = 2;" +
      "        ctx.beginPath();" +
      "        ctx.arc(bx, by, 6, 0, Math.PI * 2);" +
      "        ctx.stroke();" +
      "      }" +
      "    });" +
      "  }" +
      "  sweepAngle += 0.04 * direction;" +
      "  if (sweepAngle >= maxAngle || sweepAngle <= minAngle) {" +
      "    direction *= -1;" + # Bounce boundary direction
      "  }" +
      "}" +
      "setInterval(drawRadar, 100);" + # in ms
      "</script></div>"
    )
  
  end # web_add_main_button()
  

end # class 

if global.parser_instance != nil
    tasmota.remove_driver(global.parser_instance)
end
# Use Tx=GPIO1 Rx=GPIO0
global.parser_instance = HexPacketParser(1, 0)
tasmota.add_driver(global.parser_instance)

The above works in principle:

I have two issues:
Issue 1:
I am not quite sure as how to refresh the webserver.content_send content to be in sync with web_sensor().
I tried calling the function self.web_add_main_button() but the radar blip does not get refreshed.

Issue 2:
The placeholder for Radar Screen animation appears twice when I make a function call inside the web_sensor() above.

Still the auto refresh does not work.

The javascript code on its own gets refreshed but I do not know how to repeat the Berry calculations in this part:

  # Hook to render the canvas element and radar animation loop
  def web_add_main_button()
  

    # Physical Sensor: Measures distance from 10 cm to 800 cm  (upto 8m)
	# Radar Screen max distance is 90px
	# divide the self.distance1 by 10 to make it cm
    var scaled_distance1 = (self.distance1/10 - 10.0) * (90.0 - 0.0) / (800.0 - 10.0) + 0.0
	# Constrain distance bounds so it doesn't bleed off the canvas
    if scaled_distance1 > 90.0  scaled_distance1 = 90.0 end
    if scaled_distance1 < 0.0   scaled_distance1 = 0.0  end

      "function drawRadar() {" +
      "  ctx.fillStyle = 'rgba(0, 17, 0, 0.20)';" +
      "  ctx.fillRect(0, 0, 200, 200);" +
      "  ctx.strokeStyle = '#00ff00';" +
.
.
.
      "}" +
      "setInterval(drawRadar, 100);" + # in ms
      "</script></div>"

Need some suggestions to get the data sent to Radar Animation when web sensor is invoked.

Also note that my serial data read part needs improvement to check the frame header and process the rest. I know how to do that.

Any other suggestions to improve the code is more than welcome.

Thanks in advance!

[sfromis]

With the regular front page mechanism relying on what is returned from the web_sensor() callback, this slider code example shows a trick to have JavaScript code executed as part of these updates:
http://sfromis.strangled.net/tasmota/berry/examples/slider.be
The key part is:

  def web_sensor()
    import webserver
    if webserver.has_arg(self.id)
      self.setvalue(int(webserver.arg(self.id)))
    elif self.value && self.value != self.oldvalue
      self.oldvalue = self.value
      tasmota.web_send(self.DOMupdate(self.id, self.value))
    end
  end

  def DOMupdate(id, value)
    # This trick allows DOM updates, while <script> tags would be blocked for security reasons
    return f"<img src='data:x,' style='display:none' onerror=\"let obj=eb('{id}');if (obj) obj.{value=};this.remove();\">"
  end

Beware of the f-string syntax, where {value=} is short form for value={value}

Maybe it would be feasible to call an update function there, with the page already having the main JS code.

Not clear what you ask for with "how to repeat the Berry calculations", what the issue is?

While I did not look much at the code, I did notice a conversion pattern repeated a lot. Instead of:
self.speed2 = ((bytes_obj.get(16,2) & 0x8000) ? bytes_obj.get(16,2) - 32768 : 0 - bytes_obj.get(16,2))
For readability, you could create a small conversion function:
var conv = def (le) return (le & 0x8000) ? le - 32768 : 0 - le end
And then each of the calls like:
self.speed2 = conv(bytes_obj.get(16,2))
Of course, you could also have a named function in the class, the above is a bit shorter....

BTW. The config function does calls like tasmota.delay(200) - this is not recommended, as Tasmota is blocked while you do that. Of course, if it is once-only......

[jkwim]

Thanks for your prompt response as always.

If I understood correctly I may be able to inject the following two lines in to the javascript. Is that the correct understanding?

      "        let bx = 100 + blip.d * Math.cos(blip.a);" +
      "        let by = 100 + blip.d * Math.sin(blip.a);" +

If I can change the values of blip.d and blip.a we are through. I mean basically we can use two variable names and assignments here.

[jkwim]

While I did not look much at the code, I did notice a conversion pattern repeated a lot. Instead of:
self.speed2 = ((bytes_obj.get(16,2) & 0x8000) ? bytes_obj.get(16,2) - 32768 : 0 - bytes_obj.get(16,2))
For readability, you could create a small conversion function:
var conv = def (le) return (le & 0x8000) ? le - 32768 : 0 - le end
And then each of the calls like:
self.speed2 = conv(bytes_obj.get(16,2))
Of course, you could also have a named function in the class, the above is a bit shorter....

Will definitely incorporate this change.

[sfromis]

I still do not understand what the issue with that calculation in JavaScript is. What you posted looks like valid js code (I'm not at all well-versed in the language). Where would you like to "change the values of blip.d and blip.a"?

It looks like your Berry code is putting data into a JSON structure which is then made part of the JavaScript code, and getting into blip. The idea with doing something like my slider position update code example would be that you there can call js code to process the data. You can update the values in Berry or in js, depending on what you prefer. But your <script> block should be adjusted to have a callable function which you then can invoke from the fake image error event code. I'd not be surprised if you can keep using window.radarBlips to have the data, before calling, but again, my JavaScript knowledge is very limited.

[jkwim]

Tried to play with the DOMUpdate.

Here are the steps I tried:

1. Introduced two new global variables called blipa and blipd (look at the last two lines)

    webserver.content_send(
      "<div style='text-align:center;'><h3>120° Radar Screen</h3>" +
      "<div id='radarDebug' style='font-family:monospace;font-size:12px;color:#00ff00;background:#111;padding:5px;margin:10px auto;width:200px;border:1px solid #333;border-radius:4px;'>Waiting...</div>" +
      "<canvas id='radarCanvas' width='200' height='200' style='background:#252525;border-radius:50%;'></canvas>" +
      "<script>" +

      # Assign the data immediately at the top of the script block
      string.format("window.radarBlips = %s;", json_data) + 
      "window.blipa = window.radarBlips[0].a;" +
      "window.blipd = window.radarBlips[0].d;" +

Since it is assumed that webserver.content_send function will be called only once, the global variables will pick the values from the JSON once.

2. Modified the code which calculates the x,y coordinates of the blip to use the new variables. Introduced the debug tag also.

      "    window.radarBlips.forEach(blip => {" +
      "      if (window.blipa >= minAngle && window.blipa <= maxAngle) {" + # Boundary safety

      "        let bx = 100 + window.blipd * Math.cos(window.blipa);" +
      "        let by = 100 + window.blipd * Math.sin(window.blipa);" +
	  
	  "    debugDiv.innerHTML = ' blipa/blipd  ' + ' | ' + window.blipa + '/' + window.blipd;" +

3. Introduced the function into the class

  def DOMupdate_globals(val1, val2)
    print("DOM Scaled Angle/Dist: ",val1, val2)
    # Targets global window variables directly, then removes itself
    return f"<img src='data:x,' style='display:none' onerror=\"window.blipa={val1};window.blipd={val2};this.remove();\">"
  end

4. Added a function call in web_sensor

	# Perform an update of Javascript code for Radar Screen
    #print("Scaled Angle/Dist: ",scaled_angle_rad1, scaled_distance1)

	var html_payload = self.DOMupdate_globals(scaled_angle_rad1, scaled_distance1)
	
  end # web_sensor()

Observations:

1. The print command on step 3 prints at an interval of about 3 seconds. That means web_sensor gets called up periodically and the DOMupdate_globals function gets executed periodiclaly

2. Debug window gets updated but the values do not get changed
   " debugDiv.innerHTML = ' blipa/blipd ' + ' | ' + window.blipa + '/' + window.blipd;" +

What am I doing wrong?

[sfromis]

I've not worked through the details, but what I posted about was:

your <script> block should be adjusted to have a callable function which you then can invoke from the fake image error event code.

You need to do something for every update, it does not help merely setting a couple of variables without invoking code to redraw.

[jkwim]

Quick Update:
I managed to get it working but with lot of changes to javascript code as well.

Spent some long sessions with Gemini to cleanup everything.

I am in the process of expanding the code to show all three targets detected by the sensor.

Will post the complete code once I have done that.

One of the main flaws that I had in my code was the missing content_send command in the following code snippet

	# Perform an update of Javascript code for Radar Screen
        #print("Scaled Angle/Dist: ",scaled_angle_rad1, scaled_distance1)
	var html_payload = self.DOMupdate_globals(scaled_angle_rad1, scaled_distance1)
	
  end # web_sensor()

The data was not getting into browser.

Fix was to add:

webserver.content_send(html_payload)

Final Solution:

  def web_sensor()
   ...

        # Perform an update of Javascript code for Radar Screen
        #print("Scaled Angle/Dist: ",scaled_angle_rad1, scaled_distance1)
        var html_payload = self.DOMupdate_globals(scaled_angle_rad1, scaled_distance1)
        webserver.content_send(html_payload) 	
  end # web_sensor()

  def DOMupdate_globals(val1, val2)
    print("DOM Scaled Angle/Dist: ",val1, val2)
    # Targets global window variables directly, then removes itself
    return f"<img src='data:x,' style='display:none' onerror=\"window.blipa={val1};window.blipd={val2};this.remove();\">"
  end

Inside the javascript code the data is picked up by global variables:

       # Initialize global variables
       "window.blipa = -2.445173;" + 
       "window.blipd = 9.285731;" +

[sfromis]

The intended structure, as shown in my slider example code, is that the web_sensor callback uses tasmota.web_send (or tasmota.web_send_decimal) to supply the sensor update, while webserver.content_send is meant for building HTML parts elsewhere. Arguably, including HTML parts with the special table tags for sensor data is what worked, outside the primary function of that API call.

[jkwim]

This is what the output looks like:

[s-hadinger]

This is awesome. Would you consider packing it all in a Tasmota Extension so other users can easily load it?

By the way, construct like:

var gui_rows = string.format(
      "{s}RD-03D Data<hr>{e}" .. 
      "{s}1st Target X{m}%i mm{e}" ..
      "{s}1st Target Y{m}%i mm{e}" ..
      "{s}1st Target Speed{m}%i cm/sec{e}" ..
[...]

Can be better written with a single literal string (no need for ..) at the end, and it avoids costly string concatenation:

var gui_rows = string.format(
      "{s}RD-03D Data<hr>{e}"
      "{s}1st Target X{m}%i mm{e}"
      "{s}1st Target Y{m}%i mm{e}"
      "{s}1st Target Speed{m}%i cm/sec{e}"
[...]

[sfromis]

Not hard to do, see: https://tasmota.github.io/docs/Tasmota-Extension/

[jkwim]

Thanks for your suggestions.

I had to park the activity for a week or more due to some other activity and revisited today.

Will certainly try to write an extension.

I am fine tuning the script more.

Added a json_append() to the class and it works;

  def json_append()
    # Tasmota Callback
    var msg = string.format(',"RD-03D":{"X1":%s, "Y1":%s, "SPEED1":%s, "DIST1":%s, "ANGLE1":%s, "X2":%s, "Y2":%s, "SPEED2":%s, "DIST2":%s, "ANGLE2":%s, "X3":%s, "Y3":%s, "SPEED3":%s, "DIST3":%s, "ANGLE3":%s}'
    ,
    self.x1, self.y1, self.speed1, self.distance1, self.angle1, self.x2, self.y2, self.speed2, self.distance2, self.angle2, self.x3, self.y3, self.speed3,  self.distance3, self.angle3
    )

    tasmota.response_append(msg)
  end # json_append()

Got a small enclosure 3D printed to help testing further :)

Based on:
https://www.printables.com/model/1264928-radar-presence-sensor-hlk-ld2450-wemos-d1-mini-v4

BTW, LD2450 and RD03D are identical in physical dimensions so it fitted the slot in the lid nicely.

[jkwim]

Here is my main code which reads the serial data. I have stripped off the middle part for clarity.

Currently I am reading the entire buffer. Most of the time the buffer will only have 30 bytes. Occasionally I can see two frames ie. 60 bytes.

I want to improve this code to:

1. Check whether the first 4 bytes are AA FF 03 00
2. Check whether the last 2 bytes are 55 CC
3. Pick only 30 bytes.

If I read one byte at a time from the incoming buffer, I can do it. However I believe that it will be ineficient.

Could you suggest a way to read a sliding window of 30 bytes at a time and and then check for header and the tail?

  # This loops continuously every 50ms
  def every_50ms() # originally 50ms. increasing to 250ms caused buffer to get 2,3 frames 

    #print("ser available", self.ser.available())

    if self.ser.available() > 0
      #print("ser available", self.ser.available())
      # Sensor sends 30 Bytes 
      # -----------------------------------------------
      # Frame Size (30 Bytes)
      # Frame Header (4 Bytes) = AA FF 03 00 
      # Frame Data (24 Bytes) = 8 Bytes per Target x 3
      # Frame Tail (2 Bytes) = 55 CC
      # -----------------------------------------------
      
      
      var bytes_obj = self.ser.read(self.ser.available())
      
      tasmota.log("Read bytes: " + bytes_obj.tohex(),3) # default Weblog Level is 2. To reduce noise shifted this log to level 3





      # Define a function to strip of the MSB and pick the value from 16bit Little Endean register
      var conv = def (le) return (le & 0x8000) ? le - 32768 : 0 - le end      

	  #----------------------------
	  Read Target 1
	  -----------------------------#
      # pick the values as signed 16bit little-endean
      # pick from offset 4 ans size of 2 bytes. (For big-endean use size as -2,-3,-4)
      self.x1 = conv(bytes_obj.get(4,2)) # mm
      self.y1 = conv(bytes_obj.get(6,2)) # mm
      self.speed1 = conv(bytes_obj.get(8,2)) # cm/s
      self.distance_res1 = bytes_obj.get(10,2) # mm


      self.distance1 = math.sqrt((self.x1 * self.x1) + (self.y1 * self.y1))
      self.angle1 = math.atan2(self.y1, self.x1) * 180 / math.pi
	  
      tasmota.log(string.format("[1st Target: x1 %i y1 %i speed %i dist_res %i dist %i angle %i] [2nd Target: x2 %i y2 %i speed %i dist_res %i dist %i angle %i] [3rd Target: x3 %i y3 %i speed %i dist_res %i dist %i angle %i]", self.x1, self.y1, self.speed1, self.distance_res1,self.distance1, self.angle1, self.x2, self.y2, self.speed2, self.distance_res2,self.distance2, self.angle2, self.x3, self.y3, self.speed3, self.distance_res3,self.distance3, self.angle3),3) # default Weblog Level is 2. To reduce noise shifted this long to level 3
	  
	  #----------------------------	   
	  Read Target 2
	  -----------------------------#
.
.
.
	  #----------------------------
	  Read Target 3
	  -----------------------------#
.
.
.

     end # self.ser.available() > 0

  end # every_50ms()

[sfromis]

Instead of a sliding window, I'd probably read all available bytes every time, concatenate to an existing bytes buffer, and if the data is "long enough" (30+ bytes) look for header/tail. If ok, then pick the data. If no tail found, just leave the buffer till next round. And if a tail found (with our without valid data), chop off the bytes up to and including the tail.

Normally, it should be no problem if the buffer has two or even 3 frames, when the length is so short. This way out get results similar to using a sliding window, but simpler and faster logic.

Since you are doing "costly" things like logging in your every_50ms(), my approach would be to add the received bytes to the buffer, and exit after having done a tasmota.defer to have processing done outside of the callback.

[jkwim]

Actually I want to do away with every50ms and use a long interval. The sensor sends too many frames then.
I will also explore the possibility of setting up the sensor to use a longer interval

[sfromis]

Unless you want to skip frames, the short interval is fine. Just avoid doing all the processing before exiting the callback, by pushing it out into a separate method.