Real-world signal processing and control
The goal of creating machines is to enhance comfort and reduce costs in daily life This spectrum ranges from basic mechanical devices to advanced electronic gadgets like smartphones The most effective devices leverage electronics, sophisticated signal processing, and cutting-edge software.
In order to allow processing, real signals must be converted into another format that can be processed and the result should be used for intervention, as shown in Figure 1.1
Figure 1.1 General real-world interaction
The same principle is used in machines in general (Figure 1.2)
Figure 1.2 Machine – real world interaction
Modern devices leverage both analogue and digital electronics, utilizing software to efficiently process information Today's compact, battery-operated gadgets exemplify this efficiency, with smartphones standing out as prime examples These multifunctional devices seamlessly integrate telephony, photography, wireless communication, computing, sensors, and GPS, all within a single, streamlined unit.
Figure 1.3 illustrates the detailed block diagram of an electronic device where sensors convert various physical signals—such as displacement, force, pressure, acceleration, temperature, and light intensity—into manageable electrical signals like voltage, current, resistance, capacitance, and inductance The sensor outputs are then transformed into a suitable voltage range, typically a few volts, for efficient processing An analogue-to-digital converter subsequently translates this voltage into integer numbers for digital processing, while a similar principle is employed for reverse transformations.
Figure 1.3 Electronic device – real world interaction
Several analogue and digital integrated circuits have been developed to support the manufacture of electronic devices One of the most compact and most efficient components is the microcontroller.
Microcontrollers
The microcontroller unit (MCU) is a compact yet powerful single-chip microcomputer that integrates all essential components for operation, often requiring minimal external parts, such as supply decoupling capacitors Typically powered by a single supply voltage between 1.8 V and 5 V, an MCU can even function with a simple coin cell battery.
Microcontrollers are versatile and compact electronic components equipped with various peripherals to detect real-world signals and trigger events They feature a processor core that executes software, allowing the same hardware to be utilized across multiple applications This flexibility enables easy performance upgrades simply by updating the software, making microcontrollers powerful tools for a wide range of uses.
There is a very wide range of microcontrollers on the market from sizes of 2 mm × 2 mm and from a power consumption of 30 W to a speed of several hundred MHz
Most modern microcontrollers incorporate comparators, analogue-to-digital and digital-to- analogue converters and temperature sensors – therefore, they are often called mixed-signal (both analogue and digital) microcontrollers
Figure 1.4 illustrates some typical components of a modern mixed-signal microcontroller; the details will be given in the next chapter
External signals Sensor Signal conditioning
D/A converter digital electrical signals(binary values)
Microcontroller core and integrated peripherals
The microcontroller core features a processor that includes essential components such as an arithmetic logic unit (ALU) and multiple registers Modern microcontrollers typically adhere to RISC architecture principles, exemplified by the PIC, AVR, and ARM families, although some, like the 8051, follow CISC architecture.
Many devices utilize Harvard architecture, which features separate memory for data and programs, ensuring non-volatile program storage and minimizing code corruption while enhancing execution speed Additionally, the word length of these memory types can vary Microcontrollers may adopt either von Neumann or Harvard architecture, with options for users to configure memory usage, as seen in the ARM Cortex-M3 32-bit microcontroller family.
Modern microcontrollers feature both volatile SRAM memory and non-volatile, reprogrammable flash memory, which eliminates the need for external integrated circuits This flash memory stores the code and can be reprogrammed using specialized devices via a few microcontroller pins (in-circuit programming, JTAG) or, in some instances, directly by the microcontroller itself Additionally, some microcontrollers may include separate flash or EEPROM for non-volatile data storage, such as configuration, calibration, and statistical data.
UART SMBUS/I2C SPI BUS CAN/LIN BUS
PROCESSOR SUPPORT PERIPHERLS POWER ON
Flash memory can be rewritten approximately 100,000 times, with a typical data retention period exceeding 20 years Additionally, it offers protection features that prevent users from accessing the stored code.
When on-chip memory is insufficient for an application, developers can opt for microcontrollers equipped with an external memory interface, allowing the connection of static RAM or other memory types in various sizes This capability enhances memory flexibility and accommodates larger data requirements.
‘memory mapped’ peripherals including A/D converters, D/A converters, FIFO memories, etc
In the following the most typical processor support peripherals will be described briefly
A Power On Reset (POR) generator is essential for ensuring the proper operation of digital circuitry during power-up When power is switched on, the supply voltage may increase gradually as filtering and decoupling capacitors charge, while the supply current remains limited To prevent malfunction, the microcontroller's start-up must be delayed until the supply voltage reaches a safe operating level Once this threshold is detected, the POR generates a brief additional delay to ensure stability before the system fully activates.
1 ms to about 100 ms) and finally releases the reset line
A power supply monitor, also known as a brown-out detector, is essential for maintaining safe operating levels of voltage during operation, especially when sudden heavy current loads occur If the supply voltage drops below the safe threshold, it can lead to erroneous code execution, prompting the supply monitor circuit to generate a reset While programmers have the option to disable this feature, utilizing the supply monitor is highly recommended to ensure system reliability.
A Low-Dropout (LDO) regulator is essential for microcontrollers that require different voltage levels for their core and digital I/O ports These integrated voltage regulators ensure a stable and often programmable supply voltage derived from the input supply LDOs are designed to operate with a minimal voltage difference, typically around 100 mV, between the input and output, making them efficient for various applications.
A watchdog timer (WDT) is essential for preventing processors from falling into infinite loops or being disrupted by electromagnetic interference, which can lead to significant issues in applications like motor control, heating systems, and healthcare devices The WDT requires periodic writing to its refresh register within a specified timeframe, typically ranging from tens of milliseconds to several seconds; failure to do so triggers a reset If the processor successfully writes to the register, the timer resets, avoiding a system reset It is recommended to utilize the watchdog timer consistently, except during code development or simple test projects Quality microcontrollers automatically enable the watchdog timer upon reset to enhance system reliability.
Oscillator, PLL All processors need a clock signal to schedule instruction execution
Modern microcontrollers feature integrated oscillators and offer compatibility with external quartz crystals or clock signals They often include optional phase-locked loop (PLL) clock multipliers paired with clock dividers, enabling a diverse range of higher processor clock frequencies Generally, on-chip oscillators provide an accuracy range of 1% to 20%.
9 crystal oscillators can fall below 0.01% The developer can choose the solution that suits the particular application best
The debug interface is a crucial component for integrated development environments, enabling developers to download code to flash memory and supporting memory uploads It allows for programming security bits to safeguard code against unauthorized uploads This interface facilitates single stepping, breakpoint support, and tracking of variables, memory, and peripheral registers, streamlining code development and testing JTAG (Joint Test Action Group), adhering to the IEEE 1149.1 Standard Test Access Port and Boundary-Scan Architecture, is the most widely used interface standard for modern microcontrollers.
Digital peripherals include the digital input/output pin drivers and internal digital circuits related to timing, communication and computation acceleration
General-purpose input/output (GPIO) and port input/output (Port I/O) enable processors to read from and write to memory and on-chip peripherals via a bidirectional data bus Some processors include a direct memory access (DMA) controller, allowing data transfer between memory and peripherals without processor involvement Since data is valid only briefly, general-purpose outputs require latches to retain information until new data is written The outputs from these latches connect to chip pins, driving LEDs and providing logic signals for external digital circuits, typically organized in 8-bit groups to form bytes Additionally, pins can be configured as digital inputs, allowing microcontrollers to read buttons, switches, and digital signals, often utilizing internal or external pull-up resistors for connectivity.
Microcontrollers play a crucial role in controlling electronic devices across various applications, including household, automotive, and industrial sectors Essential functions such as timing, event counting, and periodic event generation are facilitated by built-in 8-, 16-, or 32-bit Timer/Counter modules These modules can be configured as timers, driven by an oscillator, or as counters, which increment based on the rising or falling edges of external signals Additionally, timers are vital for managing the timing of serial communication peripherals and both A/D and D/A converters.
The Programmable Counter Array (PCA) features a free-running counter controlled by an oscillator, along with 3 to 6 independent compare/capture registers These registers can latch the counter value upon detecting a change in a digital input signal and can also store data for comparison with the counter value to trigger events upon matching The PCA is versatile, enabling the measurement of pulse width, period, or frequency, as well as generating pulse width modulated (PWM) signals, special logic signal patterns, and periodic interrupts.
A Real-Time Clock (RTC) is essential for measuring real time and synchronizing events in microcontrollers, featuring a dedicated precise oscillator and a 32 to 48-bit counter Typically utilizing a 32,768 Hz tuning fork crystal, this low-power oscillator allows the integrated clock to function independently from the main processor It can be powered by a button battery, ensuring continuous operation even when the microcontroller is not powered on.
10 measuring real time, this peripheral can serve to wake the microcontroller up at a certain time – in other words, to provide alarm function
Microcontroller classification
Depending on the different features and according to target applications microcontrollers can be broken down into the following categories:
General-purpose microcontrollers have common digital peripherals including timers,
GPIO or UART Their typical clock frequency is around 10 MHz
Low power microcontrollers function efficiently at low clock frequencies, ranging from 1 MHz down to the tuning fork crystal frequency of 32,768 Hz or lower At 1 MHz, their supply current remains under 1 mA, with a supply sensitivity of approximately 200 µA/MHz Additionally, in power-down mode, the supply current can decrease to less than 1 µA.
Precision mixed-signal microcontrollers feature 12-bit or higher resolution Analog-to-Digital Converters (ADCs) and Digital-to-Analog Converters (DACs), with sigma-delta ADCs offering resolutions up to 24 bits Additionally, these microcontrollers include Programmable Gain Amplifiers (PGAs) that allow for software programmable gains ranging from 1 to 128.
High-speed microcontrollers execute most of their instructions within a single clock cycle and can operate at frequencies from about 25 MHz to several hundred MHz
According to the bus width there are 8-bit, 16-bit and 32-bit microcontroller families
8-bit microcontrollers typically consume less power, while 32-bit microcontrollers have more processing power
Industrial and automotive microcontrollers are designed to function within a wide temperature range of -40 °C to 85 °C, ensuring reliability in diverse conditions They feature internal peripherals with stringent specifications, enhancing performance and accuracy, with internal oscillators maintaining better than 1% precision across the entire operating temperature range Additionally, these microcontrollers are equipped with industrial or automotive communication interfaces, such as CAN and LIN buses, facilitating effective data transmission.
Secure microcontrollers play a crucial role in security-sensitive applications such as electronic banking, payment systems, and communication They provide robust protection for code and data, effectively preventing reverse engineering, tampering, data monitoring, and physical attacks To enhance security, these microcontrollers incorporate hardware cryptographic modules, random number generators, and efficient data and code encryption, ensuring the integrity and confidentiality of sensitive information.
2 Architecture and properties of the C8051Fxxx microcontroller family
C8051Fxxx microcontrollers developed by Silicon Laboratories [1, 2] are among the most powerful modern derivatives of the popular MCS-8051 MCU [2] introduced by Intel A short summary of these devices follows
The 8051 microcontroller, part of the MCS-51 family, is an 8-bit Harvard architecture device developed by Intel in the 1980s for embedded applications Its user-friendly and upgradable architecture has established it as a standard among manufacturers, leading to the continued popularity of various derivatives in the market, thanks to their ease of use and well-designed peripheral management.
The 8051 family of microcontrollers is user-friendly and highly programmable, making it accessible for experts, educators, students, and hobbyists alike With a wide array of free and professional development tools available, users can easily find source code examples to address various challenges Additionally, manufacturers offer valuable resources such as application notes, knowledge bases, and active user forums to support development efforts.
Manufacturers include Silicon Laboratories, Maxim/Dallas, Analog Devices, Atmel and NXP (formerly Philips)
The C8051Fxxx family from Silicon Laboratories offers a diverse array of speed options, code and data memory sizes, and both analog and digital peripherals, catering to various power requirements This family significantly enhances the original 8051 microcontroller's peak performance, which has been upgraded to 1 MIPS.
100 MIPS peak speed and the integrated flash memory, debug interface and very rich set of analogue and digital peripherals make the C8051Fxxx family a good choice for various applications
The chips can have sizes of 2 mm × 2 mm (10 pins) to 16 mm × 16 mm (100 pins).
The C8051Fxxx microcontroller family
The C8051Fxxx microcontrollers feature a maximum clock frequency ranging from 25 MHz to 100 MHz, with the flexibility to operate at slower speeds down to DC, as no minimum frequency is specified Users can program the internal oscillator to balance low power consumption at lower frequencies with higher processing speeds that require increased power For instance, the C8051F410 processor operates at 50 MHz with a core supply current of approximately 15 mA, while at a reduced frequency of 32 kHz, it consumes less than 20 µA, making it ideal for long-lasting battery-powered applications.
On-chip flash memory sizes range from 2 kbyte to 128 kbyte, while internal RAM capacity varies from 256 to 8448 bytes The flash memory not only stores code but can also be utilized by the code for non-volatile data storage.
The C8051Fxxx microcontrollers can have up to six 16-bit timers and a programmable counter array with 6 independent channels Some devices include a real-time clock with battery backup power option
Communication peripherals include UARTs, I 2 C/SMBus, SPI, USB, CAN, LIN serial interfaces and the parallel external memory interface that also supports the connection of fast external ADCs, DACs and more
From 6 to 64 GPIO pins are available with configurable output driving options (open-drain with or without internal pull-up and push-pull mode)
The C8051Fxxx family offers high-performance analog peripherals, featuring ADC resolutions ranging from 10 to 12 bits and sample rates between 100 kHz and 200 kHz Notably, the C8051F06x series includes two independent 1-MHz 16-bit ADCs, while the C8051F35x microcontroller boasts an 8-channel 24-bit ADC equipped with a programmable-gain amplifier for detecting sub-μV signals Additionally, some models are equipped with a 32-channel multiplexer prior to the ADCs and provide DACs with resolutions from 8 to 12 bits The analog peripherals may also feature up to three comparators with programmable response times and hysteresis, enhancing their versatility in various applications.
The company offers a range of development tools, including a free integrated development environment that is compatible with the widely-used open-source Small Device C Compiler (SDCC) Additionally, a configuration wizard application simplifies the setup of peripherals by generating source code in both assembly and C.
Hardware development platforms are also available There are simple and full-featured development kits for almost all C8051Fxxx processors.
The CIP-51 architecture
The Silicon Laboratories C8051Fxxx microcontrollers have the so-called CIP-51 architecture
[6] The simplified block diagram is shown in Figure 2.1
The architecture closely resembles the original Intel 8051 design, ensuring code compatibility while offering significant enhancements Key improvements include accelerated instruction execution, integrated flash memory, and increased RAM capacity.
In the following the main features of the architecture will be discussed
The following table summarises the 8-bit registers, with short descriptions and the reset values [2] The registers can be used in several instructions The accumulator (A or ACC)
The 15 registers store the outcomes of arithmetic and logic operations, along with the program status word (PSW), which includes various flags altered by these operations Additionally, other registers facilitate indirect addressing and stack management Generally, instructions execute more rapidly when the operands are located in registers.
B general-purpose register and register for multiplication and division 0
R0.–R7 general-purpose registers, R0 and R1 are also used in indirect addressing 0
Bit 7: CY carry bit (set by addition or subtraction, ADDC,
Bit 6: AC auxiliary carry bit (at 3rd bit, used in 4-bit arithmetics) 0
Bit 2: OV overflow (set by instructions MUL, DIV, ADD,
Bit 0: PAR parity bit: 1 if sum of bits in A is 1 0
DPH, DPL DPTR, data pointer, used in 16-bit indirect code or RAM addressing 0
SP stack pointer, modified by subroutine and interrupt routine calls or push/pop instructions 7
Special Function Registers (SFRs) provide access to peripherals and specific registers in a system For instance, the ACC, which is equivalent to the accumulator (A), can be accessed both as an SFR and a register This dual access enables the accumulator to be utilized in certain instructions where regular registers are not applicable, such as in push and pop operations.
Special Function Registers (SFRs) are accessed through direct addressing instructions, specifically within the address range of 0x80 to 0xFF This allows SFRs to function as memory-mapped registers, enabling programs to read from or write to them as if they were standard RAM.
The following table shows the standard 8051 SFR registers
0x88 TCON TMOD TL0 TH0 TL1 TH1
Note that SFRs in column 0 are bit addressable.
The SFRs listed in the table are the following (some of them will be discussed in the next chapters):
The port input/output special function registers (SFRs) P0, P1, P2, and P3 are linked to the microcontroller's pins, with P0 controlling the logic signals on its eight corresponding pins It is crucial for programmers to exercise caution, as writing a value of 1 to P0 will activate the least significant bit while simultaneously clearing the other seven bits.
The P0 register is bit addressable, allowing for the independent reading or writing of individual bits without altering the others For instance, modifying P0.0 affects only the least significant bit, leaving all other bits intact This capability is particularly beneficial for accessing specific bits in status and other registers, where each bit may hold distinct significance.
ACC and B provide SFR access to the accumulator and to the B register
PSW is the program status word Its individual bits are accessible using bit addressing For example, PSW.7 is the carry bit
SP is the stack pointer
DPL and DPH are the low- and high-order bytes of the data pointer DPTR
IE and IP are the interrupt enable and priority registers Their individual bits are accessible using bit addressing
TCON, TMOD, TL0, TH0, TL1 and TH1 are used to access and control the Timer 0 and Timer 1 peripherals
SCON and SBUF are associated with the serial port communication peripheral
The 8051 processors utilize Harvard architecture, featuring distinct memory spaces for code and data This design allows the code memory to also function as read-only data memory The processors offer two types of RAM: internal RAM, which has a capacity of 256 bytes, and external RAM, accessible via a 16-bit pointer, enabling a maximum size expansion.
The internal RAM structure, illustrated in Figure 2.2, features the first 128 bytes (0x00-0x7F) accessible through both direct and indirect addressing methods Within this space, the general-purpose registers are allocated 8 bytes, determined by the RS0 and RS1 bits of the PSW register Additionally, the 16-byte range from address 0x20 to 0x2F is bit-addressable, allowing for the utilization of 128 individual bit variables.
Figure 2.2 Internal memory structure of CIP-51 microcontrollers
The Special Function Registers (SFRs) are mapped to the upper 128 bytes of the address space and can be accessed through direct addressing, while the remaining upper 128 bytes of internal RAM may also be utilized It's important to note that stack handling uses indirect addressing via the stack pointer, allowing the upper RAM to serve as stack space Upon system reset, the stack pointer initializes at 7 and increments from that point; however, it is advisable to set the initial stack pointer (SP) to the first available data memory location, just above the variables, ensuring that all free memory can be utilized as stack space.
Modern C8051Fxxx processors incorporate external RAM (XRAM) of up to 8192 bytes, previously supplied by SRAM chips Access to XRAM memory is facilitated exclusively through 16-bit indirect addressing utilizing the DPTR pointer, which comprises the DPH and DPL registers.
XRAM at 0x00-0xFF can also be accessed by 8-bit indirect addressing using either the R0 or the R1 register
Off-chip memory often exhibits slower performance compared to on-chip memory, which necessitates the configuration of control timing parameters—such as data setup and hold times, as well as write/read pulse widths—through specialized SFR registers.
RS1,RS0 RS1,RS0 RS1,RS0 RS1,RS0
The XRAM configuration in C8051Fxxx processors allows for versatile memory access, enabling the processor to utilize on-chip memory exclusively, off-chip memory only, or a combination of both, depending on availability Additionally, the 8-bit addressable space can be relocated to a different 256-byte page It's important to note that not all C8051Fxxx models support off-chip memory.
Figure 2.3 External memory structure of CIP-51 microcontrollers
Data accessibility varies based on its location—whether in registers, memory, or code—and the addressing mode used The four addressing modes are summarized in the table below, accompanied by relevant examples.
Description register MOV A, B A = B, copy the content of B to A immediate constant
MOV A, #10 A = 10 (value), copy the value 10 to A direct MOV A, 10
A = byte in internal RAM at address 10
A = bits at port P0 (SFR access) indirect MOV A, @R0
A = byte in internal RAM at address pointed to by R0
A = byte in external RAM at address pointed to by DPTR
A brief summary of the available instructions are given in the following [2] Instructions are classified into groups and tables summarise their function and the flags affected by them
OFF-CHIP 0x0100-0xFFFF (16-bit indirect)
DIR IND REG IMM CY AC OV P
INC DPTR DPTR=DPTR+1 only DPTR
DIV AB A=integer part of A/B
ANL byte,#const byte=byte & const
ORL byte,#const byte=byte | const
XRL byte,#const byte=byte ^ const
RL A Rotate A left by 1 bit
RLC A Rotate A left through Carry
C = bit 7 of the original value of A only A
RR A Rotate A right by 1 bit
RRC A Rotate A right through Carry
C = bit 7 of the original value of A only A
SWAP A Swap nibbles of A only A
MOV byte1, byte2 byte1 = byte2
MOV DPTR,#const16 DPTR = 16-bit immediate constant
POP byte byte = RAM[SP]
XCH A,byte exchange the content of A and byte
XCHD A,@Ri exchange low nibbles of A and
2.3.5.6 External and code memory access
JMP address Jump to address
JMP @A+DPTR Jump to A+DPTR
ACALL address Call subroutine at 11-bit
SP = SP+1 RAM[SP] = PC lower order byte
SP = SP+1 RAM[SP] = PC higher order byte
LCALL address Call subroutine at 16-bit address
SP = SP+1 RAM[SP]= PC lower order byte
SP = SP+1 RAM[SP] = PC higher order byte
2.3.5.8 Return from subroutines and interrupts
PC = RAM[SP]*256 + RAM[SP-1]
PC = RAM[SP]*256 + RAM[SP-1]
SP = SP-2 restore the interrupt logic to accept further interrupts
Note that if a conditional jump occurs, the program counter is updated as PC=PC+address, where the address is an 8-bit two’s complement number in the range of -128 to 127
JZ address Jump if A = 0 only A
JNZ address Jump if A !=0 only A
DJNZ byte, address Decrement and jump if not zero
CJNE A,byte, address Jump if A != byte
CJNE byte,#const, address Jump if byte != const
JB bit, address Jump if bit = 1
JNB bit, address Jump if bit = 0
JBC bit, address Jump if bit = 1; CLR bit
The CIP-51 architecture executes most of the operations in 1 or 2 system clock cycles Depending on the specific device, the system clock can have maximum frequencies from
Processors with clock frequencies ranging from 25 MHz to 100 MHz can achieve instruction execution times as low as 10 ns The cycle time distribution for various instructions highlights that processors exceeding 25 MHz often employ pipelining techniques, which involve prefetching instructions into a fast buffer to mitigate flash code memory access time limitations However, this can lead to occasional stalls for a few clock cycles, particularly during jump or branching operations.
The 8051 processors utilize a CISC architecture that enables instruction coding with 1, 2, or 3 bytes The initial byte represents the instruction type, while the subsequent bytes specify the operands Examples of this instruction structure are detailed in the accompanying table, which also outlines the corresponding cycle counts.
SDCC C compiler
The market offers various 8051 C Compilers, with KEIL C51 being the most popular professional option Additionally, Small Device C Compiler (SDCC) serves as a noteworthy open-source alternative Its free availability, high quality, and comprehensive documentation make SDCC an excellent educational tool This article highlights the essential additions to C necessary for utilizing the features of the 8051 processor.
Variables can be placed in different memory types; for this purpose, the compiler supports the declaration of storage classes:
data unsigned char x; // internal RAM
xdata unsigned char x; // external RAM
idata unsigned char x; // internal indirectly addressable RAM
pdata unsigned char x; // 8-bit addressed external RAM
code unsigned char x=3; // constant in code memory
sbit at 0xD7 CARRY; // SFR bit
xdata at (0x4000) unsigned char x[16]; // external RAM, absolute address code at (0x7f00) char Msg[] = "Message"; // code memory, absolute address bit at (0x80) GPIO_0; // bit, absolute address
Inserting assembly into C can be done using the asm and endasm directives: unsigned char x;
The assembly code fragment begins with clearing the accumulator and initializing registers R0 and R1 with specific values, including a hexadecimal constant It then copies the content of the R2 register to the accumulator and accesses a variable declared in C The code includes a conditional jump to a label if the accumulator is zero, followed by another instruction to clear register R0.
endasm; // end of assembly code fragment
The variable types are listed in the following table
(bits) default signed range unsigned range
bit 1 unsigned - 0,1 char 8 signed -128–127 0–255 short 16 signed -32768–32767 0–65535 int 16 signed -32768–32767 0–65535 long 32 signed -2147483648
In embedded programming, variable types largely mirror those in standard C, with notable exceptions due to resource constraints The SDCC compiler introduces the bit keyword for defining bit variables, enabling efficient memory usage in bit addressable memory space While floating-point arithmetic is supported, only single precision 4-byte float variables are available, which provide adequate precision of 6-7 digits for most embedded applications Double precision is not an option, as it would lead to longer execution times and increased code size.
Generic pointers in the 8051 microcontroller are unique due to the variety of memory types it utilizes These 3-byte wide pointers specify the address using two bytes and indicate the memory type—internal RAM, external RAM, or code memory—on the third byte Additionally, programmers can create single-byte pointers that directly reference internal memory locations, as there are only 256 possible locations available.
Microcontroller programming often requires the manipulation of bits Here are two simple examples: x = x & ~(1 1024) DoSomething(); // here x cannot be changed by IntHandler() }
During the critical block, interrupts are disabled by the compiler, which saves and clears the EA (Enable Interrupts) flag, ensuring that no interrupts can occur within this section However, this can lead to increased interrupt latency and the potential for missed interrupts if the critical block takes an extended time to execute.
It is also possible to protect a variable from being modified by the interrupt routine by introducing a user flag as illustrated in the following example
32 volatile bit protect_x; // flag variable volatile unsigned short x; // this variable can be changed in the
// interrupt handler routine protect_x=1; // switch protection on if (x>10) DoSomething(); // here x cannot be changed protect_x=0; // switch protection off
In the interrupt handler: if (!protect_x) // allow changes only if protect_x is 0
{ x=(ADC0H