Update README with supported hardware details. Fixes issue #55 . Also add some other similar SUMP projects to the bottom of the README. Fix the Makefile as well since I moved the sketches into examples. The Makefile needs more work to add the Leonardo and Sigrok sketches but that is more of an exercise for the reader.

Add empty LogicAnalyzer.h for arduino-lint.
Rearrange the repository and add a library.properties file to make this installable as a .ZIP library in the Arduino IDE.
2026-05-06 14:17:28 +03:00 · 2023-10-10 10:49:48 -05:00 · 2023-10-05 22:48:18 -05:00 · 2023-10-05 22:32:52 -05:00 · 2023-10-03 23:48:07 -05:00 · 2023-10-03 23:00:05 -05:00
19 changed files with 60420 additions and 185 deletions
--- a/22
+++ b/22
@@ -0,0 +1,22 @@
+Copyright (c) 2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023 Andrew Gillham
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY ANDREW GILLHAM ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL ANDREW GILLHAM BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/37
+++ b/37
@@ -1,19 +1,24 @@
 #
-# Makefile for an Arduino based logic analyzer using the 'arduino-core'
-# package and makefiles.
+# Makefile for an Arduino based logic analyzer using the arduino-cli
 #
-#	$Id: Makefile,v 1.3 2011-03-07 02:47:26 gillham Exp $
+
+TARGET	= examples/logic_analyzer
+FQBN	= arduino:avr:diecimila
+SERIAL	= /dev/ttyUSB*
+
+
+all:
+	@echo ""
+	@echo "---> run 'make build' to compile for Arduino Duemilanove"
+	@echo "---> run 'make upload' to upload to /dev/ttyUSB*"
+	@echo ""
+
+build:
+	arduino-cli compile --fqbn $(FQBN) $(TARGET)
+
+upload:
+	arduino-cli upload --fqbn $(FQBN) --port $(SERIAL) $(TARGET)
+
+#
+# end-of-file
 #
