Objective

This example includes several simple examples of the Configurable Custom Logic (CCL) using the SAM L21 Xplained Pro Development Board.

 Materials

Hardware Tools

SAM L21 Xplained Pro

Software Tools

Tool	‍ About	Installers			‍ Installation Instructions
		‍ Windows	‍ Linux	‍ Mac OSX
Atmel® Studio Integrated Development Environment	‍	‍	‍	‍	‍

Exercise Files

File	Download			‍ Installation Instructions
	‍ Windows	‍ Linux	‍ Mac OSX
‍ Project and Source Files	‍	‍	‍	‍

Additional Files

Files
‍ SAM L21 Xplained Pro User Guide

 Procedure

There are several simple projects shown in this training and all require the same initial setup. You can select the various configurations by entering the ID number of the desired configuration through the Universal Asynchronous Receiver Transmitter (UART). Additionally, (by uncommenting two lines in main) you can sequence through the configuration by pushing SW0. The Debug UART is used both for this operator entry as well as to output the ID of the present configuration. The program is structured to easily allow more demo configurations to be added. Currently, all the project configurations are in system_saml21.c; the specific function names are listed with each project description below.

Setup for all Projects

The following table describes the peripherals, signals, and GPIO where signals can be viewed.

Another way to understand the setup is to look at it graphically routed through the Event System depicted below.

Some items worth noting:

1. Neither Channel 2 or 4 have input events. This is because we are only triggering them by the SW command when we want to start the two groups of timers.
2. Channels 0,1, and 3 are used simply to bring events out to pins.
3. The Port module in the upper right works as follows:
   • Any PORT event can select any Event system channel(s) as its input.
   • Any Port Event can select any GPIO on the part (only one at a time, though).
   • A given GPIO can be driven by up to four events, each with different actions if desired. See the spec for the priority of simultaneous incoming events.
   • GPIO actions taken on an incoming event from its PORT event include:
     1. Pass the event through unchanged. This option has zero latency. We use this option twice - for the PER0 and the LUT3 output.
     2. Set pin.
     3. Clear pin.
     4. Toggle pin. We use this option once – for the PER7 output.

Project Demo 0

This project demonstrates ANDing two GPIO signals and putting the result out to two different GPIOs. Specifically, we are:

• Bringing in a 1/2 Hz square wave and output of SWO. These feed IN[0] and IN[1], respectively of LUT3.
• The truth table is set up to AND these signals.
• The ANDed result is sent to two places:
  1. The only GPIO eligible for the “LUT 3 OUT” signal (PB17).
  2. The GPIO that drives LED0 on the Xplained PRO board. The internal routing is via Event System (EVSYS) Channel 3. This step demonstrates how to extend LUT outputs to any pin on the part.

Function: void init_CCL_LUT3_to_AND_GPIOs(void)

Everything is handled with one custom function void init_CCL_LUT3_to_AND_GPIOs(void).
The function performs the following steps:

1. Set up the synchronous clock to CCL
2. Set up pins designated as inputs to LUT (see data sheet “Table 7-1. PORT Function Multiplexing”) in the PORT - I/O Pin Controller fields
3. Disable LUT and CCL
4. For two inputs of LUT, configure IO pins as input
5. Disable the sequential logic
6. Set the truth table to AND input from PER7 signal with SWO input with the third input to the LUT masked
7. Enable the EVENT Output of LUT
8. Set up the Event Channel to take in the LUT OUT signal
   • Set up the synchronous clock to EVSYS
   • Set up the asynchronous clock to EVSYS Channel you plan to use (each channel picks its own asynchronous clock)
   • Have one of the EVSYS channels select the LUT OUT signal
   • Enable one of the EVSYS channels as asynchronous
9. Set up EV OUT2 signal from Event System to drive PB10
10. Set GPIO connected to LED0 to select the EVOUT signal
11. Have an EV OUT signal select the event channel fed by the LUT

Observation:

1. Button is blinking on/off at a 1 Hz rate with button-up.
2. Push button down and LED0 stops blinking and holds its state.

Project Demo 1

This project demonstrates the effect of an Edge Detector on the LUT output. It processes identical inputs with and without Edge Detection and outputs it to GPIO.

Function: void init_CCL_edge_detect_demo(void)

Everything is handled with one custom function void init_CCL_edge_detect_demo(void)
The function configures the following:

