Detailed explanation of the method steps of C language in programming a variety of embedded systems

C language is a general-purpose computer programming language that is widely used. The C language is designed to provide a programming language that can be easily compiled, processed with low-level memory, generated with a small amount of machine code, and run without any runtime environment support.

Although the C language provides many low-level processing functions, it still maintains good cross-platform features. The C language program written in a standard specification can be compiled on many computer platforms, even including some embedded processors ( MCU) and supercomputer and other operating platforms.

In the 1980s, in order to avoid differences in the C language grammar used by various developers, the National Bureau of Standards established a complete set of international standard grammar for the C language, called ANSI C, as the initial standard of the C language.

C language embedded system programming considerations

Different from the general form of software programming, embedded system programming is built on a specific hardware platform, which is bound to require its programming language to have strong hardware direct operation capability. Undoubtedly, assembly language has such qualities. However, due to the complexity of the assembly language development process, it is not a general choice for embedded system development. In contrast, the C language, a "high-level, low-level" language, is the best choice for embedded system development. In the development process of embedded system project, the author feels the exquisiteness of C language again and again, and indulges the convenience brought by C language to embedded development.

The hardware platform of most embedded systems. It consists of two parts:

(1) A general-purpose processor-centric protocol processing module for processing network control protocols;

(2) A digital signal processor (DSP)-centric signal processing module for modulation, demodulation, and digital/analog signal conversion.

The discussion in this article focuses on general-purpose processor-centric protocol processing modules because it involves more specific C programming skills. DSP programming focuses on specific digital signal processing algorithms, mainly related to the field of communication, and is not the focus of this article.

Focusing on the discussion of common embedded system C programming skills, the system's protocol processing module does not choose a special CPU, but chooses the well-known CPU chip --80186. Every reader who has studied "Microcomputer Principle" should The chip has a basic understanding and is familiar with its instruction set. The word length of the 80186 is 16 bits, and the memory space that can be addressed is 1MB, only the real address mode. The pointer generated by C language compilation is 32 bits (double word), the upper 16 bits are segment addresses, and the lower 16 bits are compiled in segments, and a segment is up to 64 KB.

The FLASH and RAM in the protocol processing module are almost all necessary equipment for each embedded system. The former is used to store programs, while the latter is used to store instructions and data storage locations. The FLASH and RAM selected by the system have a bit width of 16 bits, which is consistent with the CPU.

The real clock chip can be timed for the system, giving the current year, month, day and specific time (hours, minutes, seconds and milliseconds). It can be set to give an interrupt to the CPU or set the alarm time when the time comes. The CPU proposes an interrupt (similar to the alarm function).

NVRAM (Non-Volatile Detachable RAM) has the feature of power-down without losing data, and can be used to save system setup information, such as network protocol parameters. The previous setup information can still be read after the system is powered down or restarted. Its bit width is 8 bits, which is smaller than the CPU word length. The article deliberately chooses a memory chip that is inconsistent with the CPU word length, creating conditions for the discussion in the next section.

The UART completes the conversion of CPU parallel data transmission and RS-232 serial data transmission. It can send an interrupt to the CPU after receiving [1~MAX_BUFFER] bytes. MAX_BUFFER stores the maximum buffer of the received byte for the UART chip.

The keyboard controller and display controller complete the control of the system man-machine interface.

The above provides a more complete embedded system hardware architecture, the actual system may contain fewer peripherals. The reason why we choose a complete system is to discuss all aspects of embedded system C language programming skills in a more comprehensive way. All the equipment will become the analysis target of the following.

Embedded systems require good software development environment support. Because the target system resources of embedded systems are limited, it is impossible to build a large and complex development environment on them, so the development environment and target operating environment are separated from each other. Therefore, the development method of the embedded application software is generally to establish a development environment on the host (Host), perform application coding and cross-compilation, and then the host establishes a connection with the target (Target), and downloads the application to the target machine. Cross-commissioning, debugging and optimization, and finally the application is solidified to the actual operation of the target machine.

CAD-UL is an embedded application software development environment for x86 processors. It runs on top of the Windows operating system and can generate object code for x86 processors and pass the COM port (RS-232 serial port) or Ethernet of the PC. The port is downloaded to the target machine to run. The monitor program resident in the FLASH memory of the target machine can monitor the user debugging instructions on the host Windows debugging platform, and obtain the value of the CPU register, the storage space of the target machine, and the content of the I/O space.

The following chapters will explain the programming skills of the C language embedded system from the aspects of software architecture, memory operation, screen operation, keyboard operation, performance optimization and so on. Software architecture is a macro concept, and has little connection with specific hardware; memory operation mainly involves FLASH, RAM and NVRAM chips in the system; screen operation involves display controller and real clock; keyboard operation mainly involves keyboard controller; performance optimization Then give some specific techniques to reduce program time and space consumption.

There will be 25 passes in our cultivation journey. These gates are divided into two categories, one is skill type and has strong applicability; the other is common sense type, which has some meaning in theory.

So, let's go.

C language embedded system programming considerations software architecture articles

