EBK7000 (Winkel/Längen Messung) mit Arduino Mega 2560

Guten Tag sehr geehrtes Forum,

für mein jetziges Projekt soll ich mit einem Evaluations Kit (EBK7000) von Sensitec Winkel und Längen messungen über einen Arduino durchführen. In dem Kit sind Sensoren sowie Maßstäbe und Poolringe zum magnetischen erfassend er Daten wie ich über rechere erfahren habe über ein Shield passieren der auf einem Arduino plaziert wird.

  1. in dem Fall habe ich einen Arduino Mega 2560 erhalten nach rechere soll der Shield für ein Arduino UNO sein, würde es mit einem Mega auch gehen?

Ich bin ein totaler Anfänger was den Arduino angeht im Programmieren habe ich Grundkenntnisse. Seit paar Tagen recherchiere ich für mein neues Projekt jetzt im Internet und auf der Hersteller Seite sowie schaue ich mir endliche Videos auf YouTube zum Arduino an um einen Einstieg zu erhalten.

Zuerst dachte ich mir (learning by doing) doch habe jetzt zuviel Zeit ohne Erfolg investiert. Somit wende ich mich jetzt an das Forum.

2.Auf der Hersteller Seite gibt es zwei zip Dateien die man in die Bibliothek einbindet dies habe ich gemacht jedoch werden sie mir ncih angezeigt ausser die TW2 Datei. Wofür wäre die ?

3.Wenn ich den fertigen Code habe und versuche etwas zu messen wo kann ich ihn mir ausgeben lassen , geshen habe ich ein virtuellen Monitor doch dort wird nicht mehr als eine Zeile angezeigt. Muss ich selber mehr einprogrammieren? sowie einen extra Dispaly an den Arduino anschließen ?

Für mich wäre es wichtig im ersten Schritt vieleicht etwas zu messen wie dies ausgegeben bekomme in dem virtuellen Monitor. Auf der Hersteller Seite www.sensitec.com habe ich alle Kataloge durch sowie den zum EBK7000 doch speziell zu Programmierung steht nichts genaues bei. Vielleicht sagen Sie mir einen bessern Einstieg wie und wo ich weitermache.

ich Entschuldige mich im Vorfeld für meine sehr schwache Rechtschreibung und bedanke mich für Antworten.

Die Informationn des Herstellers gehen ja gegen Null. Der Link mit mehr Informationen kommt nicht zurück. Wo soll es denn die Libs zum Download geben?

Da mache ich Dir nicht viel Hoffnung, dass da einer etwas Sinnvolles findet, es sei denn jemand hat durch Zufall damit schon gearbeitet.

Gruß Tommy

Bei RS konnte man noch etwas finden.
Wie es klingt, arbeitet das Teil mit I2C (Two Wire). Das liegt auf dem Mega auf anderen Pins, als am UNO. Somit dürftest Du mit dem Mega Probleme bekommen.

Gruß Tommy

Guten Abend Tommy,

danke für die schnelle Antwort.

Da das shield auch explizit vom Hersteller ist glaube ich auch das es reiner Zufall sein wird das jemand sich schonmmal jemand damit befasst hat. Zu den Bibliotheken die man einbinden soll Downloadbereich / Engineering Tools | Sensitec GmbH sind die zwei oberen relevant sagne mir aber sehr wenig als Anfänger. Die TW2 konnte ich soweit einbinden und die Sketches öffnen aber ich lernen leider nichts daraus, da auch keine Kommentare in dem Code hinterlegt sind. Somit dachte ich das ich mich villeicht in die Sensortechnik einleses oder mir wer dabei weiter Infos geben kann wie denn der Arduino die anspricht.

somit werden ja phasenverschobene Sinussiganle von dem Magnet-Sensor aufgenommen und durch das Shield (a/d wandler u. weiters) zu Daten weiter über den Arduino weitergegeben, dass wäre jetzt erstmal mein anhaltspunkt. leider bekomme ich aber nichts ausgegeben.

Gruss Mika

mzumika:
Ich bin ein totaler Anfänger was den Arduino angeht im Programmieren habe ich Grundkenntnisse.
... Vielleicht sagen Sie mir einen bessern Einstieg wie und wo ich weitermache.

