BLDC Desktop Fan

Project Description:
This is a brushless motor table fan. The structural components can be manufactured using 3D printing, and some metal parts are also used. It has a built-in battery that charges via a Type-C interface, allowing for simultaneous charging and use. The screen can display the battery level and heatsink temperature in real time and can be used as a thermometer when not in use.
Project Functions
1. Ratchet structure, which can adjust the pitch angle and orientation of the fan and fix it
2. Only one encoder is used for speed adjustment and start/stop, which is convenient to use and has a simple appearance
2. Closed-loop speed control, the user experience is not affected by battery voltage
3. (Jialichuang) 11-blade fan with light curing printing, low noise, large air volume, and high toughness, but safety is not guaranteed. After weighing the pros and cons, it is used
Update Log
24/08/26:
(1) The program has been optimized to improve the startup speed and success rate
24/08/29 : (1)
Fixed the problem of the OLED screen freezing after a period of use
(2) Added 2212 self-locking motor dedicated silent fan blades 24/08/31: (1) Fixed the problem in the comparator interrupt function, which caused the motor to make abnormal noise at high speed (2) The fixed delay of 30 degrees electrical angle commutation was changed to a freely settable delay angle 24/9/1: (1) Optimized part of the speed control PID code, reduced some noise, and changed the speed sampling to be performed in the timer interrupt 24/9/10: (1) Improved the problems with OLED by using DMA to transfer data. (2) Improved some abnormal issues. (3) The model file provides assemblies for reference during assembly. (4) Provided a new fan model with a better appearance and slightly increased airflow. (5) The 2212 motor is not very effective, and the fan blades are a mess. It is not recommended to use it. Principle Analysis (Hardware Description) Power Supply Section: PD/Fast Charging Protocol Spoofing: A CH224K transistor is used to induce 12V. When spoofing is successful, the PG output is low. The main controller detects this and displays a prompt on the screen. Main Control Power Supply : A DC-DC converter is used for higher efficiency and energy saving . Power Stage: An upper-side PMOS and lower-side NMOS design is adopted, achieving a duty cycle of up to 100%. It is also equipped with a high-efficiency gate driver, resulting in very low heat generation from the MOS transistors . //Note: Do not solder the IN- resistor connected to the gate driver; that is, R16, R17, and R20 on the board do not need to be soldered. // This is the gate waveform when the gate resistance is 2 ohms. You can continue to adjust it as needed. Zero-Crossing Detection Circuit: The correctness and timing of commutation greatly affect motor noise and efficiency. Below is a common zero-crossing detection resistor network. I used... An external comparator was used for further processing, which is compatible with microcontrollers without built-in comparators. I also believe that using a comparator for detection is faster and more accurate. However, I added an RC filter at the output to remove glitches, but I feel that it might be better without it. Early test boards did not have this filter, and software filtering of glitches seemed to result in less noise. Those who like to tinker can try it without soldering and modifying the code. Programmer interface: This is an RJ1 telephone jack, which is a rather special design. A separate programmer is needed for this, which you may find troublesome. However, you can use this programmer in your future projects. This interface is very durable, easy to plug and unplug, and has a secure connection. Software code overall framework Part code details: How to know when to switch phases and which phase to switch to? This issue can be referenced at https://blog.csdn.net/snail_dongbin/article/details/82803076. In the code implementation, the interrupt trigger of the three output I/O ports of the comparator is configured to be edge-triggered, and both rising and falling edges will trigger the interrupt. In the interrupt, the level state of the three I/O ports is read, and then the phase to be switched is determined based on this level state. uint8_t BLDC_ReadFB(uint8_t filter) { uint8_t date; while (filter--) { date = GPIOA->IDR & 0xE0; // 1110 0000 PA7 PA6 PA5 } return date >> 5; } void BLDC_XPHAS_Close(void) { uint8_t rotorloca; rotorloca = BLDC_ReadFB(1); switch (GlobalDir) { case 1: switch (rotorloca) { case 5: // C+B- BLDC_MosCtrl(CpBn); EXTI->IMR |= EXTI_IMR_MR5; // Enable phase A interrupt break; case 4: // C+A- BLDC_MosCtrl(CpAn); EXTI->IMR |= EXTI_IMR_MR6; // Enable phase B interrupt break; case 6: // B+A- BLDC_MosCtrl(BpAn); EXTI->IMR |= EXTI_IMR_MR7; // Enable phase C interrupt break; case 2: // B+C-





























































