2026 Executive Summary: The MAP SensorThe Manifold Absolute Pressure (MAP) sensor is a critical component in modern internal combustion and hybrid engines. It measures air pressure inside the intake manifold to calculate air density and determine the precise fuel mass required for combustion. Failure leads to poor fuel economy, rough idling, and failed emissions tests.Key Data Points (2026):Lifespan: Typically 80,000 to 100,000 miles.Replacement Cost: $50–$250 (Part) + $100–$200 (Labor).Primary Codes: P0106, P0107, P0108.Why is the MAP Sensor Important in 2026?The powertrain control module (PCM) relies on the Manifold Absolute Pressure (MAP) sensor to monitor intake manifold pressure instantaneously. Because pressure is inversely related to vacuum, the PCM utilizes the MAP sensor input to calculate engine vacuum and load with high precision. In modern 2026 vehicle architectures, including hybrids, this data controls fuel injection pulse width, ignition timing, and EGR flow.This comprehensive guide details the diagnostic power of the MAP sensor, updated for 2026 maintenance standards.Video: Testing a MAP Sensor with modern diagnostic tools.Ⅰ What is a MAP Sensor?A MAP (Manifold Absolute Pressure) sensor is an electronic device that calculates air density by measuring the pressure variance inside the intake manifold. The Engine Control Unit (ECU) uses this real-time data to adjust the air-fuel mixture to the ideal stoichiometric ratio (14.7:1 for gas engines) and optimize ignition timing. This ensures the engine operates efficiently, minimizing emissions and maximizing power output.Ⅱ What is the Main Function of a MAP Sensor?The primary function of the MAP sensor is to provide the PCM with instantaneous manifold pressure data to calculate engine load. Specifically, it allows the computer to decide exactly how much fuel to inject into the cylinders. Furthermore, it retards or advances ignition timing to prevent "spark knock" (detonation), protecting internal engine components from severe damage.Ⅲ How Does A MAP Sensor Work (Technical Breakdown)Figure: Piezoresistive element operation within the sensor.The MAP sensor functions by converting intake air pressure changes into a voltage signal recognizable by the ECU. Modern sensors utilize a technology called piezoresistivity.The Mechanism: Inside the sensor housing lies a sealed vacuum chamber covered by a flexible silicon chip (diaphragm).Engine Off: When the engine is off, the pressure inside the manifold equals atmospheric pressure. This baseline helps the ECU determine altitude/air density.Engine Idle: When the engine starts, the pistons create a vacuum, lowering the pressure. The silicon chip flexes, altering its electrical resistance.Acceleration: When the throttle opens, air rushes in, increasing pressure (reducing vacuum). The chip flexes upward, resistance drops, and the output voltage signal to the ECU rises.The ECU processes this voltage spike (typically 0.5V to 4.5V range) to immediately enrich the fuel mixture for acceleration.Ⅳ Why is the MAP Sensor Critical for Fuel Economy?The MAP sensor ensures that the engine does not waste fuel or run too lean (which causes overheating). By providing "Total Mass Air Flow" calculations indirectly, it allows the vehicle to adapt to changing environments—such as driving from sea level to a high-altitude mountain pass—without driver intervention.Ⅴ 9 Common Bad MAP Sensor Symptoms (2026 Update)Diagnosing a failing sensor early prevents catalytic converter damage. Always start by scanning for Diagnostic Trouble Codes (DTCs).1. Check Engine Light (DTC P0106 - P0109)The most reliable indicator. Common codes include P0106 (Range/Performance), P0107 (Low Input), and P0108 (High Input). Note: A vacuum leak can trick the sensor into triggering these codes even if the sensor itself is healthy.2. Decreased Engine PowerIf the ECU cannot read load, it defaults to a "safe mode," retarding timing and reducing fuel, making the car feel sluggish—especially on inclines.3. Hard StartingWithout an atmospheric pressure reading at key-on, the ECU may inject too little or too much fuel for startup.4. Poor Fuel EconomyThe ECU may default to a "rich" mixture to protect the engine, causing a noticeable drop in MPG (often 10-20% reduction).5. Rough IdleFluctuating RPMs while stopped are common. The engine may hunt for a steady idle as the ECU struggles to compensate for missing pressure data.6. Engine MisfiresLean mixtures cause "lean pops," while rich mixtures foul spark plugs. Both result in misfires that shake the vehicle.7. Rich Fuel Smell from ExhaustIf the sensor reads high pressure erroneously, the ECU dumps excess fuel. This unburned fuel exits the tailpipe, creating a strong gasoline odor and potentially ruining the catalytic converter.8. SurgingYou may feel the car speed up or slow down unexpectedly while maintaining a steady throttle position.9. Failed Emission TestsHigh NOx (from running lean) or high HC/CO (from running rich) will cause an immediate failure in state inspections.Ⅵ How to Replace a MAP Sensor (Step-by-Step)Replacing a MAP sensor is typically a Level 1 DIY repair achievable in 15 minutes.Safety First: Disconnect the negative battery terminal to reset the ECU and prevent shorts.Locate: Find the sensor on the intake manifold (usually top or side) or connected via a vacuum hose near the firewall.Disconnect: Unclip the electrical harness. If there is a locking tab, slide it back first.Remove: Unscrew the retaining bolts (usually T20 Torx or 10mm) or carefully pull the sensor if it is held by friction/O-rings.Install: Lubricate the O-ring of the new sensor with a drop of clean oil, push it in, secure bolts, and reconnect the harness.Ⅶ Diagnostic Workflow: Is it the Sensor or Wiring?Before purchasing parts, verify the failure:1. Electrical CheckInspect the connector for corrosion or bent pins. Wiggle the wires while the engine idles; if the idle changes, you have a wiring short or open circuit, not a bad sensor.2. Vacuum Hose CheckIf your sensor connects via a hose, check for cracks. A $2 hose replacement often fixes "Bad Sensor" codes. Ensure the intake port is free of carbon buildup.3. Voltage TestWith the key ON (engine off), a healthy sensor reads atmospheric pressure (approx 4.5V or 100kPa). Upon starting, voltage should drop to approx 1.0V-1.5V. If it stays stuck, replace the sensor.Ⅷ Can You Clean a MAP Sensor?Yes, but with caution. Sensors blocked by carbon or blow-by oil can be restored.Remove Sensor: Carefully extract the sensor from the manifold.Select Cleaner: Use a dedicated Electronic Parts Cleaner or MAF Sensor Cleaner. Do not use Brake Cleaner, as it can melt the plastic housing and destroy the membrane.Spray: Hold the sensor with the port facing down. Spray the cleaner gently into the port.NO TOUCHING: Never insert a cotton swab, screwdriver, or compressed air into the sensor port. The silicon chip is thinner than a human hair and will break.Dry: Allow it to air dry completely (about 10 minutes) before reinstalling.If cleaning does not clear the error code, the piezoresistive electronics have failed and the unit must be replaced.Ⅸ MAP vs. MAF: What is the Difference?Most 2026 vehicles use both, but they function differently.MAP (Manifold Absolute Pressure): Measures Pressure (Air Density). Located on the manifold. Better for estimating load on turbocharged engines.MAF (Mass Air Flow): Measures Air Volume/Mass. Located on the intake tube before the throttle body. More precise for fuel tuning but sensitive to vacuum leaks.FeatureMAP SensorMAF SensorReliabilityHigh. Not affected by air leaks before the sensor.Sensitive. Any leak after the sensor throws off readings.PrecisionCalculated Load (Indirect).Actual Flow (Direct). More accurate for MPG.Ⅹ How Much Does MAP Sensor Replacement Cost in 2026?Prices have adjusted for the 2026 market. Replacing a MAP sensor remains an affordable repair relative to the damage ignoring it causes.DIY Cost: $40 to $150 for the part (Aftermarket vs. OEM).Professional Repair: $150 to $400 total.Note: Professional labor rates in 2026 average $120–$180 per hour. Since this is a quick job, shops often charge a minimum 1-hour diagnostic/labor fee.Ⅺ Frequently Asked Questions (FAQ)1. Do I need to upgrade my MAP sensor for tuning?Yes, only if adding a turbocharger. Stock sensors typically read up to 1 Bar (atmospheric). Boosted engines require 2-Bar or 3-Bar sensors to read positive pressure. You will need a "Plug-and-Play" adapter and an ECU retune to scale the new voltage map.2. Does a bad MAP sensor always throw a code?Not always. A sensor can be "lazy"—reading slowly or slightly off-spec—without triggering a hard fault code immediately. However, you will likely see "Pending Codes" on an OBD2 scanner before the check engine light turns on.3. Is it safe to drive with a bad MAP sensor?You can drive short distances in an emergency, but it is not recommended. The car may stall at intersections, suffer from severely reduced power ("Limp Mode"), and dump unburned fuel into the exhaust, which can destroy your catalytic converter—a repair costing over $1,000.4. Can a bad MAP sensor cause a misfire?Yes. If the sensor reports higher pressure than actual, the ECU injects too much fuel, fouling the spark plugs and causing misfires. Conversely, a low reading causes a lean misfire.5. Why does a bad MAP sensor prevent the car from starting?The ECU uses the MAP sensor reading before the engine cranks to determine barometric pressure. If this initial reading is dead, the ECU cannot calculate the initial fuel prime, leading to a "crank, no start" condition.6. How long do MAP sensors last?Modern sensors are designed for the life of the engine but realistically fail between 80,000 and 100,000 miles due to heat cycles and carbon contamination from the intake manifold.7. Will a bad MAP sensor trigger Limp Mode?Yes. Because the MAP sensor is critical for load calculation, losing its signal forces the ECU into "Open Loop" or Limp Mode to protect the engine, significantly restricting RPM and speed.{ "@context": "https://schema.org", "@type": "Article", "headline": "The Ultimate Guide to MAP Sensors: Symptoms, Function & Replacement (2026)", "datePublished": "2022-05-16", "dateModified": "2026-01-08", "author": { "@type": "Organization", "name": "ApogeeWeb Tech Team" }, "mainEntity": [ { "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "What is a MAP Sensor?", "acceptedAnswer": { "@type": "Answer", "text": "A Manifold Absolute Pressure (MAP) sensor is an electronic component that measures the pressure inside the intake manifold to help the engine control unit (ECU) calculate air density and determine the correct fuel injection rate." } }, { "@type": "Question", "name": "What are the symptoms of a bad MAP sensor?", "acceptedAnswer": { "@type": "Answer", "text": "Common symptoms include a Check Engine Light (codes P0106-P0109), poor fuel economy, rough idling, hard starting, engine misfires, and a smell of gas from the exhaust." } }, { "@type": "Question", "name": "Can you clean a MAP sensor?", "acceptedAnswer": { "@type": "Answer", "text": "Yes, you can clean a MAP sensor using specialized electronic parts cleaner. However, do not touch the internal sensor element with any physical object, as it is fragile." } }, { "@type": "Question", "name": "How much does it cost to replace a MAP sensor in 2026?", "acceptedAnswer": { "@type": "Answer", "text": "In 2026, the part typically costs between $40 and $150. If you hire a professional, expect to pay an additional $100 to $200 in labor, bringing the total to $150–$350." } } ] }, { "@type": "HowTo", "name": "How to Clean a MAP Sensor", "step": [ { "@type": "HowToStep", "name": "Locate and Remove Sensor", "text": "Disconnect the negative battery terminal, locate the MAP sensor on the intake manifold, unplug the connector, and remove the screws." }, { "@type": "HowToStep", "name": "Inspect Sensor", "text": "Check for carbon buildup or oily residue on the sensor port." }, { "@type": "HowToStep", "name": "Apply Cleaner", "text": "Spray Electronic Parts Cleaner or MAF Cleaner into the sensor port. Do not use brake cleaner or touch the element." }, { "@type": "HowToStep", "name": "Dry and Reinstall", "text": "Shake out excess fluid gently and let it air dry for 10 minutes before reinstalling." } ] } ]}

IntroductionWhat is RS485?MaterialsMAX485 pinoutHalf duplex operationHere is how the program worksFull duplex operationHalf duplex operation codeFull duplex codeIntroductionIn digital computer communication between two computers can be made using either parallel or serial method. In parallel communication separate line is dedicated for a one-bit information to transfer. This communication is fast and easy, but it requires a lot of wires at least as many as the number of bits need to be sent in parallel. For example, to transfer a 64-bit data from one device to another, 64 data lines will be required which is impractical in embedded systems. The alternative method to transfer data is to use serial communication. In serial communication one bit at a time is transferred from one device to another one. While this method solves the wiring problem it has a lot of other problems such as bandwidth, data lagging, complex protocol, and electrical standards. There are lot of different methods to do serial communication while one method is good in one situation another one is better in another situation. In this article we will discuss RS485 communication protocol which is one of the many available serial communication methods.Materials1MAX485 module2STM32 F401CDU6What is RS485?An industry specification called RS-485 outlines the physical layer and electrical interface for point-to-point electrical device communication. RS485 is the industrial standard for communication that defines the electrical interface and physical layer for point-to-point communication. RS485 is a robust communication system it can support multiple devices on a single bus, works in a noisy environment as well and requires a maximum of 4 lines.RS485 was first developed in 1983 and has since been used in many industrial applications because of its robustness and simplicity. It has the ability to transmit data over long distances while at the same time it is cheap, thus engineers are using it in all sorts of applications such as automotive, manufacturing, and theater spaces. Nowadays almost all motor controllers, VFDs and manufacturing machines will have a port available for RS485.RS485 is actually a standard that defines the electrical characteristics of the transmitters and receivers for communication protocols. RS482 uses two lines usually called A and B which must be balanced and differential. It means that the two lines must have same impedance, nearly same length and must be differential. The key features of RS485 communication are given belowMultipoint operation10 Mbps data transfer rate at 40 feet lengthMaximum cable length is 4000 feetRS485 works both in half duplex as well full duplex mode. In half duplex mode one device can either transmit or receive data at a time. While in full duplex mode, a device can transmit and receive data at the same time. Having more than one device on a bus can cause problem when two or more devices transmit data at the same time. Therefore, software control is necessary to ensure only one device transmit data at a time.RS485 is the physical layer of communication in the OSI model. It means this layer can be used as a base for other protocols such as UART which in most application people use because UART is an asynchronous communication protocol that does not require any clock signal which make it very easy to use. In this article we will demonstrate how RS485 can be used between two STM32 microcontrollers to communicate and exchange data. We will be using MAX485 module which is an easily available RS485 module. MAX485 pinoutRO → Receiver outputRE → Receiver enableDE → Data enableDI → Data inputVCC → Input voltageGND → GroundA, B → RS485 differential linesHalf duplex operationIn half duplex operation either data can be received or transmitted at a time. Both operations cannot be done at the same time. MAX485 has data flow control pins called DE and RE which puts the module in receiver mode or in transmit mode. Making them low puts the module in receiving mode while making them high puts the device in transmitter mode.In CubeMX the microcontroller of our choice is selected which in our case is STM32 F401CDU6. In connectivity UART1 should be enabled with 115200 bps baud rate. Other necessary settings are given below.RCC → Crystal/Ceramic ResonatorSYS → Debug → Serial WireClock Configuration → HCLK → 84 MHzClock Configuration → PLL Source Mux → HSEGPIO A7 is set as outputHere is how the program worksThe setup has two microcontrollers. We will call one side as A and the other side as B. When a user presses the user key on A STM32 microcontroller it will send the information to the B microcontroller via RS485. The receiving B microcontroller will switch on the onboard LED and will responds with an OK message. The OK message will blink the led on A microcontroller twice. Similarly, when the user presses key on B microcontroller it will transmit a message to A microcontroller and turns on the onboard LED and will responds with an OK message. The OK message will blink LED on B microcontroller twice. Similarly pressing the button again will do the same except this time it will turn off the LED.Full duplex operationIn full duplex operation data can be received or transmitted at the same time. Both operations can be done at the same time. In this mode two MAX485 modules will be required at each end and overall, 4 MAX485 modules will be used. It means that the two MAX485 modules will be constantly in receiving mode while the other two will constantly in transmission mode. MAX485 has data flow control pins called DE and RE which puts the module in receiver mode or in transmit mode. We will put the data control pins of two module as high while put the data control pins of other two module low. The configuration is shown below.The program works the same way as it was working in the half duplex mode however, this time the transmitted and received by MCUs at the same time.Half duplex operation code#include "main.h" UART_HandleTypeDef huart1; /* USER CODE BEGIN PV */int8_t R_Data[1] = {0};int8_t T_Data[1] = {69};/* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/void SystemClock_Config(void);static void MX_GPIO_Init(void);static void MX_USART1_UART_Init(void); int main(void){   HAL_Init();   SystemClock_Config();     MX_GPIO_Init();  MX_USART1_UART_Init();  /* USER CODE BEGIN 2 */  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);   //Put RS485 module in receiving mode  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);   //Turn Off LED pin    while (1)  {      HAL_UART_Receive(&huart1, R_Data, 1, 10);  // If button is pressed on the other MCU  if(R_Data[0] == 83)  {  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);                //Toggle LED pin  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);    //Put RS485 module in transmission mode  HAL_UART_Transmit(&huart1, T_Data, 1, 10);             //Send acknowledgment  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  //Put RS485 module in transmission mode  R_Data[0] = 0;  }  // If OK message is receive  if(R_Data[0] == 69)  {  if (HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_13))  {  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  }  else  {  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  }  R_Data[0] = 0;  }  // Button is pressed  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0))  {  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);    //Put RS485 module in transmission mode  T_Data[0] = 83;  HAL_UART_Transmit(&huart1, T_Data, 1, 10);  T_Data[0] = 69;  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);    //Put RS485 module in Receiving mode  }  }  /* USER CODE END 3 */}Full duplex code#include "main.h" UART_HandleTypeDef huart1; /* USER CODE BEGIN PV */int8_t R_Data[1] = {0};int8_t T_Data[1] = {69};/* USER CODE END PV */ /* Private function prototypes -----------------------------------------------*/void SystemClock_Config(void);static void MX_GPIO_Init(void);static void MX_USART1_UART_Init(void); int main(void){   HAL_Init();   SystemClock_Config();     MX_GPIO_Init();  MX_USART1_UART_Init();  /* USER CODE BEGIN 2 */  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);   //Turn Off LED pin    while (1)  {      HAL_UART_Receive(&huart1, R_Data, 1, 10);  // If button is pressed on the other MCU  if(R_Data[0] == 83)  {  HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);                //Toggle LED pin  HAL_UART_Transmit(&huart1, T_Data, 1, 10);             //Send acknowledgment  R_Data[0] = 0;  }  // If OK message is receive  if(R_Data[0] == 69)  {  if (HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_13))  {  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  }  else  {  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);  HAL_Delay(500);  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);  }  R_Data[0] = 0;  }  // Button is pressed  if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0))  {  T_Data[0] = 83;  HAL_UART_Transmit(&huart1, T_Data, 1, 10);  T_Data[0] = 69;  }  }  /* USER CODE END 3 */}  

Catalog Introduction How does an LDR work? How to setup ADC in STM32 Introduction The majority of streetlights and outdoor lights are typically operated manually. To manually turn on and off lights is not only risky, but it also wastes energy well as the timing of turning on and off is not optimized. Therefore, an optimized, efficient, and automatic light system is needed to efficiently control light brightness and turn on and off them automatically. In this article, a brief introduction to automatic control of light brightness is given as well as its practical implementation using an STM32 microcontroller and a cheap LDR sensor shown in Figure 1 is demonstrated. Figure 1 LDR breakout board In an automatic light control system, a light detection system is employed that senses the light intensity. If the application requires only to turn on and off a light system, then a threshold value of light intensity is set below which the light will turn on, and above it, the light will turn off. However, if the application is to control the light brightness based on the light intensity in the environment, then a PWM-controlled voltage is provided to the automatic light system. For light detection, a Light Dependent Resistor commonly known as LDR is used. LDR is a sensor whose resistance varies with the intensity of light. This property of an LDR can be used to sense darkness and brightness. Thus, it can be used to automatically control the turn on and off as well as the intensity of the light system. A typical LDR has a maximum resistance value in mega ohms and a minimum resistance value in several kilo ohms. Materials 1STM32 F401/F1032LDR sensor3Potentiometer4LED How does an LDR work? So, how exactly does an LDR operate? LDR works on the principle of photoconductivity. It is an optical phenomenon in which material conductivity increases when light falls upon it. When light or photon strikes the material, the electrons in the semiconductor material's valence band are stimulated to the conduction band. The incident photons must have energy larger than the bandgap of the semiconductor material to cause the electrons to move from the valence band to the conduction band. Hence as light intensity increases more and more electrons are excited to the conduction band which produces a large number of charge carriers. This means that more current will flow in the circuit, and as a result, the resistance will decrease. LDR resistance that changes with the intensity of light cannot be read in a microcontroller. To make it readable in a microcontroller the resistance is represented in terms of voltage. For this purpose, a circuit needs to be designed. Many circuits can be used for LDR. These can be based upon MOSFET, BJET, or an amplifier. However, the most commonly used circuit for LDR to convert its resistance into voltage is the voltage divider circuit. In this circuit, two resistors are installed in series. One side is attached to the positive terminal of the battery while the other is attached to the ground. The schematic of the voltage divider is shown in Figure 2. The output of the voltage divider can be fed to another circuit for other purposes such as a comparator i.e LM393. Usually, a comparator is used in on-off operations where the lights are needed to be turned on and off when a threshold value of light intensity is absorbed by the LDR. A typical circuit for the LM393 comparator is shown below. Figure 2 LM393 comparator usage with LDR The calculation for the voltage divider circuit is pretty easy. Referring to Figure 2, the following equation can be used to measure the output voltage.   In this equation, it is assumed that there is no load on the output voltage because that load can affect the output voltage. The output of the circuit is shown in Figure 2 where the change in resistance changes the voltage at the IN1+ pin of the comparator. As we know the voltage changes with the intensity of light. The circuit gives maximum voltage in complete darkness while minimum voltage when placed in bright light. The ADC of the STM32 controller can be used to sense the change in the voltage while the results obtained via ADC can be used to generate PWM. It is the PWM that generates average voltage and hence controls the intensity of light. In this article, both the manual and automatic light intensity control is demonstrated using an LED light. The program and procedure for automatic and manual light brightness control is same, the only difference is that in automatic light brightness control and LDR is used while in manual mode simple potentiometer is used. How to setup ADC in STM32 In STM32, ADC can be configured in three different ways. 1) Polling 2) Interrupt 3) DMA. Polling: In the polling method when ADC conversion starts the CPU operation halts. It is only after the conversion is completed, the CPU resumes working. Interrupt: The second method is by using the interrupt service routine. When ADC conversion competes, it generates an interrupt during which required functions are executed which in our case is to update the PWM value. DMA: The third method is to use direct memory access (DMA). In this method, the ADC directly transfers the data to memory bypassing the CPU altogether. This is the most efficient method of all as it does not involve CPU in the ADC operations and keeps it available for other tasks. In this experiment, we will be using interrupt methods which are both simple and efficient. Required hardware STM32 F401/F103LDR sensor (breakout board will be better)PotentiometerLED Let's build the program step by step Open STM32CubeIDE and start a new projectSelect an MCU which in our case is STM32F401CDGo to SYS -> Debug and select Serial Wire. Select SystTick in TimeBase Source. Go to RCC-> High Speed Clock and select Crystal/Ceramic Resonator.   Configure ADC1. Select IN1 and set it to be triggered by software. From the NVIC controller tab check the global interrupt box. Configure Timer 1 in PWM mode with output on CH1. Set the counter period register value to 839 and Prescaler register value to 100. This will ensure 1000 Hz frequency at the output.  The following formula can be used to set PWM frequency Setting Prescaler value to 99 while the required frequency is 1000 Hz, the ARR value can be calculated as 839.     Finally set the clock frequency to 84 MHz and select HSE as the clock source. And generate the code. The final code is given below #include "main.h"ADC_HandleTypeDef hadc1;TIM_HandleTypeDef htim1;void SystemClock_Config(void);static void MX_GPIO_Init(void);static void MX_ADC1_Init(void);static void MX_TIM1_Init(void);uint16_t AD_Data = 0; uint16_t minimumADC = 1000; uint16_t maximumADC = 3000;int main(void){  HAL_Init()  SystemClock_Config();  MX_GPIO_Init();  MX_ADC1_Init();  MX_TIM1_Init();  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);  while (1)  {  HAL_ADC_Start_IT(&hadc1);  TIM1->CCR1 = ((AD_Data-minimumADC)*840)/maximumADC;  }}void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc){    AD_Data = HAL_ADC_GetValue(&hadc1);} Figure 3 Duty Cycle in Bright Light Figure 4 Duty Cycle in Low Light   Resources Automatics Light.zip