INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Baubericht von Klausis Arduino Oscilloscope - KARO
08.10.2015, 19:38 (Dieser Beitrag wurde zuletzt bearbeitet: 08.10.2015 20:17 von Klaus(i).)
Beitrag #1
Baubericht von Klausis Arduino Oscilloscope - KARO
Ich habe beschlossen mir ein kleines Spielzeug aus einem Arduino zu bauen. Als Vorbereitung habe ich das Internet durchpflügt und ein paar brauchbare Varianten von Arduino Oszilloskopen gefunden.
Am besten hat mir das von Bob Davis gefallen.
Somit habe ich beschlossen auch so etwas in der Art zu bauen.

   
Was hat das hier denn zu suchen?

Schnell habe ich aber festgestellt, dass brauchbare A/D-Wandler schwer zu bekommen sind und teuer sind. Weil das Oszilloskop von mir sowieso nur für niederfrequente Teile benutzt wird, habe ich mich für eine einfache Variante entschieden: Einen Nano als ADC, entkoppelt vom Haupt-Arduino.

Also habe ich angefangen. Zuerst der ADC.
   

Hier habe ich mir ein paar Grundkenntnisse zu dem ADC im Arduino angelesen (den Artikel kann ich empfehlen).



Dann habe ich mir Gedanken gemacht, wie das Teil aussehen soll und was ich alles dafür brauche.
Dies ergab eine kleine Einkaufsliste.
   

Dann habe ich angefangen und das Board und das Display zusammengefügt. Sofort habe ich beschlossen, dass ich mehr Platz zwischen Board und TFT brauche.
   

Weil ich die Brotbretter nicht mag und lose Elektronik auch nicht so richtig, bin ich zum Entschluss gekommen dem Oszilloskop ein Zuhause zu verpassen und da kommt jetzt auch die Kugel von oben wieder ins Spiel.
   

Damit da alles Platz findet braucht es einen Einbaurahmen.
Ich hab als Modellbauer dafür 3mm Balsa verwendet. Das lässt sich mit einem Skalpell oder Cutter super schneiden. Als Kleber verwende ich Sekundenkleber.
   

So ein schönes Zuhause braucht auch ein Namensschild.
   



Parallel dazu erfolgte dann auch das Coding. Zuerst habe ich den Nano programmiert, der die Datenerfassung vornehmen soll.
Dazu habe ich mich der Grundlagen aus oben stehenden Artikel bedient.

Code:
//-----------------------------------------------------
// ARDUINO als A/D-Wandler
//-----------------------------------------------------
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

byte value;

//#define DEBUG;

//-----------------------------------------------------
//SETUP
//-----------------------------------------------------
void setup() {
  #ifdef DEBUG
    Serial.begin(9600);
    Serial.println("--start--");
    DDRD = B00000000;
  #else
    Serial.end();
    //D0 bis D7 Output. Vorsicht Serial geht dann nicht mehr
    DDRD = B11111111;
  #endif
  
  value = 0;
  Setup_ADC();
}
//-----------------------------------------------------
//LOOP
//-----------------------------------------------------
void loop() {
  //--- Lese Byte ---
  // ADC start sample
  sbi(ADCSRA, ADSC);
  // wait until ADSC bit goes low = new sample ready
  while(bit_is_set(ADCSRA, ADSC));
  // read value
  value = ADCH;

  //--- Schreibe Byte ---
  #ifdef DEBUG
    Serial.println(value);
  #else
    //--- Schreibe Byte in D0 bis D7 ---
    PORTD = value;
  #endif
}

//------------------------------------------------------
//Setup A/D Wandler
//------------------------------------------------------
void Setup_ADC() {
  //ADLAR=1 --> Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet.
  //Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt.
  //Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.
  ADMUX = 0x65; // set ADC to read pin A5, ADLAR to 1 (left adjust)
  cbi(ADCSRA,ADPS2); // set prescaler to 8 / ADC clock = 2MHz
  sbi(ADCSRA,ADPS1);
  sbi(ADCSRA,ADPS0);
}
//-----------------------------------------------------

Das sind nur ein paar Zeilen und die soll der Nano zügig abarbeiten.