BLDC_MosCtrl(BpCn);
EXTI->IMR |= EXTI_IMR_MR5; // Enable A-phase interrupt
break;
case 3: // A+C-
BLDC_MosCtrl(ApCn);
EXTI->IMR |= EXTI_IMR_MR6; // Enable B-phase interrupt
break;
case 1: // A+B-
BLDC_MosCtrl(ApBn);
EXTI->IMR |= EXTI_IMR_MR7; // Enable C-phase interrupt
break;
default:
break;
}
break;
........
The induced electromotive force in the diagram, after being processed by the comparator, can be viewed as high and low levels. Arranging abc into three binary numbers from low to high, we can see that when the floating phase voltage jumps, the obtained numbers correspond one-to-one with the cases in the code above. The code example above is the reverse of the order in the diagram, from CB to AB. A pattern can be observed from the numbers in the case statements: the two phases to be conducted correspond to the numbers in the case statements (+ corresponds to 1, - corresponds to 0), while the floating phases alternate between 0 and 1. If the bit representing the floating phase in each case statement is inverted, the code corresponding to the inversion is obtained.
By utilizing the COM event function of the advanced timer TIM1, seamless switching of the switching states of the six MOSFETs can be achieved. To do this, the initialization function should call `TIM_CCPreloadControl(TIM1, ENABLE);` // Enable preloading of complementary output enable registers `
void BLDC_MosCtrl(MoState_TypeDef`)
{
`TIM1->CCER &= ~(TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E |
TIM_CCER_CC1NE | TIM_CCER_CC2NE | TIM_CCER_CC3NE);` // Clear PWM output
`TIM1->CCMR1 |= TIM_CCMR1_OC1M;`
`TIM1->CCMR1 &= ~TIM_CCMR1_OC1M_0;` // Reset complementary output A to PWM mode `
TIM1->CCMR1 |= TIM_CCMR1_OC2M;` `
TIM1->CCMR1 &= ~TIM_CCMR1_OC1M_0;` ~TIM_CCMR1_OC2M_0; // Reset B phase complementary output to PWM mode
TIM1->CCMR2 |= TIM_CCMR2_OC3M;
TIM1->CCMR2 &= ~TIM_CCMR2_OC3M_0; // Reset C phase complementary output to PWM mode
switch (mostate) {
case ApBn:
TIM1->CCER |= TIM_CCER_CC1E;
TIM1->CCER |= TIM_CCER_CC2NE;
TIM1->CCMR1 |= TIM_CCMR1_OC2M_0;
TIM1->CCMR1 &= ~TIM_CCMR1_OC2M_1; // Force B phase lower transistor to turn on
break;
case CpBn:
TIM1->CCER |= TIM_CCER_CC3E;
TIM1->CCER |= TIM_CCER_CC2NE;
TIM1->CCMR1 |= TIM_CCMR1_OC2M_0;
TIM1->CCMR1 &= ~TIM_CCMR1_OC2M_1; // Force B-phase tube opening
break;
case CpAn:
TIM1->CCER |= TIM_CCER_CC3E;
TIM1->CCER |= TIM_CCER_CC1NE;
TIM1->CCMR1 |= TIM_CCMR1_OC1M_0;
TIM1->CCMR1 &= ~TIM_CCMR1_OC1M_1; // Force A-phase tube opening
break;
case BpAn:
TIM1->CCER |= TIM_CCER_CC2E;
TIM1->CCER |= TIM_CCER_CC1NE;
TIM1->CCMR1 |= TIM_CCMR1_OC1M_0;
TIM1->CCMR1 &= ~TIM_CCMR1_OC1M_1; // Force A-phase tube opening
break;
case BpCn:
TIM1->CCER |= TIM_CCER_CC2E;
TIM1->CCER |= TIM_CCER_CC3NE;
TIM1->CCMR2 |= TIM_CCMR2_OC3M_0;
TIM1->CCMR2 &= ~TIM_CCMR2_OC3M_1; // Force C-phase tube opening
break;
case ApCn:
TIM1->CCER |= TIM_CCER_CC1E;
TIM1->CCER |= TIM_CCER_CC3NE;
TIM1->CCMR2 |= TIM_CCMR2_OC3M_0;
TIM1->CCMR2 &= ~TIM_CCMR2_OC3M_1; // Force C-phase tube opening
break;
default:
BLDC_OstClaer();
break;
}
TIM1->EGR |= TIM_EGR_COMG; // Update the above registers
}

As shown in the code above, the enable register and mode register of TIM1 are both preloaded. Reading and writing their contents will not immediately change the output state of the PWM channel. It will only change when a COM event bit is written to the event generation register at the end. In this way, all 6 PWM output channels can be changed at the same time.
How to achieve 30-degree electrical angle commutation with delay?
TIM7 uses single-count mode. After an external interrupt connected to the comparator is triggered, TIM7 is enabled to start counting. Then, within the TIM7 interrupt, BLDC_GetDelayAngleVal(30) is called. This function calculates the time elapsed between two adjacent commutations and assigns the return value to the timer's ARR register to determine the delay time after the next external interrupt triggered by the comparator.
void TIM7_IRQHandler(void)
{
if (TIM7->SR & TIM_SR_UIF) { // Check the interrupt flag
TIM7->ARR = BLDC_GetDelayAngleVal(30);
BLDC_XPHAS_Close();
// EXTI->IMR |= (EXTI_IMR_MR5 | EXTI_IMR_MR6 | EXTI_IMR_MR7); // Enable commutation interrupt
}

TIM7->SR &= !TIM_SR_UIF; // The specific implementation of clearing
the interrupt flag
involves reading the count value of a timer that is constantly in a timing state, saving the previous count value, and subtracting the previous count value from the current count value to obtain the interval between two commutations. Since the electrical angle interval between two commutations is 60 degrees, half of the difference is taken, or processed as shown in the code below to implement an optional delay angle. The if statement is for overflow judgment. Because the CNT value ranges from 0 to 65535, if the previous CNT value is close to 65535, the current value obtained is likely to be a smaller value, requiring processing. The code snippet
`uint16_t BLDC_GetDelayAngleVal(uint16_t angle)
{
float delayval;

Anglast_cntval = Angcntval;
Angcntval = TIM2->CNT;
delayval = Angcntval - Anglast_cntval;

if (delayval < 0) { delayval
= 65535 + delayval;
}

delayval /= (60 / angle);
delayval` is used to determine the delay angle. += 0.5; // Rounding
return delayval;
}

How to start the motor?
As we all know, when a motor stops rotating, it cannot generate back electromotive force, so the current position of the motor rotor is unknown. My strategy is to first call BLDC_BackLoca() to forcibly drag the rotor to a certain position.
void BLDC_BackLoca(void)
{
BLDC_SetGlobalPwm(0.15);
BLDC_MosCtrl(ApBn);
vTaskDelay(300)

; BLDC_MosCtrl(ApCn)
; vTaskDelay(300);

BLDC_MosCtrl(ApBn);
vTaskDelay(300);
}
Then start timer 6 to drag back and forth between two adjacent phases at a fixed time interval, creating a rapid jittering effect. After a certain number of times, disable interrupts and enable the interrupt line connected to the comparator to enter closed-loop commutation
void BLDC_OpenLoopStartup_ISR(void)
{
static uint8_t Temp;
static uint16_t xphascount;
static uint8_t state = BLDC_start;
switch (state) {
case BLDC_start:
// BLDC_OpenLoopCtrl(startcycle, startperiod, GlobalDir, 1);
xphascount = 0;
Temp = 1;
state = BLDC_Pull;
break;
case BLDC_Pull:
if (Temp) {
BLDC_MosCtrl(ApBn);
Temp = 0;
} else {

BLDC_MosCtrl(ApCn);
Temp = 1;
}
state = BLDC_counting;
break;
case BLDC_counting:
if (xphascount >= 10) {
xphascount = 0;
// startperiod -= 100;
state = BLDC_speedup;
} else {
xphascount++;
state = BLDC_Pull;
}
break;
case BLDC_speedup:
state = BLDC_start;
xphascount = 0;
StartUpFlag = 1; // Set the start flag to 1
TIM6->CR1 &= ~TIM_CR1_CEN; // Turn off timer 6 and exit open-loop control
BLDC_CloseLoopStartUp(0.1, 1); // Start closed-loop control:
`xQueueSendFromISR(xQueue_MotorStartUp, &StartUpFlag, NULL);` // Send start signal: `
break;`
default:
`BLDC_OstClaer();` // Shut down all MOSFETs: `
break;
`
Firmware
download
and firmware burning:
First, install WCHISPTool. The software interface is shown in the image, and the options are the same. In the User Program File section, select the firmware to be burned.
Use tweezers to short-circuit the pad below the arrow and the pin indicated by the arrow, and simultaneously insert the USB cable to connect to the computer. At this time, you will hear a prompt sound from the computer, and the device will automatically appear in the USB device list. Then you can release the tweezers and click Download.
This firmware burner is actually WCHLINK. After burning the firmware, the default mode is RCICV. After unplugging the USB cable, press and hold the button on the front of the board and then plug it back in. Wait for both LEDs to light up, indicating that it has switched to ARM mode.
Motherboard firmware burning:
Method 1: If you have VS Code installed and have configured the EIDE plugin environment, you can directly click Workspace in the package,
then click Build in the upper right corner, and then click Burn.
Method 2: Click Keil project, open it, click Magic Wand, and select STM32F103VE as Device.
Select DAP for Debug,
click Utilities-setting
and check all options, then compile and flash. Normally, I've already selected all the steps for you. You can check
the assembly process
. First, heat-fit the motor cable compartment and the base ratchet disc with a 8mm nut and
press the ball-head plunger into the part shown in the picture.
Press the ratchet disc into the connecting piece.
Install the part with the ball-head plunger just pressed into the pitch seat.
Place a 608 bearing and press it all the way down.
Place the ratchet disc into the base and tighten it with locking screws. Place a washer on the bearing and screw contact surface.
Assemble the parts shown in the picture. Use M3X12 screws for the fan cover and M3X6 screws for the support rod. Use an electric screwdriver to drive them in; they are very sturdy. Remember to leave enough motor cable length. Finally, tighten the connecting piece with locking screws.
Pass the motor cable through the hole in the base ratchet disc, then use M3X6 screws to fix the support rod to the base ratchet disc.
Fix the OLED module with the soldered PH terminal wire and the encoder module to the base using M2X6 screws.
Due to a design error, the Type-C on the motherboard... The order of the battery connectors is reversed compared to the purchased materials. You can either solder the connectors backwards or manually modify the wiring sequence. The wiring sequence is already marked on the motherboard. Simply use tweezers to slightly pry up the plastic piece shown in the diagram to easily pull out the terminal wires.
Solder the motor wires to the motherboard's surface-mount component side, then use M3X6 screws to fix the motherboard to the base housing. Add a washer between the motherboard and the screws. Note that the Type-C connector requires removing the battery housing to access the connector, so you'll eventually need to disconnect the wires. It's recommended to simply modify the wiring sequence.
After confirming that the battery's positive and negative wire sequences correspond to the markings on the motherboard, connect them correctly. Observe that the OLED display is normal, then press the encoder to start the fan. If the rotation direction is incorrect, press the fan to stop, or directly remove the battery. Toggle the switch marked DIR. If your motor has a positive thread, the correct direction is counter-clockwise; if it has a negative thread, the correct direction is clockwise. If the direction is incorrect, the motor will not be able to self-lock the blades, causing a hazard.
Finally, tidy up all the wires, place the base on the bottom housing, and tighten it with M3X12 screws. Then install the three feet on the bottom housing, and you can start using it!
My current model files provide fan covers with inner diameters of 140 and 150 mm, and both sizes offer three motor mounting options: the readily available MT2204, RS2205, and 1806 motor mountings. I personally use the 2204, which requires a separate propeller mount. You can choose according to your preference and actual needs.
If any abnormalities occur and the device malfunctions, you can restore it by pressing the reset button through the small hole on the bottom shell.