Wenn Du schon Grundkenntnisse hast, weißt Du vermutlich auch, was ein Programmablaufplan ist. Und für den Einstieg nimmst Du Dir am besten die Beispiele der Arduino-IDE vor. Ansonsten gäbe es da noch mein Geschreibsel (unten). HTH.

Zum Eigentlichen: Von welchem Katalog redest Du? Kannst Du einen Link/URL nennen?

Mach' vielleicht ein Foto von dem Kit, auf dem man erkennt, womit Du es zu tun hast.

Gruß

Gregor

Es ist nicht I2C sondern eine eigene Two-Wire-Software. Damit dürfte es auch auf dem Mega laufen.

Packe aus dem EBK7000_PGA_TW2.zip die Datei EBK7000_PGA_TW2.ino in ein Verzeichnis EBK7000_PGA_TW2 in Deinem Sketch-Ordner.
Verschiebe den Ordner TW2 in Deinen Sketchordner\libraries.

Stelle Deinen Seriellen Monitor aud 57600 Baud und versuche grundlegend zu verstehen, was die EBK7000_PGA_TW2.ino macht.
Ohne Grundlagenkenntnisse wird das allerdings sehr schwer werden.

Gruß Tommy

Edit: Was hast Du dem Aufgabenersteller getan oder ist das Deine Studienrichtung?

Die genau Anleitung zu dem EBK700 ist die https://www.sensitec.com/fileadmin/sensitec/Service_and_Support/Downloads/Product_Information/Product_Information/SENSITEC_EBK7000_PIE_01.pdf

Dann kannst Du ja anfangen oder was willst Du uns damit sagen?

Gruß Tommy

Tommy das habe ich dann heute mal vor und versuche weiters aus dem Code zu verstehen und halte euch mal auf dem laufenden.

zu deiner Frage. Getan habe ich ihm nichts :grinning: nur sein Projekt angenommen was in meinem Plan im 4. Semster Maschbau dazugehört

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
So ist er auch auf portablen Geräten lesbar. Das kannst Du auch noch nachträglich ändern.

Gruß Tommy

/**************************************/
/* SENSITEC Evaluationkit EBK7000     */
/* Version: 0.1 / 16.23.2016          */
/* Author: R.Buß                      */
/*------------------------------------*/
/* Description:                       */
/* PGA - Control                      */
/* Setting the iC-TW2 (Interpolator)  */
/* Install the TW2 library first!     */
/* Serial setting: 57600 baud         */
/*                                    */
/* software only for evaluation!      */
/**************************************/

//INCLUDES
#include <TW2.h>
TW2 TW2(13,12);                   //Init TW2 SCL- and SDA-Port

//DEFINES
#define VERSION "v0.1"
#define LED_INFO   11
#define LED_PROG   12
#define PGA_ADDR3  10
#define PGA_ADDR2  9
#define PGA_ADDR1  8

//GLOBALS
char Button;
char Buffer[16];

unsigned char Adress = 0;
unsigned char Data = 0;
char Delimiter[] = ",;";
char *ptr;

int Value=0;

int PGA_Dip;
int PGA_Gain[]={1,2,4,8,16,32,64,128};
int TW2_Backup[]={130,16,64,0,1,127,11,1,0,0,18,8,0,0,0,0};

void setup() {
  Serial.begin(57600);
  pinMode(LED_INFO, OUTPUT); 
  
  Show_Menu();       
}

void loop() {
  int n=0;
  
  if (Serial.available() > 0) {   //check serial buffer
    Button = Serial.read();
    switch(Button)
    {
      case '?':
      Show_Menu();
      break;

      case 'i':
      Show_Info();
      break;
      
      case 'v':  //show version
      Serial.println(VERSION);      
      break;
      
      case 'G':  //read PGA-Setting
      PGA_Show_Settings();
      break;

      case 'R':  //read all TW2 settings
      TW2_Read_all();
      break;

      case 'S':  //Save settings to EEPROM
      TW2_Save2EEPROM();
      break;

      case 'B': //Restore default iC-TW2 values
      TW2_Restore_Backup();
      break;

      case 'r': //read single address of TW2
      TW2_Read_Register();
      break;

      case 'w':  //write single address of TW2
      TW2_Write_register();
      break;

      case 'l':  //switch on the info LED
      digitalWrite(LED_INFO,HIGH);
      break;
      
    }
  }
}

