Accrochages

Niiiice!

I don't know if this is what you are looking for but I just added a version of the Processing code that allows "zooming" using "+" and "-". It's attached to the post.

Absolutely. Never tried it but should work fine using the Teensyduino add-on. Keep us posted if you try it.

If you only get a black screen, processing does not find the right serial port.
Try following:

void setup() 
{
  size(640, 480);
    
  println(Serial.list());    //<--- add this line
    
  port = new Serial(this, Serial.list()[0], 9600); //(text below) change number in [ ]
  values = new int[width];
  smooth();
}

Then look into the console output of processing. You should see a list with all availible COM ports. E. g. my Arduino was at " [2] COM3 ". Next you have to change the number [0] to the number of your Arduino's COM port (in my case to [2] ). Then it works.

----

The idea of this oscilloscope is really nice!!! But the speed is not perfect ;) . Another thing to a multichannel oscilloscope: there is only ONE ADC in the ATmega and all analogue inputs are multiplexed with this one ADC. So if you need higher sample rates do NOT read from more than one channel. Maybe I will write a small article about tweaking the analogue reading for oscilloscope applications.

i have used your code,i have placed the controlip5 in the right folder also, but i get error as insufficient memory,wen i change it to 2GB in preferences, i get error as memory too high,finally i set it to 1.2 GB,where i get no error but i dont see the output

kindly help

import processing.serial.*;

int HEIGHT = 1024; int WIDTH = 800; boolean PAUSE = false; int numtraces = 6; int DIV = 8; int[] values; int val; int mode1 = 1; //numtraces = sovrapposte, 1 = distanziate int mode2 = 1; //0 = sovrapposte, 1 = distanziate

 */

  int x, y;
  int size;
  color basecolor, highlightcolor;
  color currentcolor;
  boolean over = false;
  boolean pressed = false;   

  void update() 
  {
    if(over()) {
      currentcolor = highlightcolor;
    } 
    else {
      currentcolor = basecolor;
    }
  }

  boolean pressed() 
  {
    if(over) {
      locked = true;
      return true;
    } 
    else {
      locked = false;
      return false;
    }
  }

  boolean over() 
  { 
    return true;
  }

  boolean overRect(int x, int y, int width, int height) 
  {
    if (mouseX >= x && mouseX <= x+width && 
      mouseY >= y && mouseY <= y+height) {
      return true;
    } 
    else {
      return false;
    }
  }

  boolean overCircle(int x, int y, int diameter) 
  {
    float disX = x - mouseX;
    float disY = y - mouseY;
    if(sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
      return true;
    } 
    else {
      return false;
    }
  }

class CircleButton extends Button {

  PFont myFont;
  String label;
  CircleButton(String l,int ix, int iy, int isize, color icolor, color ihighlight) 
  {
    myFont = createFont("DejaVu Serif", 22);
    label = new String(l);
    x = ix;
    y = iy;
    size = isize;
    basecolor = icolor;
    highlightcolor = ihighlight;
    currentcolor = basecolor;
  }

  boolean over() 
  {
    if( overCircle(x, y, size) ) {
      over = true;
      return true;
    } 
    else {
      over = false;
      return false;
    }
  }

  void display() 
  {
    stroke(255);
    fill(currentcolor);
    ellipse(x, y, size*2, size);
    stroke(0);
    textFont(myFont);
    strokeWeight(2);
    textAlign(CENTER);
    fill(0, 102, 153);
    text(label, x, y);
  }

  RectButton(int ix, int iy, int isize, color icolor, color ihighlight) 
  {
    x = ix;
    y = iy;
    size = isize;
    basecolor = icolor;
    highlightcolor = ihighlight;
    currentcolor = basecolor;
  }

  boolean over() 
  {
    if( overRect(x, y, size, size) ) {
      over = true;
      return true;
    } 
    else {
      over = false;
      return false;
    }
  }

  void display() 
  {
    stroke(255);
    fill(currentcolor);
    rect(x, y, size, size);
  }