-ARDUINO_DIR  = /usr/share/arduino
-
-TARGET       = logic_analyzer
-ARDUINO_LIBS = 
-
-MCU          = atmega328p
-F_CPU        = 16000000
-ARDUINO_PORT = /dev/ttyUSB*
-AVRDUDE_ARD_BAUDRATE = 57600
-AVRDUDE_ARD_PROGRAMMER = arduino
-
-include /usr/share/arduino/Arduino.mk
-
--- a/73
+++ b/73
@@ -1,73 +0,0 @@
-SUMP compatible logic analyzer for Arduino
-==========================================
-
-This Arduino sketch implements a SUMP protocol compatible with the standard
-SUMP client as well as the alternative client from here:
-	http://www.lxtreme.nl/ols/
-
-The alternative client version is highly recommended.  Download version
-"ols-0.9.7" or newer for built-in device profiles.
-
-This SUMP protocol compatible logic analyzer for the Arduino board supports
-5 channels consisting of digital pins 8-12, which are the first 5 bits (0-4)
-of PORTB. Arduino pin 13 / bit 5 is the Arduino LED, bits 6 & 7 are the
-crystal oscillator pins.
-
-Uncomment CHAN5 below if you want to use the LED pin as an input and have
-6 channels.
-
-On the Arduino Mega board 8 channels are supported and 7k of samples.
-Pins 22-29 (Port A) are used by default.
-
-To use this with the original or alternative SUMP clients,
-use these settings:
-
-Sampling rate: 4MHz (or lower) (no 2MHz on ATmega168)
-Channel Groups: 0 (zero) only
-Recording Size:
-   ATmega168:  532 (or lower)
-   ATmega328:  1024 (or lower)
-   ATmega2560: 7168 (or lower)
-Noise Filter: doesn't matter
-RLE: disabled (unchecked)
-
-Triggering is still a work in progress, but generally works for samples
-below 1MHz.  1MHz works for a basic busy wait trigger that doesn't store
-until after the trigger fires.
-Please try it out and report back.
-
-Older Notes
-===========================================================================
-NOTE: With v0.11 you can now sample at 4MHz & 2MHz rates in addition to the 
-      previous 1MHz and lower rates.  This is done via unrolled loops which
-      makes the source code huge and the binary takes much more of the flash.
-      v0.11 is just slightly to big for an ATmega168's flash.  You can comment
-      out either captureInline2mhz() or captureInline4mhz() and it will fit.
-      [ The code automatically skips the 2MHz code now, this isn't needed. ]
-
-NOTE: v0.09 switched the channels BACK to pins 8-13 for trigger reliability.
-      Please report any issues.  Uncomment USE_PORTD for pins 2-7.
-
-NOTE: The device profiles should be included with this code.  Copy them to the
-      'plugins' directory of the client.  The location varies depending on the
-      platform, but on the mac it is here by default:
-      /Applications/LogicSniffer.app/Contents/Resources/Java/plugins
-      [ These are included in ols-0.9.7 or newer so do not copy them. ]
-
-NOTE: If you are using the original SUMP client, then you will get a
-      "device not found" error.
-      You must DISABLE the Arduino auto reset feature to use this logic analyzer
-      code. There are various methods to do this, some boards have a jumper,
-      others require you to cut a trace.  You may also install a *precisely*
-      120 Ohm resistor between the reset & 5V piins.  Make sure it is really
-      120 Ohm or you may damage your board.  It is much easier to use the
-      alternative SUMP client referenced above.
-      [ This is not needed with ols-0.9.7 or newer. ]
-      [ DO NOT use this resistor unless absolutely necessary on old clients. ]
-
-NOTE: This master branch now supports Arduino 1.0 only.
-      Checkout branch logic_analyzer_v0_5 for Arduino 22 support.
-
-
-Release: v0.12 September 6, 2013.
-
--- a/README.md
+++ b/README.md
@@ -0,0 +1,204 @@
+# SUMP compatible logic analyzer for Arduino
+
+This Arduino sketch implements a SUMP protocol compatible logic analyzer.
+This implementation is compatible with the standard SUMP client as well as
+an alternative OLS client.  More recently support has been added to Sigrok.
+
+This logic analyzer for Arduino supports 6 channels consisting of digital
+pins 8-13, which are the first 6 bits (0-5) of PORTB.
+Arduino pin 13 / bit 5 is the Arduino LED, bits 6 & 7 are the crystal
+oscillator pins. Comment out CHAN5 if you don't want to use the
+LED pin for an input.
+
+On the Arduino Mega board 8 channels are supported and 7k of samples.
+Pins 22-29 (Port A) are used by default.
+
+# Supported Hardware
+The AGLA sketch supports many Arduino boards based on the following microcontrollers, generally using an FTDI based USB to serial, or builtin in the case of the ATmega32U4.  Many inexpensive boards use the 'CH340' USB to serial chipset which may or may not work well.  Please test yours and file an issue.
+
+Generally I test the Arduino Duemilanove and Arduino UNO R3 the most, but I do want to make as many boards as possible work.
+
+The microcontrollers are listed below with corresponding Arduino boards.  This is not an exhaustive list and I do not own all of these boards to test them.  Again please test and file any issues.
+
+## ATmega168
+- Arduino Diecimila
+- Arduino Mini (Original was '168)
+
+## ATmega328P
+- Arduino Duemilanove
+- Arduino Mini (Original was '168)
+- Arduino Nano
+- Arduino Pro
+- Arduino Pro Mini
+- Arduino Uno (Rev2, R3, SMD)
+- Arduino Uno Mini
+
+## ATmega1280
+- Arduino Mega
+
+## ATmega2560
+- Arduino Mega 2560
+
+## ATmega32U4
+- Arduino Leonardo
+- Arduino Micro
+
+# Installation
+
+## Arduino IDE Library Manager
+Starting with v0.17 you can install directly in the Arduino IDE using the Library Manager.
+Look under the menu 'Sketch -> Include Library -> Manage Libraries...' to open the Library Manager, then enter 'LogicAnalyzer' in the search field and it should find this project and you can click INSTALL.
+
+## Manual via ZIP file
+You can use the GitHub 'Download ZIP' feature to get an installable "library"
+for use with the Arduino IDE.  Select 'Sketch -> Include Library -> Add .ZIP Libary'
+from the Arduino IDE 2.x and select the zip file you downloaded from GitHub, then select open.
+
+## After Installation
+Once installed you can use the 'File -> Examples -> LogicAnalyzer' menu to find
+different versions of the sketches.  You might want to start with `logic_analyzer_sigrok`
+and use PulseView.
+
+# Client Software
+
+## Sigrok
+
+Sigrok support via the 'ols' device configuration has been added. This
+mostly involved returning the capture buffer in the reverse order.
+
+Use the `logic_analyzer_sigrok` sketch.  Since the OLS alternative client
+mentioned below has some issues with newer Java versions, Sigrok is currently
+the only practical way to use this logic analyzer.  If you use an older machine
+with an older operating system and older Java you can probably use the OLS client.
+
+Sigrok support seems to work fairly well so I would currently recommend it for
+anyone interested in trying this sketch.
+
+Run PulseView like this on Linux: (I'll add Windows options after more testing)
+```
+PulseView --driver=ols:conn=/dev/ttyUSB0 --dont-scan
+```
+
+It may be necessary to exit and relaunch PulseView to get it to recognize the device.
+An easy way to test the device is using the `sigrok-cli` utility. The command below
+samples channel 2 at 1MHz.  If you get a device not found error, but /dev/ttyUSB0 exists,
+run this command a couple times and usually it will start working. Due to the way opening
+the serial port resets the Arduino there are some issues/bugs to work out yet.
+```
+sigrok-cli --driver=ols:conn=/dev/ttyUSB0 --config samplerate=1Mhz --config pattern=External --samples 1024 --channels 2
+```
+
+## OLS Client(s)
+
+*NOTE: This section needs work as due to various Java issuses building a working OLS client is somewhat broken right now.*
+
+The OLS alternative client hasn't had an official release recently so you will
+need to compile it yourself.
+
+Follow the build instructions here: https://github.com/jawi/ols
+
+Older details on the OLS client is available at the project page:
+https://lxtreme.nl/projects/ols/
+
+Direct link to older releases of the OLS alternative client:
+http://www.lxtreme.nl/ols/
+
+The alternative client version is highly recommended.  You can tried the older
+release ols-0.9.7.2 but most likely need to build it yourself. Use "ols-0.9.7"
+or newer for built-in device profiles.
+
+To use this with the original or alternative SUMP clients, use these settings:
+```
+Sampling rate: 4MHz (or lower) (no 2MHz on ATmega168)
+Channel Groups: 0 (zero) only
+Recording Size:
+   ATmega168:  532 (or lower)
+   ATmega328:  1024 (or lower)
+   ATmega2560: 7168 (or lower)
+Noise Filter: doesn't matter
+RLE: disabled (unchecked)
+```
+
+# Using the Logic Analyzer
+
+Triggering is still a work in progress, but generally works for samples
+below 1MHz.  1MHz works for a basic busy wait trigger that doesn't store
+until after the trigger fires.
+
+Please try it out and report back.  Please provide a detailed bug report
+if you file an issue.
+
+# Debugging
+
+You can uncomment the `#define DEBUG_MENU` line to add some diagnostic menu
+options for capturing or dumping the capture buffer.
+You can uncomment the `#define DEBUG` and `#define DEBUG_MENU` for a couple
+extra menu options and logging of the received commands.  The DEBUG option
+is generally only useful for development, while the DEBUG_MENU option is
+good for troubleshooting when the logic_analyzer sketch isn't working for you.
+Both are disabled by default to conserve RAM for improved stability.
+
+# CLI compiling
+
+If you want to use the `arduino-cli` tool to compile this using the Makefile,
+you'll need to install the tool first following instructions here:
+https://arduino.github.io/arduino-cli/
+
+If you use Debian or Ubuntu you can install `arduino-cli` and the AVR toolchain like this:
+```bash
+sudo snap install arduino-cli
+arduino-cli core install arduino:avr
+```
+
+Once installed you can simply type `make` and you should get some basic help:
+```bash
+$ make
+---> run 'make build' to compile for Arduino Duemilanove
+---> run 'make upload' to upload to /dev/ttyUSB*
+```
+
+# Other SUMP compatible projects
+
+There are other projects doing some similar that have been created in the last 12 years or so since I started my work.  I'll start the list with one I've read about recently.
+
+This first project runs on a Raspberry Pi Pico and has some amazing logic analyzer specs for a $5 board!
+
+[μLA: Micro Logic Analyzer](https://github.com/dotcypress/ula/)
+
+[An earlier RPi Pico SUMP logic analyzer](https://github.com/perexg/picoprobe-sump)
+
+[ESP32 based Logic Analyzer](https://github.com/EUA/ESP32_LogicAnalyzer)
+
+[Flexible SUMP library](https://github.com/pschatzmann/logic-analyzer)
+
+[STM32 based SUMP logic analyzer](https://github.com/ag88/SumpSTM32F401cc)
+
+[Another STM32 based logic analyzer](https://github.com/jpbarraca/LogicAlNucleo)
+
+[ESP32 SUMP logic analyzer for Sigrok](https://github.com/Ebiroll/esp32_sigrok)
+
+[Another STM32 logic analyzer](https://github.com/ddrown/stm32-sump)
+
+# Older Notes
+
+```text
+NOTE: Starting with v0.11 you can sample at 4MHz & 2MHz rates in addition to the 
+      previous 1MHz and lower rates.  This is done via unrolled loops which
+      makes the source code huge and the binary takes much more of the flash.
+      v0.11 is just slightly too big for an ATmega168's flash. The code 
+      automatically skips the 2MHz code on ATmega168
+
+NOTE: v0.09 switched the channels BACK to pins 8-13 for trigger reliability.
+      Please report any issues.  Uncomment USE_PORTD for pins 2-7.
+
+NOTE: If you are using the original SUMP client, then you will get a
+      "device not found" error.
+      You must DISABLE the Arduino auto reset feature to use this logic analyzer
+      code. There are various methods to do this, some boards have a jumper,
+      others require you to cut a trace.  You may also install a *precisely*
+      120 Ohm resistor between the reset & 5V piins.  Make sure it is really
+      120 Ohm or you may damage your board.  It is much easier to use the
+      alternative SUMP client referenced above.
+      [ This is not needed with ols-0.9.7 or newer. ]
+      [ DO NOT use this resistor unless absolutely necessary on old clients. ]
+```
--- a/examples/logic_analyzer/logic_analyzer.ino
+++ b/examples/logic_analyzer/logic_analyzer.ino
@@ -2,7 +2,7 @@
 *
 * SUMP Protocol Implementation for Arduino boards.
 *
- * Copyright (c) 2011,2012,2013,2014 Andrew Gillham
+ * Copyright (c) 2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023 Andrew Gillham
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -46,7 +46,7 @@
 *
 * To use this with the original or alternative SUMP clients,
 * use these settings:
- * 
+ *
 * Sampling rate: 4MHz (or lower) (no 2MHz on ATmega168)
 * Channel Groups: 0 (zero) only
 * Recording Size:
@@ -62,7 +62,7 @@
 * until after the trigger fires.
 * Please try it out and report back.
 *
- * Release: v0.12 September 6, 2013.
+ * Release: v0.17 October 5, 2023.
 *
 */

@@ -81,18 +81,15 @@ void blinkled(void);
 void get_metadata(void);
 void debugprint(void);
 void debugdump(void);
-
+void prettydump(void);
+void captureInline4mhz(void);
+void captureInline2mhz(void);

 /*
 * Should we use PORTD or PORTB?  (default is PORTB)
 * PORTD support with triggers seems to work but needs more testing.
 */
 //#define USE_PORTD 1
-#if defined(USE_PORTD)
-#define SHIFTBITS 2
-#elif defined(__AVR_ATmega32U4__)
-#define SHIFTBITS 1
-#endif

 /*
 * Arduino device profile:      ols.profile-agla.cfg
@@ -119,15 +116,6 @@ void debugdump(void);
 #define CHAN5 7
 #else
 #define CHANPIN PINB
-#if defined(__AVR_ATmega32U4__)
-#define CHAN0 SCK
-#define CHAN1 MOSI
-#define CHAN2 MISO
-#define CHAN3 8
-#define CHAN4 9
-#define CHAN5 10
-#define CHAN6 11
-#else
 #define CHAN0 8
 #define CHAN1 9
 #define CHAN2 10
@@ -135,9 +123,8 @@ void debugdump(void);
 #define CHAN4 12
 /* Comment out CHAN5 if you don't want to use the LED pin for an input */
 #define CHAN5 13
-#endif /* AVR_ATmega32U4 */
 #endif /* USE_PORTD */
-#endif /* Mega1280 or Mega2560 */
+#endif
 #define ledPin 13

 /* XON/XOFF are not supported. */
@@ -170,8 +157,8 @@ void debugdump(void);
 #define DEBUG_CAPTURE_SIZE 7168
 #define CAPTURE_SIZE 7168
 #elif defined(__AVR_ATmega32U4__)
-#define DEBUG_CAPTURE_SIZE 1536
-#define CAPTURE_SIZE 1536
+#define DEBUG_CAPTURE_SIZE 2048
+#define CAPTURE_SIZE 2048
 #elif defined(__AVR_ATmega328P__)
 #define DEBUG_CAPTURE_SIZE 1024
 #define CAPTURE_SIZE 1024
@@ -188,8 +175,11 @@ void debugdump(void);
 #define DEBUG_ENABLE DDRD = DDRD | B10000000
 #define DEBUG_ON PORTD = B10000000
 #define DEBUG_OFF PORTD = B00000000
-#endif
-#define DEBUG
+#endif /* USE_PORTD */
+
+//#define DEBUG_MENU
+//#define DEBUG
+
 #ifdef DEBUG
 #define MAX_CAPTURE_SIZE DEBUG_CAPTURE_SIZE
 #else
@@ -223,10 +213,6 @@ boolean rleEnabled = 0;
 void setup()
 {
  Serial.begin(115200);
-  while (!Serial) {
-    ; // wait for serial port to connect. Needed for Leonardo only
-  }
-

  /*
   * set debug pin (digital pin 8) to output right away so it settles.
@@ -244,15 +230,14 @@ void setup()
 #ifdef CHAN5
  pinMode(CHAN5, INPUT);
 #endif
-#ifdef CHAN6
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  pinMode(CHAN6, INPUT);
-#endif
-#ifdef CHAN7
  pinMode(CHAN7, INPUT);
-#endif
+#else
 #ifndef CHAN5
  pinMode(ledPin, OUTPUT);
 #endif
+#endif /* Mega */

 #if 0

@@ -286,10 +271,10 @@ void loop()

  if (Serial.available() > 0) {
    cmdByte = Serial.read();
-    switch(cmdByte) {
+    switch (cmdByte) {
    case SUMP_RESET:
      /*
-       * We don't do anything here as some unsupported extended commands have
+         * We don't do anything here as some unsupported extended commands have
       * zero bytes and are mistaken as resets.  This can trigger false resets
       * so we don't erase the data or do anything for a reset.
       */
@@ -303,14 +288,14 @@ void loop()
      break;
    case SUMP_ARM:
      /*
-       * Zero out any previous samples before arming.
+         * Zero out any previous samples before arming.
       * Done here instead via reset due to spurious resets.
       */
      for (i = 0 ; i < MAX_CAPTURE_SIZE; i++) {
        logicdata[i] = 0;
      }
      /*
-       * depending on the sample rate we need to delay in microseconds
+         * depending on the sample rate we need to delay in microseconds
       * or milliseconds.  We can't do the complex trigger at 1MHz
       * so in that case (delayTime == 1 and triggers enabled) use
       * captureMicro() instead of triggerMicro().
@@ -319,45 +304,45 @@ void loop()
      if (divider == 24) {
        /* 4.0MHz */
        captureInline4mhz();
-      } 
+      }
      else if (divider == 49) {
        /* 2.0MHz */
-#if defined(__AVR_ATmega168P__)
+#if !defined(__AVR_ATmega168__)
        captureInline2mhz();
 #endif
-      } 
+      }
      else if (useMicro) {
        if (trigger && (delayTime != 1)) {
          triggerMicro();
-        } 
+        }
        else {
          captureMicro();
        }
-      } 
+      }
      else {
        captureMilli();
      }
      break;
    case SUMP_TRIGGER_MASK:
      /*
-       * the trigger mask byte has a '1' for each enabled trigger so
+         * the trigger mask byte has a '1' for each enabled trigger so
       * we can just use it directly as our trigger mask.
       */
      getCmd();
-#ifdef SHIFTBITS
-      trigger = cmdBytes[0] << SHIFTBITS;
+#ifdef USE_PORTD
+      trigger = cmdBytes[0] << 2;
 #else
      trigger = cmdBytes[0];
 #endif
      break;
    case SUMP_TRIGGER_VALUES:
      /*
-       * trigger_values can be used directly as the value of each bit
+         * trigger_values can be used directly as the value of each bit
       * defines whether we're looking for it to be high or low.
       */
      getCmd();
-#ifdef SHIFTBITS
-      trigger_values = cmdBytes[0] << SHIFTBITS;
+#ifdef USE_PORTD
+      trigger_values = cmdBytes[0] << 2;
 #else
      trigger_values = cmdBytes[0];
 #endif
@@ -368,7 +353,7 @@ void loop()
      break;
    case SUMP_SET_DIVIDER:
      /*
-       * the shifting needs to be done on the 32bit unsigned long variable
+         * the shifting needs to be done on the 32bit unsigned long variable
       * so that << 16 doesn't end up as zero.
       */
      getCmd();
@@ -381,7 +366,7 @@ void loop()
      break;
    case SUMP_SET_READ_DELAY_COUNT:
      /*
-       * this just sets up how many samples there should be before
+         * this just sets up how many samples there should be before
       * and after the trigger fires.  The readCount is total samples
       * to return and delayCount number of samples after the trigger.
       * this sets the buffer splits like 0/100, 25/75, 50/50
@@ -405,7 +390,7 @@ void loop()
      break;
    case SUMP_GET_METADATA:
      /*
-       * We return a description of our capabilities.
+         * We return a description of our capabilities.
       * Check the function's comments below.
       */
      get_metadata();
@@ -413,37 +398,85 @@ void loop()
    case SUMP_SELF_TEST:
      /* ignored. */
      break;
-#ifdef DEBUG
+#ifdef DEBUG_MENU
      /*
-       * a couple of debug commands used during development.
+         * a couple of debug commands used during development.
       */
+    case '?':
+      Serial.println("");
+#ifdef DEBUG
+      Serial.println("0 = clear cmd buffer");
+      Serial.println("1 = print cmd buffer");
+#endif /* DEBUG */
+      Serial.println("2 = print data buffer");
+      Serial.println("3 = pretty print buffer");
+      Serial.println("4 = capture at 4MHz");
+      Serial.println("5 = capture at 1MHz");
+      Serial.println("6 = capture at 500KHz");
+      break;
+#ifdef DEBUG
    case '0':
      /*
-       * This resets the debug buffer pointer, effectively clearing the
+         * This resets the debug buffer pointer, effectively clearing the
       * previous commands out of the buffer. Clear the sample data as well.
       * Just send a '0' from the Arduino IDE's Serial Monitor.
       */
-      savecount=0;
+      savecount = 0;
      for (i = 0 ; i < MAX_CAPTURE_SIZE; i++) {
        logicdata[i] = 0;
      }
      break;
    case '1':
      /*
-       * This is used to see what commands were sent to the device.
+         * This is used to see what commands were sent to the device.
       * you can use the Arduino serial monitor and send a '1' and get
       * a debug printout.  useless except for development.
       */
      blinkled();
      debugprint();
      break;
+#endif /* DEBUG */
    case '2':
      /*
-       * This dumps the sample data to the serial port.  Used for debugging.
+         * This dumps the sample data to the serial port.
       */
      debugdump();
      break;
-#endif /* DEBUG */
+    case '3':
+      /*
+         * Prints a visual representation of the data buffer.
+       */
+      prettydump();
+      break;
+    case '4':
+      /*
+         * This runs a sample capture at 4MHz.
+       */
+      captureInline4mhz();
+      Serial.println("");
+      Serial.println("4MHz capture done.");
+      break;
+    case '5':
+      /*
+         * This runs a sample capture at 1MHz.
+       * delayTime = 1ms for 1MHz sampling.
+       */
+      delayTime = 1;
+      captureMicro();
+      Serial.println("");
+      Serial.println("1MHz capture done.");
+      break;
+    case '6':
+      /*
+         * This runs a sample capture at 500KHz.
+       * delayTime = 2ms for 500KHz.
+       */
+      delayTime = 2;
+      captureMicro();
+      Serial.println("");
+      Serial.println("500KHz capture done.");
+      break;
+#endif /* DEBUG_MENU */
    default:
      /* ignore any unrecognized bytes. */
      break;
@@ -548,7 +581,7 @@ void captureMicro() {
      __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
    }
    DEBUG_OFF; /* debug timing measurement */
-  } 
+  }
  else if (delayTime == 2) {
    /*
     * 500KHz sample rate = 2 uS delay, still pretty fast so we pad this
@@ -565,7 +598,7 @@ void captureMicro() {
      __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
    }
    DEBUG_OFF; /* debug timing measurement */
-  } 
+  }
  else {
    /*
     * not 1MHz or 500KHz; delayMicroseconds(delay - 1) works fine here
@@ -590,8 +623,8 @@ void captureMicro() {
   * is done for any triggers, this is effectively the 0/100 buffer split.
   */
  for (i = 0 ; i < readCount; i++) {
-#ifdef SHIFTBITS
-    Serial.write(logicdata[i] >> SHIFTBITS);
+#ifdef USE_PORTD
+    Serial.write(logicdata[i] >> 2);
 #else
    Serial.write(logicdata[i]);
 #endif
@@ -618,7 +651,7 @@ void captureMicro() {
 void captureMilli() {
  unsigned int i = 0;

-  if(rleEnabled) {
+  if (rleEnabled) {
    /*
     * very basic trigger, just like in captureMicros() above.
     */
@@ -629,16 +662,16 @@ void captureMilli() {
    byte lastSample = 0;
    byte sampleCount = 0;

-    while(i < readCount) {
+    while (i < readCount) {
      /*
       * Implementation of the RLE unlimited protocol: timings might be off a little
       */
-      if(lastSample == (CHANPIN & B01111111) && sampleCount < 127) {
+      if (lastSample == (CHANPIN & B01111111) && sampleCount < 127) {
        sampleCount++;
        delay(delayTime);
        continue;
      }
-      if(sampleCount != 0) {
+      if (sampleCount != 0) {
        logicdata[i] = B10000000 | sampleCount;
        sampleCount = 0;
        i++;
@@ -650,7 +683,7 @@ void captureMilli() {

      i++;
    }
-  } 
+  }
  else {
    /*
     * very basic trigger, just like in captureMicros() above.
@@ -665,8 +698,8 @@ void captureMilli() {
    }
  }
  for (i = 0 ; i < readCount; i++) {
-#ifdef SHIFTBITS
-    Serial.write(logicdata[i] >> SHIFTBITS);
+#ifdef USE_PORTD
+    Serial.write(logicdata[i] >> 2);
 #else
    Serial.write(logicdata[i]);
 #endif
@@ -679,7 +712,7 @@ void captureMilli() {
 * This works ok at 500KHz and lower sample rates.  We don't have enough time
 * with a 16MHz clock to sample at 1MHz into the circular buffer.  A 20MHz
 * clock might be ok but all of the timings would have to be redone.
- * 
+ *
 */
 void triggerMicro() {
  unsigned int i = 0;
@@ -726,7 +759,7 @@ void triggerMicro() {
     * click stop.
     */
    return;
-  } 
+  }
  else if (delayTime == 2) {
    /*
     * 500KHz case.  We should be able to manage this in time.
@@ -755,7 +788,7 @@ void triggerMicro() {
    __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
    DEBUG_OFF; /* debug timing measurement */

-    /* 
+    /*
     * One sample size delay. ends up being 2 uS combined with assignment
     * below.  This padding is so we have a consistent timing interval
     * between the trigger point and the subsequent samples.
@@ -785,7 +818,7 @@ void triggerMicro() {
    }
    DEBUG_OFF; /* debug timing measurement */
    delayMicroseconds(100);
-  } 
+  }
  else {
    /*
     * Less than 500KHz case.  This uses delayMicroseconds() and some padding
@@ -859,8 +892,8 @@ void triggerMicro() {
    if (logicIndex >= readCount) {
      logicIndex = 0;
    }
-#ifdef SHIFTBITS
-    Serial.write(logicdata[logicIndex++] >> SHIFTBITS);
+#ifdef USE_PORTD
+    Serial.write(logicdata[logicIndex++] >> 2);
 #else
    Serial.write(logicdata[logicIndex++]);
 #endif
@@ -885,7 +918,7 @@ void setupDelay() {
  if (divider >= 1500000) {
    useMicro = 0;
    delayTime = (divider + 1) / 100000;
-  } 
+  }
  else {
    useMicro = 1;
    delayTime = (divider + 1) / 100;
@@ -906,8 +939,6 @@ void get_metadata() {
  Serial.write('A');
 #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  Serial.write('M');
-#elif defined(__AVR_ATmega32U4__)
-  Serial.write('L');
 #endif /* Mega */
  Serial.write('v');
  Serial.write('0');
@@ -918,7 +949,7 @@ void get_metadata() {
  Serial.write('0');
  Serial.write('.');
  Serial.write('1');
-  Serial.write('2');
+  Serial.write('7');
  Serial.write((uint8_t)0x00);

  /* sample memory */
@@ -929,10 +960,6 @@ void get_metadata() {
  /* 7168 bytes */
  Serial.write((uint8_t)0x1C);
  Serial.write((uint8_t)0x00);
-#elif defined(__AVR_ATmega32U4__)
-  /* 1024 bytes */
-  Serial.write((uint8_t)0x04);
-  Serial.write((uint8_t)0x00);
 #elif defined(__AVR_ATmega328P__)
  /* 1024 bytes */
  Serial.write((uint8_t)0x04);
@@ -952,26 +979,26 @@ void get_metadata() {

  /* number of probes (6 by default on Arduino, 8 on Mega) */
  Serial.write((uint8_t)0x40);
-#ifdef CHAN7
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  Serial.write((uint8_t)0x08);
-#elif CHAN6
-  Serial.write((uint8_t)0x07);
-#elif CHAN5
+#else
+#ifdef CHAN5
  Serial.write((uint8_t)0x06);
 #else
  Serial.write((uint8_t)0x05);
-#endif
+#endif /* CHAN5 */
+#endif /* Mega */

  /* protocol version (2) */
  Serial.write((uint8_t)0x41);
  Serial.write((uint8_t)0x02);

  /* end of data */
-  Serial.write((uint8_t)0x00);  
+  Serial.write((uint8_t)0x00);
 }

 /*
- * This is used by the '0' debug command to dump the contents of some
+ * This is used by the '1' debug command to dump the contents of some
 * interesting variables and the debug buffer.
 *
 */
@@ -1003,7 +1030,7 @@ void debugprint() {
  for (i = 0 ; i < savecount; i++) {
    if (savebytes[i] == 0x20) {
      Serial.println();
-    } 
+    }
    else {
      Serial.print(savebytes[i], HEX);
      Serial.write(' ');
@@ -1012,6 +1039,8 @@ void debugprint() {
  Serial.println("done...");
 }

+#endif /* DEBUG */
+#ifdef DEBUG_MENU
 /*
 * This is used by the '2' debug command to dump the contents
 * of the sample buffer.
@@ -1023,8 +1052,8 @@ void debugdump() {
  Serial.print("\r\n");

  for (i = 0 ; i < MAX_CAPTURE_SIZE; i++) {
-#ifdef SHIFTBITS
-    Serial.print(logicdata[i] >> SHIFTBITS, HEX);
+#ifdef USE_PORTD
+    Serial.print(logicdata[i] >> 2, HEX);
 #else
    Serial.print(logicdata[i], HEX);
 #endif
@@ -1036,8 +1065,36 @@ void debugdump() {
    j++;
  }
 }
-#endif /* DEBUG */
-
+
+/*
+ * This is used by the '3' debugs command to dump the first 64 bytes
+ * of the sample buffer.
+ * It prints the data in a graphical representation.
+ */
+void prettydump() {
+  int i;
+  byte j;
+  byte k;
+
+  Serial.print("\r\n");
+
+  for (i = 0 ; i < 64; i++) {
+#ifdef USE_PORTD
+    k = logicdata[i] >> 2;
+#else
+    k = logicdata[i];
+#endif
+    for (j = 0; j < 8; j++) {
+      if (k & 0x01)
+        Serial.print("| ");
+      else
+        Serial.print(" |");
+      k = k >> 1;
+    }
+    Serial.print("\r\n");
+  }
+}
+#endif /* DEBUG_MENU */



--- a/examples/logic_analyzer/logic_analyzer_inline_2mhz.ino
+++ b/examples/logic_analyzer/logic_analyzer_inline_2mhz.ino
@@ -2,7 +2,7 @@
 *
 * SUMP Protocol Implementation for Arduino boards.
 *
- * Copyright (c) 2011,2012,2013,2014 Andrew Gillham
+ * Copyright (c) 2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023 Andrew Gillham
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
--- a/examples/logic_analyzer/logic_analyzer_inline_4mhz.ino
+++ b/examples/logic_analyzer/logic_analyzer_inline_4mhz.ino
@@ -2,7 +2,7 @@
 *
 * SUMP Protocol Implementation for Arduino boards.
 *
- * Copyright (c) 2011,2012,2013,2014 Andrew Gillham
+ * Copyright (c) 2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023 Andrew Gillham
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
--- a/examples/logic_analyzer_leonardo/Makefile
+++ b/examples/logic_analyzer_leonardo/Makefile
@@ -0,0 +1,24 @@
+#
+# Makefile for an Arduino based logic analyzer using the arduino-cli
+#
+
+TARGET	= logic_analyzer_leonardo
+FQBN	= arduino:avr:leonardo
+SERIAL	= /dev/ttyUSB*
+
+
+all:
+	@echo ""
+	@echo "---> run 'make build' to compile for Arduino Leonardo"
+	@echo "---> run 'make upload' to upload to /dev/ttyUSB*"
+	@echo ""
+
+build:
+	arduino-cli compile --fqbn $(FQBN) $(TARGET)
+
+upload:
+	arduino-cli upload --fqbn $(FQBN) --port $(SERIAL) $(TARGET)
+
+#
+# end-of-file
+#
--- a/examples/logic_analyzer_leonardo/logic_analyzer_inline_2mhz.ino
+++ b/examples/logic_analyzer_leonardo/logic_analyzer_inline_2mhz.ino
--- a/examples/logic_analyzer_leonardo/logic_analyzer_inline_4mhz.ino
+++ b/examples/logic_analyzer_leonardo/logic_analyzer_inline_4mhz.ino
--- a/examples/logic_analyzer_leonardo/logic_analyzer_leonardo.ino
+++ b/examples/logic_analyzer_leonardo/logic_analyzer_leonardo.ino
--- a/examples/logic_analyzer_sigrok/logic_analyzer_inline_2mhz.ino
+++ b/examples/logic_analyzer_sigrok/logic_analyzer_inline_2mhz.ino
--- a/examples/logic_analyzer_sigrok/logic_analyzer_inline_4mhz.ino
+++ b/examples/logic_analyzer_sigrok/logic_analyzer_inline_4mhz.ino
--- a/examples/logic_analyzer_sigrok/logic_analyzer_sigrok.ino
+++ b/examples/logic_analyzer_sigrok/logic_analyzer_sigrok.ino
--- a/extras/ols.profile-agla.cfg
+++ b/extras/ols.profile-agla.cfg
--- a/extras/ols.profile-aglam.cfg
+++ b/extras/ols.profile-aglam.cfg
--- a/library.properties
+++ b/library.properties
@@ -0,0 +1,9 @@
+name=LogicAnalyzer
+version=0.17.0
+author=Andrew Gillham <gillham@roadsign.com>
+maintainer=Andrew Gillham <gillham@roadsign.com>
+sentence=A SUMP protocol compatible logic analyzer firmware
+paragraph=These firmware sketches provide a 6 channel logic analyzer for use with the SUMP protocol based OLS clients. There is also a Sigrok compatible firmware using the OpenBench Logic Sniffer (ols) driver .
+category=Signal Input/Output
+url=https://github.com/gillham/logic_analyzer
+architectures=avr
--- a/src/LogicAnalyzer.h
+++ b/src/LogicAnalyzer.h
--- a/src/use_examples_for_logic_analyzer.h
+++ b/src/use_examples_for_logic_analyzer.h
@@ -0,0 +1,2 @@
+// This is a placeholder. Use File->Examples->LogicAnalyzer menu
+// for the logic analyzer sketches.
Author	SHA1	Message	Date
Andrew Gillham	6ec9441ad6	Update README with supported hardware details. Fixes issue #55 . Also add some other similar SUMP projects to the bottom of the README. Fix the Makefile as well since I moved the sketches into examples. The Makefile needs more work to add the Leonardo and Sigrok sketches but that is more of an exercise for the reader.	2023-10-10 10:49:48 -05:00
Andrew Gillham	1a226d516d	Add empty LogicAnalyzer.h for arduino-lint.	2023-10-05 22:48:18 -05:00
Andrew Gillham	ed0666863b	Rearrange the repository and add a library.properties file to make this installable as a .ZIP library in the Arduino IDE.	2023-10-05 22:32:52 -05:00
Andrew Gillham	739144d57e	Fix off by one on the capture buffer due to earlier debugging. I finally realized I was checking if an unsigned int was less than zero. Thanks Szilárd for the correct indexes in the issue comments.	2023-10-03 23:48:07 -05:00
Andrew Gillham	0b2651864e	Add a sketch with Sigrok support. Basically returning the capture buffer in the opposite order.	2023-10-03 23:00:05 -05:00
Andrew Gillham	71b7c4790d	Move README to README.md and update it.	2021-12-21 13:28:29 -06:00
Andrew Gillham	016eabdc12	Add a LICENSE file.	2021-12-21 12:51:32 -06:00
Andrew Gillham	1cdc52febc	Add a LICENSE file.	2021-12-21 12:35:18 -06:00
Andrew Gillham	a426e85f0d	Bump the metadata version to 0.15 also.	2021-12-21 12:01:55 -06:00
Andrew Gillham	b919640c7e	Add a note about needing to compile the OLS client yourself.	2021-12-21 11:43:55 -06:00
Andrew Gillham	636df223a4	Bump release to 0.15 now that we have re-organized.	2021-12-21 11:36:21 -06:00
Andrew Gillham	57b1f18900	Move the main ATMega328P sketch into a sub-directory and add the Leonardo sketch to a sub-directory from the branch. Helps folks that download the repository via ZIP file and will allow different board support that is not easily done via ifdef checks.	2021-12-21 11:27:31 -06:00
Andrew Gillham	4f7f86f6d4	Convert Makefile to use arduino-cli since that replaces arduino-core and arduino-builder.	2021-12-21 11:11:38 -06:00
gillham	bd1fbe504e	Merge pull request #51 from qaxi/master Wrong delayTime in 500KHz menu	2021-12-20 15:14:22 -06:00
Petr Klíma	cfacce1758	500KMz 500KHz line was mistakenly 1MHz	2019-12-15 19:08:39 +01:00
gillham	11b8b5bbda	Merge pull request #27 from dhiltonp/master Give Leonardo-type Arduinos 2k sample size.	2016-02-02 10:03:21 -08:00
David P Hilton	4233770315	Give Leonardo-type arduinos 2048 storage	2016-02-02 11:14:06 -05:00
Andrew Gillham	1e3f0696af	Update for CLI compiling. Add function declarations for the inline capture functions and add a note to the README explaining how to compile from the CLI using the ‘arduino-mk’ package. Known to work on Debian 8, but untested elsewhere.	2015-12-16 11:47:31 -08:00
Andrew Gillham	5fb67c666d	v0.14. Rearrange DEBUG functionality, disable by default. v0.14. Add ‘DEBUG_MENU’ which can be uncommented to enable the basic debug menu with the ability to run a capture / dump the data etc. DEBUG and DEBUG_MENU are commented out by default to save RAM.	2015-12-16 11:15:10 -08:00
Andrew Gillham	9a065516e2	Add additional diagnostic commands. You can connect via the serial monitor and send ‘?’ to get a list of commands available. This allows some diagnostics when the board isn’t working with the OLS client. Sending ‘4’ does a 4MHz capture and ‘2’ dumbs the data buffer for example. Recommended to use this with the simulated signal via a timer. See the bottom of the setup() function and change the ‘#if 0’ to ‘#if 1’ to enable it. Also, fix a long standing bug that broke 2MHz captures and the ATmega168. (improper #if defined check)	2015-02-07 12:17:24 -08:00