void Show_Menu(){
  Serial.println("Sensitec Evaluationboard EBK7000");
  Serial.println("--------------------------------");
  Serial.println("?\t\t - this overview");
  Serial.println("v\t\t - show firmware version");
  Serial.println("a\t\t - show gain settings");
  Serial.println("B\t\t - TW2 Restore EEPROM");
  Serial.println("R\t\t - TW2 Read all registers");
  Serial.println("r[addr]\t\t - TW2 Read single register");
  Serial.println("w[addr];[data]\t - TW2 Write single register"); 
  Serial.println("S\t\t - TW2 Save to EEPROM");
  Serial.println(" ");
}

void Show_Info(void){
  Serial.println("Informations");
  Serial.println("------------"); 
  PGA_Show_Settings(); 
  Serial.print("TW2 Position: ");
  if(TW2.read_TW2_Reg(0x0F)&&0x08)
      Serial.println(TW2.read_TW2_Reg(0x0F));
  else
      Serial.println("Monitor disabled");
  Serial.print("TW2 Resolution: ");
  Serial.println(TW2.read_TW2_Reg(0x02));
  Serial.print("TW2 Z-Position: ");
  Serial.println(TW2.read_TW2_Reg(0x03));
  Serial.print("TW2 Z-Width: ");
  Serial.println(TW2.read_TW2_Reg(0x04));
  Serial.print("TW2 Gain(coarse): ");
  Serial.println(TW2.read_TW2_Reg(0x07)&0x07);
  Serial.print("TW2 Gain(A): ");
  Serial.println(TW2.read_TW2_Reg(0x07)&0x18);
  Serial.print("TW2 Gain(B): ");
  Serial.println(TW2.read_TW2_Reg(0x07)&0x50);
  Serial.print("TW2 Offset(A): ");
  Serial.println(TW2.read_TW2_Reg(0x08));
  Serial.print("TW2 Offset(B): ");
  Serial.println(TW2.read_TW2_Reg(0x09));
  Serial.print("TW2 Offset(Z): ");
  Serial.println(TW2.read_TW2_Reg(0x0B)&0xF0);
}

void PGA_Show_Settings(void){
  int tempvalue;
  
  pinMode(PGA_ADDR1, INPUT);
  pinMode(PGA_ADDR2, INPUT);
  pinMode(PGA_ADDR3, INPUT);
  tempvalue = digitalRead(PGA_ADDR3);
  PGA_Dip = tempvalue;
  PGA_Dip <<= 1;
  tempvalue = digitalRead(PGA_ADDR2);
  PGA_Dip |= tempvalue;
  PGA_Dip <<= 1;
  tempvalue = digitalRead(PGA_ADDR1);
  PGA_Dip |= tempvalue;      
  Serial.print("PGA Gain: ");
  Serial.println(PGA_Gain[PGA_Dip]);
}

void TW2_Read_all(void){
  Serial.println("Adress:\tData:");
  for(int i=0;i<16;i++){
    Serial.print(i);
    Serial.print("\t");
    Serial.println(TW2.read_TW2_Reg(i));
    delay(1);
  }
}

void TW2_Read_Register(void){
  int n=Serial.readBytesUntil('\n',Buffer,10);
  Buffer[n]='\0';
  Serial.print("read Register: ");
  Adress=atoi(Buffer);
  Serial.print(Adress);
  Serial.print("\tData: ");
  Serial.println(TW2.read_TW2_Reg(Adress));
}

void TW2_Write_register(void){
  int n=Serial.readBytesUntil('\n',Buffer,10);
  Buffer[n]='\0';
  ptr = strtok(Buffer, Delimiter);
  if(ptr != NULL) {
    Adress = atoi(ptr);
    ptr = strtok(NULL, Delimiter); // next part
    Data = atoi(ptr);
  }
  Serial.print("write Register: ");
  Serial.print(Adress);
  Serial.print("\tData: ");
  Serial.println(Data);
  TW2.write_TW2_Reg(Adress, Data);
  delay(1);
}

