... but may be difficult; a microcontroller + driver is great for learning but not the easiest. To find the pinout, measure resistance with a multimeter: with 3 wires, all pairwise readings should match (the three phases); with 4 wires, the pin that reads the same to all others is the neutral; phase Order only affects direction, so swap any two leads to reverse. To avoid damage, never apply DC across two leads, don’t stall the rotor, keep leads short (with a decoupling capacitor near the driver), and WAtch temperature.

This kind of issue is quite common when cascading multiple 74HC595 shift registers. First, make sure you're shifting out the correct number of bits—8 bits Per chip—before pulsing the latch pin. Timing can also be a factor, so try adding a small delay (like delayMicroseconds(1)) after the latch pulse. Signal integrity often becomes a problem as more ICs are added, especially with long wires or breadboards—keep connections short, use 100nF decoupling capacitors near each chip, and consider adding 100Ω series resistors on data and clock lines. Also, check that all chips share a common ground and that your power supply can handle the total current draw. Lastly, ensure your shiftOut() direction (MSBFIRST or LSBFIRST) matches your wiring. These steps usually solve most inconsistent behavior when chaining multiple 74HC595s.

I'm trying to cascade multiple 74HC595 shift registers to expand the number of digital outputs in my project. While one shift register works Perfectly on its own, as soon as I add the second (and especially the third), I start getting strange or inconsistent output—some LEDs don’t light up correctly, or they shift out of Order. Is there a timing issue I might be overlooking? Do I need to delay between latching and shifting? Could signal integrity or voltage drop be the issue when chaining several ICs?

Signal sampling is the process of measuring an analog signal at regular intervals so it can be converted into digital form by an ADC (Analog-to-Digital Converter). The sampling rate is the number of samples taken Per second, usually measured in Hertz (Hz). A proper sampling rate is essential for accurately capturing the original signal. If the sampling rate is too low, the ADC may miss important changes in the signal, leading to aliasing, where the digital representation becomes distorted or misleading. On the other hand, if the sampling rate is too high, it creates excessive data, which can strain memory, processing power, and storage without adding useful detail. Resolution, determined by the ADC’s bit depth, defines how precisely each sample represents the signal’s voltage level. However, even high-resolution data won’t help without a good sampling rate. As a general rule, sample at least twice the highest frequency in the analog signal (Nyquist rate) to ensure accuracy.

... tries to debounce but isn't ideal because it blocks the loop and prevents the Arduino from doing anything else during that time. Direct Button Read Without Edge Detection – Since you're checking digitalRead(buttonPin) == HIGH, if you hold the button down even slightly too long, it keeps toggling instead of switching just once Per press. Try the program given below. Better program to toggle LED state with a single button: const int buttonPin = 2; const int ledPin = 13; bool ledState = false; bool lastButtonState = LOW; unsigned long lastDebounceTime = ...