Am Basteltisch ging es mit dem Einbau weiter. Das Board mit dem TFT durfte schon mal Probe liegen.
   

So eine Wohnung braucht dann auch ein paar Knöpfe und einen An- / Aus-Schalter.
   



Es erfolgte der weitere Zusammenbau, die Programmierung des Mega und diverse Test.
   
Die Tiefschläge, bis dann Ding lief erspar ich Euch. Es sei nur soviel gesagt: Das Dingens lief nicht sofort von Anfang an.
Es erfolgte ein Umbau.
   

Und irgendwann gab es dann doch ein Happy-End.
   

Zu Ende ist die Geschichte noch nicht, weil ich noch eine brauchbare Eingangsschaltung einbauen möchte.




Achso, jaaaa!
Der Mega hat ja auch Code zu Essen bekommen.
Code:
//*****************************************************************
// KARO, Klausis Arduino Oscilloscope, Arduino Mega 2560 & HX8357B
// By Klaus Schwarz
// UTFT_(C)2012 Henning Karlsen
// Thanks for: Three color 5msps ext AtoD Scope By Bob Davis
//*****************************************************************
#include <memorysaver.h>
#include <UTFT.h>

extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];

UTFT myGLCD(HX8357B,38,39,40,41);
int Input=0;
byte Sample[360];
byte OldSample[360];
unsigned long StartSample=0;
unsigned long EndSample=0;
int MaxSample=0;
int MinSample=0;
int mode=0;
int delayTime=0;
int Trigger=0;
int SampleSize=0;
unsigned long SampleTime=0;
int y1;
int y2;
char buf[12];

//--- Array of delay times ---
int dTime[11]={0,0,1,2,5,10,20,50,100,200,500};

//----------------------------------------------
//SETUP
//----------------------------------------------
void setup()
{
  //--- serielle Schnittstelle auf UNO deaktivieren, da D0 und D1 benötigt wird ---
  //Serial1.end();

  //--- Input von A/D Wandler ---
  // Auf dem Mega 2560 Verwendung Portregister K (A8-A15)
  DDRK = B00000000;
  // Auf Uno D0-D7 auf Portregister D
  //DDRD = B00000000;

  //--- Taster an D12 und D13 für delay und trigger ---
  pinMode(12, INPUT);
  digitalWrite(12, HIGH);
  pinMode(13, INPUT);
  digitalWrite(13, HIGH);

  // --- Init TFT ---
  myGLCD.InitLCD();
  myGLCD.InitLCD();
  myGLCD.clrScr();

  myGLCD.setFont(BigFont);
  myGLCD.setBackColor(0, 0, 0);
}

