Transition from Standard C to Embedded C Programming

1. Characteristics of C Language

As a fundamental high-level programming language, C has evolved into various extensions. In embedded systems design, the primary enhancement involves hardware device drivers. This extension offers a more adaptable environment for application development. My understanding is that embedded C development involves shifting from desktop C to circuit-based C. The core concept revolves around register configuration, enabling various peripherals to connect directly with C (a high-level language), allowing them to perform distributed tasks.

2. Learning Objectives

Master basic C syntax (review if already learned, as most concepts have been forgotten). Understand embedded C design principles and be able to implement fundamental designs such as button handling, peripheral drivers, UART data transmission, and similar functionalities.

3. Practical Examples

The starting point for learning C remains: hello world

#include <stdio.h>
int main()
{
  printf("hello world");
  return 0;   
}

This approach also begins with hello world. External resource files are automatically imported by development tools, focusing primarily on source files (main function location). Let's examine the basic code:

#include <stdio.h>
#include "platform.h"
#include "xil_printf.h"
int main()
{
 init_platform();
 printf("hello world");
 clean_platform();
 return 0;
}<br></br>

The code now includes two new header files. The first is a workspace file, with the main function demonstrating its data usage. printf has been modified from console output to UART output, likely through xil_printf functionality. A few simple steps complete the transition from standard C to embedded C. It appears manageable. Zynq uses an ARM core, which naturally supports C. Indeed, C is among the most widely supported high-level languages. Other operations like calculations, character handling, and file processing should also be compatible. Future exploration is possible.

Consider another example:

#include <stdio.h>
#include "platform.h"
#include "xparameters.h"
#include "xscugic.h"
#include "xil_exception.h"
#include "xgpio.h"
#include <unistd.h> // usleep()
#include <stdbool.h> // bool
#define LED_DEVICE_ID XPAR_AXI_GPIO_1_DEVICE_ID
#define KEY_DEVICE_ID XPAR_AXI_GPIO_0_DEVICE_ID
XGpio LEDInst;
XGpio KEYInst;
u8 key_value_pre=0;
u8 key_value_now=0;
int main()
{
init_platform();
int status;
status = XGpio_Initialize(&KEYInst, KEY_DEVICE_ID); // initialize KEY
if(status != XST_SUCCESS) return XST_FAILURE;
status = XGpio_Initialize(&LEDInst, LED_DEVICE_ID); // initialize LED
if(status != XST_SUCCESS)return XST_FAILURE;
XGpio_SetDataDirection(&KEYInst, 1, 1); // set KEY IO direction as input
XGpio_SetDataDirection(&LEDInst, 1, 0); // set LED IO direction as output
XGpio_DiscreteWrite(&LEDInst, 1, 0x0);// initially turn off all LEDs
printf(">>> Press PL KEY1 ~ KEY4 one by one, and check the PL LED1 ~ LED4\n");
while(1)
{
usleep(100000); // 0.1s delay for debouncing, typical metastable states last less than 20ms
key_value_pre=key_value_now;
key_value_now= XGpio_DiscreteRead(&KEYInst, 1) & 0x0F;
XGpio_DiscreteWrite(&LEDInst, 1, key_value_now);
if(key_value_pre!=key_value_now) printf("key state changed!\n");
}
cleanup_platform();
return 0;
}

This code originates from Xiao Mao Xiong Classroom.

Note: This code runs on a specific hardware platform and cannot be ported elsewhere. This represents a trade-off required for flexibility. The choice between portability and flexibility depends on individual needs. The code complexity increases here, so let's analyze the header files (omitting those already covered):

xparameters.h: As the name suggests, it's a parameter definition library containing #define statements. This is familiar to anyone who has studied programming languages and doesn't require detailed explanation. Note the preceding # symbol.

xscugic.h: Likely a library required for u8 declarations.

xil_exception.h: A Xilinx-specific extension package, explained further in syntax.

xgpio.h: Appears to define GPIO ports.

unistd.h: Contains the usleep delay function.

stdbool.h: Required library for boolean variables.

In the main program execution, C follows sequential execution - don't forget this when coming from Verilog.

The initialization function init_platform(); serves as the standard beginning.

Examining the XGpio_Initialize function, the first argument is the address of an XGpio variable, and the second is the AXI bus assigned address. Together, they convert AXI-GPIO IP core signals into macros (or structures) and initialize them. An int variable stores the status to verify bus validity.

The while loop is easier to understand. It stores previous and current states, compares them, and outputs via UART if different. LED outputs follow key changes.

The main challenge lies in struct declaration requiring hardware design knowledge for allocated addresses and familiarity with various XGpio access functions.

This aspect may require dedicated time investment for C developers.