Connecting 6 ILI9341 and SD Card to STM32F103C8T6 (Blue Pill) controller

on

 To connect multiple ILI9341 displays and their SD card readers to an STM32F103C8T6 microcontroller, you'll need to consider the following connections:

  1. Power Supply:

    • Both the ILI9341 displays and the SD card readers require 3.3V power supply.

  2. SPI Communication:

    • ILI9341 displays usually communicate via SPI, so you'll need to set up SPI communication.
    • Multiple SPI devices can share the same MISO, MOSI, and SCK lines, but each device needs a separate Chip Select (CS) line.

  3. GPIO Pins:

    • Control pins like CS, DC (Data/Command), RST (Reset), and possibly backlight control for each ILI9341.
    • CS line for each SD card reader.

Example Connections

STM32F103C8T6 Pins

  • SPI1 Pins:
    • SCK: PA5
    • MISO: PA6
    • MOSI: PA7

ILI9341 Display 1

  • CS: PB0
  • DC: PB1
  • RST: PB2

ILI9341 Display 2

  • CS: PB3
  • DC: PB4
  • RST: PB5

SD Card Reader 1

  • CS: PB6

SD Card Reader 2

  • CS: PB7

Circuit Diagram Outline

  1. Connect Power Supply:

    • Connect 3.3V and GND to all ILI9341 displays and SD card readers.

  2. SPI Connections:

    • Connect SCK (PA5) to SCK pins of both ILI9341 displays and SD card readers.
    • Connect MISO (PA6) to MISO pins of both ILI9341 displays and SD card readers.
    • Connect MOSI (PA7) to MOSI pins of both ILI9341 displays and SD card readers.

  3. ILI9341 Control Pins:

    • Connect CS pins to PB0 (Display 1) and PB3 (Display 2).
    • Connect DC pins to PB1 (Display 1) and PB4 (Display 2).
    • Connect RST pins to PB2 (Display 1) and PB5 (Display 2).

  4. SD Card Reader Control Pins:

    • Connect CS pins to PB6 (SD Card Reader 1) and PB7 (SD Card Reader 2).

Example Code Snippet (Pseudo-Code)

Here's a simple example in pseudo-code to illustrate how you might initialize and use the displays and SD card readers:

cpp:
// Include necessary libraries
#include <SPI.h>
#include <ILI9341.h>
#include <SD.h>

// Define pins for ILI9341
#define TFT1_CS PB0
#define TFT1_DC PB1
#define TFT1_RST PB2

#define TFT2_CS PB3
#define TFT2_DC PB4
#define TFT2_RST PB5

// Define pins for SD cards
#define SD1_CS PB6
#define SD2_CS PB7

// Create display objects
ILI9341 tft1(TFT1_CS, TFT1_DC, TFT1_RST);
ILI9341 tft2(TFT2_CS, TFT2_DC, TFT2_RST);

void setup() {
  // Initialize SPI
  SPI.begin();

  // Initialize displays
  tft1.begin();
  tft2.begin();

  // Initialize SD cards
  if (!SD.begin(SD1_CS)) {
    // Handle error
  }
  if (!SD.begin(SD2_CS)) {
    // Handle error
  }

  // Load and display images
  displayImage(tft1, SD1_CS, "image1.bmp");
  displayImage(tft2, SD2_CS, "image2.bmp");
}

void displayImage(ILI9341 &tft, uint8_t sdCsPin, const char* filename) {
  // Select the appropriate SD card
  SD.begin(sdCsPin);

  // Load the image from the SD card and display it on the screen
  // You will need a function to read and display BMP images
  // Example: readBMP(filename, tft);
}

void loop() {
  // Main loop
}

This setup assumes you're using a library for the ILI9341 and the SD card, such as Adafruit_GFX and SD.h in an Arduino-like environment. Adjust pin assignments and library functions according to your development environment and libraries.in the above setup itself if planning to connect 6 ILI9341 and I'm planning to give the serial inputs like which display should display which image and time period to clear the display. can you arrange for itEnsure your power supply can handle the current requirements for all 6 displays and SD card readers.

  1. SPI Communication:

    • You can still use shared SPI lines (SCK, MISO, MOSI) for all displays and SD card readers.
    • Each device will need its own CS line.

  2. GPIO Pins:

    • Control pins (CS, DC, RST) for each display and CS for each SD card reader.

  3. Serial Communication:

    • Use the serial port to receive commands for controlling the displays.