//----------------------------------------------
//LOOP
//----------------------------------------------
void loop() {
    //--- Raster zeichnen ---
    DrawMarkers();
    
    //--- select delay time ---
    if (digitalRead(13) == 0) mode++;
    if (mode > 10) mode = 0;
    delayTime = dTime[mode];
    
    //--- select trigger level ---
    if (digitalRead(12) == 0) Trigger=Trigger + 10;
    if (Trigger > 50) Trigger=0;
    
    //--- Warten auf Input-Signal >= Trigger ---
    while (Input < Trigger){
      //Verwendung Portregister K auf Mega (A8-A15)
       Input = PINK;
      //Auf Uno D0-D7 auf Portregister D
      //Input = PIND;
    }
  
    //---------- Daten auslesen ------------
    //Startzeit merken
    StartSample = micros();
    for(int xpos = 0; xpos < 360; xpos++) {
      // Verwendung Portregister K auf Mega (A8-A15)
      Sample[xpos] = PINK;
      
      //Auf Uno D0-D7 auf Portregister D
      //Sample[xpos] = PIND;

      delayMicroseconds(delayTime);
    }
    //Endezeit merken
    EndSample = micros();
    //--------------------------------------
    
    //--- Daten anzeigen ---
    for(int xpos=0; xpos<359; xpos++) {
      // --- alte Daten löschen ---
      y1 = 319 - OldSample[xpos+1] * 1.25;
      y2 = 319 - OldSample[xpos+2] * 1.25;
      myGLCD.setColor(0, 0, 0);
      myGLCD.drawLine (xpos+1, y1, xpos+2, y2);  
      if (xpos==0) myGLCD.drawLine (xpos+1, 1, xpos+1, 319);
      
      // --- neue Daten anzeigen ---
      y1 = 319 - Sample[xpos] * 1.25;
      y2 = 319 - Sample[xpos+1] * 1.25;
      myGLCD.setColor(255, 255, 255);
      myGLCD.drawLine (xpos, y1, xpos+1, y2);
    }  

    //--- Spannung (V) ermitteln ---
    MaxSample = Sample[100];
    MinSample = Sample[100];
    for(int xpos=0; xpos<360; xpos++) {
      OldSample[xpos] = Sample[xpos];  
      if (Sample[xpos] > MaxSample) MaxSample=Sample[xpos];
      if (Sample[xpos] < MinSample) MinSample=Sample[xpos];
    }
    
    //--- Farbe auf blau für Texte ---  
    myGLCD.setColor(0, 0, 255);
    
    //--- Anzeige Verzögerung ---
    myGLCD.print("Delay", 364, 10);
    myGLCD.print("      ", 364, 30);
    myGLCD.print(itoa(delayTime, buf, 10), 364, 30);
    
    //--- Anzeige Trigger ---
    myGLCD.print("Trigg.", 364, 70);
    myGLCD.print(itoa(Trigger, buf, 10), 364, 90);

    //--- Berechne sample time ---
    SampleTime=EndSample-StartSample;
    //--- Anzeige sample time ---
    myGLCD.print("uSec.", 364, 130);
    myGLCD.print("       ", 364, 150);
    myGLCD.print(ltoa(SampleTime, buf, 10), 364, 150);

    // Bob hatte nur 6 Bit (A0-A5), A6, A7 sind nv.
    //--- Range of 0 to 256 * 19 = 4864 mV ---
    SampleSize=(MaxSample-MinSample)*19;
    myGLCD.print("mVolt", 364, 190);
    myGLCD.print("      ", 364, 150);
    myGLCD.print(itoa(SampleSize, buf, 10), 364, 210);
    
    //--- Name rechts unten in der Ecke in weiß ---
    myGLCD.setColor(255, 255, 255);
    myGLCD.print("KARO", 364, 260);

} //END loop

//----------------------------------------------
// TFT 3.2 inch TFT 480x320:
//----------------------------------------------
void DrawMarkers(){
  //--- zeichne Raster ---
  myGLCD.setColor(0, 220, 0);
  
  //--- vertical lines ---
  myGLCD.drawLine(0, 0, 0, 319);
  myGLCD.drawLine(60, 0, 60, 319);
  myGLCD.drawLine(120, 0, 120, 319);
  myGLCD.drawLine(180, 0, 180, 319);
  myGLCD.drawLine(240, 0, 240, 319);
  myGLCD.drawLine(300, 0, 300, 319);
  myGLCD.drawLine(360, 0, 360, 319);
  myGLCD.drawLine(479, 0, 479, 319);
  
  //--- horizontal lines ---
  myGLCD.drawLine(0, 0, 479, 0);
  myGLCD.drawLine(0, 60, 479, 60);
  myGLCD.drawLine(0, 120, 479, 120);
  myGLCD.drawLine(0, 180, 479, 180);
  myGLCD.drawLine(0, 240, 479, 240);
  myGLCD.drawLine(0, 300, 479, 300);
}

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
08.10.2015, 21:33
Beitrag #2
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
Wirklich interessantes Projekt.
Bin gespannt, wie es weiter geht und wie die technischen Daten aussehen.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
08.10.2015, 21:55 (Dieser Beitrag wurde zuletzt bearbeitet: 08.10.2015 21:57 von Klaus(i).)
Beitrag #3
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
(08.10.2015 21:33)hotsystems schrieb:  Wirklich interessantes Projekt.
Bin gespannt, wie es weiter geht und wie die technischen Daten aussehen.
Danke.
Um die technischen Daten beurteilen zu können, brauche ich noch eine vernünftige Signalquelle.
Rein subjektiv kommt es mir im Moment noch langsam vor und ich werde wohl versuchen den Code weiter zu verbessern.
Auch überlege ich doch einen "echten" A/D-Wandler vorzuschalten.
Wenn da jemand eine Empfehlung für einen schnellen 8 bit ADC hat, der nicht so teuer ist (max. 10 €), dann bin ich für Vorschläge offen.

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 07:59 (Dieser Beitrag wurde zuletzt bearbeitet: 09.10.2015 09:01 von HaWe.)
Beitrag #4
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
was, wenn du als ADC einen DUE verwendest? Ein Due-Klon kostet keine 30 EUR, eher deutlich weniger (Ebay), du hast die restichen Pins vom Mega gleich mit dabei. Das hat schon mal jemand mit 688,000 samples/sec gemacht: https://hackaday.io/project/425-arduino-...cilloscope
(editiert)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 10:03 (Dieser Beitrag wurde zuletzt bearbeitet: 09.10.2015 10:04 von Klaus(i).)
Beitrag #5
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
(09.10.2015 07:59)HaWe schrieb:  was, wenn du als ADC einen DUE verwendest? Ein Due-Klon kostet keine 30 EUR, eher deutlich weniger (Ebay), du hast die restichen Pins vom Mega gleich mit dabei. Das hat schon mal jemand mit 688,000 samples/sec gemacht: https://hackaday.io/project/425-arduino-...cilloscope
(editiert)
Bei dem Nano habe ich den Prescaler auf 2Mhz eingestellt und greife auch über die Portregister zu. Der Atmel brauch für einen Messwert 13 Zyklen. Dies ergibt dann auch eine theoretische Rate von 154kHz. Der DUE hat dann gerade mal die 5-fache Leistung. Dafür lohnt dann der Aufwand nicht.
Trotzdem Danke für den Vorschlag.