  int swidth, sheight;    // width and height of bar
  int xpos, ypos;         // x and y position of bar
  float spos, newspos;    // x position of slider
  int sposMin, sposMax;   // max and min values of slider
  int loose;              // how loose/heavy
  boolean over;           // is the mouse over the slider?
  boolean locked;
  float ratio;
  int[] FFTmodes = {
    4,8,16,64,128,256,512
  };

  HScrollbar (int xp, int yp, int sw, int sh, int l) {
    swidth = sw;
    sheight = sh;
    int widthtoheight = sw - sh;
    ratio = (float)sw / (float)widthtoheight;
    xpos = xp;
    ypos = yp-sheight/2;
    spos = xpos + swidth/2 - sheight/2;
    newspos = spos;
    sposMin = xpos;
    sposMax = xpos + swidth - sheight;
    loose = l;
  }

  void update() {
    if(over()) {
      over = true;
    } 
    else {
      over = false;
    }
    if(mousePressed && over) {
      locked = true;
    }
    if(!mousePressed) {
      locked = false;
    }
    if(locked) {
      newspos = constrain(mouseX-sheight/2, sposMin, sposMax);
    }
    if(abs(newspos - spos) > 1) {
      spos = spos + (newspos-spos)/loose;
      DIV =   constrain ( round( (spos/swidth)*16 ), 1, 16 );  
      for (int i = 0; i< 7; i++) {
        if (FFTmodes[i] < width/DIV) {
          FFTsamples = FFTmodes[i];
          //println(FFTsamples);
        }
      }
    }
  }

  int constrain(int val, int minv, int maxv) {
    return min(max(val, minv), maxv);
  }

  boolean over() {
    if(mouseX > xpos && mouseX < xpos+swidth &&
      mouseY > ypos && mouseY < ypos+sheight) {
      return true;
    } 
    else {
      return false;
    }
  }

  void display() {
    fill(255);
    rect(xpos, ypos, swidth, sheight);
    if(over || locked) {
      fill(153, 102, 0);
    } 
    else {
      fill(102, 102, 102);
    }
    rect(spos, ypos, sheight, sheight);
    text("Resolution "+DIV, width - 80, 50);
  }

  float getPos() {
    // Convert spos to be values between
    // 0 and the total width of the scrollbar
    return spos * ratio;
  }

class gui {

  HScrollbar hs1;
  CircleButton changeMode, stop, pause,FFT;
  color currentcolor;
  gui() {
    // Define and create circle button
    color buttoncolor = color(204);
    color highlight = color(153);
    ellipseMode(CENTER);
    stop = new CircleButton( "Stop",width - 50, height -100,50, buttoncolor, highlight);
    // Define and create circle button
    changeMode = new CircleButton( "Mode",width - 50, height -200,50, buttoncolor, highlight);
    pause = new CircleButton( "Pause",width - 50, height -300,50, buttoncolor, highlight);
    FFT = new CircleButton( "FFT",width - 50, height -400,50, buttoncolor, highlight);
    hs1 = new HScrollbar(0,10, width, 10, 1);
  }
  void update(int x, int y)
  {
    if(locked == false) {
      changeMode.update();
      pause.update();
      stop.update();
      hs1.update();
      FFT.update();
    } 
    else {
      locked = false;
    }

    if(mousePressed) {
      if(changeMode.pressed()) {
        if ( (mode2 == 1)&&(mode1==1) ) {
          mode1 = numtraces;
          mode2 = 0;
        } 
        else {
          mode1 = 1;
          mode2 = 1;
        }
      } 
      else if(stop.pressed()) {
        exit();
      } 
      else if(pause.pressed()) {
        if (PAUSE)
          PAUSE = false;
        else
          PAUSE = true;
      }
      else if(FFT.pressed()) {
        if (FMODE)
          FMODE = false;
        else
          FMODE = true;
      }
    }
  }
  void display() {
    background(0);
    update(mouseX, mouseY);
    stop.display();
    changeMode.display();
    pause.display();
    hs1.display();
    FFT.display();
  }

/* ----------------------------------------------FFT------------------------------------------

 */

  private final double re;   // the real part
  private final double im;   // the imaginary part