Example Connections

STM32F103C8T6 Pins

  • SPI1 Pins:
    • SCK: PA5
    • MISO: PA6
    • MOSI: PA7

ILI9341 Displays

  • CS1: PB0
  • DC1: PB1
  • RST1: PB2
  • CS2: PB3
  • DC2: PB4
  • RST2: PB5
  • CS3: PB8
  • DC3: PB9
  • RST3: PB10
  • CS4: PB11
  • DC4: PB12
  • RST4: PB13
  • CS5: PB14
  • DC5: PB15
  • RST5: PC13
  • CS6: PC14
  • DC6: PC15
  • RST6: PA8

SD Card Readers

  • CS1: PA9
  • CS2: PA10
  • CS3: PA11
  • CS4: PA12
  • CS5: PA15
  • CS6: PB6

Circuit Diagram Outline

  1. Connect Power Supply:

    • Connect 3.3V and GND to all ILI9341 displays and SD card readers.

  2. SPI Connections:

    • Connect SCK (PA5) to SCK pins of all ILI9341 displays and SD card readers.
    • Connect MISO (PA6) to MISO pins of all ILI9341 displays and SD card readers.
    • Connect MOSI (PA7) to MOSI pins of all ILI9341 displays and SD card readers.

  3. ILI9341 Control Pins:

    • Connect CS, DC, and RST pins for each display to the appropriate GPIO pins.

  4. SD Card Reader Control Pins:

    • Connect CS pins for each SD card reader to the appropriate GPIO pins.

Example Code Snippet (Pseudo-Code)

Here's an example in pseudo-code to illustrate how you might handle multiple displays and serial commands:

cpp:
#include <SPI.h>
#include <ILI9341.h>
#include <SD.h>

// Define pins for ILI9341
#define TFT1_CS PB0
#define TFT1_DC PB1
#define TFT1_RST PB2
#define TFT2_CS PB3
#define TFT2_DC PB4
#define TFT2_RST PB5
#define TFT3_CS PB8
#define TFT3_DC PB9
#define TFT3_RST PB10
#define TFT4_CS PB11
#define TFT4_DC PB12
#define TFT4_RST PB13
#define TFT5_CS PB14
#define TFT5_DC PB15
#define TFT5_RST PC13
#define TFT6_CS PC14
#define TFT6_DC PC15
#define TFT6_RST PA8

// Define pins for SD cards
#define SD1_CS PA9
#define SD2_CS PA10
#define SD3_CS PA11
#define SD4_CS PA12
#define SD5_CS PA15
#define SD6_CS PB6

// Create display objects
ILI9341 tft1(TFT1_CS, TFT1_DC, TFT1_RST);
ILI9341 tft2(TFT2_CS, TFT2_DC, TFT2_RST);
ILI9341 tft3(TFT3_CS, TFT3_DC, TFT3_RST);
ILI9341 tft4(TFT4_CS, TFT4_DC, TFT4_RST);
ILI9341 tft5(TFT5_CS, TFT5_DC, TFT5_RST);
ILI9341 tft6(TFT6_CS, TFT6_DC, TFT6_RST);

void setup() {
  // Initialize SPI
  SPI.begin();

  // Initialize Serial Communication
  Serial.begin(9600);

  // Initialize displays
  tft1.begin();
  tft2.begin();
  tft3.begin();
  tft4.begin();
  tft5.begin();
  tft6.begin();

  // Initialize SD cards
  if (!SD.begin(SD1_CS)) {
    // Handle error
  }
  if (!SD.begin(SD2_CS)) {
    // Handle error
  }
  if (!SD.begin(SD3_CS)) {
    // Handle error
  }
  if (!SD.begin(SD4_CS)) {
    // Handle error
  }
  if (!SD.begin(SD5_CS)) {
    // Handle error
  }
  if (!SD.begin(SD6_CS)) {
    // Handle error
  }
}

