Abstract:

This video provides a comprehensive tutorial on implementing the Serial Peripheral Interface (SPI) protocol on the CH32V003 microcontroller, building upon previous tutorials in the series. The demonstration utilizes an ADXL345 3-axis accelerometer sensor, wired for 4-wire SPI communication, to illustrate data transfer. The presenter details the hardware setup, including the CH32V003, a debugger, and a USB-to-UART converter, and conducts the software development within the MounRiver Studio v2 IDE. Key aspects covered include the configuration of GPIO pins for SPI, a comparison of SPI's full-duplex capabilities and chip-select advantages over I²C, and the creation of custom functions for SPI data transfer, register reading, and writing. The video culminates in reading and processing the accelerometer's raw data, converting it to G-units, and visualizing the real-time acceleration data on a serial plotter, highlighting the high-speed data acquisition capabilities.

Summarizing the CH32V003 SPI Tutorial with ADXL345 Accelerometer

• 0:00 Introduction to SPI: The video continues a CH32V003 tutorial series by focusing on the SPI communication protocol, comparing it to previously covered topics like I²C and timers.
• 0:29 Hardware Setup:
  • Demonstrates SPI communication using an ADXL345 3-axis accelerometer sensor.
  • The sensor is wired according to the 4-wire SPI protocol: Chip Select (CS), Master Out Slave In (MOSI), Master In Slave Out (MISO), and Serial Clock (SCK).
  • Uses the CH32V003F4P6 microcontroller programmed via an SWIO debugger module, with serial communication (UART) handled by a USB-to-UART converter on the debugger.
• 1:39 Software Development Environment: All software is implemented in WCH's MounRiver Studio, specifically version 2, which the presenter praises for its improvements.
• 5:06 ADXL345 Chip Overview & SPI Protocol Advantages:
  • Highlights the ADXL345's ability to communicate via both SPI and I²C, choosing SPI for the tutorial.
  • Emphasizes SPI's advantages:
    • Speed: Much higher data rates than I²C.
    • Full-Duplex: SPI allows simultaneous two-way communication (master sending and slave receiving at the same time), unlike I²C's half-duplex.
    • Chip Select: SPI uses a dedicated chip select pin, avoiding address conflicts common with I²C devices (e.g., multiple identical displays).
  • Suggests consulting the ADXL345 datasheet for detailed serial communication requirements.
• 8:08 SPI Initialization (Software Implementation):
  • Initializes GPIO pins for SPI:
    • PC4 (Chip Select): Configured as GPIO output push-pull, manually pulled HIGH by default, then pulled LOW to initiate communication.
    • PC5 (SCK) & PC6 (MOSI): Configured as alternative function (AF) push-pull outputs for master-driven clock and data.
    • PC7 (MISO): Configured as a floating input, driven by the slave device.
  • Initializes the SPI peripheral (SPI1) as a master:
    • Set to two lines, full-duplex communication.
    • 8-bit data size.
    • Clock polarity (CPOL) set to HIGH (idle clock is high).
    • Clock phase (CPHA) set to the second clock edge for sampling and shifting data (as required by ADXL345).
    • Software chip select enabled (manual control).
    • Baud rate prescaler set to 32, resulting in a 1.5 MHz bus speed (48 MHz / 32).
    • Most Significant Bit (MSB) first bit order.
• 16:52 SPI Transfer Function: A custom SPI_Transfer function is created:
  • Sends data using SPI_I2S_SendData.
  • Waits until the transmit buffer is empty (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE)).
  • Waits until the receive buffer is not empty (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE)).
  • Returns the received data using SPI_I2S_ReceiveData.
• 19:24 Register Write Function: A writeRegister function is implemented:
  • Pulls Chip Select (PC4) LOW.
  • Transfers the register address.
  • Transfers the data value.
  • Pulls Chip Select (PC4) HIGH.
• 21:18 Register Read Function: A readRegister function is implemented for single or multiple byte reads:
  • Constructs a "command byte" by OR-ing the register address with:
    • 0x80: Sets the read bit (D7) for read operation.
    • 0x40 (if numberOfBytes > 1): Sets the multi-byte bit (D6) to inform the accelerometer to return multiple bytes consecutively.
  • Pulls Chip Select (PC4) LOW.
  • Transfers the constructed command byte.
  • Loops numberOfBytes times, calling SPI_Transfer (with dummy byte) to read data into a buffer.
  • Pulls Chip Select (PC4) HIGH.
• 27:18 ADXL345 Initialization & Device ID Check:
  • A initializeChip function writes to specific ADXL345 registers:
    • 0x2D (Power Control) with 0x08 to enable measurement mode.
    • 0x31 (Data Format) to configure full resolution (13-bit), 4-wire SPI, and +/- 2G range.
    • 0x2C (BW Rate) to set the output data rate to the highest (3200Hz).
  • Reads the 0x00 (Device ID) register; if the returned value is 0xE5, the chip is successfully recognized.
• 34:50 Reading and Processing Acceleration Data:
  • Reads 6 bytes from 0x32 (DATAX0 register), which contains the X, Y, Z acceleration values (two 8-bit bytes per axis). The multi-byte read feature automatically increments the address.
  • Combines the two 8-bit bytes for each axis into a single 16-bit integer (e.g., (buffer[1] << 8) | buffer[0]).
  • 40:01 Conversion to G-Units (Floating Point Emulation):
    • Due to microcontroller limitations with floating-point numbers, a trick is used:
      • Raw data is scaled up by 10,000 and divided by the LSB value (256) to get an integer representing G * 10,000.
      • The whole and fractional parts are then extracted for printing using integer division and modulo operations.
• 44:10 Real-time Data Visualization:
  • Prints the X, Y, Z acceleration values in a specific comma-separated format to the serial terminal.
  • Demonstrates using the Arduino IDE's Serial Plotter to visualize the real-time G-force readings for each axis as the accelerometer is tilted, confirming proper functionality.
• 48:40 Conclusion & Resources: Discusses further applications like tap detection and vibration analysis. Encourages viewers to visit the accompanying website for a detailed article and GitHub for the source code, and to support the channel through membership.