  // create a new object with the given real and imaginary parts
  public Complex(double real, double imag) {
    re = real;
    im = imag;
  }

  // return a string representation of the invoking Complex object
  public String toString() {
    if (im == 0) return re + "";
    if (re == 0) return im + "i";
    if (im <  0) return re + " - " + (-im) + "i";
    return re + " + " + im + "i";
  }

  // return abs/modulus/magnitude and angle/phase/argument
  public double abs() { 
    return Math.hypot(re, im);
  }  // Math.sqrt(re*re + im*im)
  public double phase() { 
    return Math.atan2(im, re);
  }  // between -pi and pi

  // return a new Complex object whose value is (this + b)
  public Complex plus(Complex b) {
    Complex a = this;             // invoking object
    double real = a.re + b.re;
    double imag = a.im + b.im;
    return new Complex(real, imag);
  }

  // return a new Complex object whose value is (this - b)
  public Complex minus(Complex b) {
    Complex a = this;
    double real = a.re - b.re;
    double imag = a.im - b.im;
    return new Complex(real, imag);
  }

  // return a new Complex object whose value is (this * b)
  public Complex times(Complex b) {
    Complex a = this;
    double real = a.re * b.re - a.im * b.im;
    double imag = a.re * b.im + a.im * b.re;
    return new Complex(real, imag);
  }

  // scalar multiplication
  // return a new object whose value is (this * alpha)
  public Complex times(double alpha) {
    return new Complex(alpha * re, alpha * im);
  }

  // return a new Complex object whose value is the conjugate of this
  public Complex conjugate() {  
    return new Complex(re, -im);
  }

  // return a new Complex object whose value is the reciprocal of this
  public Complex reciprocal() {
    double scale = re*re + im*im;
    return new Complex(re / scale, -im / scale);
  }

  // return the real or imaginary part
  public double re() { 
    return re;
  }
  public double im() { 
    return im;
  }

  // return a / b
  public Complex divides(Complex b) {
    Complex a = this;
    return a.times(b.reciprocal());
  }

  // return a new Complex object whose value is the complex exponential of this
  public Complex exp() {
    return new Complex(Math.exp(re) * Math.cos(im), Math.exp(re) * Math.sin(im));
  }

  // return a new Complex object whose value is the complex sine of this
  public Complex sin() {
    return new Complex(Math.sin(re) * Math.cosh(im), Math.cos(re) * Math.sinh(im));
  }

  // return a new Complex object whose value is the complex cosine of this
  public Complex cos() {
    return new Complex(Math.cos(re) * Math.cosh(im), -Math.sin(re) * Math.sinh(im));
  }

  // return a new Complex object whose value is the complex tangent of this
  public Complex tan() {
    return sin().divides(cos());
  }

public class FFT {

  Complex[] buffer;
  int[] spectrum;
  FFT() {
    spectrum = new int[256];
  }
  int[] computeFFT( circularBuffer samples ) {
    buffer = new Complex[FFTsamples];
    for (int i=0;i<FFTsamples;i++) {
      //println( samples[width/DIV-1 - FFTsamples +i] );
      buffer[i] = new Complex((double) samples.get(width/DIV-1 - FFTsamples +i),(double) 0);
    }
    buffer= fft( buffer );
    for (int i=0;i<FFTsamples/2;i++) {
      spectrum[i] = round( (float)buffer[i].abs() );
    }
    for (int i=0;i<FFTsamples/2;i++) {
      spectrum[i] = round(spectrum[i]/(float)max(spectrum)*(height-20));
    }
    return spectrum;
  }

