I'm trying to get serial data from a device that I do not have control over. It is transmitting data at ~250 kHz, which is just too much for my Arduino/Raspberry to read and react to. This data is used on a device for a shift register, TPIC6C595

I want to be able to read this serial data at a lower clock. How can I achieve this?

The important thing is not only to read the data, but to read it with regard to the clear and latch signals that are coming into a register

A very basic idea is to make two cascades of shift registers, one cascade will read data at the device's clock and transfer it to parallel form and the other cascade will gather parallel data to serial at Arduino's clock. As I have 35 bits of info being stored, the wiring of this board will be real mess, andit seems overcomplicated.

I think I need something like a TPIC6C595, a shift register that reads serial data, stores it into storage register, but instead of parallel data output has a serial output on different clock. Is there such an IC?

Do you have any other ideas on how can I do it?

  • \$\begingroup\$ Perhaps you can share what Arduino/Raspberry you tried, with source code. Most devices will have hardware to receive clocked data (SPI). \$\endgroup\$ May 3, 2023 at 11:18
  • 1
    \$\begingroup\$ Your title is this: How to change frequency of a serial data yet, in your question body you say I'm trying to get serial data from a device, that I do not have control on so, do you see the problem here? \$\endgroup\$
    – Andy aka
    May 3, 2023 at 11:22
  • 2
    \$\begingroup\$ There are several ways to clock in and store your 35 bits, but the easiest solution is to make your Arduino or RPi capture it in hardware directly. Which pins do you have available, or can make available to read your 250 kHz data? \$\endgroup\$
    – winny
    May 3, 2023 at 11:29
  • 1
    \$\begingroup\$ Please describe briefly exactly how you're currently trying to read this 250kHz data into your Arduino or RPi. 250Khz is not really all that fast for serial data, so it should be possible to achieve without resorting to hacky add-ons. \$\endgroup\$
    – brhans
    May 3, 2023 at 11:48
  • \$\begingroup\$ @Andyaka well, i see your point, but I'm really asking for an IC or combination of ICs that could achive result I explained in the question (letting me read data with lower frequency), not for a way to read the 'fast' data \$\endgroup\$
    – smplio
    May 3, 2023 at 12:33

2 Answers 2


I understand that you want a microcontroller to pretend to be a 74xx595 shift register, so it receives the same data when connected in parallel with a real 74xx595 shift register.

250kHz is not that fast for data transmission, but possibly too fast for bit-banging on a slower microcontroller. See if your microcontroller has a feature called SPI slave, or USART. The signal you want can be received by either of these. The hardware will gather the bits into bytes and then you only have to read the bytes, so the microcontroller is fast enough.

Or, get a faster microcontroller. There are many that are fast enough to bit-bang 250kHz.

  • \$\begingroup\$ Unfortunately, using SPI bus is not an option, because: 1) SPI has only clock and data lines, but i need to get all the inputs from the register. Because if some data may be disregarded if certain signal is present on TPIC6C595 2) Arduino nano has one SPI and it's already occupied( \$\endgroup\$
    – smplio
    May 3, 2023 at 12:41
  • \$\begingroup\$ @smplio connect to the inputs of the register, not the outputs, then simulate the register, so that you get the same 35 outputs based on the same 3 inputs. A 595 register is the same as an SPI receiver. \$\endgroup\$ May 4, 2023 at 18:00
  • \$\begingroup\$ @smplio What do you mean "get all the inputs"? Do you need a logic analyzer sort of reading of the signals? What minimum sample rate do you need then? (At least half the clock rate, presumably.) \$\endgroup\$ May 4, 2023 at 21:27
  • \$\begingroup\$ @TimWilliams they want all the 35 outputs from the shift register without soldering 35 wires. The obvious way to do that is to use the 3 inputs, instead. \$\endgroup\$ May 4, 2023 at 21:54

If you insist on buffering data, a FIFO such as 74ACT2229 might be usable. You will need additional logic to track state of the buffer and read it out, or perhaps use a wider (e.g. 64x4 or more) one if you want to record more status lines at the same time, or even make something more akin to a logic analyzer. (Which won't be any easier to read out via MCU, and will most likely need an FPGA to build practically.)

You'll notice this device is rather obscure, expensive and poorly stocked. Likely the reason is this type of device is largely obsoleted by the availability of fast MCUs, with good peripherals, and FPGAs. This is why other comments have urged a solution using such resources. Perhaps it's not a perfect fit for whatever data you're trying to read, perhaps it can be made to work with a little cleverness.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.