public/logic_analyzer_sump
1
0
Fork 0
mirror of https://github.com/gillham/logic_analyzer.git synced 2026-05-07 00:01:09 +03:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: public:aglan_alpha
Branches Tags
public:master public:agla_v0_17 public:agla_v0_16 public:agla_v0_15 public:agla_v0_14 public:agla_v0_13 public:agla_leonardo public:agla_v0_12 public:agla_v0_11 public:agla_v0_10 public:agla_v0_9 public:aglan_alpha public:agla_v0_8 public:agla_v0_7 public:agla_v0_6 public:agla_megaram public:agla_v0_5 public:agla_v0_4 public:agla_v0_3
public:0.17.0
..
compare: public:agla_v0_5
Branches Tags
public:master public:agla_v0_17 public:agla_v0_16 public:agla_v0_15 public:agla_v0_14 public:agla_v0_13 public:agla_leonardo public:agla_v0_12 public:agla_v0_11 public:agla_v0_10 public:agla_v0_9 public:aglan_alpha public:agla_v0_8 public:agla_v0_7 public:agla_v0_6 public:agla_megaram public:agla_v0_5 public:agla_v0_4 public:agla_v0_3
public:0.17.0

2 Commits
aglan_alph ... agla_v0_5

Author SHA1 Message Date
Andrew Gillham
cebcba7d6c Fix ATmega168 comment. 2011-11-04 18:31:11 -07:00
Andrew Gillham
5734af2468 Fix check for ATmega328 
The define is __AVR_ATmega328P__ (note the 'P')
 2011-11-04 18:26:17 -07:00
4 changed files with 275 additions and 442 deletions
Expand all files Collapse all files

8
README
View File

@@ -1,9 +1,6 @@
SUMP compatible logic analyzer for Arduino SUMP compatible logic analyzer for Arduino
========================================== ==========================================
NOTE: NOTE: v0.09 switches the channels BACK to pins 8-13 for trigger reliability.
Please report any issues. Uncomment USE_PORTD for pins 2-7.
This Arduino sketch implements a SUMP protocol compatible with the standard This Arduino sketch implements a SUMP protocol compatible with the standard
SUMP client as well as the alternative client from here: SUMP client as well as the alternative client from here:
http://www.lxtreme.nl/ols/ http://www.lxtreme.nl/ols/
@@ -51,8 +48,5 @@ below 1MHz. 1MHz works for a basic busy wait trigger that doesn't store
until after the trigger fires. until after the trigger fires.
Please try it out and report back. Please try it out and report back.
This master branch now supports Arduino 1.0 only. Release: v0.05 November 4, 2011.
Checkout branch logic_analyzer_v0_5 for Arduino 22 support.
Release: v0.09 June 22, 2013.

423
logic_analyzer.ino → logic_analyzer.pde
View File