  // compute the FFT of x[], assuming its length is a power of 2
  public Complex[] fft(Complex[] x) {
    int N = x.length;

    // base case
    if (N == 1) return new Complex[] { 
      x[0]
    };

    // radix 2 Cooley-Tukey FFT
    if (N % 2 != 0) { 
      throw new RuntimeException("N is not a power of 2");
    }

    // fft of even terms
    Complex[] even = new Complex[N/2];
    for (int k = 0; k < N/2; k++) {
      even[k] = x[2*k];
    }
    Complex[] q = fft(even);

    // fft of odd terms
    Complex[] odd  = even;  // reuse the array
    for (int k = 0; k < N/2; k++) {
      odd[k] = x[2*k + 1];
    }
    Complex[] r = fft(odd);

    // combine
    Complex[] y = new Complex[N];
    for (int k = 0; k < N/2; k++) {
      double kth = -2 * k * Math.PI / N;
      Complex wk = new Complex(Math.cos(kth), Math.sin(kth));
      y[k]       = q[k].plus(wk.times(r[k]));
      y[k + N/2] = q[k].minus(wk.times(r[k]));
    }
    return y;
  }

/* ----------------------------------------------Sampling---------------------------------------

 */

  private long last;
  private long ctime;
  private int  val;
  timerscale(int s) {
    super(s,0);
    last = 0;
    ctime = 0;
    val = 0;
  }
  public void stat() {
  };
  public void labels() {
  };
  private void add() {
    ctime = millis();
    if ( (ctime-last) > 1000 ) {
      if (  (val>0)&&( (ctime-last) < 2000 ) )
        val = 0;
      else
        val = 1024/height * 10;
      last = ctime;
    }
    super.add(val);
  }
  int getY(int val) {
    return (int)(val / 1023.0f* height + 1);
  }

class trace_container {

  PFont myFont1, myFont2;
  trace[] traces;
  timerscale t;
  long last;
  float mean;
  private void FFTgui() {
    //freq = fs * (0 : N/2) / N;
    float fs = 1/mean*1000;
    float s = FFTsamples/2;
    textAlign(LEFT);
    textFont(myFont2);
    text("0 Hz", 0,height-10);
    textAlign(CENTER);
    text(round((fs * s/4) / FFTsamples) + "Hz", (width/4),height - 10);
    text(round((fs * s/2) / FFTsamples) + "Hz", (2*width/4 ), height - 10);
    text(round((fs * 3*s/4) / FFTsamples) + "Hz", (3*width/4),height - 10);
    textAlign(RIGHT);
    text(round(fs * s / FFTsamples) + "Hz", width, height - 10);
  }
  trace_container() {
    mean = 0;
    last = millis();
    myFont1 = createFont("DejaVu Serif", 28);
    myFont2 = createFont("DejaVu Serif", 16);
    textFont(myFont1);
    strokeWeight(2);
    traces = new trace[numtraces];
    t =  new timerscale( 150);
    for (int i=0;i<numtraces;i++) {
      traces[i] = new trace( (int)(255/numtraces*i ),i);
    }
  }
  void mean_updt() {            //media ricorsiva
    long per = millis() - last;
    last += per;
    mean = mean + 0.004*( per - mean );
  }
  void showmean() {
    textFont(myFont2);
    text("Samplerate " + round(mean) + " ms", width - 150, height -5);
  }
  void plot() {
    while (port.available() >= (numtraces*2 + 1) ) {
      if (port.read() == 0xff) {
        mean_updt();
        for (int i=0;i<numtraces;i++) {
          int val =  (port.read() << 8) | (port.read());
          traces[i].add(  val  );
          //print("Read " + val  + " on " + i +"\t");
        }
        //println("\n");
      }
    }
    textFont(myFont1);
    textAlign(LEFT);
    for (int i=0;i<numtraces;i++) {
      traces[i].shift();
      traces[i].plot();
    }
    if(FMODE) {
      FFTgui();
      return;
    }
    t.add();
    t.shift();
    t.plot();
    showmean();
  }

class circularBuffer {

