Analog waves working well

pieter3d · pieter3d · commit ba96fba11129 · 2025-09-13T21:43:06.000-07:00
diff --git a/README.md b/README.md
@@ -57,12 +57,9 @@ A list of features that have not yet been implemented.
 * A colorscheme that works with white backgrounds.
 * Polish: Syntax highlighting of macros
 * Source window: Need a clean way to add multiple signals from the source to the waves at once.
-* Expose local nets in functions and tasks
-* Expose local variables in always blocks?
 * Time multiplier for waves (e.g. wave 1 unit is really X us/ns/ps/)
 * Wave + source should be able to figure out enums in waves.
 * Search for value in wave.
-* Analog signals.
 * Detect unrolled arrays in waves, make them expandable in the waveforms
 * Lazy / on-demand loading of VCD wave data. Not clear if this is useful since
   loading anything requires parsing the whole file anyway.
diff --git a/src/wave_image.cc b/src/wave_image.cc
@@ -1,17 +1,37 @@
 #include "wave_image.h"
+
 #include <cstdlib>
+#include <string_view>
 
 namespace sv {
 
+char BraillePatternToAscii(uint8_t b) {
+  constexpr std::string_view lo_lut = " .,:;a&#@";
+  constexpr std::string_view hi_lut = " '\":PM&#@";
+  int num_bits = 0;
+  int num_lo_bits = 0;
+  int num_hi_bits = 0;
+  for (int i = 0; i < 8; ++i) {
+    if ((b >> i) & 1) {
+      num_bits++;
+      // Count the number of bits in the upper and lower half of the character.
+      if (i <= 4 && i != 2) {
+        num_hi_bits++;
+      } else {
+        num_lo_bits++;
+      }
+    }
+  }
+  return (num_lo_bits < num_hi_bits ? hi_lut : lo_lut)[num_bits];
+}
+
 void WaveImage::SetPixel(int x, int y) {
   if (x < 0 || x >= width_) return;
   if (y < 0 || y >= height_) return;
-  buffer_[y * width_ * x] = true;
+  buffer_[y * width_ + x] = true;
 }
 
 void WaveImage::DrawLine(int x0, int y0, int x1, int y1) {
-  if (x0 < 0 || x1 < 0 || x0 >= width_ || x1 >= width_) return;
-  if (y0 < 0 || y1 < 0 || y0 >= height_ || y1 >= height_) return;
   // Bresenham's Line Algorithm
   const bool steep = std::abs(y1 - y0) > std::abs(x1 - x0);
   if (steep) {
@@ -49,9 +69,9 @@ uint16_t WaveImage::GetBrailleChar(int x, int y) {
   // 1 4
   // 2 5
   // 6 7
-  // nicode value is 0x28xx, with xx being the 8-bits above.
+  // Unicode value is 0x28xx, with xx being the 8-bits above.
   uint16_t braille = 0x2800;
-  if (x >= width_ / 2 || y >= height_ / 4) return braille;
+  if (x < 0 || y < 0 || x >= width_ / 2 || y >= height_ / 4) return braille;
   braille |= buffer_[(4 * y + 0) * width_ + (2 * x + 0)] << 0;
   braille |= buffer_[(4 * y + 1) * width_ + (2 * x + 0)] << 1;
   braille |= buffer_[(4 * y + 2) * width_ + (2 * x + 0)] << 2;
@@ -64,20 +84,52 @@ uint16_t WaveImage::GetBrailleChar(int x, int y) {
 }
 
 WaveImage RenderWaves(const WaveImageConfig &cfg, const std::vector<WaveData::Sample> &wave) {
-  
-
-
   // Braille patterns are 2x4 dots, "pixels".
-  WaveImage img(cfg.char_w * 2, cfg.char_h * 4);
+  const int img_w = cfg.char_w * 2;
+  const int img_h = cfg.char_h * 4;
+  WaveImage img(img_w, img_h);
 
   int p0_idx = cfg.left_idx;
   while (p0_idx > 0 && wave[p0_idx].time > cfg.left_time) {
     p0_idx--;
   }
-  // Draw stable signal up to the first point.
-  if (wave[p0_idx].time > cfg.left_time) {
+  // Make a list of all points and track the max value.
+  std::vector<std::pair<double, double>> samples;
+  double max = 0;
+  double min = 0;
+  for (int i = p0_idx; i < wave.size(); ++i) {
+    double v = 0;
+    switch (cfg.radix) {
+    case Radix::kFloat:
+      if (wave[i].value.size() <= 32) {
+        v = BinStringToFp32(wave[i].value).value_or(0);
+      } else {
+        v = BinStringToFp64(wave[i].value).value_or(0);
+      }
+      break;
+    case Radix::kSignedDecimal: v = BinStringToSigned(wave[i].value).value_or(0); break;
+    default: v = BinStringToUnsigned(wave[i].value).value_or(0);
+    }
+    if (v > max) max = v;
+    if (v < min) min = v;
+    samples.push_back({static_cast<double>(wave[i].time) - cfg.left_time, v});
+    if (wave[i].time >= cfg.right_time) break;
   }
 
+  const double x_scale = (img_w - 1) / static_cast<double>(cfg.right_time - cfg.left_time);
+  const double y_scale = max == min ? 1 : ((img_h - 1) / (max - min));
+  for (int i = 1; i < samples.size(); ++i) {
+    const int x0 = std::lround(samples[i - 1].first * x_scale);
+    const int y0 = img_h - 1 - std::lround(samples[i - 1].second * y_scale);
+    const int x1 = std::lround(samples[i].first * x_scale);
+    const int y1 = img_h - 1 - std::lround(samples[i].second * y_scale);
+    if (cfg.analog_type == AnalogWaveType::kLinear) {
+      img.DrawLine(x0, y0, x1, y1);
+    } else if (cfg.analog_type == AnalogWaveType::kSampleAndHold) {
+      img.DrawLine(x0, y0, x1, y0);
+      img.DrawLine(x1, y0, x1, y1);
+    }
+  }
 
   return img;
 }
diff --git a/src/wave_image.h b/src/wave_image.h
@@ -22,6 +22,8 @@ class WaveImage {
   std::vector<bool> buffer_;
 };
 
+enum class AnalogWaveType { kSampleAndHold = 0, kLinear };
+
 struct WaveImageConfig {
   int char_w;
   int char_h;
@@ -30,8 +32,12 @@ struct WaveImageConfig {
   uint64_t left_time;
   uint64_t right_time;
   Radix radix = Radix::kBinary;
+  AnalogWaveType analog_type;
 };
 
 WaveImage RenderWaves(const WaveImageConfig &cfg, const std::vector<WaveData::Sample> &wave);
 
+// Returns a close-enough ASCII character for the given braille pattern.
+char BraillePatternToAscii(uint8_t b);
+
 } // namespace sv
diff --git a/src/waves_panel.cc b/src/waves_panel.cc
@@ -162,8 +162,8 @@ void WavesPanel::FindEdge(bool forward, bool *time_changed, bool *range_changed)
 void WavesPanel::SnapToValue() {
   const auto *item = visible_items_[line_idx_];
   if (item->signal == nullptr) return;
-  auto time_per_char = TimePerChar();
-  auto &wave = wave_data_->Wave(item->signal);
+  const double time_per_char = TimePerChar();
+  const std::vector<WaveData::Sample> &wave = wave_data_->Wave(item->signal);
   // See if there is an edge within the current cursor's character span
   const uint64_t left_time = left_time_ + cursor_pos_ * time_per_char;
   const uint64_t right_time = left_time_ + (cursor_pos_ + 1) * time_per_char;
@@ -416,7 +416,7 @@ void WavesPanel::Draw() {
     int left_sample_idx = wave_data_->FindSampleIndex(left_time_, item->signal);
     // Save the locations of transitions and times to fill in values.
     struct WaveValueInfo {
-      int xpos;
+      int xpos = 0;
       int size;
       uint64_t time;
       std::string value;
@@ -441,14 +441,27 @@ void WavesPanel::Draw() {
     const int num_rows = item->analog_rows > 1 ? item->analog_rows : 1;
     std::optional<WaveImage> analog_image;
     if (analog) {
-      // TODO
+      const WaveImageConfig cfg = {
+          .char_w = max_w - wave_x,
+          .char_h = item->analog_rows,
+          .left_idx = left_sample_idx,
+          .left_time = left_time_,
+          .right_time = right_time_,
+          .radix = item->radix,
+          .analog_type = item->analog_type,
+      };
+      analog_image.emplace(RenderWaves(cfg, wave));
     }
     for (int render_row = 0; render_row < num_rows && row < max_h; render_row++, row++) {
       // Draw charachter by charachter
       wmove(w_, row, wave_x);
       for (int x = 0; x < max_w - wave_x; ++x) {
         if (analog) {
-          // TODO
+          if (unicode_) {
+            AddUnicodeChar(w_, analog_image->GetBrailleChar(x, render_row));
+          } else {
+            waddch(w_, BraillePatternToAscii(analog_image->GetBrailleChar(x, render_row)));
+          }
         } else {
           // Find what sample index corresponds to the right edge of this character.
           const int right_sample_idx = wave_data_->FindSampleIndex(
@@ -486,7 +499,8 @@ void WavesPanel::Draw() {
               } else {
                 waddch(w_, '|');
               }
-              // Only save value locations if they are at least 3 characters.
+              // Only save value locations if they are at least 3 characters, comparing against the
+              // previous one.
               if (x - wvi.xpos >= 3) {
                 wvi.size = x - wvi.xpos;
                 wvi.value = FormatValue(wave[wave_value_idx].value, item->radix, leading_zeroes_,
@@ -546,17 +560,17 @@ void WavesPanel::Draw() {
     if (!analog) {
       // Draw waveform values inline where possible.
       SetColor(w_, kWavesInlineValuePair + highlight);
-      for (const auto &wv : wave_value_list) {
+      for (const WaveValueInfo &wv : wave_value_list) {
         int start_pos, char_offset;
         if (wv.size - 1 < wv.value.size()) {
           start_pos = wv.xpos + 1;
           char_offset = wv.value.size() - wv.size + 1;
         } else {
-          start_pos = wv.xpos + wv.size / 2 - wv.value.size() / 2;
+          start_pos = wv.xpos + 1 + (wv.size - 1) / 2 - wv.value.size() / 2;
           char_offset = 0;
         }
         // Draw on row-1, since row was already incremented after rendering the wave.
-        wmove(w_, row-1, start_pos + wave_x);
+        wmove(w_, row - 1, start_pos + wave_x);
         for (int i = char_offset; i < wv.value.size(); ++i) {
           waddch(w_, (i == char_offset && char_offset != 0) ? '.' : wv.value[i]);
         }
@@ -568,19 +582,23 @@ void WavesPanel::Draw() {
   // Draw the cursor and markers.
   const auto draw_vline = [&](int row, int col) {
     const int current_line = 1 + line_idx_ - scroll_row_;
-    if (visible_items_[line_idx_]->signal != nullptr) {
+    if (visible_items_[line_idx_]->signal != nullptr &&
+        visible_items_[line_idx_]->analog_rows == 0) {
       // Draw the line in two sections, above and below the current line to
-      // avoid overwriting the drawn wave.
+      // avoid overwriting the drawn wave. Draw over analog waves though.
       if (current_line > row) {
         mvwvline(w_, row, col, ACS_VLINE, current_line - row);
       }
-      if (current_line < max_h - 1) {
-        mvwvline(w_, current_line + 1, col, ACS_VLINE, max_h - current_line - 1);
+      const int next_line_start =
+          current_line + std::max(1, visible_items_[line_idx_]->analog_rows);
+      if (next_line_start < max_h) {
+        mvwvline(w_, next_line_start, col, ACS_VLINE, max_h - next_line_start);
       }
     } else {
       mvwvline(w_, row, col, ACS_VLINE, max_h - row);
     }
   };
+  // Helper to see if the marker should start under the current time, to avoid covering it.
   auto vline_row = [&](int col) { return col >= time_width ? 0 : 1; };
   for (int i = -1; i < 10; ++i) {
     const uint64_t time = i < 0 ? marker_time_ : numbered_marker_times_[i];
@@ -590,17 +608,17 @@ void WavesPanel::Draw() {
       std::string marker_label = "m";
       if (i >= 0) marker_label += '0' + i;
       SetColor(w_, kWavesMarkerPair);
-      const int col = wave_x + marker_pos;
-      const int row = vline_row(wave_x + marker_pos);
-      draw_vline(row, col);
+      const int marker_col = wave_x + marker_pos;
+      const int marker_row = vline_row(wave_x + marker_pos);
+      draw_vline(marker_row, marker_col);
       if (marker_pos + marker_label.size() < max_w) {
-        mvwaddstr(w_, row, col, marker_label.c_str());
+        mvwaddstr(w_, marker_row, marker_col, marker_label.c_str());
       }
     }
   }
   // Also the interactive cursor.
-  int cursor_col = wave_x + cursor_pos_;
-  int cursor_row = vline_row(cursor_col);
+  const int cursor_col = wave_x + cursor_pos_;
+  const int cursor_row = vline_row(cursor_col);
   SetColor(w_, kWavesCursorPair);
   draw_vline(cursor_row, cursor_col);
 
@@ -636,6 +654,7 @@ void WavesPanel::UIChar(int ch) {
 
   bool time_changed = false;
   bool range_changed = false;
+  bool edge_search = false;
   // Most actions cancel multi-line.
   bool cancel_multi_line = true;
   if (showing_path_) {
@@ -846,7 +865,10 @@ void WavesPanel::UIChar(int ch) {
       }
       break;
     case 'e':
-    case 'E': FindEdge(ch == 'e', &time_changed, &range_changed); break;
+    case 'E':
+      FindEdge(ch == 'e', &time_changed, &range_changed);
+      edge_search = true;
+      break;
     case 'r':
       if (item->signal != nullptr) {
         item->CycleRadix();
@@ -890,11 +912,14 @@ void WavesPanel::UIChar(int ch) {
     case 'A':
       if (item->analog_rows > 0) item->analog_rows--;
       break;
+    case 0x1: // Ctrl-a
+      item->CycleAnalogType();
+      break;
     default: Panel::UIChar(ch);
     }
   }
   if (time_changed) {
-    SnapToValue();
+    if (!edge_search) SnapToValue();
     UpdateValues();
   }
   if (range_changed) UpdateWaves();
@@ -1168,9 +1193,6 @@ std::vector<Tooltip> WavesPanel::Tooltips() const {
         {"-", "default color"},
     };
   }
-  // TODO: Missing features
-  // "C-r": "Reload",
-  // "aA" : "Adjust analog height",
   std::vector<Tooltip> tt{
       {"zZ", "Zoom"},
       {"F", "Zoom full"},
@@ -1179,25 +1201,26 @@ std::vector<Tooltip> WavesPanel::Tooltips() const {
       {"eE", "Prev/next edge"},
       {"sS", "Adjust size"},
       {"aA", "Analog size"},
-      {"0", "Show leading zeroes"},
-      {"c", "Change signal color"},
-      {"p", "Show full signal path"},
+      {"C-a", "Analog type"},
+      {"0", "Leading zeroes"},
+      {"c", "Signal color"},
+      {"p", "Show path"},
       {"T", "Go to time"},
       {"t", "Cycle time units"},
       {"m", "Place marker"},
-      {"M", "Place numbered marker"},
+      {"M", "Place # marker"},
       {"C-g", "Create group"},
       {"R", "Rename group"},
-      {"UD", "Move signal up / down"},
-      {"b", "Insert blank signal"},
-      {"x", "Delete highlighted signal"},
-      {"r", "Cycle signal radix"},
+      {"UD", "Move signal up/dn"},
+      {"b", "Insert blank"},
+      {"x", "Delete"},
+      {"r", "Cycle radix"},
       {"C-u", "Toggle Unicode"},
       {"C-o", "Open list file"},
       {"C-s", "Save list file"},
   };
   if (Workspace::Get().Design() != nullptr) {
-    tt.push_back({"d", "Show signal declaration in source"});
+    tt.push_back({"d", "Declaration"});
   }
   return tt;
 }
@@ -1218,6 +1241,13 @@ void WavesPanel::ListItem::CycleRadix() {
   }
 }
 
+void WavesPanel::ListItem::CycleAnalogType() {
+  switch (analog_type) {
+  case AnalogWaveType::kLinear: analog_type = AnalogWaveType::kSampleAndHold; break;
+  case AnalogWaveType::kSampleAndHold: analog_type = AnalogWaveType::kLinear; break;
+  }
+}
+
 std::optional<const WaveData::Signal *> WavesPanel::SignalForSource() {
   if (signal_for_source_ == nullptr) return std::nullopt;
   auto s = signal_for_source_;
diff --git a/src/waves_panel.h b/src/waves_panel.h
@@ -5,6 +5,7 @@
 #include "radix.h"
 #include "text_input.h"
 #include "wave_data.h"
+#include "wave_image.h"
 
 namespace sv {
 
@@ -38,10 +39,12 @@ class WavesPanel : public Panel {
     // Helpers
     std::string Name() const;
     void CycleRadix();
+    void CycleAnalogType();
     // Member data.
     Radix radix = Radix::kHex;
     const WaveData::Signal *signal = nullptr;
     int analog_rows = 0;
+    AnalogWaveType analog_type = AnalogWaveType::kSampleAndHold;
     int depth = 0;
     int custom_color = -1;
     // Members when this item represents a group container.
