any raspberry pi people here?

Are you serious about using yet another aliexpress toy for some real design? Other than the obvious question above, does not ARM have some sort of timebase register as part of the core? This might be usable to some extent, depending on how much jitter you can tolerate.

My understanding is that the /Raspberry/ Pi(s) don't have hardware for keeping time when the CPU isn't running.

Some of the other Pi(s) and the likes do have timer hardware.

The Raspberry Pi is like Ethernet, in that it's the most inexpensive thing that gets done what 80% of the users need. If you're in the other

20%, you want something else, be it a hat or different board.

mandag den 18. juli 2022 kl. 21.13.15 UTC+2 skrev John Larkin:

which version of pi?

using a pi I assume you'll be running some kind of linux I don't see how you could do 1us timing in linux

maybe look at this:

uses an SoC that has two extra risc cpus with access to everything on the chip for realtime tasks

chapter 4

a PI has everything it needs, just add power (and an SC card*)

*or get a CM4 compute module with eMMC

My RPi2B is loaded with BSD 14 and its nanosleep() function provides 1ns resolution for my iic interface. Danke,

sure as long as your code is running and not interrupted you can busy wait with nanosec resolution up to few ms

try reacting on a signal to measure it's frequency or timestamp it ....

May as well go with 4B.

Of course I need hardware to do microsecond timings. The c programs would pick up the numbers from the hardware.

4B seems to have a 19.2 MHz crystal, but it doesn't look like it accessable to an external gadget, like an FPGA. I can add a VCXO.

Not exactly a toy. But it would save us using up our stock of FPGAs and ARM chips, and I know a guy who would like to do the programming. He's a retired Fellow of United Technologies (Collins) who really likes to code.

The ARM in the pi seems to have none of the usual counter/timer stuff, so we'd have to do that externally, in a small FPGA probably. We might have three frequency counters and maybe six edge time stampers in a FIFO or something. Pretty simple.

Some torque sensors make tricky timing waveforms.

BSD nanosleep() suspends execution of the calling thread. Danke,

Oh I know it is fairly complex and it is widely used in consumer stuff, people watch videos on it etc. I just don't see that sort of thing in the kind of products you seem to be doing. But then if it is the easiest way to do things and you find it stable enough why not.

I was talking of something like the PPC timebase register, it is a free running 64 bit counter. If they have something like that you could timestamp events using some IRQ, the jitter you would get would depend mostly on the IRQ latency then. But I am really no ARM person.

The RasPi 4 is a very nice machine. The CM4 even more so if only you could buy one at the moment. The CM4 has a PCI-e interface which gives lots of possibilities. The Beaglebone Black is also good, but it has less RAM than the Raspi 4 and only has a 100Mbit/s ethernet port whereas the PI 4 has 1Gbit/s. The extra processors do allow time critical software to be written though.

There are add-on modules with real time clock chips for the Pi and the BBB.

Alternatively, look at the RasPi pico board or the RP2040 microcontroller which it uses. Both of these have the big advantage that they can be bought in large quantities at the moment. The RP2040 has multiple programmable state machines which allow very complex i/o operations with precise timing. There are also multiple counter-timer modules. It is a two-core ARM M0+. Finally, don't forget the XMOS devices, many of which support USB and/or ethernet together with deterministic timing and multiple cores. John

for _atleast_ the time you requested, have you tried looking at the actual signals you get?

anyway, that doesn't help for reacting and timing external signals

Did you overlooked the iic part of my original followup up there? ^^^ My RPi Apps use nanosleep to react to and time external Inter-Integrated Circuit signals. ...

OK, maybe you're supposed to say i2c instead of iic. Danke,

afaik it has a 64 bit system timer that always runs at 1MHz

you are generating signals, not reacting and measuring. That easy you just burn cycles while waiting and iic will work just fine with milli second timing ...

How is nanosleep going to help if you want to time when and for how long and external signal it asserted?

mandag den 18. juli 2022 kl. 23.37.57 UTC+2 skrev John Larkin:

you'll need an FPGA or at least an mcu with a capture timer

how about an RP2040 ? with two 133MHz M0+ and fancy HW statemachines it has plenty of horsepower to do it spit out result on spi/uart or what ever

in all cars that how the ECU figure out the engine position

one everything Bosch like your Audi it is 60 minus 2 teeth

At the resolution of the thread scheduler.

Cheers

Phil Hobbs

<snip>

You need to generate and interpret signals with nano second timing to use i2c. Here's a power-on code snippet from my App:

/* Initialize when power supply conditions are not met: */ nSleep (15000000L); /* Wait 15 ms, 15000000 ns */ iicWrite(0x00); /* RS=Instruction; RW=Write; */ nSleep (40L); /* Wait 40 ns */ iicWrite(0x34); /* E; DB5=Function Set; DB4=8-bit */ nSleep (230L); /* Wait 230 ns */ Danke,

it doesn't time the input from an external event...

and if you changed 40ns to 10ms I suspect it wouldn't change a thing

The timing diagram says something different... Danke,