1. Synchronous and asynchronous clocks for the CCL are set up as in example ID 0.
2. Set up three LUTs with identical inputs. Each LUT takes in two Pulse Width Modulation (PWM) signals, one generated by a Timer Clock (TC) and the other generated by a Timer Counter for Control Applications (TCC).
3. The TCs (TC0/1/2) are set up identically with their start times synchronized.
4. Similarly, the three TCCs (TCC0/1/2) are set up identically (although at a lower frequency and duty cycle than the TCs) with their start times synchronized as well.
5. The TCs and TCCs are NOT synchronized with each other. This is to show the effect on the output of using asynchronous inputs.
6. The difference between the three LUTs is that the Truth table and the Edge Detection controls are set up as:

Scope Probe points:

Observations:

1. Output of LUT0 represents the ANDing of two internal signals and outputting the result to one of the LUTs output pins. No Edge detection is enabled.
2. Outputs of LUT1 and LUT2 are 125 ns wide pulses (due to 8 MHZ clock supplied to the CCL) at leading and trailing edges, respectively, of 380 ns wide pulses from LUT0.

Since the filter is not enabled for any of the LUT outputs, and the TC and TCC inputs to any given LUT are asynchronous to each other, we can get both a variable number of pulses and runt pulses (one is circled below on the LUT0 output).

Project Demo 2

This project demonstrates synchronizing two channels.

Function: void init_CCL_synchronize_channels_demo(void)

Everything is handled with one custom function:
void init_CCL_synchronize_channels_demo(void)

Configuration: Steps 1-4 are the same as with Project Demo 1 (same inputs to all channels) but now two of the channels are put through the synchronizer.

1. Synchronous and asynchronous clocks for the CCL are set up as in example ID 0.
2. Set up three LUTs with identical inputs. Each LUT takes in two PWM signals, one generated by a TC and the other generated by a TCC.
3. The TCs (TC0/1/2) are set up identically with their start times synchronized.
4. Similarly, the three TCCs (TCC0/1/2) are set up identically (although at a lower frequency and duty cycle than the TCs) with their start times synchronized as well.

Scope Probe points:

Observations:

1. Outputs of LUT1 and LUT2 are always synchronized with each other.
2. With the synchronizer/filter is enabled, the output will be delayed by two to five GCLK cycles.

Project Demo 3

This project demonstrates the effect of filtering on LUT output.

Function: void init_CCL_filter_demo (void)

Everything is handled with one custom function:
: void init_CCL_filter_demo (void))

Steps 1-4 are the same as with Project Demo 2 (same inputs to all channels) but now, rather than using edge detection, we enable different synchronizing/filtering options in each channel to show the effect on both runt pulses and throughput delay.

1. Synchronous and asynchronous clocks for the CCL are set up as in example ID 0.
2. Set up three LUTs with identical inputs. Each LUT takes in two PWM signals, one generated by a TC and the other generated by a TCC.
3. The TCs (TC0/1/2) are set up identically with their start times synchronized.
4. Similarly, the three TCCs (TCC0/1/2) are set up identically (although at a lower frequency and duty cycle than the TCs) with their start times synchronized as well.

Specifically, the Truth table and Edge Detection controls for the LUT0,1, and 2 are set up as:

Scope Probe points:

Observations:

1. LUT0 (neither synchronized nor filtered) still has occasional runt pulses but no discernable throughput delay.
2. LUT1 (synchronized) (nothing only 1 GCLK in width) has a delay relative to the LUT0.
3. LUT2 no longer has any runt pulses is further delayed relative to LUT0.

Project Demo 4

This project demonstrates the effect of the event input by the built-in Edge Detection on SAML21. This edge detector is BEFORE the LUT.

Function: void init_CCL_event_input_demo(void)

Everything is handled with one custom function:
void init_CCL_event_input_demo(void)

1. Bring PER0 event into LUT0 (internally – no GPIO needed)
2. Configure truth table to put PER0 through without qualification (no gating with other signals, edge detection, synchronizing, or filtering)

Scope Probe points:

Observations:

1. Outputs of LUT (blue trace at the bottom) is the pulse of a single asynchronous clock width, regardless of the width of input pulse (in this case the yellow trace, which is part of an ~1 msec wide pulse).
2. Edge detector is always applied to Events coming into LUTs, even if the EDGESEL bit in control fields is set to 0.
3. This edge detector is before the LUT input and is distinct from that used at the output of the LUT (the one used in DEMO ID 1). The next two scope shots are obtained by setting the truth table to take in an event as high for the first plot and low for the next plot. Note that the pulse is triggered off the leading edge regardless.

 Conclusions

This series of projects will give you a better understanding of the CCL for any future projects that will benefit from code independent logic.