void loop() {
  if (Serial.available() > 0) {
    // Read command from serial
    String command = Serial.readStringUntil('\n');
    processCommand(command);
  }
}

void processCommand(String command) {
  // Parse the command
  int displayIndex;
  char filename[20];
  int duration;

  // Assuming command format: "DISPLAY_INDEX FILENAME DURATION"
  sscanf(command.c_str(), "%d %s %d", &displayIndex, filename, &duration);

  // Select the appropriate display and SD card
  ILI9341* tft;
  uint8_t sdCsPin;

  switch (displayIndex) {
    case 1:
      tft = &tft1;
      sdCsPin = SD1_CS;
      break;
    case 2:
      tft = &tft2;
      sdCsPin = SD2_CS;
      break;
    case 3:
      tft = &tft3;
      sdCsPin = SD3_CS;
      break;
    case 4:
      tft = &tft4;
      sdCsPin = SD4_CS;
      break;
    case 5:
      tft = &tft5;
      sdCsPin = SD5_CS;
      break;
    case 6:
      tft = &tft6;
      sdCsPin = SD6_CS;
      break;
    default:
      // Invalid display index
      return;
  }

  // Display the image
  displayImage(*tft, sdCsPin, filename);

  // Clear the display after the specified duration
  delay(duration * 1000);
  tft->fillScreen(ILI9341_BLACK);
}

void displayImage(ILI9341 &tft, uint8_t sdCsPin, const char* filename) {
  // Select the appropriate SD card
  SD.begin(sdCsPin);

  // Load the image from the SD card and display it on the screen
  // You will need a function to read and display BMP images
  // Example: readBMP(filename, tft);
}

Explanation

  1. Serial Communication:

    • The Serial.begin(9600); initializes serial communication.
    • The loop() function checks if there are any serial commands available and processes them using processCommand(command);.

  2. Command Processing:

    • The processCommand() function parses the command and determines which display to use and for how long.
    • The command format is assumed to be "DISPLAY_INDEX FILENAME DURATION", e.g., "1 image1.bmp 5".

  3. Display Image:

    • The displayImage() function initializes the appropriate SD card, loads the image, and displays it on the specified screen.
    • After displaying the image, the display is cleared after the specified duration.

  4. Delay and Clear Display:

    • The delay(duration * 1000); function waits for the specified duration in seconds.
    • The tft->fillScreen(ILI9341_BLACK); function clears the display by filling it with black.

Adjust the code according to your specific requirements and hardware setup. Ensure you have the necessary libraries for handling the ILI9341 displays and SD card readers.

since i'm using multiple SPI's connected to STM controller in the previous chat do it need to give any pull up resistor


    • Each device should have its own Chip Select (CS) line.
    • Pull-up resistors on the CS lines can help ensure the lines are in a known state during initialization. A common value for pull-up resistors is 10k ohms.

  2. MISO Line:

    • If multiple devices share the MISO line, ensure that only one device is driving the line at any time. This is typically handled by the SPI protocol where only the selected device (with CS low) drives the MISO line.

  3. Noise Reduction:

    • In noisy environments or with long traces, using pull-up or pull-down resistors on the SPI lines can help stabilize the signals. Typical values are between 4.7k and 10k ohms.

  4. Internal Pull-ups:

    • The STM32 can enable internal pull-ups on its GPIO pins. If additional external pull-ups are not used, ensure internal pull-ups are configured correctly.

Here’s how you can configure the GPIO pins in your code:

Example Code to Enable Internal Pull-ups

Here’s an example of how to configure the GPIO pins with internal pull-ups in an STM32 environment using the HAL library:

cpp:

// Include necessary libraries
#include "stm32f1xx_hal.h"

// SPI GPIO pin configuration
void SPI_GPIO_Init(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Enable GPIO Clocks
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();

    // SPI1 SCK, MISO, MOSI Pins (PA5, PA6, PA7)
    GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // ILI9341 Control Pins (CS, DC, RST)
    GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    // Additional ILI9341 Control Pins
    GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_8;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // SD Card CS Pins (PA9, PA10, PA11, PA12, PA15, PB6)
    GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_15;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_6;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}