void TW2_Restore_Backup(void){
  for(int i=0;i<16;i++){
    TW2.write_TW2_Reg(i, TW2_Backup[i]);
    delay(1);
  }
  TW2.write_TW2_Reg(14,64);
  delay(100);  
}

void TW2_Save2EEPROM(void){
  TW2.write_TW2_Reg(14,64);
  delay(100);
}

Der Code ist von der Herstellerseite mit dem Dateinamen (EBK7000_PGA_TW2)

Aus meinem Wissensstand kann das doch nicht der Code sein um daten zu messen, oder ? Da das Programm ja im loop teil mit eine switch anweisung beginnt auch wenn ich den virtuellen monitor aufhabe und z.B. einen Buchstaben drücke passiert nichts...
Würde euch der Code etwas sagen, also wüsstet ihr was er Grob macht, und woher wiess ich welche sensor jetzt angeschlossen ist und welcher angesprochen ist ?

Zu dem Kit habe ich 4 Sensoren die ich an das shield anschließen kann ein Hauptsensor und den Referenzsensor.

Weiss man aus dem Code welcher Sensor angesprochen ist und wie sie zusammenarbeiten oder arbeiten sie überhaupt zusammen ?Habe nochmal neu angehängt danke für die schnellen antworten Tommy

Gruß mika

Auf welcher Baudrate steht Dein serieller Monitor?

Gruß Tommy

Hallo mzumika,

auf dem EBK7000 Shield sind 2 Hauptkomponenten drauf.

  1. PGA
  2. Interpolationsbaustein

Das Shield bereitet die analogen Rohsignale (nur wenige mV Amplitude) so auf, das man damit was anfangen kann.

  1. Durch den PGA (programmable amplifier) werden die Sensorsignale (differenzielles Sinus- und Cosinussignal) verstärkt und können an der Klemme mit einem Oszilopskop gemessen werden, werden aber auch dem ADC-Pins vom Arduino zugeführt und können da weiterverarbeitet werden.
    Der PGA kann durch die DIP-Switch's auf dem Shield eingestellt werden - mit der Software (EBK7000_PGA_TW2) kann die eingestellte Verstärkung ausgelesen werden.

  2. Der Interpolationsbaustein TW2 wandelt die analogen Sinus- und Cosinussignale in digiale Quadratursignale (PA, PB und PZ) - diese können leicht "gezählt" werden und viele Steuerungen in der Antriebstechnik verwenden solche Encodersignale von Positions- und/oder Drehzahlgebern.
    Der Baustein ermöglicht es auch die Sensorsignale zu korrigieren (z.B. Offset). Ebenfalls kann die Auflösung eingestellt werden (wieviele "Zählschritte" pro analoger Sensorsignaleingangsperiode erzeugt werden). Diese Zählsignale stehen durch das Shield auf digitalen Eingängen des Arduino zur Verfügung und können in einer eigenen Anwendung genutzt werden.
    Die Software (EBK7000_PGA_TW2) bietet einige Funktionen den Interpolationsbaustein einzustellen (über eine Zweidrahtschnittstelle).

Die Software (EBK7000_Analog_Plotter) verwendet die analogen Sensorsignale, wandelt diese mit dem Arduino internen ADC und berechnet mittels Arcustangens die Winkelinformation.
D.h. aus den Sensorsignalen wird eine Winkelinformation berechnet. Diese kann dann abhängig von verwendeten Sensor zu einer Positionsinformation skaliert werden.

Wenn du ein paar Infos zu deiner Aufgabenstellung schreiben würdest wäre das sehr hilfreich, um dir besser zu helfen.

Grüße RB

Guten Tag Retiarius,

die Informationen haben mir sehr stark geholfen ! Meine Aufgabe ist es stumpf gesagt "zu Messen" längenmessungen sowie vielleicht winkelmessungen.

Zu der Funktion habe ich mich im vorfeld auch Informiert was das Shield den genau tut, nur ist jetzt das Problem was zu messen da mir der Arduino keine Werte ausgibt sobald ich von Sensitec z.B das programm (EBK7000_PGA_TW2) benutze. Welches Programm ich den überhaupt benutzen soll für das Messen mit dem EBK7000.