The "plan" of the module division is the meaning of planning, which means how to reasonably divide a large software into a series of functionally independent parts to complete the system.

Module division

The "plan" of the module division is the meaning of planning, which means how to reasonably divide a large software into a series of functionally independent parts to complete the system. As a structured programming language, C language mainly depends on functions in the division of modules (division according to function becomes an error in object-oriented design, Newton's law encounters relativity), C language modular programming needs to be understood as follows concept:

(1) The module is a combination of a .c file and a .h file. The header file (.h) is a declaration for the interface of the module;

(2) The external functions and data provided by a module to other modules must be declared with the extern keyword in the file in .h;

(3) The functions and global variables in the module must be declared with the staTIc keyword at the beginning of the .c file;

(4) Never define variables in the .h file! The difference between defining a variable and declaring a variable is that the definition creates an operation for memory allocation, which is the concept of the assembly phase; the declaration simply tells the module containing the declaration to look for external functions and variables from other modules during the connection phase. Such as:

/*module1.h*/

Int a = 5; /* defines int a */ in the .h file of module 1.

/*module1 .c*/

#include "module1.h" /* Contains module #'s .h file in module 1*/

/*module2 .c*/

#i nclude “module1.h” /* contains the .h file of module 1 in module 2*/

/*module3 .c*/

#i nclude "module1.h" /* Contains module #'s .h file in module 3*/

The result of the above procedure is that the integer variables a are defined in modules 1, 2, and 3, and a corresponds to different address units in different modules. This kind of program is never needed in the world. The correct way is:

/*module1.h*/

Extern int a; /* declare int a */ in the .h file of module 1.

/*module1 .c*/

#i nclude “module1.h” /* contains module 1.h file* in module 1.

Int a = 5; /* defines int a * in the .c file of module 1.

/*module2 .c*/

#i nclude “module1.h” /* contains the .h file of module 1 in module 2*/

/*module3 .c*/

#i nclude "module1.h" /* Contains module #'s .h file in module 3*/

Thus, if modules 1, 2, and 3 operate a, they correspond to the same memory unit.

An embedded system usually consists of two types of modules:

(1) a hardware driver module, one specific hardware corresponding to one module;

(2) The software function module, the division of the module should meet the requirements of low coupling and high cohesion.

Multitasking or single task

The so-called "single task system" means that the system cannot support multi-task concurrent operations and performs a task in a macroscopic manner. Multitasking systems can perform multiple tasks "simultaneously" in a macroscopic parallel (possibly serially).

Multitasking concurrent execution typically relies on a multitasking operating system (OS). The core of a multitasking OS is the system scheduler, which uses task control blocks (TCBs) to manage task scheduling functions. The TCB includes information such as the current state of the task, priority, events or resources to wait, the start address of the task code, and the initial stack pointer. The scheduler uses this information when the task is activated. In addition, the TCB is also used to store the "context" of the task. The context of a task is all the information to be saved when an ongoing task is stopped. Usually, the context is the current state of the computer, that is, the contents of each register. When a task switch occurs, the context of the currently running task is stored in the TCB, and the context of the task to be executed is taken from its TCB and placed in each register.

Typical examples of embedded multitasking OS are Vxworks, ucLinux, and so on. Embedded OS is not an unreachable altar. We can use a less than 1000 lines of code to implement a simpler OS kernel for the 80186 processor. The author is preparing for this work, hoping to contribute to everyone. .

Whether to choose multi-tasking or single-tasking, depends on whether the software system is huge. For example, most mobile phone programs are multi-tasking, but some PHS protocol stacks are single-tasking. Without an operating system, their main programs take turns to call the processing programs of various software modules to simulate a multi-tasking environment.

Single task program typical architecture

(1) Execute from the specified address at the time of CPU reset;

(2) Jump to the assembly code startup to execute;

(3) Jump to the main program of the user main program, complete in main:

a. Initially test each hardware device;

b. Initialize each software module;

c. Enter the infinite loop (infinite loop), call the processing function of each module

The user main program and the processing functions of each module are completed in C language. The user's main program finally enters an infinite loop, and its preferred solution is:

While(1)

{

}

Some programmers write this:

For(;;)

{

}

This grammar does not exactly express the meaning of the code. We can't see anything from for(;;), only to understand that for(;;) means unconditional loop in C language to understand its meaning.

Here are a few "famous" infinite loops:

(1) The operating system is an infinite loop;

(2) WIN32 program is an infinite loop;

(3) Embedded system software is an infinite loop;

(4) The thread processing function of a multithreaded program is an infinite loop.

You may argue and say out loud: "Everything is not absolute. 2, 3, and 4 are not infinite loops." Yes, you are right, but you can't get flowers and applause. In fact, this is a point that doesn't make much sense, because the world never needs a WIN32 program that calls the OS to kill it after processing a few messages. It doesn't need an embedded system that just breaks itself when it starts RUN. You don't need to start somehow to get rid of your own thread. Sometimes it is not convenience but trouble to make too strict. Never seen, the five-layer TCP/IP protocol stack goes beyond the rigorous ISO/OSI seven-layer protocol stack to become the de facto standard?

There are often netizens discussing:

Printf("%d,%d",++i,i++); /* What is the output? */

c = a+++b; /* c=? */

And so on. In the face of these problems, we can only express our heartfelt feelings: there are still many meaningful things in the world waiting for us to digest the food we eat.

In fact, embedded systems have to run to the end of the world.

Interrupt service routine

Interrupts are an important part of an embedded system, but do not include interrupts in Standard C. Many compiler developers have added support for interrupts on standard C, providing new keywords for signing interrupt service routines (ISRs), similar to __interrupt, #program interrupt, and so on. When a function is defined as an ISR, the compiler automatically adds the interrupt on-site stacking and popping code required by the interrupt service routine for the function.

The interrupt service routine needs to meet the following requirements:

(1) cannot return a value;

(2) The parameters cannot be passed to the ISR;

(3) The ISR should be as short as possible;

(4) The printf(char * lpFormatString,...) function introduces reentrancy and performance issues and cannot be used in ISR.

In the development of a project, we designed a queue. In the interrupt service program, we just add the interrupt type to the queue. In the infinite loop of the main program, we continuously scan the interrupt queue for interrupts. The first interrupt type is processed accordingly.

/* Store interrupted queues*/

Typedef struct tagIntQueue

{

Int intType; /* interrupt type */

Struct tagIntQueue *next;

}IntQueue;

IntQueue lpIntQueueHead;

__interrupt ISRexample ()

{

Int intType;

intType = GetSystemType();

QueueAddTail(lpIntQueueHead, intType);/* Add a new interrupt at the end of the queue*/

}

Determine if there is an interruption in the main program loop:

While(1)

{

If( !IsIntQueueEmpty() )

{

intType = GetFirsTInt();

Is switch(intType) /* very similar to the message parsing function of a WIN32 program? */

{

/* Yes, our interrupt type resolution is very similar to message driver*/

Case xxx: /* We call it "interrupt drive"? */

...

Break;

Case xxx:

...

Break;

...

}

}

}

The interrupt service program designed as described above is small, and the actual work is performed by the main program.

The "plan" of the module division is the meaning of planning, which means how to reasonably divide a large software into a series of functionally independent parts to complete the system.

Hardware driver module

A hardware driver module should usually include the following functions:

(1) Interrupt service program ISR

(2) Hardware initialization

a. Modify the register, set the hardware parameters (such as the UART should set its baud rate, AD / DA equipment should set its sampling rate, etc.);

b. Write the interrupt service routine entry address to the interrupt vector table:

/* Set the interrupt vector table */

m_myPtr = make_far_pointer(0l); /* returns a void far pointer void far * */

m_myPtr += ITYPE_UART; /* ITYPE_UART: uart interrupt service routine */

/* Offset from the first address of the interrupt vector table */

*m_myPtr = &UART _Isr; /* UART _Isr: Interrupt Service Routine for UART*/

(3) Set the CPU control line for the hardware

a. If the control line can be used for PIO (programmable I/O) and control signals, set the corresponding register in the CPU as a control signal;

b. Set the interrupt mask bit for the device inside the CPU and set the interrupt mode (level trigger or edge trigger).

(4) Provide a series of operational interface functions for the device. For example, for an LCD, the driver module should provide functions such as drawing pixels, drawing lines, drawing a matrix, and displaying a character dot matrix; for a real clock, the driver module needs to provide functions such as acquisition time and set time.

Object-oriented C

In the object-oriented language, the concept of a class appears. A class is a collection of specific operations on a particular piece of data. A class contains two categories: data and operations. The struct in C is just a collection of data. We can use function pointers to simulate a struct as a "class" containing data and operations. The following C program simulates one of the simplest "classes":

#ifndef C_Class

#define C_Class struct

#endif

C_Class A

{

C_Class A *A_this; /* this pointer*/

Void (*Foo)(C_Class A *A_this); /* Behavior: function pointer */

Int a; /* data*/

Int b;

};

We can use C language to simulate three object-oriented features: encapsulation, inheritance and polymorphism, but more often, we just need to encapsulate data and behavior to solve the problem of software structure confusion. The purpose of C-simulating object-oriented thinking is not to simulate the behavior itself, but to solve the problem that the overall framework structure of the program is scattered, data and functions are disconnected when programming in C language in some cases. We will see examples of this in the following chapters.

to sum up

This article introduces the knowledge of embedded system programming software architecture, including module partitioning, multitasking or single task selection, single task program typical architecture, interrupt service program, hardware driver module design, etc., which gives an embedded macroscopically. The main elements of the system software.

Remember: the software structure is the soul of the software! The confusing procedures are extremely difficult, and debugging, testing, maintenance, and upgrading are extremely difficult.

C language embedded system programming considerations memory operation

In the programming of embedded systems, it is often required to read and write content in a specific memory unit, and assemble corresponding MOV instructions, and the programming languages ​​other than C/C++ have no direct access to absolute addresses.

Data pointer

In the programming of embedded systems, it is often required to read and write content in a specific memory unit, and assemble corresponding MOV instructions, and programming languages ​​other than C/C++ have basically no direct access to absolute addresses. In the actual debugging of the embedded system, the C-language pointer has the ability to read and write the contents of the absolute address unit. Direct manipulation of memory with pointers occurs in the following situations:

(1) An I/O chip is located in the storage space of the CPU instead of the I/O space, and the register corresponds to a specific address;

(2) The two CPUs communicate with each other in a dual port RAM, and the CPU needs to write content in a specific unit (called a mail box) of the dual port RAM to generate an interrupt in the other CPU;

(3) Read Chinese characters and English fonts burned in specific units of ROM or FLASH.

for example:

Unsigned char *p = (unsigned char *)0xF000FF00;

*p=11;

The meaning of the above program is to write 11 at the absolute address 0xF0000 + 0xFF00 (80186 uses a 16-bit segment address and a 16-bit offset address).

When using an absolute address pointer, be aware that the result of the pointer incrementing and decrementing operation depends on the data type pointed to by the pointer. The result of p++ in the above example is p = 0xF000FF01, if p points to int, ie:

Int *p = (int *)0xF000FF00;

The result of p++ (or ++p) is equivalent to: p = p+sizeof(int), and the result of p-(or -p) is p = p-sizeof(int).

Similarly, if executed:

Long int *p = (long int *)0xF000FF00;

Then the result of p++ (or ++p) is equivalent to: p = p+sizeof(long int) , and the result of p-(or -p) is p = p-sizeof(long int).

Remember: the CPU is addressed in bytes, and the C language pointer is incremented and decremented by the length of the data type pointed to. Understanding this is important for manipulating memory directly with pointers.

Function pointer

First understand the following three questions:

(1) The function name in C language directly corresponds to the address of the instruction code generated by the function in memory, so the function name can be directly assigned to the pointer to the function;

(2) The calling function is actually equivalent to "transfer instruction + parameter transfer processing + return position onto the stack". Essentially, the most core operation is to assign the first address of the target code generated by the function to the PC register of the CPU;

(3) Because the essence of the function call is to jump to the code of an address unit to execute, so you can "call" a function entity that does not exist at all, halo? Please look down:

Please take out any of the university's "Microcomputer Principles" textbooks that you can get. The book says that after the 186 CPU starts, it jumps to the absolute address 0xFFFF0 (corresponding to the C language pointer is 0xF000FFF0, 0xF000 is the segment address, 0xFFF0 is the segment Offset) Execution, please see the following code:

Typedef void (*lp) ( ); /* Defines a parameterless, no return type */

/* function pointer type */

Lp lpReset = (lp)0xF000FFF0; /* Define a function pointer to */

/* The position of the first instruction executed after the CPU is started*/

lpReset(); /* Call function */

In the above program, we didn't see any function entity at all, but we executed a function call like this: lpReset(), which actually acts as a "soft restart" and jumps to the first time after the CPU starts. The location of the instruction to be executed.

Remember: the function has no it, only the instruction set ear; you can call a function without a function body, essentially just start an instruction with another address!

Array vs dynamic application

Dynamic memory applications in embedded systems have stricter requirements than general system programming. This is because the memory space of embedded systems is often very limited. Inadvertent memory leaks can quickly lead to system crashes.

So be sure to ensure that your malloc and free pairs appear, if you write a program like this:

Char * (void)

{

Char *p;

p = (char *)malloc(...);

If(p==NULL)

...;

... /* A series of operations for p*/

Return p;

}

Call () somewhere, use the memory after the dynamic application, and then free it, as follows:

Char *q = ();

...

Free(q);

The above code is obviously unreasonable because it violates the principle that malloc and free appear in pairs, that is, the principle of "who applies, who releases it". Failure to satisfy this principle will result in increased code coupling because the user needs to know the internal details when calling the function!

The correct way is to apply for memory at the call and pass in the function as follows:

Char *p=malloc(...);

If(p==NULL)

...;

(p);

...

Free(p);

p=NULL;

The function receives the parameter p as follows:

Void (char *p)

{

... /* A series of operations for p*/

}

Basically, dynamic application memory can be replaced with a larger array. For programming novices, I recommend you try to use arrays! Embedded systems can receive flaws with a broad mind, and cannot be "Haina" errors. After all, Guo Jing, who has worked hard in the most stupid way, has surpassed Yang Kang, who is clever and intelligent, but who is politically wrong and takes the counter-revolutionary path.

Give the principle:

(1) Use arrays as much as possible, and arrays cannot be accessed across borders (the truth is one step beyond the delay, and the array is gloriously completes a chaotic embedded system).

(2) If you use the dynamic application, you must judge whether the application is successful after the application, and malloc and free should appear in pairs!

In the programming of embedded systems, it is often required to read and write content in a specific memory unit, and assemble corresponding MOV instructions, and the programming languages ​​other than C/C++ have no direct access to absolute addresses.

Keyword const

Const means "read only". The function of distinguishing the following code is very important, and it is also an old growth sigh. If you don't know the difference between them, and you have been crawling in the program world for many years, you can only say that this is a sad thing:

Const int a;

Int const a;

Const int *a;

Int * const a;

Int const * a const;

(1) The role of the keyword const is to convey very useful information to those who read your code. For example, adding a const keyword in front of a function's formal parameters means that this parameter will not be modified in the body of the function and is an "input parameter." When there are multiple formal parameters, the caller of the function can clearly distinguish which input parameters and which are the possible output parameters by means of whether there is a const keyword before the parameter.

(2) Proper use of the keyword const allows the compiler to naturally protect parameters that are not desired to be changed, preventing them from being modified by unintentional code, thus reducing the occurrence of bugs.

Const contains a richer meaning in the C++ language, but in the C language only means: "can only read ordinary variables", can be called "variables that cannot be changed" (this statement seems to be very vocal, but The most accurate expression of the essence of const in C language), the constants required in the compilation phase can still only be defined by #define macro! Therefore, the following procedures are illegal in C:

Const int SIZE = 10;

Char a[SIZE]; /* Illegal: Variables cannot be used in the compile phase */

Keyword volaTIle

The C compiler optimizes the code written by the user, such as the following code:

Int a,b,c;

a = inWord(0x100); /*Read the contents of the I/O space 0x100 port and store it in the a variable*/

b = a;

a = inWord (0x100); / * Read the contents of the I/O space 0x100 port again and store it in the a variable */

c = a;

Most likely it is optimized by the compiler to:

Int a,b,c;

a = inWord(0x100); /*Read the contents of the I/O space 0x100 port and store it in the a variable*/

b = a;

c = a;

However, such an optimization result may cause an error. If the contents of the 0/100 port of the I/O space are written by the other program after the first read operation, the content read by the second read operation is different from the first time. The values ​​of b and c should be different. Adding the volaTIle keyword before the definition of the variable a prevents similar optimizations of the compiler. The correct approach is:

Volatile int a;

The volatile variable may be used in the following situations:

(1) The hardware registers of the parallel device (such as the status register, the code in the example belongs to this class);

(2) Non-automatic variables (ie global variables) that are accessed in an interrupt service routine;

(3) Variables shared by several tasks in a multi-threaded application.

CPU word length is inconsistent with memory bit width

As mentioned in the background article, this paper deliberately chooses a memory chip that is inconsistent with the CPU word length, in order to solve the discussion in this section and solve the problem that the CPU word length and the memory bit width are inconsistent. The word length of the 80186 is 16, and the bit width of the NVRAM is 8. In this case, we need to provide NVRAM with an interface for reading and writing bytes and words, as follows:

Typedef unsigned char BYTE;

Typedef unsigned int WORD;

/* Function: Read bytes in NVRAM

* Parameter: wOffset, the offset of the read position from the NVRAM base address

* Return: the byte value read

*/

Extern BYTE ReadByteNVRAM(WORD wOffset)

{

LPBYTE lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* Why is the offset ×2? */

Return *lpAddr;

}

/* Function: Read the word in NVRAM

* Parameter: wOffset, the offset of the read position from the NVRAM base address

* Return: the word read

*/

Extern WORD ReadWordNVRAM(WORD wOffset)

{

WORD wTmp = 0;

LPBYTE lpAddr;

/* Read high byte */

lpAddr = (BYTE*)(NVRAM + wOffset * 2); /* Why is the offset ×2? */

wTmp += (*lpAddr)*256;

/* Read low byte */

lpAddr = (BYTE*)(NVRAM + (wOffset +1) * 2); /* Why is the offset ×2? */

wTmp += *lpAddr;

Return wTmp;

}

/* Function: Write a byte to NVRAM

*Parameter: wOffset, offset of the write position from the NVRAM base address

* byData, the byte to be written

*/

Extern void WriteByteNVRAM(WORD wOffset, BYTE byData)

{

...

}

/* Function: Write a word to NVRAM*/

*Parameter: wOffset, offset of the write position from the NVRAM base address

* wData, the word to be written

*/

Extern void WriteWordNVRAM(WORD wOffset, WORD wData)

{

...

}

Zigong asks: Why is the Why offset multiplied by 2?

Sub-æ›°: The interconnection between 16-bit 80186 and 8-bit NVRAM can only be connected to A0 by address line A1, and A0 of the CPU itself is not connected to NVRAM. Therefore, the address of NVRAM can only be an even address, so advance each time in units of 0x10!

Zigong asks again: So why is the address line A0 of the 80186 not connected to the A0 of the NVRAM?

This article mainly describes the related skills of memory operation in embedded system C programming. Mastering and understanding the relevant knowledge about data pointers, function pointers, dynamic application memory, const and volatile keywords is a basic requirement for an excellent C language programmer. When we have mastered the above techniques, we have learned 99% of the C language, because the essence of the C language is reflected in the memory operation.

The reason why we use C language for programming in embedded systems is 99% because of its powerful memory operation!

If you love programming, please love C language;

If you love C language, please love the pointer;

If you love the pointer, please love the pointer of the pointer!

C language embedded system programming notes screen operation

The problem to be solved now is that the embedded system often does not use a complete Chinese character library, and often only needs to provide a limited number of Chinese characters for the necessary display functions.

Chinese character processing

The problem to be solved now is that the embedded system often does not use a complete Chinese character library, and often only needs to provide a limited number of Chinese characters for the necessary display functions. For example, it is not necessary to provide a function of displaying "email" on the LCD of a microwave oven; a "short message" does not need to be displayed on an LCD of an air conditioner providing a Chinese character display function, and the like. However, a mobile phone and PHS usually need to include a more complete Chinese character library.

If the included Chinese character library is relatively complete, then it is quite simple to calculate the offset of the Chinese character font in the library from the inner code: the Chinese character library is arranged in the order of the location, the previous byte is the area code of the Chinese character, the latter The byte is the bit number of the word. Each zone records 94 Chinese characters, and the bit number is the position of the word in the zone. Therefore, the formula for calculating the specific position of Chinese characters in the Chinese character library is: 94* (area number-1) + bit number-1. The decrease of 1 is because the array starts with 0 and the area code starts with 1. Simply multiply the number of bytes occupied by a Chinese character font, that is: (94* (area number-1) + bit number -1) * A Chinese character font occupies the number of bytes, taking the 16*16 dot matrix font as an example. The calculation formula is: (94 * (area number - 1) + (bit number - 1)) * 32. The 32-byte information from the position in the Chinese character library records the font information of the word.

For systems that contain a more complete Chinese character library, we can calculate the position of the font using the above rules. But what if you only provide a small amount of Chinese characters? For example, tens to hundreds? The best practice is:

Define the macro:

# define EX_FONT_CHAR()

# define EX_FONT_UNICODE_VAL() (),

# define EX_FONT_ANSI_VAL() (),

Define the structure:

Typedef struct _wide_unicode_font16x16

{

WORD ; /* inner code */

BYTE data[32]; /* font dot matrix*/

}Unicode;

#define CHINESE_CHAR_NUM ... /* Number of Chinese characters*/

Array of font storage:

Unicode chinese[CHINESE_CHAR_NUM] =

{

{

EX_FONT_CHAR("业")

EX_FONT_UNICODE_VAL(0x4e1a)

{0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04, 0x44, 0x44, 0x46, 0x24, 0x4c, 0x24, 0x48, 0x14, 0x50, 0x1c, 0x50, 0x14, 0x60, 0x04, 0x40, 0x04, 0x40, 0x04 , 0x44, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00}

},

{

EX_FONT_CHAR ("Medium")

EX_FONT_UNICODE_VAL(0x4e2d)

{0x01, 0x00, 0x01, 0x00, 0x21, 0x08, 0x3f, 0xfc, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08, 0x21, 0x08,

0x3f, 0xf8, 0x21, 0x08, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00}

},

{

EX_FONT_CHAR ("cloud")

EX_FONT_UNICODE_VAL (0x4e91)

{0x00, 0x00, 0x00, 0x30, 0x3f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xff, 0xfe, 0x03, 0x00, 0x07, 0x00,

0x06, 0x40, 0x0c, 0x20, 0x18, 0x10, 0x31, 0xf8, 0x7f, 0x0c, 0x20, 0x08, 0x00, 0x00}

},

{

EX_FONT_CHAR ("piece")

EX_FONT_UNICODE_VAL(0x4ef6)

{0x10, 0x40, 0x1a, 0x40, 0x13, 0x40, 0x32, 0x40, 0x23, 0xfc, 0x64, 0x40, 0xa4, 0x40, 0x28, 0x40, 0x2f, 0xfe,

0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40, 0x20, 0x40}

}

}

To display a specific Chinese character, you only need to find the internal code from the array and the same required Chinese character code to get the font. If the preceding Chinese characters are arranged in the order of the inner code size in the array, the binary font search method can be used to find the font of the Chinese character more efficiently.

This is a very effective way to organize a small Chinese character library, which can ensure that the program has a good structure.

System time display

The time of the system can be read from the NVRAM. The system typically reads the current time every second and displays it on the LCD with the second interrupt generated by the NVRAM. There is an efficiency issue with regard to the display of time. Because time has its particularity, it is only one minute change in 60 seconds, and one hour change in 60 minutes. If we re-refresh the time on the screen every time, it will waste a lot of system. time.

A better approach is to store the hours, minutes, and seconds as static variables in the time display function, and update the display only when its content changes.

Extern void DisplayTime(...)

{

Static BYTE byHour,byMinute,bySecond;

BYTE byNewHour, byNewMinute, byNewSecond;

byNewHour = GetSysHour();

byNewMinute = GetSysMinute();

byNewSecond = GetSysSecond();

If(byNewHour!= byHour)

{

... /* shows hours*/

byHour = byNewHour;

}

If(byNewMinute!= byMinute)

{

... /* shows minutes*/

byMinute = byNewMinute;

}

If(byNewSecond!= bySecond)

{

... /* shows seconds*/

bySecond = byNewSecond;

}

}

This example can also be used as a proof of the power of the static keyword in C language. Of course, in the C++ language, static has a more powerful power, which makes some data and functions separate from the "object" and becomes part of the "class". It is this feature that has made countless excellent designs of software.

Animated display

The animation is indifferent, there is no such thing as it, and the still picture goes a lot, and it becomes an animation. As time changes, displaying different still images on the screen is the essence of animation. Therefore, in order to display animation on the LCD of an embedded system, it is necessary to use a timer. A world without hardware or software timers is unimaginable:

(1) Without a timer, an operating system will not be able to rotate the time slice, so multi-tasking scheduling cannot be performed, so it is no longer a multi-tasking operating system;

(2) Without a timer, a multimedia player software will not work because it does not know when it should switch to the next frame;

(3) Without a timer, a network protocol will not work because it cannot know when the packet transmission has timed out and retransmitted, and it is impossible to complete a specific task at a specific time.

因此，没有定时器将意味着没有操作系统、没有网络、没有多媒体，这将是怎样的黑暗？所以，合理并灵活地使用各种定时器，是对一个软件人的最基本需求！

在80186为主芯片的嵌入式系统中，我们需要借助硬件定时器的中断来作为软件定时器，在中断发生后变更画面的显示内容。在时间显示“xx:xx”中让冒号交替有无，每次秒中断发生后，需调用ShowDot：

void ShowDot（）

{

static BOOL bShowDot = TRUE; /* 再一次领略static关键字的威力*/

if（bShowDot）

{

showChar（'：'，xPos，yPos）;

}

Else

{

showChar（' '，xPos，yPos）;

}

bShowDot = ！ bShowDot;

}

菜单操作

无数人为之绞尽脑汁的问题终于出现了，在这一节里，我们将看到，在C语言中哪怕用到一丁点的面向对象思想，软件结构将会有何等的改观！

要求以键盘上的“← →”键切换菜单焦点，当用户在焦点处于某菜单时，若敲击键盘上的OK、CANCEL键则调用该焦点菜单对应之处理函数。我曾经傻傻地这样做着：

/* 按下OK键*/

void onOkKey（）

{

/* 判断在什么焦点菜单上按下Ok键，调用相应处理函数*/

Switch（currentFocus）

{

case MENU1：

menu1OnOk（）;

Break;

case MENU2：

menu2OnOk（）;

Break;

...

}

}

/* 按下Cancel键*/

void onCancelKey（）

{

/* 判断在什么焦点菜单上按下Cancel键，调用相应处理函数*/

Switch（currentFocus）

{

case MENU1：

menu1OnCancel（）;

Break;

case MENU2：

menu2OnCancel（）;

Break;

...

}

}

终于有一天，我这样做了：

/* 将菜单的属性和操作“封装”在一起*/

typedef struct tagSysMenu

{

char *text; /* 菜单的文本*/

BYTE xPos; /* 菜单在LCD上的x坐标*/

BYTE yPos; /* 菜单在LCD上的y坐标*/

void （*onOkFun）（）; /* 在该菜单上按下ok键的处理函数指针*/

void （*onCancelFun）（）; /* 在该菜单上按下cancel键的处理函数指针*/

}SysMenu， *LPSysMenu;

当我定义菜单时，只需要这样：

static SysMenu menuï¼»MENU_NUMï¼½ =

{

{

“menu1”， 0， 48， menu1OnOk， menu1OnCancel

}

,

{

“ menu2”， 7， 48， menu2OnOk， menu2OnCancel

}

,

{

“ menu3”， 7， 48， menu3OnOk， menu3OnCancel

}

,

{

“ menu4”， 7， 48， menu4OnOk， menu4OnCancel

}

...

};

OK键和CANCEL键的处理变成：

/* 按下OK键*/

void onOkKey（）

{

menu［currentFocusMenu］.onOkFun（）;

}

/* 按下Cancel键*/

void onCancelKey（）

{

menu［currentFocusMenu］.onCancelFun（）;

}

程序被大大简化了，也开始具有很好的可扩展性！我们仅仅利用了面向对象中的封装思想，就让程序结构清晰，其结果是几乎可以在无需修改程序的情况下在系统中添加更多的菜单，而系统的按键处理函数保持不变。

面向对象，真神了！

模拟MessageBox函数

MessageBox函数，这个Windows编程中的超级猛料，不知道是多少入门者第一次用到的函数。还记得我们第一次在Windows中利用MessageBox输出“Hello，World！”对话框时新奇的感觉吗？无法统计，这个世界上究竟有多少程序员学习Windows编程是从MessageBox（“Hello，World！”，…）开始的。在我本科的学校，广泛流传着一个词汇，叫做“'Hello，World'级程序员”，意指入门级程序员，但似乎“'Hello，World'级”这个说法更搞笑而形象。

嵌入式系统中没有给我们提供MessageBox，但是鉴于其功能强大，我们需要模拟之，一个模拟的MessageBox函数为：

/******************************************

/* 函数名称： MessageBox

/* 功能说明： 弹出式对话框，显示提醒用户的信息

/* 参数说明： lpStr --- 提醒用户的字符串输出信息

/* TYPE --- 输出格式（ID_OK = 0， ID_OKCANCEL = 1）

/* 返回值： 返回对话框接收的键值，只有两种KEY_OK， KEY_CANCEL

/******************************************

typedef enum TYPE { ID_OK，ID_OKCANCEL }MSG_TYPE;

extern BYTE MessageBox（LPBYTE lpStr， BYTE TYPE）

{

BYTE key = -1;

ClearScreen（）; /* 清除屏幕*/

DisplayString（xPos，yPos，lpStr，TRUE）; /* 显示字符串*/

/* 根据对话框类型决定是否显示确定、取消*/

switch （TYPE）

{

case ID_OK：

DisplayString（13，yPos+High+1， “ 确定”， 0）;

Break;

case ID_OKCANCEL：

DisplayString（8， yPos+High+1， “ 确定”， 0）;

DisplayString（17，yPos+High+1， “ 取消”， 0）;

Break;

Default:

Break;

}

DrawRect（0， 0， 239， yPos+High+16+4）; /* 绘制外框*/

/* MessageBox是模式对话框，阻塞运行，等待按键*/

while（ （key ！= KEY_OK） || （key ！= KEY_CANCEL） ）

{

key = getSysKey（）;

}

/* 返回按键类型*/

if（key== KEY_OK）

{

return ID_OK;

}

Else

{

return ID_CANCEL;

}

}