// Main function
int main(void) {
    // HAL Initialization
    HAL_Init();

    // Configure the system clock
    SystemClock_Config();

    // Initialize SPI GPIO pins
    SPI_GPIO_Init();

    // Main loop
    while (1) {
        // Your code here
    }
}

Using External Pull-up Resistors

If you decide to use external pull-up resistors for additional stability, connect them as follows:

  • Connect a 10k ohm resistor between each CS line and VCC (3.3V).
  • If necessary, add pull-up resistors on the SCK, MISO, and MOSI lines to VCC (3.3V).

Example Circuit Diagram

Here’s a simple representation of connecting one ILI9341 with an external pull-up resistor on the CS line:

scss:
STM32F103C8T6        ILI9341 Display 1
  PA5 (SCK)   ------> SCK
  PA6 (MISO)  ------> MISO
  PA7 (MOSI)  ------> MOSI
  PB0 (CS)    ------> CS
  PB1 (DC)    ------> DC
  PB2 (RST)   ------> RST
                |
               10k
                |
               VCC (3.3V)

Repeat similar connections for the additional displays, ensuring each has its own unique CS line and optional pull-up resistor.

This setup should provide a stable configuration for using multiple ILI9341 displays with the STM32F103C8T6 microcontroller. Adjust the pin numbers and configuration based on your specific hardware and requirements.ChatGPT can make mistakes. Check important info.





for the above conversation, is the ino file be updated to STM32 by means of AVR programming
ChatGPT

To program an STM32 microcontroller using the Arduino IDE, you don't use AVR programming methods since AVR is specific to the Atmel (now Microchip) family of microcontrollers (like those used in Arduino Uno). Instead, you'll use the STM32 programming methods available in the Arduino IDE. Here’s how you can update your .ino file and ensure it is programmed correctly to an STM32 microcontroller like the STM32F103C8T6:

Steps to Program STM32 with Arduino IDE

  1. Install the Arduino IDE:

  2. Install STM32 Core:

    • Open the Arduino IDE.
    • Go to File > Preferences.
    • In the "Additional Boards Manager URLs" field, add:
      bash
      https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json
    • Click "OK".
    • Go to Tools > Board > Boards Manager.
    • Search for "STM32" and install the STM32 package.

  3. Select STM32 Board:

    • Go to Tools > Board > STM32 Boards (selected from submenu) > Generic STM32F1 series.
    • In Tools > Board part number, select BluePill F103C8 (or your specific STM32F103C8T6 board).

  4. Configure Upload Method:

    • In Tools > Upload Method, select STLink if you're using an ST-LINK programmer, or Serial if you're using a USB-to-Serial adapter.

  5. Write or Paste Your Code:

    • Open a new sketch in the Arduino IDE and paste your provided code.

  6. Install Required Libraries:

    • You need the Adafruit_ILI9341 and SD libraries. Install them via the Arduino Library Manager:
      • Go to Sketch > Include Library > Manage Libraries.
      • Search for and install Adafruit ILI9341.
      • Search for and install SD.

  7. Connect Your Hardware:

    • Connect your STM32 board to your computer using the appropriate programmer (ST-LINK or USB-to-Serial).

  8. Compile and Upload:

    • Click the "Verify" button to compile the code.
    • Click the "Upload" button to upload the code to your STM32 board.

Your .ino File

Here is the code in a complete .ino file format:

cpp:
#include <SPI.h>
#include <Adafruit_ILI9341.h>
#include <SD.h>

// Define pins for ILI9341
#define TFT1_CS PB0
#define TFT1_DC PB1
#define TFT1_RST PB2
#define TFT2_CS PB3
#define TFT2_DC PB4
#define TFT2_RST PB5
#define TFT3_CS PB8
#define TFT3_DC PB9
#define TFT3_RST PB10
#define TFT4_CS PB11
#define TFT4_DC PB12
#define TFT4_RST PB13
#define TFT5_CS PB14
#define TFT5_DC PB15
#define TFT5_RST PC13
#define TFT6_CS PC14
#define TFT6_DC PC15
#define TFT6_RST PA8