Weil wenn ich selber versuche ein Code zu schreiben den ich vielleicht selber verstehe, ich nicht weiss wie ich den Shield oder explizit den Sensor anspreche (da ich bestimmt nicht die standartfunktion benutzen kann? Wegen dem Firmenabhängigen Shield)

Zum weitern Welchen sensor ich als Incremental- und welchen als Reference sensor benutze. Ich habe auch durch versuche den GF708 als Refence sensor benutzt und als main den AL780, dabei ist auch nicht klar wie ich die Sensoren an z.B. den Maßstab halten muss (meine wie ich den Reference sensor benutze ?) Anleitung habe ich jede von der Sensitec Seite ausgearbeitet leider keine Informationen oder ich habe es übersehen.

Mit freundlichen Grüßen und einen schönen start in die Woche
Mika

Hallo Mika,

die Software EBK7000_PGA_TW2 beinhaltet lediglich Funktionen um den Interpolator-Baustein zu programmieren. Du benötigst diese Software nur, wenn du den Interpolator umprogrammieren willst. Dazu solltest/müsstest du dich auch mit dem Interpolator auseinandersetzen (um z.B. einen Offsetabgleich oder eine andere Interpolation einzustellen).

Die Ausgangssignale des Sensors stehen als verstärkte Signale an den analogen Arduino-Ports A0 und A1 zur Verfügung. Diese kannst du mit den ganz normalen Arduino-Funktionen
value_sinus = analogRead(0);
value_cosinus = analgRead(1);
in deinem eigenen Programm auslesen.

Da die Sensorsignale sehr klein sind werden diese über einen PGA verstärkt. Stelle die DIP-Switchs auf dem Shield auf eine Verstärkung von 16 oder 32 ein.

Ich habe mal ein Bild angehängt, wo du siehst wie der Hauptsensor (z.B. AL780) zum Maßstab angeordnet werden muss.

Diesen Steckst du in den vorgesehenen Steckplatz auf dem Shield (incremental sensor (Main)).

Wenn du den Maßstab an dem Sensor vorbeischiebst, sollten auch die LED's A und B auf dem Shield blinken. Das sind die Aufgänge des Interpolators. Der wandelt die analogen Signale in digitale Quadratursignale. Diese werden auf dem Shield auf die digitalen Pins 5 und 7 geleitet. Mit einer eigenen Software könntest du diese Signale "zählen" (einfach googlen nach Quadratursignale, wenn du diese noch nicht kennst). Damit kannst du dann auch eine Position ermitteln, wenn die dieAuflösung des Interpolators kennst, weißt du nach welcher Strecke ein weiterer Zählschritt erfolgt.

Einfacher am Anfang ist es aber die analogen Signale über den ADC (wie oben beschrieben) einzulesen.
Wenn du diese hast kannst du mittels Arcustangensfunktion den Winkel bzw. die Position ausrechnen.
Beim AL780 bekommst du alle 5 mm eine Signalperiode Sinus und Cosinus. D.h. 360° entsprechen 5 mm.

Das Programm EBK7000_Analog_Plotter macht genau das. Es wandelt die Analogsignale und berechnet einen Winkel mittels Arcustangens und gibt diesen dann aus.

Stelle deine Baudrate auf 57600 und nutze den Amnalog-Plotter der Arduino IDE, dann solltest du einige Signale sehen, wenn du den Maßstab bewegst.

Die Verwendung des Refrenz-Sensors, um bei dem Quadratursignal zusätzlich zu A und B ein Z-Signal zu erzeugen ist etwas komplizierter und nicht in ein paar Zeilen zu erklären.

Ich hoffe, dass du mit dieser Hilfe deinem Ziel noch etwas näher kommst. Wenn du etwas Code geschrieben hast kannst du ihn gerne hier posten, dann helfe ich gerne weiter.

Grüße René

Guten Tag René,

vielen Dank für deine Umfangreiche Antwort, dass hat uns sehr weitergeholfen! Sobald wir weiter mit unserem Projekt (Code) kommen melde ich mich wieder.

Grüße
Mika

Hallo,

meine Gruppe und ich kommen momentan nicht weiter. Wir verstehen nicht, wie wir über die Schnittstelle den iC-TW2 programmieren können. Geht das alles über die Software von Sensitec oder muss man da ein komplett eigenes Programm schreiben ?
Ich habe es mit dem Programm versucht, das hilft mir aber gar nicht weiter...

