Active-low
Something that is ON when its signal is 0 V. The user LEDs on this board have their anode on 3.3 V, so the MCU turns them on by driving the pin low.
Short, plain explanations of the words the manuals assume you know. Each one links to the page that explains it properly, and to the guides where you use it.
Something that is ON when its signal is 0 V. The user LEDs on this board have their anode on 3.3 V, so the MCU turns them on by driving the pin low.
The analog-to-digital converter measures a voltage on a pin and turns it into a number (up to 16 bits on the H7). 0 V reads as 0 and VREF+ (3.3 V here) as the maximum.
A routine built into each ADC that measures its own offset and linearity errors and corrects for them. On the STM32H7 you run it once after the ADC leaves deep power-down and before you enable it, by setting ADCAL in ADC_CR; it takes tens of milliseconds.
Instead of being a plain GPIO, a pin can be handed to a peripheral (UART, timer, SPI…). Each pin has up to 16 options numbered AF0 to AF15; the datasheet tables say which number gives which signal, and GPIOx_AFRL/AFRH select it.
A timer counts from 0 up to the value in TIMx_ARR, then wraps to 0: that wrap is the update event, so one period is ARR + 1 ticks. Each channel also has a compare register TIMx_CCRn; in PWM mode 1 the output is high while the counter is below it, so CCR sets the duty cycle.
The general-purpose RAM, in three power domains: 512 KB AXI SRAM at 0x24000000 (the roomy one, good for frame buffers), SRAM1/2/3 (128 + 128 + 32 KB) at 0x30000000 for DMA buffers, and SRAM4 (64 KB) at 0x38000000.
The LEDs behind the LCD that make it visible. On this board a driver chip switches them on from the pin LCD_BL (PK0); without it the screen can show a picture that is too dark to see.
A solder ball under a BGA chip, named by row letter and column number (for example T6). The schematic shows the ball next to each pin name; the datasheet lists balls per package.
The number of bits per second on a serial line. Both ends must agree; the board’s virtual COM port expects 115200 baud, 8 data bits, no parity, 1 stop bit (8N1).
A group of bits inside a register with one meaning, like the two MODER9[1:0] bits that set the mode of pin 9. You change it with a read-modify-write: clear the bits with a mask, then OR in the new value.
A write-only GPIO register that sets (low 16 bits) or clears (high 16 bits) individual pins in one write, without touching the others. Safer than read-modify-write of ODR.
The CPU clock is divided down to feed the buses the peripherals sit on: AXI/AHB (fast, up to 240 MHz here) and APB (slower, up to 120 MHz). A peripheral can be clocked no faster than its bus allows, so the dividers matter.
The Cortex-M7 has a small fast copy of recently used memory (instruction and data cache). Hardware that reads RAM directly (DMA, LTDC, DMA2D) does not see data still sitting in the CPU cache, so after the CPU writes a shared buffer you must clean the cache for that range.
A small chip behind the glass that measures where fingers are and reports coordinates over I2C. The board connects it to I2C4 and signals "new data" on a separate interrupt line.
An STM32H7 specific step: each ADC input channel you want to convert must also have its bit set in ADC_PCSEL. The bit closes an analog switch in the pin that is too slow to follow the ADC multiplexer, so it has to be on beforehand.
The square wave that steps a digital circuit. The CPU clock decides how fast code runs; each peripheral also has a clock that sets things like baud rate and timer tick.
Arm’s standard headers. The device header stm32h750xx.h defines a struct per peripheral, so GPIOJ->BSRR is the BSRR register of port J and RCC_AHB4ENR_GPIOJEN is the bit mask.
The document for this exact chip family: which peripherals exist, which pin can carry which signal, and electrical limits. It does not explain how to program anything.
A mechanical button does not switch cleanly: for a few milliseconds it flips between open and closed. Debouncing means ignoring changes for a short time after the first edge.
A panel needs pulses and gaps around each line and frame: a sync pulse, a back porch before the first visible pixel and a front porch after the last. The numbers come from the panel documentation; the LTDC counts them in pixel-clock periods (horizontal) and lines (vertical).
A hardware block that copies data between memory and peripherals by itself while the CPU does other work.
A DMA made for graphics: it fills rectangles, copies images and converts pixel formats into the framebuffer much faster than CPU loops.
The extended interrupt controller turns edges on GPIO pins into interrupts. Line n listens to pin n of one port, chosen in SYSCFG_EXTICRx.
Flash is slower than the CPU, so at higher clock speeds the CPU must wait extra cycles on each flash read. You raise LATENCY in FLASH_ACR before raising the clock.
The Flexible Memory Controller connects external memories (SDRAM, SRAM, NOR) so they appear in the memory map like internal RAM.
A block of RAM that holds one value per pixel. Change a value and the pixel on screen changes at the next refresh. 480 × 272 pixels in RGB565 take 261,120 bytes.
ST’s Hardware Abstraction Layer: C functions like HAL_GPIO_WritePin() that write the registers for you. Great for getting started; reading the registers it touches is how you learn what really happens.
The external high-speed clock input. On this board a 25 MHz oscillator (X1) feeds it, which is more accurate than the HSI.
A mode where the HSE input takes a ready-made clock signal (from an oscillator module) instead of driving a quartz crystal itself. Set with HSEBYP in RCC_CR.
The internal 64 MHz RC oscillator. The chip runs from it after reset, so your first programs need no clock setup at all.
A two-wire bus (clock SCL and data SDA, both open-drain with pull-ups) where one master talks to many devices, each with a 7-bit address. On this board I2C4 talks to the touch panel and the audio codec.
A hardware signal that makes the CPU stop what it is doing, run a handler function, and then continue. It lets you react to a button or a received byte without checking in a loop.
Many peripherals have two clocks: the bus clock, which lets the CPU access their registers (enabled in RCC_xxxENR), and a kernel clock that times what the peripheral itself does, such as the bits of a UART or the ADC conversions. The kernel clock source is chosen in an RCC register (for the USARTs RCC_D2CCIP2R, for the ADCs RCC_D3CCIPR).
The linear regulator that makes the core voltage from the 3.3 V supply. Some STM32H7 parts can use a switching regulator (SMPS) instead; the STM32H750B-DK only supports the LDO, and VOS0 needs it.
The file that tells the linker where code and data go in memory (which flash, which RAM). On the H750 it matters because internal flash is only 128 KB.
The LCD-TFT display controller. It continuously reads a picture from memory (the framebuffer) and sends it to the panel pixel by pixel with the right sync signals, without any CPU work.
The table of which address range belongs to what: flash, the RAMs, and every peripheral. A register address is the peripheral base address plus the register offset.
A whole computer on one chip: CPU, flash, RAM and peripherals. On this board it is the STM32H750XBH6, a Cortex-M7 running at up to 480 MHz.
A Cortex-M7 block that lets you give address ranges attributes: cacheable or not, writable or not, executable or not. A common use on the H7 is marking a DMA buffer as non-cacheable so you do not need cache maintenance.
A named wire on the schematic, like LED1 or VCP_TX. Every place that shows the same net name is electrically the same wire, even on different sheets.
The Nested Vectored Interrupt Controller inside the Cortex-M7. Every peripheral interrupt must be enabled here as well as in the peripheral. It also sets priorities.
A hardware block inside the MCU that does one job on its own, like a UART, a timer or the LCD controller. You control it by writing its registers.
Each GPIO pin is in one of four modes set by two bits in GPIOx_MODER: input, output, alternate function or analog. After reset most pins are analog to save power.
The number of bytes from the start of one row of the framebuffer to the start of the next. For a tightly packed 480-pixel RGB565 row it is 960 bytes, but it can be larger if rows are padded.
How a pixel is stored in memory. RGB565 uses 16 bits (5 red, 6 green, 5 blue); ARGB8888 uses 32 bits with alpha. Smaller formats save RAM and bandwidth.
A circuit that multiplies a slow, stable clock up to a fast one (for example 25 MHz up to 480 MHz for the CPU). The H7 has three PLLs.
A divider in front of a counter. A timer clocked at 200 MHz with prescaler 199 counts at 1 MHz (it divides by PSC + 1).
The C library does not know your hardware. In a CubeIDE project printf ends in _write, which calls __io_putchar(ch) once per character. Defining __io_putchar so it sends the character on a USART makes printf print to the PC. This comes from the toolchain, not from the ST manuals.
Describes the Arm Cortex-M7 CPU core: exceptions and interrupts, NVIC, SysTick, MPU, caches and the instruction set. Same for every Cortex-M7 chip, not only ST ones.
A resistor that holds a pin at a known level when nothing drives it. The MCU has weak internal ones (GPIOx_PUPDR); the user button on this board already has an external 220 kΩ pull-down.
Push-pull outputs drive both high and low (the default, right for LEDs). Open-drain outputs only pull low and need a pull-up for the high level; I2C uses that.
A fast on/off square wave whose on-time (duty cycle) sets the average power. It dims LEDs, drives servos and sets motor speed.
A fast SPI with four data lines for external flash. In memory-mapped mode the flash appears at 0x90000000 and the CPU can run code from it, which is how big H750 programs work.
The block that distributes clocks. Every peripheral is switched off after reset; you must set its enable bit in an RCC register (for GPIO port J that is GPIOJEN in RCC_AHB4ENR) before its registers do anything.
The big manual (3000+ pages) that explains how every peripheral works and what each register bit does. You read one chapter at a time, never cover to cover.
A 32-bit memory location that controls a peripheral. Writing bits configures it, reading bits tells you its state. The RM documents every bit, its reset value and whether it is read-only.
Before converting, the ADC connects the input to a small internal capacitor and waits for it to charge to the input voltage. The wait is the sampling time, in ADC clock cycles. A source with a higher output resistance (a big potentiometer, a sensor) charges the capacitor more slowly and needs a longer one.
The circuit diagram of the board. It is the ground truth for what each pin is connected to, including resistors, pull-ups and solder bridges along the way.
External RAM on the board, reached through the FMC at address 0xD0000000 once initialised. The chip holds 128 Mbit, but only 16 of its 32 data lines are wired, so 8 MB is usable: still room for many framebuffers.
The LTDC layer registers are double-buffered: what you write is held in a shadow copy and only becomes active when you ask for a reload (LTDC_SRCR). Forget the reload and your new layer settings never take effect.
A tiny pair of pads on the PCB that can be joined with solder (ON) or left open (OFF). ST uses them to choose between two uses of a pin. Their default state is listed in the user manual.
A fast four-wire bus (clock, MOSI, MISO, chip select) for sensors, displays and memories. Common on Arduino shields.
The debug probe built into the board (STLINK-V3E, USB connector CN14). It flashes your program, lets you step through code, powers the board and provides the virtual COM port.
ST’s free IDE (Eclipse + GCC) with the CubeMX configurator built in. You pick the board, click pins and peripherals, and it generates the startup code and HAL calls.
Serial Wire Debug, the two-wire link (SWDIO, SWCLK) the ST-LINK uses to program and debug the Cortex-M7.
A simple 24-bit down-counter inside the Cortex-M7, meant for a periodic tick (usually 1 ms). HAL_Delay() and most RTOSes are built on it.
Small RAMs wired straight to the Cortex-M7 so access is as fast as possible and takes the same time every time: ITCM (64 KB at 0x00000000) for code, DTCM (128 KB at 0x20000000) for data and the stack. Only the CPU and MDMA can reach them: DMA2D, LTDC and most other DMAs cannot.
A peripheral that counts clock ticks. It can raise an interrupt every N ticks, measure the time between edges, or generate PWM on a pin.
A serial port: bytes are sent one bit at a time on a TX wire and received on an RX wire, at an agreed speed. The simplest way to print text from the board to your PC.
The manual of the Discovery board itself: power options, jumpers, connectors, LEDs and buttons, and which on-board chip is wired to which MCU peripheral.
Inside a PLL the input is first divided by M, then multiplied by N inside the VCO (voltage-controlled oscillator), and the VCO output is split by the post-dividers P, Q and R into three clocks. Each step has a legal frequency range.
The ST-LINK on the board also acts as a USB serial adapter. Its serial side is wired to USART3 of the MCU, so text sent on USART3 appears on your PC as a serial port.
The core voltage the internal regulator produces. Higher voltage allows a higher clock: after reset the chip is in VOS3 (up to 200 MHz CPU); VOS1 allows 400 MHz and VOS0 allows 480 MHz. You raise the voltage first, then the clock.
The voltage the ADC compares its input against: an input equal to VREF+ gives the largest code (65535 at 16 bits). Any error in VREF+ is an error in every reading, so for accurate work measure it.
Running code directly from an external flash that the QUADSPI has mapped into the address space, without copying it to RAM first. A small program in internal flash sets up the QUADSPI and then jumps to the code at 0x90000000.