@@ -2,7 +2,7 @@
* *
* SUMP Protocol Implementation for Arduino boards. * SUMP Protocol Implementation for Arduino boards.
* *
* Copyright (c) 2011,2012,2013 Andrew Gillham * Copyright (c) 2011 Andrew Gillham
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@@ -25,30 +25,21 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* $Id: logic_analyzer.pde,v 1.17 2011-08-04 02:31:01 gillham Exp $
* *
*/ */
/* /*
* NOTE: This is an ALPHA of support for an Ethernet attached Logic Analyzer.
* Tested with an Arduino Duemilanove and W5100 based Ethernet shield.
* It may work with other combinations, but I haven't tested it.
*
* USE: Configure the mac address (if you want) and the ip address (mandatory)
* for your network and upload it. In the OLS client select network
* instead of serial and use your ip address and port 1234.
* Click capture! You should get some data back from your Arduino.
*
*
* NOTE: v0.09 switches the channels BACK to pins 8-13 for trigger reliability.
* Please report any issues. Uncomment USE_PORTD for pins 2-7.
*
* This Arduino sketch implements a SUMP protocol compatible with the standard * This Arduino sketch implements a SUMP protocol compatible with the standard
* SUMP client as well as the alternative client from here: * SUMP client as well as the alternative client from here:
* http://www.lxtreme.nl/ols/ * http://www.lxtreme.nl/ols/
* *
* This SUMP protocol compatible logic analyzer for the Arduino board supports * This SUMP protocol compatible logic analyzer for the Arduino board supports
* 6 channels consisting of digital pins 2-7, which are the last 6 bits (2-7) * 5 channels consisting of digital pins 8-12, which are the first 5 bits (0-4)
* of PORTD. Bits 0 & 1 are the UART RX/TX pins. * 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. * On the Arduino Mega board 8 channels are supported and 7k of samples.
* Pins 22-29 (Port A) are used by default, you can change the 'CHANPIN' below * Pins 22-29 (Port A) are used by default, you can change the 'CHANPIN' below
@@ -81,19 +72,16 @@
* ATmega2560: 7168 (or lower) * ATmega2560: 7168 (or lower)
* Noise Filter: doesn't matter * Noise Filter: doesn't matter
* RLE: disabled (unchecked) * RLE: disabled (unchecked)
* NOTE: Preliminary RLE support for 50Hz or less exists, please test it.
* *
* Triggering is still a work in progress, but generally works for samples * 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 * below 1MHz. 1MHz works for a basic busy wait trigger that doesn't store
* until after the trigger fires. * until after the trigger fires.
* Please try it out and report back. * Please try it out and report back.
* *
* Release: v0.09 June 22, 2013. * Release: v0.05 November 4, 2011.
* *
*/ */
#include <SPI.h>
#include <Ethernet.h>
/* /*
* Function prototypes so this can compile from the cli. * Function prototypes so this can compile from the cli.
* You'll need the 'arduino-core' package and to check the paths in the * You'll need the 'arduino-core' package and to check the paths in the
@@ -111,12 +99,9 @@ void debugprint(void);
void debugdump(void); void debugdump(void);
/* /*
* Should we use PORTD or PORTB? (default is PORTB) * Uncomment CHAN5 to use it as an additional input on a normal Arduino.
* PORTD support with triggers seems to work but needs more testing. * You'll need to change the number of channels in the device profile as well.
*/ *
#define USE_PORTD 1
/*
* Arduino device profile: ols.profile-agla.cfg * Arduino device profile: ols.profile-agla.cfg
* Arduino Mega device profile: ols.profile-aglam.cfg * Arduino Mega device profile: ols.profile-aglam.cfg
*/ */
@@ -131,24 +116,13 @@ void debugdump(void);
#define CHAN6 28 #define CHAN6 28
#define CHAN7 29 #define CHAN7 29
#else #else
#if defined(USE_PORTD)
#define CHANPIN PIND
#define CHAN0 2
#define CHAN1 3
#define CHAN2 4
#define CHAN3 5
#define CHAN4 6
#define CHAN5 7
#else
#define CHANPIN PINB #define CHANPIN PINB
#define CHAN0 8 #define CHAN0 8
#define CHAN1 9 #define CHAN1 9
#define CHAN2 10 #define CHAN2 10
#define CHAN3 11 #define CHAN3 11
#define CHAN4 12 #define CHAN4 12
/* Comment out CHAN5 if you don't want to use the LED pin for an input */ //#define CHAN5 13
#define CHAN5 13
#endif /* USE_PORTD */
#endif #endif
#define ledPin 13 #define ledPin 13
@@ -164,11 +138,10 @@ void debugdump(void);
#define SUMP_TRIGGER_VALUES 0xC1 #define SUMP_TRIGGER_VALUES 0xC1
#define SUMP_TRIGGER_CONFIG 0xC2 #define SUMP_TRIGGER_CONFIG 0xC2
/* Most flags (except RLE) are ignored. */ /* flags are ignored. */
#define SUMP_SET_DIVIDER 0x80 #define SUMP_SET_DIVIDER 0x80
#define SUMP_SET_READ_DELAY_COUNT 0x81 #define SUMP_SET_READ_DELAY_COUNT 0x81
#define SUMP_SET_FLAGS 0x82 #define SUMP_SET_FLAGS 0x82
#define SUMP_SET_RLE 0x0100
/* extended commands -- self-test unsupported, but metadata is returned. */ /* extended commands -- self-test unsupported, but metadata is returned. */
#define SUMP_SELF_TEST 0x03 #define SUMP_SELF_TEST 0x03
@@ -179,25 +152,16 @@ void debugdump(void);
* ATmega2560: 7168 (or lower) * ATmega2560: 7168 (or lower)
*/ */
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define DEBUG_CAPTURE_SIZE 7168 #define DEBUG_CAPTURE_SIZE 7168
#define CAPTURE_SIZE 7168 #define CAPTURE_SIZE 7168
#elif defined(__AVR_ATmega328P__) #elif defined(__AVR_ATmega328P__)
#define DEBUG_CAPTURE_SIZE 1024 #define DEBUG_CAPTURE_SIZE 1024
#define CAPTURE_SIZE 1024 #define CAPTURE_SIZE 1024
#else #else
#define DEBUG_CAPTURE_SIZE 532 #define DEBUG_CAPTURE_SIZE 532
#define CAPTURE_SIZE 532 #define CAPTURE_SIZE 532
#endif #endif
#ifdef USE_PORTD
#define DEBUG_ENABLE DDRB = DDRB | B00000001
#define DEBUG_ON PORTB = B00000001
#define DEBUG_OFF PORTB = B00000000
#else
#define DEBUG_ENABLE DDRD = DDRD | B10000000
#define DEBUG_ON PORTD = B10000000
#define DEBUG_OFF PORTD = B00000000
#endif
#define DEBUG #define DEBUG
#ifdef DEBUG #ifdef DEBUG
#define MAX_CAPTURE_SIZE DEBUG_CAPTURE_SIZE #define MAX_CAPTURE_SIZE DEBUG_CAPTURE_SIZE
@@ -227,63 +191,35 @@ unsigned int trigger_values = 0;
unsigned int useMicro = 0; unsigned int useMicro = 0;
unsigned int delayTime = 0; unsigned int delayTime = 0;
unsigned long divider = 0; unsigned long divider = 0;
boolean rleEnabled = 0;
/*
* Enter a MAC address and IP address for your Arduino.
*/
byte mac[] = {
0x40, 0x00, 0x01, 0x02, 0x03, 0x04 };
IPAddress ip(192,168,1,200);
// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(1234);
EthernetClient client;
void setup() void setup()
{ {
Serial.begin(115200); Serial.begin(115200);
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
/* /*
* set debug pin (digital pin 8) to output right away so it settles. * set debug pin to output right away so it settles.
* this gets toggled during sampling as a way to measure * this gets toggled during sampling as a way to measure
* the sample time. this is used during development to * the sample time. this is used during development to
* properly pad out the sampling routines. * properly pad out the sampling routines.
*/ */
DEBUG_ENABLE; /* debug measurement pin */ DDRD = DDRD | B10000000; /* debug measurement pin */
pinMode(CHAN0, INPUT); pinMode(CHAN0, INPUT);
digitalWrite(CHAN0, LOW);
pinMode(CHAN1, INPUT); pinMode(CHAN1, INPUT);
digitalWrite(CHAN1, LOW);
pinMode(CHAN2, INPUT); pinMode(CHAN2, INPUT);
digitalWrite(CHAN2, LOW);
pinMode(CHAN3, INPUT); pinMode(CHAN3, INPUT);
digitalWrite(CHAN3, LOW);
pinMode(CHAN4, INPUT); pinMode(CHAN4, INPUT);
digitalWrite(CHAN4, LOW); #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
pinMode(CHAN5, INPUT);
pinMode(CHAN6, INPUT);
pinMode(CHAN7, INPUT);
pinMode(ledPin, OUTPUT);
#else
#ifdef CHAN5 #ifdef CHAN5
pinMode(CHAN5, INPUT); pinMode(CHAN5, INPUT);
digitalWrite(CHAN5, LOW);
#endif
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
pinMode(CHAN6, INPUT);
digitalWrite(CHAN6, LOW);
pinMode(CHAN7, INPUT);
digitalWrite(CHAN7, LOW);
#else #else
#ifndef CHAN5
pinMode(ledPin, OUTPUT); pinMode(ledPin, OUTPUT);
#endif #endif /* CHAN5 */
#endif /* Mega */ #endif /* Mega */
} }
@@ -291,13 +227,8 @@ void loop()
{ {
int i; int i;
// listen for incoming clients if (Serial.available() > 0) {
client = server.available(); cmdByte = Serial.read();
if (client) {
Serial.println("new client");
while (client.connected()) {
if (client.available()) {
cmdByte = client.read();
switch(cmdByte) { switch(cmdByte) {
case SUMP_RESET: case SUMP_RESET:
/* /*
@@ -308,10 +239,10 @@ void loop()
break; break;
case SUMP_QUERY: case SUMP_QUERY:
/* return the expected bytes. */ /* return the expected bytes. */
client.write('1'); Serial.print('1', BYTE);
client.write('A'); Serial.print('A', BYTE);
client.write('L'); Serial.print('L', BYTE);
client.write('S'); Serial.print('S', BYTE);
break; break;
case SUMP_ARM: case SUMP_ARM:
/* /*
@@ -345,11 +276,7 @@ void loop()
* we can just use it directly as our trigger mask. * we can just use it directly as our trigger mask.
*/ */
getCmd(); getCmd();
#ifdef USE_PORTD
trigger = cmdBytes[0] << 2;
#else
trigger = cmdBytes[0]; trigger = cmdBytes[0];
#endif
break; break;
case SUMP_TRIGGER_VALUES: case SUMP_TRIGGER_VALUES:
/* /*
@@ -357,11 +284,7 @@ void loop()
* defines whether we're looking for it to be high or low. * defines whether we're looking for it to be high or low.
*/ */
getCmd(); getCmd();
#ifdef USE_PORTD
trigger_values = cmdBytes[0] << 2;
#else
trigger_values = cmdBytes[0]; trigger_values = cmdBytes[0];
#endif
break; break;
case SUMP_TRIGGER_CONFIG: case SUMP_TRIGGER_CONFIG:
/* read the rest of the command bytes, but ignore them. */ /* read the rest of the command bytes, but ignore them. */
@@ -400,9 +323,8 @@ void loop()
delayCount = MAX_CAPTURE_SIZE; delayCount = MAX_CAPTURE_SIZE;
break; break;
case SUMP_SET_FLAGS: case SUMP_SET_FLAGS:
/* read the rest of the command bytes and check if RLE is enabled. */ /* read the rest of the command bytes, but ignore them. */
getCmd(); getCmd();
rleEnabled = ((cmdBytes[1] & B1000000) != 0);
break; break;
case SUMP_GET_METADATA: case SUMP_GET_METADATA:
/* /*
@@ -435,7 +357,9 @@ void loop()
* you can use the Arduino serial monitor and send a '1' and get * you can use the Arduino serial monitor and send a '1' and get
* a debug printout. useless except for development. * a debug printout. useless except for development.
*/ */
#ifndef CHAN5
blinkled(); blinkled();
#endif /* !CHAN5 */
debugprint(); debugprint();
break; break;
case '2': case '2':
@@ -448,13 +372,8 @@ void loop()
default: default:
/* ignore any unrecognized bytes. */ /* ignore any unrecognized bytes. */
break; break;
} /* switch */ }
} /* if client.available() */ }
} /* while */
delay(1);
client.stop();
Serial.println("client disconnected?");
} /* if client */
} }
void blinkled() { void blinkled() {
@@ -473,10 +392,10 @@ void blinkled() {
*/ */
void getCmd() { void getCmd() {
delay(10); delay(10);
cmdBytes[0] = client.read(); cmdBytes[0] = Serial.read();
cmdBytes[1] = client.read(); cmdBytes[1] = Serial.read();
cmdBytes[2] = client.read(); cmdBytes[2] = Serial.read();
cmdBytes[3] = client.read(); cmdBytes[3] = Serial.read();
#ifdef DEBUG #ifdef DEBUG
if (savecount < 120 ) { if (savecount < 120 ) {
@@ -509,7 +428,7 @@ void captureMicro() {
int i; int i;
/* /*
* basic trigger, wait until all trigger conditions are met on port. * basic trigger, wait until all trigger conditions are met on port B.
* this needs further testing, but basic tests work as expected. * this needs further testing, but basic tests work as expected.
*/ */
if (trigger) { if (trigger) {
@@ -528,16 +447,16 @@ void captureMicro() {
* this is used during development to measure the sample intervals. * this is used during development to measure the sample intervals.
* it is best to just leave the toggling in place so we don't alter * it is best to just leave the toggling in place so we don't alter
* any timing unexpectedly. * any timing unexpectedly.
* Arduino digital pin 8 is being used here. * Arduino pin 7 is being used here.
*/ */
DEBUG_ENABLE; DDRD = DDRD | B10000000;
DEBUG_ON; PORTD = B10000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_OFF; PORTD = B00000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_ON; PORTD = B10000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_OFF; PORTD = B00000000;
delayMicroseconds(20); delayMicroseconds(20);
if (delayTime == 1) { if (delayTime == 1) {
@@ -545,20 +464,20 @@ void captureMicro() {
* 1MHz sample rate = 1 uS delay so we can't use delayMicroseconds * 1MHz sample rate = 1 uS delay so we can't use delayMicroseconds
* since our loop takes some time. The delay is padded out by hand. * since our loop takes some time. The delay is padded out by hand.
*/ */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
for (i = 0 ; i < readCount; i++) { for (i = 0 ; i < readCount; i++) {
logicdata[i] = CHANPIN; logicdata[i] = CHANPIN;
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
} }
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
} }
else if (delayTime == 2) { else if (delayTime == 2) {
/* /*
* 500KHz sample rate = 2 uS delay, still pretty fast so we pad this * 500KHz sample rate = 2 uS delay, still pretty fast so we pad this
* one by hand too. * one by hand too.
*/ */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
for (i = 0 ; i < readCount; i++) { for (i = 0 ; i < readCount; i++) {
logicdata[i] = CHANPIN; logicdata[i] = CHANPIN;
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
@@ -568,7 +487,7 @@ void captureMicro() {
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
} }
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
} }
else { else {
/* /*
@@ -577,13 +496,13 @@ void captureMicro() {
* a better logic analyzer) * a better logic analyzer)
* start of real measurement * start of real measurement
*/ */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
for (i = 0 ; i < readCount; i++) { for (i = 0 ; i < readCount; i++) {
logicdata[i] = CHANPIN; logicdata[i] = CHANPIN;
delayMicroseconds(delayTime - 1); delayMicroseconds(delayTime - 1);
__asm__("nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t");
} }
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
} }
/* re-enable interrupts now that we're done sampling. */ /* re-enable interrupts now that we're done sampling. */
@@ -594,11 +513,7 @@ void captureMicro() {
* is done for any triggers, this is effectively the 0/100 buffer split. * is done for any triggers, this is effectively the 0/100 buffer split.
*/ */
for (i = 0 ; i < readCount; i++) { for (i = 0 ; i < readCount; i++) {
#ifdef USE_PORTD Serial.print(logicdata[i], BYTE);
client.write(logicdata[i] >> 2);
#else
client.write(logicdata[i]);
#endif
} }
} }
@@ -620,42 +535,8 @@ void captureMicro() {
* this basic functionality. * this basic functionality.
*/ */
void captureMilli() { void captureMilli() {
int i = 0; int i;
if(rleEnabled) {
/*
* very basic trigger, just like in captureMicros() above.
*/
if (trigger) {
while ((trigger_values ^ (CHANPIN & B01111111)) & trigger);
}
byte lastSample = 0;
byte sampleCount = 0;
while(i < readCount) {
/*
* Implementation of the RLE unlimited protocol: timings might be off a little
*/
if(lastSample == (CHANPIN & B01111111) && sampleCount < 127) {
sampleCount++;
delay(delayTime);
continue;
}
if(sampleCount != 0) {
logicdata[i] = B10000000 | sampleCount;
sampleCount = 0;
i++;
continue;
}
logicdata[i] = (CHANPIN & B01111111);
lastSample = (CHANPIN & B01111111);
delay(delayTime);
i++;
}
}
else {
/* /*
* very basic trigger, just like in captureMicros() above. * very basic trigger, just like in captureMicros() above.
*/ */
@@ -667,13 +548,8 @@ void captureMilli() {
logicdata[i] = CHANPIN; logicdata[i] = CHANPIN;
delay(delayTime); delay(delayTime);
} }
}
for (i = 0 ; i < readCount; i++) { for (i = 0 ; i < readCount; i++) {
#ifdef USE_PORTD Serial.print(logicdata[i], BYTE);
client.write(logicdata[i] >> 2);
#else
client.write(logicdata[i]);
#endif
} }
} }
@@ -703,16 +579,16 @@ void triggerMicro() {
* this is used during development to measure the sample intervals. * this is used during development to measure the sample intervals.
* it is best to just leave the toggling in place so we don't alter * it is best to just leave the toggling in place so we don't alter
* any timing unexpectedly. * any timing unexpectedly.
* Arduino digital pin 8 is being used here. * Arduino pin 7 is being used here.
*/ */
DEBUG_ENABLE; DDRD = DDRD | B10000000;
DEBUG_ON; PORTD = B10000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_OFF; PORTD = B00000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_ON; PORTD = B10000000;
delayMicroseconds(20); delayMicroseconds(20);
DEBUG_OFF; PORTD = B00000000;
delayMicroseconds(20); delayMicroseconds(20);
if (delayTime == 1) { if (delayTime == 1) {
@@ -737,9 +613,9 @@ void triggerMicro() {
* we always start capturing at the start of the buffer * we always start capturing at the start of the buffer
* and use it as a circular buffer * and use it as a circular buffer
*/ */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
while ((trigger_values ^ (logicdata[logicIndex] = CHANPIN)) & trigger) { while ((trigger_values ^ (logicdata[logicIndex] = CHANPIN)) & trigger) {
/* DEBUG_OFF; */ /* PORTD = B00000000; */
/* increment index. */ /* increment index. */
logicIndex++; logicIndex++;
if (logicIndex >= readCount) { if (logicIndex >= readCount) {
@@ -751,11 +627,11 @@ void triggerMicro() {
* __asm__("nop\n\t""nop\n\t""nop\n\t"); * __asm__("nop\n\t""nop\n\t""nop\n\t");
*/ */
__asm__("nop\n\t"); __asm__("nop\n\t");
/* DEBUG_ON; */ /* PORTD = B10000000; */
} }
/* this pads the immediate trigger case to 2.0 uS, just as an example. */ /* this pads the immediate trigger case to 2.0 uS, just as an example. */
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
/* /*
* One sample size delay. ends up being 2 uS combined with assignment * One sample size delay. ends up being 2 uS combined with assignment
@@ -770,7 +646,7 @@ void triggerMicro() {
triggerIndex = logicIndex; triggerIndex = logicIndex;
/* keep sampling for delayCount after trigger */ /* keep sampling for delayCount after trigger */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
/* /*
* this is currently taking: * this is currently taking:
* 1025.5 uS for 512 samples. (512 samples, 0/100 split) * 1025.5 uS for 512 samples. (512 samples, 0/100 split)
@@ -785,7 +661,7 @@ void triggerMicro() {
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
} }
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
delayMicroseconds(100); delayMicroseconds(100);
} }
else { else {
@@ -798,23 +674,17 @@ void triggerMicro() {
* and use it as a circular buffer * and use it as a circular buffer
* *
*/ */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
while ((trigger_values ^ (logicdata[logicIndex] = CHANPIN)) & trigger) { while ((trigger_values ^ (logicdata[logicIndex] = CHANPIN)) & trigger) {
/* DEBUG_OFF; */ /* PORTD = B00000000; */
/* increment index. */ /* increment index. */
logicIndex++; logicIndex++;
if (logicIndex >= readCount) { if (logicIndex >= readCount) {
logicIndex = 0; logicIndex = 0;
} }
else { /* PORTD = B10000000; */
/* pad the same number of cycles as the above assignment (needs verification) */
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
} }
delayMicroseconds(delayTime - 3); PORTD = B00000000; /* debug timing measurement */
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t""nop\n\t");
/* DEBUG_ON; */
}
DEBUG_OFF; /* debug timing measurement */
/* 'logicIndex' now points to trigger sample, keep track of it */ /* 'logicIndex' now points to trigger sample, keep track of it */
triggerIndex = logicIndex; triggerIndex = logicIndex;
@@ -823,13 +693,10 @@ void triggerMicro() {
* This needs adjustment so that we have the right spacing between the * This needs adjustment so that we have the right spacing between the
* before trigger samples and the after trigger samples. * before trigger samples and the after trigger samples.
*/ */
delayMicroseconds(delayTime - 2); delayMicroseconds(delayTime);
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t");
/* keep sampling for delayCount after trigger */ /* keep sampling for delayCount after trigger */
DEBUG_ON; /* debug timing measurement */ PORTD = B10000000; /* debug timing measurement */
for (i = 0 ; i < delayCount; i++) { for (i = 0 ; i < delayCount; i++) {
if (logicIndex >= readCount) { if (logicIndex >= readCount) {
logicIndex = 0; logicIndex = 0;
@@ -840,7 +707,7 @@ void triggerMicro() {
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t"); __asm__("nop\n\t""nop\n\t""nop\n\t");
} }
DEBUG_OFF; /* debug timing measurement */ PORTD = B00000000; /* debug timing measurement */
delayMicroseconds(100); delayMicroseconds(100);
} }
@@ -861,11 +728,7 @@ void triggerMicro() {
if (logicIndex >= readCount) { if (logicIndex >= readCount) {
logicIndex = 0; logicIndex = 0;
} }
#ifdef USE_PORTD Serial.print(logicdata[logicIndex++], BYTE);
client.write(logicdata[logicIndex++] >> 2);
#else
client.write(logicdata[logicIndex++]);
#endif
} }
} }
@@ -901,69 +764,61 @@ void setupDelay() {
*/ */
void get_metadata() { void get_metadata() {
/* device name */ /* device name */
client.write((uint8_t)0x01); Serial.print(0x01, BYTE);
client.write('A'); Serial.print('A', BYTE);
client.write('G'); Serial.print('G', BYTE);
client.write('L'); Serial.print('L', BYTE);
client.write('A'); Serial.print('A', BYTE);
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
client.write('M'); Serial.print('M', BYTE);
#endif /* Mega */ #endif /* Mega */
client.write('v'); Serial.print('v', BYTE);
client.write('0'); Serial.print('0', BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
/* firmware version */
client.write((uint8_t)0x02);
client.write('0');
client.write('.');
client.write('0');
client.write('9');
client.write((uint8_t)0x00);
/* sample memory */ /* sample memory */
client.write((uint8_t)0x21); Serial.print(0x21, BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
/* 7168 bytes */ /* 7168 bytes */
client.write((uint8_t)0x1C); Serial.print(0x1C, BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
#elif defined(__AVR_ATmega328P__) #elif defined(__AVR_ATmega328P__)
/* 1024 bytes */ /* 1024 bytes */
client.write((uint8_t)0x04); Serial.print(0x04, BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
#else #else
/* 532 bytes */ /* 532 bytes */
client.write((uint8_t)0x02); Serial.print(0x02, BYTE);
client.write((uint8_t)0x14); Serial.print(0x14, BYTE);
#endif /* Mega */ #endif /* Mega */
/* sample rate (1MHz) */ /* sample rate (1MHz) */
client.write((uint8_t)0x23); Serial.print(0x23, BYTE);
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
client.write((uint8_t)0x0F); Serial.print(0x0F, BYTE);
client.write((uint8_t)0x42); Serial.print(0x42, BYTE);
client.write((uint8_t)0x40); Serial.print(0x40, BYTE);
/* number of probes (6 by default on Arduino, 8 on Mega) */ /* number of probes (5 by default on Arduino, 8 on Mega) */
client.write((uint8_t)0x40); Serial.print(0x40, BYTE);
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
client.write((uint8_t)0x08); Serial.print(0x08, BYTE);
#else #else
#ifdef CHAN5 #ifdef CHAN5
client.write((uint8_t)0x06); Serial.print(0x06, BYTE);
#else #else
client.write((uint8_t)0x05); Serial.print(0x05, BYTE);
#endif /* CHAN5 */ #endif /* CHAN5 */
#endif /* Mega */ #endif /* Mega */
/* protocol version (2) */ /* protocol version (2) */
client.write((uint8_t)0x41); Serial.print(0x41, BYTE);
client.write((uint8_t)0x02); Serial.print(0x02, BYTE);
/* end of data */ /* end of data */
client.write((uint8_t)0x00); Serial.print(0x00, BYTE);
} }
/* /*
@@ -976,36 +831,34 @@ void debugprint() {
int i; int i;
#if 0 #if 0
client.print("divider = "); Serial.print("divider = ");
client.println(divider, DEC); Serial.println(divider, DEC);
client.print("delayTime = "); Serial.print("delayTime = ");
client.println(delayTime, DEC); Serial.println(delayTime, DEC);
client.print("trigger_values = "); Serial.print("trigger_values = ");
client.println(trigger_values, BIN); Serial.println(trigger_values, BIN);
#endif #endif
client.print("readCount = "); Serial.print("readCount = ");
client.println(readCount, DEC); Serial.println(readCount, DEC);
client.print("delayCount = "); Serial.print("delayCount = ");
client.println(delayCount, DEC); Serial.println(delayCount, DEC);
client.print("logicIndex = "); Serial.print("logicIndex = ");
client.println(logicIndex, DEC); Serial.println(logicIndex, DEC);
client.print("triggerIndex = "); Serial.print("triggerIndex = ");
client.println(triggerIndex, DEC); Serial.println(triggerIndex, DEC);
client.print("rleEnabled = ");
client.println(rleEnabled, DEC);
client.println("Bytes:"); Serial.println("Bytes:");
for (i = 0 ; i < savecount; i++) { for (i = 0 ; i < savecount; i++) {
if (savebytes[i] == 0x20) { if (savebytes[i] == 0x20) {
client.println(); Serial.println();
} }
else { else {
client.print(savebytes[i], HEX); Serial.print(savebytes[i], HEX);
client.write(' '); Serial.print(' ', BYTE);
} }
} }
client.println("done..."); Serial.println("done...");
} }
/* /*
@@ -1016,17 +869,13 @@ void debugdump() {
int i; int i;
int j = 1; int j = 1;
client.print("\r\n"); Serial.print("\r\n");
for (i = 0 ; i < MAX_CAPTURE_SIZE; i++) { for (i = 0 ; i < MAX_CAPTURE_SIZE; i++) {
#ifdef USE_PORTD Serial.print(logicdata[i], HEX);
client.print(logicdata[i] >> 2, HEX); Serial.print(" ");
#else
client.print(logicdata[i], HEX);
#endif
client.print(" ");
if (j == 32) { if (j == 32) {
client.print("\r\n"); Serial.print("\r\n");
j = 0; j = 0;
} }
j++; j++;
@@ -1035,9 +884,3 @@ void debugdump() {
#endif /* DEBUG */ #endif /* DEBUG */

14
ols.profile-agla.cfg
View File

@@ -7,7 +7,7 @@ device.description = Arduino Generic Logic Analyzer
# The device interface, SERIAL only # The device interface, SERIAL only
device.interface = SERIAL device.interface = SERIAL
# The device's native clockspeed, in Hertz. # The device's native clockspeed, in Hertz.
device.clockspeed = 16000000 device.clockspeed = 100000000
# Whether or not double-data-rate is supported by the device (also known as the "demux"-mode). # Whether or not double-data-rate is supported by the device (also known as the "demux"-mode).
device.supports_ddr = false device.supports_ddr = false
# Supported sample rates in Hertz, separated by comma's # Supported sample rates in Hertz, separated by comma's
@@ -19,7 +19,7 @@ device.capturesizes = 64, 128, 256, 512, 1024
# Whether or not the noise filter is supported # Whether or not the noise filter is supported
device.feature.noisefilter = false device.feature.noisefilter = false
# Whether or not Run-Length encoding is supported # Whether or not Run-Length encoding is supported
device.feature.rle = true device.feature.rle = false
# Whether or not a testing mode is supported # Whether or not a testing mode is supported
device.feature.testmode = false device.feature.testmode = false
# Whether or not triggers are supported # Whether or not triggers are supported
@@ -30,7 +30,7 @@ device.trigger.stages = 1
device.trigger.complex = false device.trigger.complex = false
# The total number of channels usable for capturing # The total number of channels usable for capturing
device.channel.count = 6 device.channel.count = 5
# The number of channels groups, together with the channel count determines the channels per group # The number of channels groups, together with the channel count determines the channels per group
device.channel.groups = 1 device.channel.groups = 1
# Whether the capture size is limited by the enabled channel groups # Whether the capture size is limited by the enabled channel groups
@@ -39,15 +39,13 @@ device.capturesize.bound = false
device.channel.numberingschemes = DEFAULT device.channel.numberingschemes = DEFAULT
# Is a delay after opening the port and device detection needed? (0 = no delay, >0 = delay in milliseconds) # Is a delay after opening the port and device detection needed? (0 = no delay, >0 = delay in milliseconds)
device.open.portdelay = 1500 device.open.portdelay = 500
# The receive timeout for the device (in milliseconds, 100 = default, <=0 = no timeout)
device.receive.timeout = 100
# Does the device need a high or low DTR-line to operate correctly? (high = true, low = false) # Does the device need a high or low DTR-line to operate correctly? (high = true, low = false)
device.open.portdtr = true device.open.portdtr = true
# Which metadata keys correspond to this device profile? Value is a comma-separated list of (double quoted) names... # Which metadata keys correspond to this device profile? Value is a comma-separated list of (double quoted) names...
device.metadata.keys = "AGLAv0" device.metadata.keys = "AGLAv0"
# In which order are samples sent back from the device? false = last sample first, true = first sample first # In which order are samples sent back from the device? true = last sample first, false = first sample first
device.samples.reverseOrder = true device.samples.reverseOrder = false
###EOF### ###EOF###

10
ols.profile-aglam.cfg
View File

@@ -7,7 +7,7 @@ device.description = Arduino Mega Logic Analyzer
# The device interface, SERIAL only # The device interface, SERIAL only
device.interface = SERIAL device.interface = SERIAL
# The device's native clockspeed, in Hertz. # The device's native clockspeed, in Hertz.
device.clockspeed = 16000000 device.clockspeed = 100000000
# Whether or not double-data-rate is supported by the device (also known as the "demux"-mode). # Whether or not double-data-rate is supported by the device (also known as the "demux"-mode).
device.supports_ddr = false device.supports_ddr = false
# Supported sample rates in Hertz, separated by comma's # Supported sample rates in Hertz, separated by comma's
@@ -39,15 +39,13 @@ device.capturesize.bound = false
device.channel.numberingschemes = DEFAULT device.channel.numberingschemes = DEFAULT
# Is a delay after opening the port and device detection needed? (0 = no delay, >0 = delay in milliseconds) # Is a delay after opening the port and device detection needed? (0 = no delay, >0 = delay in milliseconds)
device.open.portdelay = 2000 device.open.portdelay = 1000
# The receive timeout for the device (in milliseconds, 100 = default, <=0 = no timeout)
device.receive.timeout = 100
# Does the device need a high or low DTR-line to operate correctly? (high = true, low = false) # Does the device need a high or low DTR-line to operate correctly? (high = true, low = false)
device.open.portdtr = true device.open.portdtr = true
# Which metadata keys correspond to this device profile? Value is a comma-separated list of (double quoted) names... # Which metadata keys correspond to this device profile? Value is a comma-separated list of (double quoted) names...
device.metadata.keys = "AGLAMv0" device.metadata.keys = "AGLAMv0"
# In which order are samples sent back from the device? false = last sample first, true = first sample first # In which order are samples sent back from the device? true = last sample first, false = first sample first
device.samples.reverseOrder = true device.samples.reverseOrder = false
###EOF### ###EOF###