LCSC Skystar Development Board Expansion Board - Learning Expansion Board

Project Introduction
This project is a learning expansion board I created using some existing modules and based on the LCSC Skystar high-end version.
Project Functions
This project includes the following functions (the attached table contains specific pin usage):

Matrix button
serial port 3 leads out
4 IO leads out
8 LEDs
2 ADC module interfaces
Infrared remote control decoder interface
DS18B20/DHT11 interface
0.96-inch OLED interface
MPU6050 interface
8-digit digital tube
passive buzzer
2 servo motor drive interfaces
TB6612 module and 2 motor drive interfaces controlled by TB6612

Actual Photos
3D Drawings
Note: Some modifications and additions have been made to the silkscreen and circuit, so there are some inconsistencies with the actual product images.
Hardware Specifications
The attached table contains specific pin usage
Power Supply
Since it needs to drive some small motors, a DC-DC power supply is used. Refer to the chip datasheet for recommended circuits and add filter capacitors.
Note: Using a charger with a partial output of 12V 1A may cause a restart when driving a DC motor. The H1 interface in the
matrix button
circuit diagram can switch between 16 matrix buttons and 4 independent buttons by shorting the terminal.
Serial port 3 leads and IO leads
are provided for easy connection to other modules.
The 8 LEDs
use the same group of GPIOs for easy control of
the 2 ADC modules.
Considering that commonly used module interfaces include both digital and analog outputs, H8 and H7 interfaces are added for switching.
The infrared remote control decoder interface
uses a single row of round-hole female connectors for easy replacement
of the DS18B20/DHT11 interface.
By grounding the empty pin 3 of the DHT11, it can be adapted to the DS18B20. Round-hole female connectors are also used for easy switching.
The 0.96-inch OLED interface and MPU6050 interface
use the same IIC connection
. The segment selection and digit selection of the digital tube
use the same group of I/O, arranged sequentially for easy programming. The
passive buzzer
used is a 12mm diameter passive buzzer; the connected I/O ports can reuse timers.
Two servo drive interfaces
can be directly used to drive servo motors.
The TB6612 module and two motor drive interfaces controlled by the TB6612 are also
included. A dual-channel DC motor drive module connects all controllable pins to the core board for control. Example
software code
is attached; only basic driver
code is implemented. The character encoding used in the project is UTF-8. If Chinese characters are garbled, please switch
the encoding in the settings. Detailed
example code is included
. Directory structure: Project folder
├── BSP //Extension board driver code directory│
├── Inc
│ │ ├── bsp_adc.h //ADC driver code│
│ ├── bsp_buzzer.h //Buzzer driver code│
│ ├── bsp_ds18b20.h //DS18B20 driver code│
│ ├── bsp_iic.h // Software IIC driver code│
│ ├── bsp_infrared.h // Infrared decoding driver code│
│ ├── bsp_key.h // Button driver code│
│ ├── bsp_led.h // LED driver code│
│ ├── bsp_mpu6050.h // MPU6050 driver code, depends on bsp_iic.h
│ │ ├── bsp_nixie.h // Digital tube driver code│
│ ├── bsp_oled.h // OLED driver code, depends on bsp_iic.h
│ │ ├── bsp_oledbmp.h // OLED image array│
│ ├── bsp_oledfont.h // OLED character array│
│ ├── bsp_servo.h // Servo driver code│
│ ├── bsp_tb6612.h //Driver code for TB6612 controlling DC motors│
│ └── bsp_w25q128.h //Driver code for core board W25Q128│
└── Src
│ ├── bsp_adc.c
│ ├── bsp_buzzer.c
│ ├── bsp_ds18b20.c
│ ├── bsp_iic.c
│ ├── bsp_infrared.c
│ ├── bsp_key.c
│ ├── bsp_led.c
│ ├── bsp_mpu6050.c
│ ├── bsp_nixie.c
│ ├── bsp_oled.c
│ ├── bsp_oledbmp.c
│ ├── bsp_oledfont.c
│ ├── bsp_servo.c
│
├── bsp_tb6612.c │ └── bsp_w25q128.c
├── Drivers //HAL library driver code├──
Core
├── MDK-ARM
├── keilkill.bat //Compilation intermediate file cleanup script└──
sky_star_Expansion_board.ioc //STM32CubeMX project
main function call code
example. Use the code in the main loop, uncomment it to use
/* USER CODE BEGIN 2 */

char str[50];

MYIIC_Init();
MYADC_Init();
OLED_Init();
SERVO_Init();
TB6612_Init();
IR_Init();
MPU6050_Init();
OLED_DisplayTurn(1);
KEY_ModeChange(0);


