code wiki / (root) / nx_moonraker_telemetry_parse.nx
`nx_moonraker_telemetry_parse.nx` source

↩ module page · 460 lines · 15747 B
1// nx_moonraker_telemetry_parse.nx -- pure-substrate parser for
2// Moonraker /printer/objects/query responses; populates the
3// thermal section of NxPrintTelemetry.
4//
5// Strategy: substring-window scan (no recursive descent).  Moonraker
6// JSON shape is documented and stable enough that this approach
7// works without a full tree parser, but it IS brittle if Moonraker
8// changes the response layout -- a future arc can swap this for an
9// nx_json-based stateful parser without changing the API.
10//
11// For /printer/objects/query?extruder&heater_bed the response is:
12//   {"result":{"status":{
13//     "extruder":   {"temperature":209.8,"target":210.0,...},
14//     "heater_bed": {"temperature":59.7, "target":60.0, ...}
15//   },"eventtime":12345.678}}
16//
17// We:
18//   1. Find the scope window `"extruder":{...}` (matched braces).
19//   2. Within that window, find `"temperature":` and read the next
20//      number.  Likewise `"target":`.
21//   3. Same for heater_bed.
22//
23// Numbers convert to whole °C (truncate fractional).  1°C precision
24// is acceptable given typical 2-5°C tolerances; operator can tighten
25// if needed.  Sentinel -1 means "not found" for setpoints (lets
26// NxPrintTelemetry skip that axis cleanly).
27//
28// license_tier: ORIGINAL
29
30import "nx_syscalls.nx"
31import "nx_print_telemetry.nx"
32const NX_MAGIC_32768: i64 = 32768
33
34const NX_MR_PARSE_OK:        i64 = 0
35const NX_MR_PARSE_NO_OBJECT: i64 = 1
36const NX_MR_PARSE_BAD_INPUT: i64 = 2
37
38// Compare body[off..off+n] to literal lit (length n).  Returns 1 on
39// match, 0 otherwise.
40func mr_p_byte_eq(body: *u8, off: i64, lit: *u8, n: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      if body[off + i] != lit[i] { return 0 }
      i = i + 1
  }
  return 1