上述函数与我们平素在VC++等中使用的MessageBox是何等的神似啊？实现这个函数，你会看到它在嵌入式系统中的妙用是无穷的。

本篇是本系列文章中技巧性最深的一篇，它提供了嵌入式系统屏幕显示方面一些很巧妙的处理方法，灵活使用它们，我们将不再被LCD上凌乱不堪的显示内容所困扰。

屏幕乃嵌入式系统生存之重要辅助，面目可憎之显示将另用户逃之夭夭。屏幕编程若处理不好，将是软件中最不系统、最混乱的部分，笔者曾深受其害。

C语言嵌入式系统编程注意事项之键盘操作

处理功能键

让我们来看看WIN32编程中用到的“窗口”概念，当消息（message）被发送给不同窗口的时候，该窗口的消息处理函数（是一个callback函数）最终被调用，而在该窗口的消息处理函数中，又根据消息的类型调用了该窗口中的对应处理函数。通过这种方式，WIN32有效的组织了不同的窗口，并处理不同窗口情况下的消息。

我们从中学习到的就是：

（1）将不同的画面类比为WIN32中不同的窗口，将窗口中的各种元素（菜单、按钮等）包含在窗口之中；

（2）给各个画面提供一个功能键“消息”处理函数，该函数接收按键信息为参数；

