Double pulse generation

Question

I want to generate a double pulse with an initial delay of 50us (initial delay is power-up delay time for the gate driver IC.) The first pulse should be of 1.2 micro seconds and then off for 0.7 microseconds and then the second pulse for 0.6 microseconds then forever off. Can it be done with an Arduino Uno? It is the input for the gate driver.

Please tell how to generate it with these decimal microseconds time periods. 5% tolerance to the timings is fine.

Answer 1

After collecting additional information, the answer to your question "Can it be done with an Arduino Uno?" is:

Generally, no; in certain cases, yes.

Why is this?

An Arduino Uno runs at 16 MHz, executing most instructions in 62.5ns. Even if you control an output pin with carefully crafted assembly, you cannot get finer resolution.

Your tolerance is 5%, used for the shortest time value of 0.6µs this gives 5% * 0.6µs = 5% * 600ns = 30 ns. This is less than the half of the possible resolution.

As you found out, you can reach the required times with some deviation:

Required time	# of clocks	Achieved time	Deviation circa
0.6µs	10	0.625µs	+4%
0.7µs	11	0.6875µs	-2%
1.2µs	19	1.1875µs	-1%

But this is quite coincidental, and I suspect the 5% to be hand-waved.

You might get away with hand-crafted assembly. Use nop and out P, r instructions, they take one clock each. If you like, you can alternatively use sbi P,b and cbi P,b, respectively, which take two clocks.

---

Additionally you require a power-up delay, but the Uno has no reference to the power-up. If you power the Uno together with the driver, please note that the start-up time of the Uno and its sketch is commonly much longer than 50µs.

This does not even take power rise time into account.

---

For a correct^TM solution you need to invent another approach. Since there are many different ways to solve your task, which depend on more requirements we don't know, you are the one to research and check.

Answer 2

This is just rough estimate of how to do it and just to give you an idea of how much finer you can get with arduino. The best way to do it is to use the FPGA.

There is no built in function to provide a delay of less that one microsecond. So if you want fractional delay, you can use some processor operations to create the delay. On a 16 MHZ AVR, I believe each assembly language "nop" statement will give you 62.5 ns of delay.

void setup() {

  digitalWrite(outPin, LOW); 
  delayMicroseconds(50);      
  digitalWrite(outPin, HIGH); 
  delayMicroseconds(1);
  __asm__ __volatile__ (
  //200ns approximately (3 * 62.5ns = 195ns)
    " nop\n"
    " nop\n"
    " nop\n"
  ); 

  digitalWrite(outPin, LOW); 
  //700ns approximately (11 * 62.5ns = 687ns)
  __asm__ __volatile__ (
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
  ); 


  digitalWrite(outPin, HIGH); 
  //600ns approximately (9 * 62.5ns = 562ns)
  __asm__ __volatile__ (
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
    " nop\n"
  ); 

  digitalWrite(outPin, LOW); 

}

The nop assembly language command means "do nothing" but in fact it takes a very short period to do that nothing, hence provides a very short delay before the code continues. Two nop commands in succession take twice as long to execute but the delay in code execution is still very small.

Update: Also you might have to do some calibrations (add/remove nops) if delay is longer or shorter. Also I have not included the delay of statements like digitalWrite.