//INCLUDES
#include <TW2.h>
#include <math.h>
#include <Wire.h>
TW2 TW2(5,4);

//DEFINES
#define VERSION "v0.1"
#define LED_INFO   11
#define LED_PROG   12

//GLOBALS
char Button;
char Buffer[16];

void setup() {
  
  Serial.begin(57600);
  pinMode(LED_INFO, OUTPUT);
  pinMode(8,INPUT);
  pinMode(9,INPUT);
  pinMode(10,INPUT);
  Wire.begin();
    
}

void loop() {

digitalWrite(8,HIGH);
digitalWrite(9,HIGH);
digitalWrite(10,HIGH);

  Serial.print(analogRead(0));
  Serial.print("\t");
  Serial.println(analogRead(1)); 
  delay(100);


  
 
  Wire.beginTransmission(0x07); 
  Wire.write(32);             
  Wire.endTransmission();    
  
  delay(100);
  
  
 
  
 
}

Mit dem iC-TW2 kann ich die Kosinus- und Sinussignale digitalisieren, oder?

Vielen dank schon mal !

Grüße
Mika

Hallo Mika,

ich glaube es würde helfen, wenn du beschreiben würdest was du mit dem Shield realisieren möchtest. Ich denke da kann ich dir besser helfen, als die Software im Detail zu erklären.

Dennoch ein paar Hilfen zu der Software für den TW2.
Dieser Baustein ist von seiner Parametrierung recht komplex. Die Software hilft dir dabei mit dem Baustein zu kommunizieren und die richtigen Einstellungen im Baustein einzurichten, damit eine korrekte Verarbeitung der rohen, analogen Sensorsignale in digitale Quadratursignale erfolgt.
Hierzu musst du diese Software auf den Arduino laden und über die Arduino IDE den Seriellen Monitor aufrufen. Die Baudrate musst du auf 115200 Baud stellen.
Wenn du dann ein "i" eingibst (bitte ohne die Anführungszeichen) sollte eine Reihe von Informationen erscheinen.
Wenn das geht, bist du schon einen großen Schritt weiter.

Der Baustein TW2 verfügt auch über einen internen EEPROM in dem die Einstellungen gespeichert werden. Normalerweise ist hier eine sinnvolle Voreinstellung drin, so dass der Baustein bereits funktioniert. Du kannst aber durch drücken von "B" den Werkszustand wiederherstellen.
Es macht Sinn dies mal zu tun, um sicherzustellen, dass wieder sinnvolle Einstellungen geladen werden.

Hast du mal an der Pinleiste des Boards an den Signalen "PA" und PB gemessen, ob hier digitale Signale Quadratursignale kommen, wenn du den Sensor an einem Maßstab vorbeibewegst? Du kannst auch an den Pins "SIN" und "COS" mal messen - da sollten die verstärkten Analogsignale kommen, wenn du ebenfalls den Sensor vor dem Maßstab bewegst.

Gib mal Bescheid, ob du weitergekommen bist. Wie gesagt, es würde helfen, wenn die Aufgabenstellung bekannt wäre.

Grüße René

Guten Morgen René,

erstmal vielen Dank für deine Antwort. Wir haben den TW2 einstellen können jedoch nicht das, dass Signal um die X-Achse schwingt, also wir den Faktor für den Offset eingestellt bekommen. Dann haben wir schonmal das Zählen der Pole hinbekommen jedoch zählt er nicht Zurück. Mit dem Magneten können wir auch unseren Zähler auf Null setzten.( Zu unserem Fortschritt)

Zu unserer Aufgabe wir sollen ganz Stumpf gesagt Längen und Winkel messen explizit mit dem EBK7000, eine Linearführung mit einem Schrittmotor habe ich schon erstellt, sodass ich bei kleinem Vorschub jetzt auch mindestens 0.1 mm Schritte gehen, natürlich wenn ich genauer messen kann ich dies auch erreichen will. Sowie bei größeren Vorschub ich keine Sprünge mit dem Sensor erhalte.

Mit freundlichen Grüßen
Mika