47}
48
49// strlen-like for cstr literals.
50func mr_p_cstr_len(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != 0 { n = n + 1 }
  return n
54}
55
56// Find the first occurrence of needle (cstr) in body[start..body_len).
57// Returns offset of match or -1.
58func mr_p_find(body: *u8, body_len: i64, start: i64, needle: *u8) -> i64 {
  let n_len: i64 = mr_p_cstr_len(needle)
  if n_len == 0 { return start }
  if start < 0 { return -1 }
  if start + n_len > body_len { return -1 }
  var i: i64 = start
  let stop: i64 = body_len - n_len
  while i <= stop {
      if mr_p_byte_eq(body, i, needle, n_len) == 1 { return i }
      i = i + 1
  }
  return -1
70}
71
72// Given offset of the opening `{` of a JSON object, return the offset
73// of the matching `}`.  Counts braces, respects strings (skips escape
74// sequences).  Returns -1 if unmatched.
75func mr_p_match_brace(body: *u8, body_len: i64, open_at: i64) -> i64 {
  if open_at < 0 { return -1 }
  if open_at >= body_len { return -1 }
  if body[open_at] != 0x7B { return -1 }   // '{'
  var depth: i64 = 1
  var p: i64 = open_at + 1
  var in_string: i64 = 0
  while p < body_len {
      let c: i64 = body[p]
      if in_string == 1 {
          if c == 0x5C {     // backslash escape
              p = p + 2
          } else {
              if c == 0x22 { in_string = 0 }   // closing quote
              p = p + 1
          }
      } else {
          if c == 0x22 { in_string = 1; p = p + 1 }
          else {
              if c == 0x7B { depth = depth + 1; p = p + 1 }
              else {
                  if c == 0x7D {
                      depth = depth - 1
                      if depth == 0 { return p }
                      p = p + 1
                  } else { p = p + 1 }
              }
          }
      }
  }
  return -1
106}
107
108// Parse an integer °C from body[off..end) starting at a number.
109// Skips leading whitespace.  Stops at first non-digit (truncates
110// fractional part).  Returns sentinel -32768 if no digit found.
111func mr_p_parse_int_degrees(body: *u8, off: i64, end: i64) -> i64 {
  var q: i64 = off
  var skipping: i64 = 1
  while skipping == 1 {
      if q >= end { skipping = 0 }
      else {
          let c: i64 = body[q]
          if c == 0x20 { q = q + 1 }     // space
          else { if c == 0x09 { q = q + 1 }     // tab
              else { if c == 0x0A { q = q + 1 } // \n
                  else { if c == 0x0D { q = q + 1 }  // \r
                      else { skipping = 0 }
                  }
              }
          }
      }
  }
  if q >= end { return 0 - NX_MAGIC_32768 }
129
  var neg: i64 = 0
  if body[q] == 0x2D { neg = 1; q = q + 1 }
132
  var have_digit: i64 = 0
  var n: i64 = 0
  var reading: i64 = 1
  while reading == 1 {
      if q >= end { reading = 0 }
      else {
          let d: i64 = body[q]
          if d >= 0x30 {
              if d <= 0x39 {
                  n = n * 10 + (d - 0x30)
                  have_digit = 1
                  q = q + 1
              } else { reading = 0 }
          } else { reading = 0 }
      }
  }
149
  if have_digit == 0 { return 0 - NX_MAGIC_32768 }
  if neg == 1 { return 0 - n }
  return n
153}
154
155// Within body[scope_start..scope_end), find `"key":` then parse the
156// integer degrees that follow.  Returns sentinel -32768 if not found.
157func mr_p_extract_int_in_scope(
  body: *u8, body_len: i64,
  scope_start: i64, scope_end: i64,
  key_with_quotes_and_colon: *u8
161) -> i64 {
  let k_off: i64 = mr_p_find(body, scope_end, scope_start, key_with_quotes_and_colon)
  if k_off < 0 { return 0 - NX_MAGIC_32768 }
  let k_len: i64 = mr_p_cstr_len(key_with_quotes_and_colon)
  let val_start: i64 = k_off + k_len
  return mr_p_parse_int_degrees(body, val_start, scope_end)
167}
168
169// Public entry: parse a Moonraker /printer/objects/query response
170// into the thermal fields of an NxPrintTelemetry event.  Sets the
171// has_thermal flag if at least one of (extruder, heater_bed) was
172// found.  Setpoints not present default to -1 (skip that axis).
173//
174// Returns NX_MR_PARSE_OK on success, NO_OBJECT if neither extruder
175// nor heater_bed object was found.
176func nx_moonraker_parse_thermal(
  body: *u8, body_len: i64,
  ev: *NxPrintTelemetry
179) -> i64 {
  if (body as i64) == 0 { return NX_MR_PARSE_BAD_INPUT }
  if (ev as i64)   == 0 { return NX_MR_PARSE_BAD_INPUT }
  if body_len <= 0      { return NX_MR_PARSE_BAD_INPUT }
183
  var found: i64 = 0
185
  // ----- extruder -----
  let ex_key_start: i64 = mr_p_find(body, body_len, 0, "\"extruder\":{")
  if ex_key_start >= 0 {
      // Position of the '{'
      let ex_brace: i64 = ex_key_start + 11    // strlen("\"extruder\":") = 11
      let ex_end: i64 = mr_p_match_brace(body, body_len, ex_brace)
      if ex_end > ex_brace {
          let t: i64 = mr_p_extract_int_in_scope(
              body, body_len, ex_brace + 1, ex_end, "\"temperature\":")
          let s: i64 = mr_p_extract_int_in_scope(
              body, body_len, ex_brace + 1, ex_end, "\"target\":")
          if t != 0 - NX_MAGIC_32768 {
              ev.hotend_actual_c = t
              found = 1
          }
          if s != 0 - NX_MAGIC_32768 {
              ev.hotend_setpoint_c = s
          } else {
              ev.hotend_setpoint_c = -1
          }
      }
  }
208
  // ----- heater_bed -----
  let hb_key_start: i64 = mr_p_find(body, body_len, 0, "\"heater_bed\":{")
  if hb_key_start >= 0 {
      let hb_brace: i64 = hb_key_start + 13    // strlen("\"heater_bed\":") = 13
      let hb_end: i64 = mr_p_match_brace(body, body_len, hb_brace)
      if hb_end > hb_brace {
          let t: i64 = mr_p_extract_int_in_scope(
              body, body_len, hb_brace + 1, hb_end, "\"temperature\":")
          let s: i64 = mr_p_extract_int_in_scope(
              body, body_len, hb_brace + 1, hb_end, "\"target\":")
          if t != 0 - NX_MAGIC_32768 {
              ev.bed_actual_c = t
              found = 1
          }
          if s != 0 - NX_MAGIC_32768 {
              ev.bed_setpoint_c = s
          } else {
              ev.bed_setpoint_c = -1
          }
      }
  }
230
  if found == 1 { ev.has_thermal = 1 }
232
  if found == 0 { return NX_MR_PARSE_NO_OBJECT }
  return NX_MR_PARSE_OK
235}
236
237// ===== Motion section parser ======================================
238//
239// Parses a number like "120.5" into Q14 fixed-point: 120.5 × 16384
240// = 1974272.  Truncates at the first non-digit (stops at fraction
241// exponent etc.; Moonraker doesn't emit exponential notation for
242// position/velocity values).
243//
244// Caller passes a byte range [off, end).  Returns sentinel
245// 0 - 0x7FFFFFFF (-2147483647) for "no number found".
246const MR_P_Q14_NOT_FOUND: i64 = -2147483647
247const MR_P_Q14_SCALE:     i64 = 16384
248
249func mr_p_parse_q14(body: *u8, off: i64, end: i64) -> i64 {
  var q: i64 = off
  var skipping: i64 = 1
  while skipping == 1 {
      if q >= end { skipping = 0 }
      else {
          let c: i64 = body[q]
          if c == 0x20 { q = q + 1 }
          else { if c == 0x09 { q = q + 1 }
              else { if c == 0x0A { q = q + 1 }
                  else { if c == 0x0D { q = q + 1 }
                      else { skipping = 0 }
                  }
              }
          }
      }
  }
  if q >= end { return MR_P_Q14_NOT_FOUND }
267
  var neg: i64 = 0
  if body[q] == 0x2D { neg = 1; q = q + 1 }
270
  var have_digit: i64 = 0
  var int_part: i64 = 0
  var reading_int: i64 = 1
  while reading_int == 1 {
      if q >= end { reading_int = 0 }
      else {
          let d: i64 = body[q]
          if d >= 0x30 {
              if d <= 0x39 {
                  int_part = int_part * 10 + (d - 0x30)
                  have_digit = 1
                  q = q + 1
              } else { reading_int = 0 }
          } else { reading_int = 0 }
      }
  }
287
  var frac_q14: i64 = 0
  if q < end {
      if body[q] == 0x2E {
          q = q + 1
          // Read up to 8 fractional digits (more than enough for Q14).
          var frac_int: i64 = 0
          var frac_div: i64 = 1
          var n_frac: i64 = 0
          var reading_frac: i64 = 1
          while reading_frac == 1 {
              if q >= end { reading_frac = 0 }
              else {
                  if n_frac >= 8 { reading_frac = 0 }
                  else {
                      let d2: i64 = body[q]
                      if d2 >= 0x30 {
                          if d2 <= 0x39 {
                              frac_int = frac_int * 10 + (d2 - 0x30)
                              frac_div = frac_div * 10
                              n_frac = n_frac + 1
                              have_digit = 1
                              q = q + 1
                          } else { reading_frac = 0 }
                      } else { reading_frac = 0 }
                  }
              }
          }
          if frac_div > 1 {
              // frac_q14 = frac_int × Q14_SCALE / frac_div
              frac_q14 = (frac_int * MR_P_Q14_SCALE) / frac_div
          }
      }
  }
321
  if have_digit == 0 { return MR_P_Q14_NOT_FOUND }
323
  var n: i64 = int_part * MR_P_Q14_SCALE + frac_q14
  if neg == 1 { n = 0 - n }
  return n
327}
328
329// Within body[scope_start..scope_end), find `"key":` then parse the
330// Q14 number that follows.  Returns MR_P_Q14_NOT_FOUND if not found.
331func mr_p_extract_q14_in_scope(
  body: *u8, body_len: i64,
  scope_start: i64, scope_end: i64,
  key_with_quotes_and_colon: *u8
335) -> i64 {
  let k_off: i64 = mr_p_find(body, scope_end, scope_start, key_with_quotes_and_colon)
  if k_off < 0 { return MR_P_Q14_NOT_FOUND }
  let k_len: i64 = mr_p_cstr_len(key_with_quotes_and_colon)
  return mr_p_parse_q14(body, k_off + k_len, scope_end)
340}
341
342// Within body[scope_start..scope_end), find `"live_position":[`,
343// then parse the first 4 comma-separated Q14 numbers into
344// out_xyze[0..3].  Returns 1 on success, 0 if array not found.
345func mr_p_extract_live_position(
  body: *u8, body_len: i64,
  scope_start: i64, scope_end: i64,
  out_x_box: *i64, out_y_box: *i64,
  out_z_box: *i64, out_e_box: *i64
350) -> i64 {
  let key_off: i64 = mr_p_find(body, scope_end, scope_start, "\"live_position\":[")
  if key_off < 0 { return 0 }
  // After `[`, scan up to next `]`
  let arr_start: i64 = key_off + 17    // strlen("\"live_position\":[") = 17
  var arr_end: i64 = arr_start
  var found_close: i64 = 0
  while found_close == 0 {
      if arr_end >= scope_end { found_close = 1 }
      else {
          if body[arr_end] == 0x5D { found_close = 1 }     // ']'
          else { arr_end = arr_end + 1 }
      }
  }
  if arr_end >= scope_end { return 0 }
365
  // Parse 4 comma-separated numbers
  var p: i64 = arr_start
  let xv: i64 = mr_p_parse_q14(body, p, arr_end)
  if xv == MR_P_Q14_NOT_FOUND { return 0 }
  // Advance past the parsed number to the next comma
  var seek: i64 = p
  var found_c1: i64 = 0
  while found_c1 == 0 {
      if seek >= arr_end { found_c1 = 1 }
      else {
          if body[seek] == 0x2C { found_c1 = 1 }     // ','
          else { seek = seek + 1 }
      }
  }
  if seek >= arr_end { return 0 }
  p = seek + 1
  let yv: i64 = mr_p_parse_q14(body, p, arr_end)
  if yv == MR_P_Q14_NOT_FOUND { return 0 }
  seek = p
  var found_c2: i64 = 0
  while found_c2 == 0 {
      if seek >= arr_end { found_c2 = 1 }
      else {
          if body[seek] == 0x2C { found_c2 = 1 }
          else { seek = seek + 1 }
      }
  }
  if seek >= arr_end { return 0 }
  p = seek + 1
  let zv: i64 = mr_p_parse_q14(body, p, arr_end)
  if zv == MR_P_Q14_NOT_FOUND { return 0 }
  seek = p
  var found_c3: i64 = 0
  while found_c3 == 0 {
      if seek >= arr_end { found_c3 = 1 }
      else {
          if body[seek] == 0x2C { found_c3 = 1 }
          else { seek = seek + 1 }
      }
  }
  if seek >= arr_end { return 0 }
  p = seek + 1
  let ev2: i64 = mr_p_parse_q14(body, p, arr_end)
  if ev2 == MR_P_Q14_NOT_FOUND { return 0 }
410
  *out_x_box = xv
  *out_y_box = yv
  *out_z_box = zv
  *out_e_box = ev2
  return 1
416}
417
418// Public entry: parse the motion_report section into the supplied
419// Q14 output boxes.  Returns NX_MR_PARSE_OK on success.
420//
421// Outputs are NOT written if the motion_report is absent or
422// malformed; caller may pre-init the boxes to sentinel values to
423// detect this.
424func nx_moonraker_parse_motion(
  body: *u8, body_len: i64,
  out_x_q14: *i64, out_y_q14: *i64,
  out_z_q14: *i64, out_e_q14: *i64,
  out_velocity_q14: *i64
429) -> i64 {
  if (body as i64) == 0 { return NX_MR_PARSE_BAD_INPUT }
  if body_len <= 0      { return NX_MR_PARSE_BAD_INPUT }
432
  let mr_key: i64 = mr_p_find(body, body_len, 0, "\"motion_report\":{")
  if mr_key < 0 { return NX_MR_PARSE_NO_OBJECT }
435
  let mr_brace: i64 = mr_key + 16    // strlen("\"motion_report\":") = 16
  let mr_end: i64 = mr_p_match_brace(body, body_len, mr_brace)
  if mr_end < mr_brace { return NX_MR_PARSE_NO_OBJECT }
439
  // live_position is the primary source for x/y/z/e
  let lp_ok: i64 = mr_p_extract_live_position(
      body, body_len,
      mr_brace + 1, mr_end,
      out_x_q14, out_y_q14, out_z_q14, out_e_q14)
445
  // live_extruder_position overrides e if present
  let lep: i64 = mr_p_extract_q14_in_scope(
      body, body_len, mr_brace + 1, mr_end, "\"live_extruder_position\":")
  if lep != MR_P_Q14_NOT_FOUND { *out_e_q14 = lep }
450
  // velocity
  let v: i64 = mr_p_extract_q14_in_scope(
      body, body_len, mr_brace + 1, mr_end, "\"live_velocity\":")
  if v != MR_P_Q14_NOT_FOUND { *out_velocity_q14 = v }
455
  if lp_ok == 0 {
      if lep == MR_P_Q14_NOT_FOUND { return NX_MR_PARSE_NO_OBJECT }
  }
  return NX_MR_PARSE_OK
460}
nx_moonraker_telemetry_parse.nx source

`nx_moonraker_telemetry_parse.nx` source