... shift register, and you can daisy-chain multiple registers to control even more LEDs. This is a great solution if you need simple on/off control for your LEDs. Multiplexing – If you don’t need all LEDs to be on simultaneously, you can use a multiplexing approach. This involves arranging LEDs in a matrix where rows and columns are controlled separately, significantly reducing the number of GPIOs needed. However, since LEDs are turned on one at a time in rapid succession, brightness might be affected unless you use high-speed switching. LED Driver ICs (e.g. ...

Both are very different from each other. Here's how: Flash Memory Purpose: Primarily used to store the program (firmware) that runs on the microcontroller. Access Method: Works at the block level, meaning you write or erase data in chunks, not byte by byte. Endurance: Lower than EEPROM, typically around 10,000 to 100,000 write/erase cycles Per block. Speed: Faster read speeds compared to EEPROM. Capacity: Much larger than EEPROM (e.g., Arduino Uno has 32 KB of Flash memory). EEPROM (Electrically Erasable Programmable Read-Only Memory) Purpose: Designed to store small amounts of data that need to be saved even when the power is off (e.g., device settings or user preferences). Access Method: Data is accessed and written byte by byte, making it Perfect for small, frequently changing data. Endurance: It has a high write endurance, typically allowing 100,000 to 1,000,000 write/erase cycles. Speed: Slower compared to Flash. Capacity: Usually much smaller (e.g., Arduino Uno has only 1 KB of EEPROM). What is their purpose in Arduino boards? Flash Memory: This is where your Arduino sketch is stored when you upload it via the IDE. If you need to store constant data like lookup tables, you can use Flash with the PROGMEM directive. EEPROM: You can use it to store user-defined values like calibration data or device settings using the EEPROM library to store it Permanently.

EEPROM (Electrically Erasable Programmable Read-Only Memory) allows you to store data even after the board is powered off. It's non-volatile. This makes it useful for storing things like settings, calibration values, or any data you WAnt to retain. Let's understand the different memory types in Arduino: SRAM: Works as temporary storage while the program is running. Data in SRAM is lost when the power is turned off. Flash Memory: The Arduino stores your program code here. Like EEPROM, flash memory is non-volatile, but you can't store or retrieve any data d ...

Hey, Note: UNO R3 supports 8-bit PWM resolution, not 10. Higher resolution means the PWM output can be more finely tuned, resulting in a smoother signal. This is particularly important in applications like motor control, LED dimming, and audio signal generation. 8-bit resolution means there are 256 possible duty cycle values (from 0 to 255). That's why the analogWrite(PWM pin, PWM value) takes values bw 0 and 255. In this case, increasing the duty cycle step by step corresponds to a change of approximately 0.4% (1/256) of the full-scale value. Whereas the 16-bit resolution means there are 65,536 possible duty cycle values (from 0 to 65,535).Each step in the duty cycle corresponds to a change of approximately 0.0015% (1/65,536) of the full-scale value. As much as the resolution is important, so does the frequency of the PWM signal. The increase in PWM resolution decreases the maximum PWM frequency possible for the same clock frequency. if UNO and ESP32 have the same clock frequency i.e., 16 MHZ. The maximum possible PWM frequency(16-bit) for ESP32 will only be 244 Hz. Whereas for UNO(8-bit), it is 62.5 KHz. For example, 16 MHz / 256 and 16 MHz / 65,536. EDIT: Hey everyone! Let’s clear up the confusion regarding PWM resolution and the difference between dividing by 2^n versus 2^n - 1 The Hardware Timer Perspective In fast PWM mode, the timer counts from 0 up to a “TOP” value and then overflows back to 0. For 8-bit PWM, TOP = 255. This gives you a counter range of 0–255 = 256 distinct counts. For 2-bit PWM, TOP = 3. This gives you a counter range of 0–3 = 4 distinct counts. Thus, in terms of raw timer ticks, there are 2^n counts Per cycle. The Duty Cycle Perspective When calculating duty cycle, we typically use: Duty Cycle (%)= (Compare Register Value/TOP) ×100. For 8-bit PWM, you divide by 255 (TOP = 255), so the highest compare value 255 yields 100 % duty cycle. For 2-bit PWM, you divide by 3 (TOP = 3), so a compare value of 3 yields 100 % duty cycle. If you were to divide by 2^n directly (e.g., 256 for 8-bit), the maximum compare value (255) would give (255/256)x 100 =~ 99.6% which technically matches clock ticks but doesn’t align with the usual definition of 100 % on hardware PWM outputs. Why It Matters 0 % duty cycle: Compare Register = 0. 100 % duty cycle: Compare Register = TOP (which is 2^n - 1). Users generally expect that the maximum compare setting translates to the output being fully ON (i.e., 100 %). Summary The timer truly counts 2^n steps (from 0 to 2^n−1). However, to get a duty cycle Percentage from 0 % to 100 %, you divide the compare value by 2^n - 1. That’s why for 8-bit PWM, you’ll see many references to dividing by 255, not 256.