/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
//uart & DS18B20 example
sprintf(str, "%.2f

", DS18B20_GetTemperture());
HAL_UART_Transmit(&huart1, (uint8_t*)str, strlen(str), 50);
HAL_Delay(100);

//buzzer example
for (uint16_t i = 0; i <= 2000; i += 200)
{
Buzzer_Cfg(i,50);
Buzzer_Use(1);
HAL_Delay(1000);

Buzzer_Use(0);
HAL_Delay(1000);
}


//led Example
for (uint8_t i = 1; i <= 8; ++i)
{
Led_On(i);
HAL_Delay(50);
Led_Off(i);
HAL_Delay(50);
}

//ADC example
MYADC_GetVal();
sprintf(str, "adc1:%f", MYADC_adc1Valf);
OLED_ShowString(0, 0, (uint8_t *)str, 16, 1);
sprintf(str, "adc2:%f", MYADC_adc2Valf);
OLED_ShowString(0, 16, (uint8_t *)str, 16, 1);
OLED_Refresh();

//key example
if (KEY_flag == 1 && KEY_GetState(1))
OLED_ShowChar(0, 0, '1', 16, 1);
if (KEY_flag == 1 && KEY_GetState(2))
OLED_ShowChar(8, 0, '2', 16, 1);
if (KEY_flag == 1 && KEY_GetState(3))
OLED_ShowChar(16, 0, '3', 16, 1);
if (KEY_flag == 1 && KEY_GetState(4))
OLED_ShowChar(24, 0, '4', 16, 1);
if (KEY_flag == 1 && KEY_GetState(5))
OLED_ShowChar(32, 0, '5', 16, 1);
if (KEY_flag == 1 && KEY_GetState(6))
OLED_ShowChar(40, 0, '6', 16, 1);
if (KEY_flag == 1 && KEY_GetState(7))
OLED_ShowChar(48, 0, '7', 16,1);
if (KEY_flag == 1 && KEY_GetState(8))
OLED_ShowChar(56, 0, '8', 16, 1);
if (KEY_flag == 1 && KEY_GetState(9))
OLED_ShowChar(64, 0, '9', 16, 1);
if (KEY_flag == 1 && KEY_GetState(10))
{
sprintf(str, "10");
OLED_ShowString(72, 0, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(11))
{
sprintf(str, "11");
OLED_ShowString(88, 0, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(12))
{
sprintf(str, "12");
OLED_ShowString(0, 16, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(13))
{
sprintf(str, "13");
OLED_ShowString(16, 16, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(14))
{
sprintf(str, "14");
OLED_ShowString(32, 16, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(15))
{
sprintf(str, "15");
OLED_ShowString(48, 16, (uint8_t *)str, 16, 1);
}
if (KEY_flag == 1 && KEY_GetState(16))
{
sprintf(str, "16");
OLED_ShowString(64, 16, (uint8_t *)str, 16,1);
}
OLED_Refresh();

//servo example
for (uint8_t i = 0; i < 180; i+=5)
{
if (i < 90)
SERVO_Ch2Angle(i);
else
SERVO_Ch1Angle(i);

}
HAL_Delay(100);
OLED_Refresh();

//TB6612 control DC motor example
TB6612_Pwm1Mode(TB6612_MotorFWD);
TB6612_Pwm2Mode(TB6612_MotorFWD);
for (uint8_t i = 0; i < 100; i+=5)
{
TB6612_Pwm1Duty(i);
TB6612_Pwm2Duty(i);
HAL_Delay(100);
}
TB6612_Pwm1Mode(TB6612_MotorBRK);
TB6612_Pwm2Mode(TB6612_MotorBRK);
HAL_Delay(200);
TB6612_Pwm1Mode(TB6612_MotorREV);
TB6612_Pwm2Mode(TB6612_MotorREV);
for (uint8_t i = 0; i < 100; i+=5)
{
TB6612_Pwm1Duty(i);
TB6612_Pwm2Duty(i);
HAL_Delay(100);
}
TB6612_Pwm1Mode(TB6612_MotorBRK);
TB6612_Pwm2Mode(TB6612_MotorBRK);
TB6612_AllClose();
HAL_Delay(200);
OLED_Refresh();

//MPU6050 Example
MPU6050_ReadGyro();
MPU6050_ReadAcc();
sprintf(str, "GX%5d AX%5d", MPU6050_gyroX, MPU6050_accX);
OLED_ShowString(0, 0, (uint8_t *)str, 16, 0);
sprintf(str, "GY%5d AY%5d", MPU6050_gyroY, MPU6050_accY);
OLED_ShowString(0, 16, (uint8_t *)str, 16, 0);
sprintf(str, "GZ%5d" AZ%5d", MPU6050_gyroX, MPU6050_accZ);
OLED_ShowString(0, 32, (uint8_t *)str, 16, 0);
OLED_Refresh();


//Infrared remote control example
sprintf(str, "%3d %3d %3d %3d", IR_data[0], IR_data[1], IR_data[2], IR_data[3]);
OLED_ShowString(0, 0, (uint8_t *)str, 16, 1);
sprintf(str, "%3x %3x %3x %3x %3d", IR_data[0], IR_data[1], IR_data[2], IR_data[3], IR_repeatCnt);
OLED_ShowString(0, 16, (uint8_t *)str, 16, 1);
sprintf(str, "%3d", IR_repeatCnt);
OLED_ShowString(0, 32, (uint8_t *)str, 16, 1);
OLED_Refresh();

/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}
Note:

The output of the part used is 12V 1A The charging head may restart when driving a DC motor.
This project only uses the bottom shell, using acrylic material instead of the top shell. See the assembly process for details.

Assembly Process
: Required parts:

1 white 3D printed bottom shell,
1 acrylic panel from the LCEDA project, 4
M3x6 screws from the LCEDA project, and
M3 * 5 + 4 hexagonal copper pillars. Assemble the bottom shell, insert the screws , place the PCB from the front, and secure it with the hexagonal copper pillars . Cover with the acrylic cover and tighten the nuts. Actual product image.