I am in need for a z-measurement device for my cnc. So I checked ebay and got me a used mitotuyo depth gauge for ~60€. It has an ‘SPC’-Interface for digital readout. Fortunately there is some information on the Web on howto access that interface.
DIY connector
I didn’t want to buy an expensive Mitutoyo-cable, so I decided to solder on my own connector.
Pinout is:
1. GND (red cable)
2. Serial Data Out (OpenCollector)
3. Serial Clock Out (OpenCollector)
4. (unused)
5. Request In
The USB-Conversion is done by a tinymega microcontroller board which features an Atmega32U4 CPU. With the LUFA USB-Stack it presents itself to the host as a virtual serial port.
The implementation of the SPC-Protocol decoding is pretty straightforward. Send a request on one pin, read in data via SPI. I chose to do all of this in software with one interrupt (not using the SPI peripheral of the CPU). You can see my implementation here on github.
caliper + tinymega
Now all that is left is to hook it up to linuxcnc. I haven’t done that yet, but most likely it only requires 10 lines of python to generate a HAL-Module.
Controlling WS2812 LED-Pixels from an Raspberry-Pi can be done. Other people have done this before: https://github.com/jazzycamel/ws28128-rpi/
My approach is different, but not that new either. I already implemented similar code for the Lightpainting-Stick-Clone.
To get the required timing with the SPI we can output some patterns to make it look like the WS2812-Protocol.
The yellow line is MOSI (DIN). The 50us Reset is visible on channel 2.Closeup of the actual timing. This image shows the first 7 bits (1000010)
However, there are some issues as metioned in the inline-comments. At first it seems like the code does not work when sending dmx-data with ola_dmxconsole. Once there are more changes in a short period of time, the pixels start to react. My guess here that this is related to the scheduler of the kernel. When as the kernel switches tasks the SPI output-stream gets interrupted, thus making the timing invalid. I will investigate this further.
void SPIOutput::IndividualWS2812Control(const DmxBuffer &buffer) {
/*
* This is an hack!
*
* Basically the RaspberryPI cant drive WS2812 Pixels because they have
* some strict timing requirements.
* Using the SPI-Module we can emulate those pulses.
* This will only work if the SPI-Module outputs all data in one consecutive
* stream without any pauses. More recent versions of the Raspberry Kernel
* seem to implement DMA for SPI which makes this possible.
*
* WS2811-Chips have similar timings but not exactly the same as WS2812.
* Some sources say the most important part is the total period-time
* of one bit. There are lots of descriptions of WS2812-timing requirements
* out there, one of them is: (with +-150ns tolerance)
* 0-Bit 0.25us high, 1us low
* 1-Bit 0.6us high, 0.65us low
*
* Running the SPI at 4Mhz gives us a pulse-width of 250ns
* Using a 5-bit pattern we can emulate those timings
* 0-Bit: 10000 (0.25us high, 1us low)
* 1-Bit: 11110 (1us high, 0.25us low)
* Those values are not an exact match, but they seem to work for both
* WS2812 and WS2811 in high-speed-mode.
*
* We need to send 8 of those 5-packs for each byte. Those 40 bits are
* precalculated and stored in a lookup table.
*
* To issue an reset, the data-line needs to be low for 50us, thats
* 200 bits, or 25 bytes. For safety, we will send 27 bytes.
*
* Connect the Data-In-Pin of the LEDs to the MOSI Pin of the SPI-Module,
* ignore the clock Pin.
*
*/
const uint8_t reset_bytes = 27;
const unsigned int first_slot = m_start_address - 1; // 0 offset
// We always check out the entire string length, even if we only have data
// for part of it
const unsigned int output_len = reset_bytes + m_pixel_count *
WS2812_SLOTS_PER_PIXEL * WS2812_SPI_LUT_LEN;
uint8_t *output = m_backend->Checkout(m_output_number, output_len, 0);
if (!output)
return;
// set the reset-bytes to zero
memset(output, 0, reset_bytes);
// loop over all pixels
unsigned int output_pos = reset_bytes;
for (uint16_t px = 0; px < m_pixel_count * WS2812_SLOTS_PER_PIXEL; px++) {
uint8_t c = buffer.Get(px + first_slot);
// now output 5 bytes from the LUT
for (unsigned int lut = 0; lut < WS2812_SPI_LUT_LEN; lut++) { output[output_pos++] = WS2812_SPI_LUT[c * 5 + lut]; } } m_backend->Commit(m_output_number);
}