（3）在各画面的功能键“消息”处理函数中，判断按键类型和当前焦点元素，并调用对应元素的按键处理函数。

/* 将窗口元素、消息处理函数封装在窗口中*/

struct windows

{

BYTE currentFocus;

ELEMENT elementï¼»ELEMENT_NUMï¼½;

void （*messageFun） （BYTE key）;

...

};

/* 消息处理函数*/

void message（BYTE key）

{

BYTE i = 0;

/* 获得焦点元素*/

while （ （element .ID！= currentFocus）&& （i 《 ELEMENT_NUM） ）

{

i++;

}

/* “消息映射” */

if（i 《 ELEMENT_NUM）

{

switch（key）

{

case OK：

element.OnOk（）;

Break;

...

}

}

}

在窗口的消息处理函数中调用相应元素按键函数的过程类似于“消息映射”，这是我们从WIN32编程中学习到的。编程到了一个境界，很多东西都是相通的了。其它地方的思想可以拿过来为我所用，是为编程中的“拿来主义”。

在这个例子中，如果我们还想玩得更大一点，我们可以借鉴MFC中处理MESSAGE_MAP的方法，我们也可以学习MFC定义几个精妙的宏来实现“消息映射”。

处理数字键

用户输入数字时是一位一位输入的，每一位的输入都对应着屏幕上的一个显示位置（x坐标，y坐标）。此外，程序还需要记录该位置输入的值，所以有效组织用户数字输入的最佳方式是定义一个结构体，将坐标和数值捆绑在一起：

/* 用户数字输入结构体*/

typedef struct tagInputNum

{

BYTE byNum; /* 接收用户输入赋值*/

BYTE xPos; /* 数字输入在屏幕上的显示位置x坐标*/

BYTE yPos; /* 数字输入在屏幕上的显示位置y坐标*/

}InputNum， *LPInputNum;

那么接收用户输入就可以定义一个结构体数组，用数组中的各位组成一个完整的数字：

InputNum inputElement［NUM_LENGTH］; /* 接收用户数字输入的数组*/

High Power EEL Chip

High Power Eel Chip,Edge-Emitting Lasers Chip ,Edge Emitting Transistor Laser ,Edge Emitting Led Strip Light

AcePhotonics Co.,Ltd. , https://www.acephotonics.com