1. Practical example of C programming
Additional Lecture on C
Uli Raich
Course on Embedded Systems
UCC semester end 2017

2. C is too abstract?
Dompreh tells me you find the course on C too abstract!
What is is good for?
What are pointers good for?
Why use command line arguments?
What has all this to do with embedded systems?
Can I use it for my Physics experiments?

3. A pulse generator
A pulse generator is a device you use to test your electronics (e.g. electronics to read out an experiment which generates electronic signals
On a professional pulse generator you can:
change the wave form
sine, rectangular, triangular, sawtooth, arbitrary user defined wave form
change the frequency
change the pulse height
change rise and fall times
and many parameters more

4. The oscilloscope
Before using the signal from the pulse generator you observe the signal on an oscilloscope
How does an oscilloscope work?
What is
vertical gain
time base
auto versus normal, external, single trigger
trigger level and trigger position

5. A standard oscilloscope
A standard digital storage oscilloscope uses
a very fast (GHz) analogue to digital converter (ADC)
plenty of knobs and buttons to select
gain, timebase, trigger parameters …
a screen to display the input signal
Price: ~ 5kUS$ - 50kUS$
I have a 60 US$ oscilloscope (not useful for professional applications but ok for the slow signals we produce with our electronics) featuring
2 input channels
40 MHz sampling rate (20 MHz band width)
No screen
USB connection to a computer

6. Oscilloscope Example

7. Our pulse generator Let us create our own pulse generator!
It should provide
sine wave
rectangular wave
What do we need?
A table of numerical values that describes the wave form
A digital to analogue converter (DAC) to convert the numbers into a signal level.

8. The DAC
We have a 12 bit DAC, which creates signal levels from 0V to Vcc
What is the max. number this DAC can take in decimal and in hex?
What is the signal resolution in ‰
This is physics!

9. DAC access The DAC has 3 registers with the following bit layout:
register 0 takes the lowest 4 bits of the DAC value
register 1 takes the middle 4 bits
register 2 takes the highest 4 bits
RS selects the register
The strobe line (STR) must pulse (go high and low again) to read/ write the data (R/W line) from/to the DAC
What is the bit combination and sequence to write the middle 4 bits with the data 0xa
STR RS
R/W d3 d2 d1 d0

10. Breaking down the problem
Even though this will be still a very small and simple program, let’s break it down into smaller pieces:
Get the wave form from the user through command line arguments
Create the wave form within a table of short (16 bit) values. The upper 4 bits will always be zero
Function to write all 12 data bits to the DAC

11. Check the number of cmd line args
Write a piece of code that checks that the user has entered 1 arguments
The program prints a “Usage” message and exits if the no of arguments given by the user is not exactly 1

12. Solution: arg count

13. Argument Check
If the no of args is correct we have to check if the argument given is either
“sine”
or “rect”
To do this we need a string compare function:
int strcmp(const char *s1, const char *s2)
This function returns zero if the 2 strings match
You must include <string.h> to use this function

14. Check the argument
Improve your program to include a check if the argument given is “sine” or “rect”.
Print an error message it it is not and a success message if it is.

15. Solution: argument check

16. Creating the wave form
As we said, the DAC takes 12 bit values which can be stored in an array of short (16 bits)
The upper 4 bits of each element will be zero
The generation of the waveform goes into a separate source file and its associated include file
I give you the example for the sine wave and you write the code for the rectangular wave

17. Function test First we create the framework We will need:
the function itself (genWave.c)
an include file describing it (genWave.h) and containing definitions needed by it and useful to the calling program
a main routine (createWaveForm.c) to call it

18. Write the Test function
Write a test function (genWaveTest.c) taking one argument (the wave type) and printing which wave type has been selected.
Which definitions should go into the include file?
How do you have to modify the main program to call the genWave function?

19. Dummy function and test (main)

20. The include file

21. The test function

22. Implementing the function

23. Was it correct?

24. The rectangular wave form
Write the code for the generation of the rectangular wave form.
The signal should be zero for the first 50 values of the wave, 4095 for the following 50 values

25. Solution: Rectangular wave

26. The rectangular wave form

27. Bit handling functions
We need to learn a few bit handling functions before being able to prepare the data for the DAC:
| : bitwise or
& : bitwise and
data += 5 <=> data = data + 5
data |= 5 <=> data = data | 5
~data: invert all bits in data
data >> 4 all bits in data are shifted right by 4
data << 4 all bits in data are shifted left by 4

28. Preparing data for the DAC
Remember the bit layout of the DAC register?
We must write the lowest significant, medium significant and highest significant bits separately
We must “or” in the register select bits and read/write bits (write is usually active low)
We must strobe in the data (a pulse on the strobe bit)
STR RS
R/W d3 d2 d1 d0

29. DAC preparation Write a function which prepares a byte for the DAC
The functions takes 3 arguments:
The data nibble (4 bits of data)
The register selection (0,1,2)
The read/write bit
Leave the strobe bit zero!
What will be the result if you want to write 5 to register to the middle nibble?

30. Solution: DAC preparation
First the include file:

31. Now the test program

32. Strobe
Now create a strobe function which takes DAC data and generates a strobe signal on the
STR line without touching the other bits

33. Solution: Strobe

34. Send one short value to the DAC
Now that we know how to strobe it is easy to write a 12 bit value to the DAC
We must do it in 3 steps:
and out all the bits in the data word except the last 4 (first data nibble)
“or” in the rw and register bits (must be reg 0! )and send the dataByte to strobe
Shift the data word by for bits and do the same thing (now the register bits must be 1 of course)
Shift again by 4 bits and repeat

35. Solution: send one data word

36. ...and the test program for it

37. … with the result

38. Assembling the whole thing
Now we have all the bits and pieces and finalizing the project becomes easy.
In the file accessing the hardware we add:
and we call this in main.

39. And this is the final result