Detailed analysis of the 7 major steps to write a microcontroller application

1. Understand the functions and plan.

When you receive a MCU project design file, it's not time to start coding immediately. Instead, take the time to thoroughly analyze the technical requirements and descriptions provided by the user. Based on these, clearly define the main functions that your program should implement. This is one of the most critical steps in the entire development process. If anything is unclear, make sure to ask the customer or user for clarification. Otherwise, after completing the design, you might face unexpected issues due to overlooked features. Some functions may need to be added later, while Others could be impossible to implement without prior planning.

2. Prepare the overall flowchart and individual module flowcharts.

Once the main functions are clear, create an overall flowchart of the program. Then break down the program into several key functional modules based on this flowchart. Each module should have its own basic flowchart, which will serve as a guide during the actual coding phase. Although some changes may occur during development, having a clear roadmap helps prevent major deviations. For example, when writing a keyboard scanning routine, you can create a flowchart that determines whether a key is a function key or a numeric key. If it’s a function key, it can trigger a specific subroutine; if it’s a number key, it can be displayed on a digital tube. This approach ensures clarity and structure in your code.

3. Prepare programming resources.

Collect relevant books, articles, and documentation related to the programming language you'll be using. No programmer can remember every detail about instructions, hardware interactions, or peripheral operations. Having these materials at hand allows you to quickly refer back to them when needed, ensuring accuracy and efficiency in your work.

4. Develop the human-machine interface (HMI).

The HMI in a single-chip microcontroller project is usually simple. If it involves LED displays, choose a clear and user-friendly layout based on the number of LEDs. Ensure that the data shown fully meets the user's technical requirements, making the system intuitive and easy to use.

5. Analyze programming challenges and develop solutions.

Even experienced programmers face difficulties during the development process. To ensure smooth progress, analyze the program’s framework and identify potential challenges based on the functions and flowcharts. Use your knowledge to find the best algorithms. For instance, in larger projects, keyboard scanning and display logic often pose significant challenges.

(1) Keyboard scanning is closely tied to the hardware. You must determine whether the MCU uses a high-level or low-level strobe signal. After scanning, read the keyboard status, perform anti-jitter processing, and discard invalid readings. Only when a valid key press is confirmed should the key value be processed and sent to the display or used for other purposes. These steps involve detailed hardware interaction.

(2) The algorithm for keyboard scanning and display is more complex. It involves scanning each key, detecting jitter, determining if the key is pressed or released, and then delaying before re-reading the key value. Similarly, the display process requires traversing each digit or character, often involving complex loop structures and lookup tables.

(3) Numeric keys and function keys behave differently. Numeric keys are displayed directly, while function keys trigger subroutines. Combining both creates a more complex logic flow. For example, the MCS51 has built-in routines for this, and PIC microcontrollers can reference similar approaches.

These three areas are typically the most challenging parts of MCU programming. Identifying them early and developing corresponding algorithms makes the development process much smoother.

6. Start coding.

Once all preparations are complete, begin writing the code. With a clear flowchart and sufficient resources, most potential issues should already have solutions. Even if some problems arise later, they will be easier to resolve because of the thorough planning done beforehand. This saves time and reduces stress, allowing you to focus on writing clean, well-structured code. It's also good practice to write and test each function individually, preventing conflicts that could complicate debugging later.

7. Program debugging.

Debugging is a crucial and often complex part of software development. Most programming tools offer basic debugging features such as step-by-step execution, breakpoints, and run-to-cursor. Mastering these techniques can help solve most common issues. With experience, you’ll naturally develop better debugging skills, proving that practice indeed makes perfect.