analogRead() overflow behavior changes across AVR-to-ARM int width boundary

Answer the question first

When you port a sketch from an 8‑bit AVR (e.g., Uno) to a 32‑bit ARM or ESP32 board, the type int changes from a signed 16‑bit to a signed 32‑bit integer. Because analogRead() still returns an int, arithmetic that relied on 16‑bit wrap‑around will behave differently. The Arduino core does not provide a compiler flag that forces a diagnostic for this width change, and the public API has not been updated to use fixed‑width types. The practical, supported solution is to explicitly cast the ADC value (or the result of any expression) to the width you intend to use.

Why casting works

• It guarantees the same bit‑width on every target.
• It makes the intent of the code clear to future maintainers.
• It protects against accidental use of a wider type that could overflow later in the expression.

What you should do when writing sensor arithmetic

1. Determine the desired precision. 10‑bit ADCs on AVR give values 0–1023; 12‑bit ADCs on SAMD/ESP32 give 0–4095. If you need to keep the 10‑bit range, cast to int16_t after analogRead().
2. Use fixed‑width types for intermediate calculations. When multiplying or adding large numbers, declare the variables as int32_t or int64_t as needed.
3. Wrap map() calls in a cast if you rely on 16‑bit wrap‑around. For example:

   int16_t raw = (int16_t)analogRead(A0);
   int16_t mapped = (int16_t)map(raw, 0, 1023, -512, 511);
   

4. Prefer the map() overload that takes long parameters if you want to keep the 32‑bit range:

   long raw = analogRead(A0); // 32‑bit on ARM
   long mapped = map(raw, 0L, 1023L, -512L, 511L);
   

5. When using the result in further calculations, keep the type explicit:

   int32_t sensorValue = (int32_t)raw;
   // ...
   

Compiler diagnostics

The Arduino IDE does not enable -Wconversion by default, so implicit narrowing is silent. If you want the compiler to warn you about potential truncation, add the flag manually in the platform.txt or via the build.extra_flags field in platform.local.txt (or in the project’s platformio.ini if you use PlatformIO). Example for PlatformIO:

[env:uno]
platform = atmelavr
board = uno
build.extra_flags = -Wconversion

This will surface warnings when a 32‑bit value is assigned to a 16‑bit variable without an explicit cast.

Future core changes

As of the latest Arduino core releases (1.8.x and 2.x), there is no announced plan to change analogRead() or map() to return or accept fixed‑width types. The community has requested a deprecation of the 16‑bit int on AVR, but no migration path has been documented. Until such a change is released, explicit casting remains the only reliable method.

Ask for missing diagnostic detail

To fine‑tune the recommendation for your specific sketch, could you share the ADC resolution you are targeting (10‑bit vs 12‑bit) and whether you rely on signed overflow in any expression? This will help determine the exact width you should cast to.