// Define pins for SD cards
#define SD1_CS PA9
#define SD2_CS PA10
#define SD3_CS PA11
#define SD4_CS PA12
#define SD5_CS PA15
#define SD6_CS PB6

// Create display objects
Adafruit_ILI9341 tft1(TFT1_CS, TFT1_DC, TFT1_RST);
Adafruit_ILI9341 tft2(TFT2_CS, TFT2_DC, TFT2_RST);
Adafruit_ILI9341 tft3(TFT3_CS, TFT3_DC, TFT3_RST);
Adafruit_ILI9341 tft4(TFT4_CS, TFT4_DC, TFT4_RST);
Adafruit_ILI9341 tft5(TFT5_CS, TFT5_DC, TFT5_RST);
Adafruit_ILI9341 tft6(TFT6_CS, TFT6_DC, TFT6_RST);

void setup() {
  // Initialize SPI
  SPI.begin();

  // Initialize Serial Communication
  Serial.begin(9600);

  // Initialize displays
  tft1.begin();
  tft2.begin();
  tft3.begin();
  tft4.begin();
  tft5.begin();
  tft6.begin();

  // Initialize SD cards
  if (!SD.begin(SD1_CS)) {
    Serial.println("SD1 initialization failed!");
    return;
  }
  if (!SD.begin(SD2_CS)) {
    Serial.println("SD2 initialization failed!");
    return;
  }
  if (!SD.begin(SD3_CS)) {
    Serial.println("SD3 initialization failed!");
    return;
  }
  if (!SD.begin(SD4_CS)) {
    Serial.println("SD4 initialization failed!");
    return;
  }
  if (!SD.begin(SD5_CS)) {
    Serial.println("SD5 initialization failed!");
    return;
  }
  if (!SD.begin(SD6_CS)) {
    Serial.println("SD6 initialization failed!");
    return;
  }
}

void loop() {
  if (Serial.available() > 0) {
    // Read command from serial
    String command = Serial.readStringUntil('\n');
    processCommand(command);
  }
}

void processCommand(String command) {
  // Parse the command
  int displayIndex;
  char filename[20];
  int duration;

  // Assuming command format: "DISPLAY_INDEX FILENAME DURATION"
  sscanf(command.c_str(), "%d %s %d", &displayIndex, filename, &duration);

  // Select the appropriate display and SD card
  Adafruit_ILI9341* tft;
  uint8_t sdCsPin;

  switch (displayIndex) {
    case 1:
      tft = &tft1;
      sdCsPin = SD1_CS;
      break;
    case 2:
      tft = &tft2;
      sdCsPin = SD2_CS;
      break;
    case 3:
      tft = &tft3;
      sdCsPin = SD3_CS;
      break;
    case 4:
      tft = &tft4;
      sdCsPin = SD4_CS;
      break;
    case 5:
      tft = &tft5;
      sdCsPin = SD5_CS;
      break;
    case 6:
      tft = &tft6;
      sdCsPin = SD6_CS;
      break;
    default:
      // Invalid display index
      return;
  }

  // Display the image
  displayImage(*tft, sdCsPin, filename);

  // Clear the display after the specified duration
  delay(duration * 1000);
  tft->fillScreen(ILI9341_BLACK);
}

void displayImage(Adafruit_ILI9341 &tft, uint8_t sdCsPin, const char* filename) {
  // Select the appropriate SD card
  if (!SD.begin(sdCsPin)) {
    Serial.println("SD initialization failed!");
    return;
  }

  // Load the image from the SD card and display it on the screen
  // You will need a function to read and display BMP images
  // Example: readBMP(filename, tft);
}

Summary

  • Use the Arduino IDE with the STM32 core installed.
  • Configure the board and upload method in the Tools menu.
  • Install the necessary libraries (Adafruit_ILI9341 and SD).
  • Compile and upload your code using the Arduino IDE.

This will allow you to program your STM32F103C8T6 microcontroller effectively using the Arduino IDE

Comments

Post a Comment