Ich brauche zuerst einmal einen Maßstab. Huh
So ein Signalgenerator wär da nicht schlecht.

Ich mach mir mal Gedanken, wie ich da weiter mache.

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
09.10.2015, 11:27
Beitrag #6
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
(09.10.2015 11:04)Lötzinnerhitzer schrieb:  - Freeware-Tongenerator auf PC und Ausgang der Soundkarte
(z.B.: http://www.heise.de/download/test-tone-generator.html)
Danke für den Tipp. Hätte ich auch selbst drauf kommen können Big Grin.
Ein echtes Oscilloscope brauch ich (noch) nicht, weil das bei mir nur Spielerei ist.
Aber deine Empfehlung gefällt mir auch.

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.10.2015, 15:35 (Dieser Beitrag wurde zuletzt bearbeitet: 18.10.2015 15:38 von Klaus(i).)
Beitrag #7
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
Ein kleiner Nachtrag zu meinem Oszilloskop.
Dieses liefert plausible Werte und tut genau das, wofür ich ihn gebaut habe.
Anbei die Anzeige eines RC-PWM-Signals.
   

Das Signal hat eine Frequenz von 50Hz (20ms = 20000µs), wobei die Pulsweite zwischen 1000 und 2000µs variiert.
Auf dem Bild kann man auch einen Attiny erkennen, der in der Servo-Leitung liegt.
Der soll das PWM-Signal umkehren. Der ist aber noch in der Entwicklung.

Gruß, Klaus
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.10.2015, 15:43
Beitrag #8
RE: Baubericht von Klausis Arduino Oscilloscope - KARO
(18.10.2015 15:35)Klaus(i) schrieb:  Ein kleiner Nachtrag zu meinem Oszilloskop.
Dieses liefert plausible Werte und tut genau das, wofür ich ihn gebaut habe.
Anbei die Anzeige eines RC-PWM-Signals.


Das Signal hat eine Frequenz von 50Hz (20ms = 20000µs), wobei die Pulsweite zwischen 1000 und 2000µs variiert.
Auf dem Bild kann man auch einen Attiny erkennen, der in der Servo-Leitung liegt.
Der soll das PWM-Signal umkehren. Der ist aber noch in der Entwicklung.

Gruß, Klaus

Super, das Signal sieht sauber aus.
Wirklich toll, was du da gebaut hast.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Arduino Neuling: Zugeklappten Laptop mit Arduino aufwecken + Kiste aufklappen? Ikearegal 2 2.515 02.02.2014 07:59
Letzter Beitrag: Ikearegal

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste