Digitale Messuhren ( Messschieber, Dickenmessgeräte …) haben häufig eine Datenschnittstelle. Diese Datenschnittstelle wird entweder an extra dafür vorgesehene externe Hardware angeschlossen, um Messwerte auszulesen oder mit einem Datenkabel und entsprechender Software (meist nur für Windows verfügbar) mit dem PC verbunden. Diese Lösungen sind einerseits recht teuer (80€-300€), und anderseits für die eigentliche Weiterverarbeitung äußerst unpraktisch, so dass sich meist der Kauf dieser Extrakomponenten für Hobbyisten nicht lohnt. Hier zeigen wir, wie Hardwarekomponenten, die nur wenige Euro kosten, mit Messuhren, die über eine serielle Schnittstelle (Digimatic Protokoll) verfügen, kommunizieren können. Praktisch setzen wir das in unserer CNC-Fräse ein, die mit LINUXCNC gesteuert wird. Es wären aber auch Roboterprojekte denkbar, in denen mit wenig Aufwand genaue Messungen durchgeführt werden könnten.

Die wesentliche Hardware ist eine Messuhr (mit RB6-Schnittstelle), ein Arduino und ein Datenkabel. Es werden zwei Programme entwickelt. Das erste Programm zeigt, wie man grundsätzlich das Digimatic-Protokoll mit dem Arduino ausliest. Das zweite Programm demonstriert, wie man darauf aufbauend eigene Messsoftware entwickeln kann, wobei der Arduino dann als Elektronikkomponente zwischen der Messuhr und dem PC vermittelt.

Einen Arduino Nano, einen Widerstand und ein Transistor reichen aus, um mit der Messuhr kommunizieren zu können. Das Kabel (hier Digimatic-Kabel mit RB6/Wannenstecker) ist allerdings auch noch notwendig.

Anzahl	Hardware
1	Arduino Nano (Klon)
1	4,7 k Widerstand
1	BC 548B Transistor
1	Digimatic-Kabel
1	Wannenstecker (10-polig) 2.54mm

Grundsätzlich könnten alle Messgeräte mit dem Digimatic-Protokoll ausgelesen werden (auch andere Schnittstellen als RB6, z.B. RB5, inbegriffen). Testen konnten wir natürlich nur mit dem uns zur Verfügung stehenden Messgerät(siehe folgende Tabelle). Der Wannenstecker ist nur notwendig, wenn das Digimatic-Kabel verwendet wird. Eine Alternative ist im Abschnitt Downloads/Links aufgeführt (Adapter RB6 auf RB5).

• Digimatic Protokoll Das Digimatic-Protokoll muss gründlich verstanden sein, bevor man versucht, Daten vom Messgerät zu lesen. Insgesamt werden 13 Halfbytes (Nibble) gelesen und somit insgesamt 52 Bits bei jedem Lesevorgang empfangen.
• Arduino Testprogramm Ein erster Test mit der Messuhr und dem Arduino demonstriert das grundlegende Prinzip. Der Arduino liest die Daten von der Messuhr und zeigt sie auf der seriellen Konsole an. Wenn dieser Schritt erfolgreich beendet wurde, ist das schwierigste geschafft. Es bleibt nur noch ein ordentliches Hardware-Interface für den Dauereinsatz zu basteln und die Software für die PC-Kommunikation zu entwerfen.
• Messsoftware Eigentlich geht es ja darum, mit eigener Software die Daten der Messuhr (über den dazwischen geschalteten Arduino) zu lesen. Ein Code-Skelett, wie so eine Mess-Software aussehen kann, wird hier vorgestellt. Für LinuxCNC empfiehlt es sich, Python zu verwenden. Wir demonstrieren hier das Prinzip mit Java. Jede Programmierprache, die mit dem seriellen Port kommunizieren kann, ist natürlich erlaubt.

Zuerst geben wir den Schaltplan an, der nötig ist, um die Messuhr mit dem Arduino verbinden zu können. Für die Prototypentwicklung reicht ein Steckbrett. Ein kleiner Adapter, der die Messuhr mit dem Arduino verbindet, erleichtert allerdings den Aufbau erheblich. Für den dauerhaften Einsatz wurde die Elektronik in ein Elektronikgehäuse gelegt. Die wichtigsten Eigenschaften des Digimatic-Protokolls werden danach besprochen. Anschließend werden die kommentierten Quellcodes der beiden Programme mit zusätzlichen Erklärungen behandelt.

AbsolutSystem Digital-Messuhr (12,7 mm Messbereich) und RB6-Datenausgang, Ablesung 0,001 mm.

Die Tatsache das Datenleitung und Takt direkt vom Arduino als LOW/HIGH erkannt und somit verarbeitet werden können, erleichtert den Aufbau erheblich. Nur der Request (REQ - Pin 5) erfordert eine Nachbearbeitung.

REQ ist ein digitaler Ausgangspin vom Arduino, er wird über dem Widerstand an die Basis des Transistors angeschlossen. Der Emitter des Transistors ist mit GND und der Kollektor mit PIN 5 des Wannensteckers verbunden.

Wenn REQ vom Arduino LOW ist, dann sperrt der Transistor und am PIN 5 der Messuhr liegt ein HIGH an. Wenn REQ vom Arduino HIGH ist, öffnet der Transistor und PIN 5 des Wannensteckers wird auf GND gezogen (active LOW Prinzip). Dies ist dann das Signal, das Daten von der Messuhr gelesen werden sollen. Daten können also nur von der Messuhr gelesen werden, wenn zuvor PIN 5 der Messuhr auf GND gezogen wird.

Manuelle Herstellung der Elektronikausschnitte:

1. Mit einem CAD Programm Schablonen anfertigen und anschließend so auf dem Adapter platzieren, dass die Bohrlöcher vorgekörnt werden können.
2. Bohrlöcher vorkörnen.
3. Mit einem kleinen Bohrer (ca. 1mm) in die Ecken für die Ausschnitte bohren. Die Bohrlöcher für die Schrauben sollten ebenfalls vorgekörnt werden.
4. Mit der Laubsäge das Material entfernen.
5. Schlüsselfeilen benutzen, um alles sauber in Form zu bringen.

Das Digimatic-Protokoll erwartet, dass über den Request (Pin 5) ein Signal (Leseaufforderung) an die Messuhr geschickt wird. Anschließend stehen dann 52Bit (in 13 Halfbyte verpackt) zum Lesen zur Verfügung. Wenn man jetzt noch weiß, was die jeweils einzelnen Bits bedeuten, steht einer Auswertung nichts mehr im Wege.

1 Pinbelegung: Für einen 10-poligen Wannenstecker. Pin 1,2,3 und 5 werden verwendet.

2 Datenformat: Ein Datensatz besteht aus 13 Halfbyte (hier mit 'digits' bezeichnet). Der eigentliche Messwert steckt in den 'digits' d6 bis d12.

3 Zeitdiagramm: Ein Lesevorgang wird eingeleitet, indem über den Request (Pin 5) die Ausgabe auf LOW (Low active) gezogen wird. Jedes Bit kann dann nach einem Taktwechsel (LOW-HIGH) gelesen werden. Beachte, die Binärangaben scheinen falsch herum, da MSB zuerst gesendet wird!

Das Digimatic-Protokoll besteht (siehe Grafik) aus 13 Halfbyte, so dass insgesamt 13*4=52 Bits übertragen werden. Die Grundsätzliche Abfrage von Messdaten läuft dabei nach folgendem Schema ab:

1. Request senden, indem die Request (REQ)-Leitung auf LOW gesetzt wird.
2. Clock-Zyklus abwarten, d.h., CLOCK=HIGH-Signal abwarten, dann CLOCK=LOW-Signal abwarten.
3. Bit einlesen.
4. Ab Schritt 2 wiederholen, bis 52 Bits gelesen worden sind.
5. Request-Leitung auf HIGH setzen.

Dieses Schema ist in der Funktion

 readDialGauge()

umgesetzt. Diese Funktion wird unten noch genauer beschrieben. Da Arduino den Datentyp Halfbyte (Nibble) nicht besitzt, verwendet die Funktion den Datentype byte. D.h., die Daten werden insgesamt in ein Array von 13 Bytes gelesen, wobei jedes Byte die 4 gelesenen Bits beinhaltet.

Die Ziffern stehen im BCD-Code zur Verfügung. Falls Sie mit diesem Code nicht vertraut sind, ist das in unserem Fall aber nicht weiter wichtig, da jede Ziffer (digit) direkt als Binärzahl interpretiert werden kann.

Das folgende Programm (Arduino Sketch) läuft auf dem Arduino, der wiederum mit der Messuhr verbunden ist. Über das USB-Kabel des Arduinos werden die gelesenen Messwerte der Uhr vom Arduino auf den PC übertragen und über den integrierten seriellen Monitor der Arduino-IDE ausgegeben.

| minimal solution - reading gauge indicator

/* minimal solution - reading gauge indicator (here a device from Absolute-System)
   @author torsten roehl
   @see this code is based on https://www.instructables.com/id/Interfacing-a-Digital-Micrometer-to-a-Microcontrol/
   (there is a little big in the code from instructables - only ocurs for high inch values! )
*/
 
 
/*  ADJUST AREA START  */
 
/* pin configuration */
int pinREQ = 5;
int pinDATA = 2;
int pinCLK = 3;
 
/* pooling intervall */
int sleep = 100;
/* baudrate */
int bd = 9600;
 
/*  ADJUST AREA END  */
 
/* Keep FIXED! - data protocol format */
byte digits[13];
float value;
 
void setup() {
 
  /*    SERIAL_8N1 (the default)  */
  Serial.begin(bd);
 
  pinMode(pinREQ, OUTPUT);
  pinMode(pinCLK, INPUT_PULLUP);
  pinMode(pinDATA, INPUT_PULLUP);
  digitalWrite(pinREQ, LOW); // set request at high
 
}
 
void loop() {
 
  readDialGauge();
  decodeDialGauge();
  serialInfoMonitor();
 
  delay(sleep);
}
 
 
/*
   Read the dial gauge.
   After a call to this function the array digits[13] contains all data according to the data protocol.
   For normal data reading the first four digits should by all 'F', the function returns false if this is not the case.
 
 
 
*/
boolean readDialGauge() {
 
  /**
     Generate request by making REQ active (low level)!
  */
  digitalWrite(pinREQ, HIGH); // generate set request
 
  /* read 13 nibble (52 bit) */
  for (int i = 0; i < 13; i++ ) {
    int digit = 0;
    for (int j = 0; j < 4; j++) {
 
      while ( digitalRead(pinCLK) == LOW) {}/* Wait for CLOCK=HIGH */
      while ( digitalRead(pinCLK) == HIGH) {} /* Wait for CLOCK=LOW  */
 
      bitWrite(digit, j /*pos*/, (digitalRead(pinDATA) & 0x1));
    }
 
    digits[i] = digit;
  }
 
  digitalWrite(pinREQ, LOW);
 
 
  /* d1-d4 should be all oxF */
  int header = digits[0] + digits[1] + digits[2] + digits[3];
  return header == 60 ? true : false;
}
 
 
/*
   decodeDialGauge (according to the digomatic-protocol)
   Note: A call to readDialGauge is necessary to use this function!
 
   i) value - contains the (signed) value read out from the gauge indicator
   ii) units - if units is equal to 0 then mm is used, otherwise (1) inch is in use
   iii) decimal - the number of decimal. mm corresponds to 3 decimal numbers, whereas inch has five decimal numbers.
 
   return (signed) measured value
*/
 
void decodeDialGauge() {
 
  int units = digits[12];    // 0=mm or 1=inch
  int decimal = digits[11];  // 3 for mm and 5 for inch
 
  value = (float)digits[5] * 10000 + (float)digits[6] * 10000 + (float) digits[7] * 1000 + (float)digits[8] * 100 + (float)digits[9] * 10 + (float) digits[10];
  /* assuming digits[11] is allways 3 */
  value /= 1000.0;
 
  if (units == 1 )
    value /= 100.0;
 
  if (digits[4] == 8)
    value *= -1.0;
}
 
/*
   Helper function: This function decodes and writes the data from the dial gauge to the arduino serial monitor for debugging purposes.
   Note: A call to readDialGauge and decodeGauge is necessary to use this  function!
 
*/
void serialInfoMonitor() {
 
  int units = digits[12];// 0=mm or 1=inch
  int decimal = digits[11];// 3 for mm and 5 for inch
 
  String info = " (mm)";
  if (units == 1 )
    info = " (inch)";
 
  Serial.print(value, decimal );
  Serial.println(info);
 
}

| Arduino

/* minimal solution - reading gauge indicator (here a device from Absolute-System)
   @author torsten roehl   
*/
 
 
/*  ADJUST AREA START  */
/* pin configuration */
int pinREQ = 5;
int pinDATA = 2;
int pinCLK = 3;
 
/* baudrate */
int bd = 9600;
/*  ADJUST AREA END  */
 
/* Keep FIXED! - data protocol format */
byte digits[13];
 
/* serial communication protocol */
byte cmd;
const byte PROTOCOL_REQ =  55;
 
 
void setup() {
 
  /*    SERIAL_8N1 (the default)  */
  Serial.begin(bd);
 
  pinMode(pinREQ, OUTPUT);
  pinMode(pinCLK, INPUT_PULLUP);
  pinMode(pinDATA, INPUT_PULLUP);
  digitalWrite(pinREQ, LOW); // set request at high
 
}
 
void loop() {
 
 
  if (Serial.available() > 0) {
 
    cmd =  Serial.read();
 
    switch (cmd) {
 
      case PROTOCOL_REQ:
 
        readDialGauge();
        send();
        break;
 
    }
 
  }
 
}
 
 
/*
   Read the dial gauge.
   After a call to this function the array digits[13] contains all data according to the data protocol.
   For normal data reading the first four digits should be all 'F', the function returns false, if this is not the case.
*/
 
boolean readDialGauge() {
 
  /**
     Generate request by making REQ active (low level)!
  */
  digitalWrite(pinREQ, HIGH); // generate set request
 
  /* read 13 nibble (52 bit) */
  for (int i = 0; i < 13; i++ ) {
    int digit = 0;
    for (int j = 0; j < 4; j++) {
 
      while ( digitalRead(pinCLK) == LOW) {}/* Wait for CLOCK=HIGH */
      while ( digitalRead(pinCLK) == HIGH) {} /* Wait for CLOCK=LOW  */
 
      bitWrite(digit, j /*pos*/, (digitalRead(pinDATA) & 0x1));
    }
 
    digits[i] = digit;
  }
 
  digitalWrite(pinREQ, LOW);
 
 
  /* d1-d4 should be all oxF */
  int header = digits[0] + digits[1] + digits[2] + digits[3];
  return header == 60 ? true : false;
}
 
 
/*
   This function sends 13 bytes via the serial interface.
   The method sends the whole digimatic protocol for client side processing purposes.
*/
void send() {
 
  for (int i = 0; i < 13; i++ ) {
    Serial.write(digits[i] );
  }
 
}

Um mit Java auf den Arduino über die serielle Schnittstelle zugreifen zu können, verwenden wir die jSSC (Java Simple Serial Connector) API. Sie besteht aus nur einer jar-Datei und wird auch von der Arduino-IDE selbst verwendet. In Eclipse wird sie über Eigenschaften (Java Build Path - Add External JAR's…) dem Projekt hinzugefügt.

Programmstruktur

• main-Methode: In der main-Methode kann optional die Geräteschnittstelle mit angegeben werden. Als Standard ist /dev/ttyUSB0 gesetzt. Das Programm wird abbrechen, wenn nicht die richtige Schnittstelle ausgewählt wurde. Bei Linux ist es häufig so, dass wiederholtes ein- und abstecken der USB-Verbindung des Arduinos die Schnittstellen /dev/ttyUSB0,/dev/ttyUSB1 usw. erzeugt.
• Wichtig ist der Thread.sleep(4000), da andernfalls die Schnittstelle nicht richtig arbeiten kann!.
• Das Protokoll funktioniert so, dass der Client einen Request (55) sendet. Anschließend kann der dann einen vollständigen Datensatz (13 Bytes) empfangen. Das Protokoll kann leicht für weitere Kommandos erweitert werden, wobei zu beachten ist, dass sowohl der Server (Arduino) und der Client das gleiche Protokoll verwenden müssen.
• Das Programm gibt (oldValue) nur dann Messwerte aus, wenn sich eine Änderung ergeben hat.
• Der vollständige Datensatz wird mit der folgenden Zeile eingelesen: byte[] buffer = serialPort.readBytes(13);
• Die decodeDialGaugeAsString-Methode dekodiert die 13 Bytes und erzeugt eine lesbare Ausgabe. Sie bietet genügend Raum für Verbesserungen, demonstriert aber, wie man grundsätzlich das Protokoll auswertet.

|Demoprogramm (Skelett) für eigene Erweiterungen

/**
 * @author torsten roehl
 * Serversoftware: dial_gauge_v01.ini 
 * Verwendete API: jssc.jar
 * Demoprogramm (Skelett) für eigene Erweiterungen
 */
 
import jssc.SerialPort;
import jssc.SerialPortException;
import jssc.SerialPortTimeoutException;
 
public class DialGauge01 {
 
	public static void main(String[] args) throws InterruptedException, SerialPortTimeoutException {
 
		String dev = "/dev/ttyUSB0";
		if (args.length == 1)
			dev = args[0];
 
		SerialPort serialPort = new SerialPort(dev);
 
		try {
 
			serialPort.openPort();
			serialPort.setParams(9600, 8, 1, 0);
			System.out.println("...	initializing the serial port");
			Thread.sleep(4000); /* necessary, otherwise serial will fail!!! */
 
			byte REQ = 55; /* Protokoll */
 
			String strValue;
			String oldValue = "";
 
			while (serialPort.isOpened()) {
 
				// send request to read gauge value!
				boolean isReady = serialPort.writeByte(REQ);
 
				if (isReady) {
 
					byte[] buffer = serialPort.readBytes(13);
					strValue = DialGauge01.decodeDialGaugeAsString(buffer);
 
					if (!oldValue.equals(strValue))
						System.out.println("Messwert: " + strValue);
					oldValue = strValue;
				}
 
				Thread.sleep(10);
			}
 
			serialPort.closePort();
 
			System.out.println("port is closed!");
		} catch (SerialPortException ex) {
			System.out.println(ex);
		}
	}
 
	/*
	 * Working but q&d programming! 
	 * Auswertung fuer unsere Messuhr. Es gilt:
	 * Format (mm): ##.###    (3 Nachkommastellen)
	 * Format (inch): #.##### (5 Nachkommastellen)
	 */
	public static String decodeDialGaugeAsString(byte digits[]) {
 
		int units = digits[12]; // 0=mm or 1=inch
		String info = " (mm)";
 
		String str = "" + digits[5] +""+ digits[6] +""+ digits[7] +""+ digits[8] +""+ digits[9] +""
				+ digits[10];
 
		/* mm */
		if (units == 0) {
 
			String s1 = str.substring(0, 3);
 
			if (s1.charAt(0) == '0')
				s1 = s1.substring(1);
			if (s1.charAt(0) == '0')
				s1 = s1.substring(1);
 
			String s2 = str.substring(3);
			str = s1 + "." + s2;
 
		}
 
		/* inch */
		if (units == 1) {
			info = " (inch)";
			String s1 = str.substring(0, 1);
			String s2 = str.substring(1);
			str = s1 + "." + s2;
		}
 
		/* sign */
		if (digits[4] == 8)
			str = "-" + str;
 
		return str + info;
 
	}
 
}

Die beiden wichtigsten Quellen sind eine Datei (PDF) über das Digimatic-Protokoll und eine Anleitung von Instructables, die das Auslesen von Mitutoyo-Messgeräten aufzeigt. Unsere Messuhr ist ähnlich aufgebaut, sodass dieser Artikel hilfreich ist. Allerdings enthält der dort verwendete Code einen Bug (kommt nur bei großen Messwerten in inch zum Tragen). Außerdem ist die Verwendung von Strings, selbst wenn man schon mit „Arduinos“ programmiert, ungewöhnlich. Ohne Verwendung von Strings läuft der Code wesentlich performanter.

• Digimatic Protokoll (TechMusings)
• Quellcode: Arduino und Java (mit JSSC)

Angaben zu den Messgeräten & Kabeln.

• Kabel Digimatic https://www.amazon.de/gp/product/B0006J415K/ref=oh_aui_detailpage_o01_s00?ie=UTF8&psc=1 (Mitutoyo mt905409 Anschluss Kabel (2 m) 905409)
• Kabel Adapter https://www.shop.santool.de/de/zubehoer/anschlusskabel-digitale-messuhr.html?bruttonetto=with (Art.Nr.: MI-02027153 Anschlusskabel für digitale Messuhr)
• Messuhr https://www.amazon.de/gp/product/B0747MG36S/ref=oh_aui_detailpage_o02_s00?ie=UTF8&psc=1 (CNC QUALITÄT Digital- Messuhr 12,7 mm Messbereich, Ablesung 0,001 mm )

Java API für die serielle Schnittstelle: https://code.google.com/archive/p/java-simple-serial-connector/

Anleitung von Instructables https://www.instructables.com/id/Interfacing-a-Digital-Micrometer-to-a-Microcontrol/