  private int[] values;
  private int it;
  circularBuffer(int size) {
    values = new int[width];
    it = 0;
  }
  int get(int i) {
    return (values[ (it+i)%(width/DIV) ]);
  }
  void add(int i) {
    values[ (it++)%(width/DIV) ]=i;
  }
  float mmax() {
    int s=0;
    for (int x=1; x<(width/DIV); x++) {
      if (get(x)>s)
        s=get(x);
    }
    //print ( values[x] + "  ");
    //println( min( values)  ) ;
    return s;
  }
  float mean() {
    float sum=0;
    for (int x=1; x<(width/DIV); x++) {
      sum+=  (float)get(x);
    }
    //print ( values[x] + "  ");
    //println( min( values)  ) ;
    return round (sum/(width/DIV -1));
  }
  float mmin() {
    int s=height;
    for (int x=1; x<(width/DIV); x++) {
      if (get(x)<s)
        s=get(x);
    }
    //print ( values[x] + "  ");
    //println( min( values)  ) ;
    return s;
  }

class trace {

  private FFT mFFT;
  RectButton pause;
  private circularBuffer values;
  //private int[] values;
  private int cval;
  private int m_stroke;
  private int m_shift;
  trace(int s, int sh) {
    mFFT = new FFT();
    m_shift = sh;
    m_stroke = s;
    cval = getY(0);
    //values = new int[width];
    values = new circularBuffer(width);
  }
  public void add(int i) {
    cval = i;
    //println(i);
  }
  private float  invY(float val) {
    return round ((constrain ( round ( ( val- (mode2*m_shift*( (height-12)/numtraces ) + 12 ) )/ (((height-12 - 2)/numtraces)*mode1 )*1023.0f ),0,1024))/1024.0f*5000);
  }
  public void labels() {
    stroke(255);
    strokeWeight(1);
    line(  width-1,   height-(m_shift*( (height-12)/numtraces ) + 12), 1, height-(m_shift*( (height-12)/numtraces ) + 12));
    strokeWeight(4);
    stroke(255, m_stroke, 255 - m_stroke);
    fill(255, m_stroke, 255 - m_stroke);
    text("Analog"+m_shift, 10, height-(m_shift*( (height-12)/numtraces ) + 12));
  }

  public void plot() {
    labels();
    if (FMODE) {
      int[] fft = mFFT.computeFFT(values);
      for (int x=0; x<FFTsamples/2; x++) {
        line(round(x/(float)FFTsamples*width*2), height - getY(0),round(x/(float)FFTsamples*width*2),   height - getY(fft[x]) );//x/FFTsamples*width*2
      }
    }
    else {
      for (int x=1; x<(width/DIV); x++) {
        line(width-(x-1)*DIV,   height-values.get(x-1), width-x*DIV, height-values.get(x));
      }
    }
    stat();
  }
  public void stat() {
    if (PAUSE) {
      text("Min: "+ invY( values.mmin() ) + "mV", width/4, height-(m_shift*( (height-12)/numtraces ) + 12));
      text("Max: "+ invY( values.mmax() ) + "mV", 2*width/4, height-(m_shift*( (height-12)/numtraces ) + 12));
      text("Mean: "+ invY( values.mean() ) + "mV", 3*width/4, height-(m_shift*( (height-12)/numtraces ) + 12));
    }
  }
  public void shift() {
    if (PAUSE) {
      return;
    }
    values.add( getY( cval ) );
    //    for (int i=0; i<(width/DIV-1); i++) {
    //      values[i] = values[i+1];
    //      values[width/DIV-1] = getY( cval );
    //    }
  }
  int getY(int val) {
    return (int)(val / 1023.0f * ( ((height-12 - 2)/numtraces)*mode1 ) + mode2*m_shift*( (height-12)/numtraces ) + 12  );
  }
  public void test() {
    println("Trace OK");
    println(width);
    println(height);
  }

 */

  size(HEIGHT, WIDTH );
  t = new trace_container();
  m_gui = new gui();
  // Open the port that the board is connected to and use the same speed (9600 bps)
  //port = new Serial(this, Serial.list()[0], 9600);
  port = new Serial(this, Serial.list()[2], 115200);
  smooth();

  m_gui.display();
  t.plot();

I tried doing it but somehow the Processing app was "jamming". But it would totally make sense to do so, I just wasn't able to figure out the problem.

Resolution of the arduino's ADC is 4.9 mV, worst-case sampling rate is approximately 10kHz (if not using serial communication at the same time).

Dear friend, Could you share your oscilloscope code (Arduino and Processing)? Thanks