Nothing "Import ant" , just a simple library for implementing both MLP & Recurrent Neural-Networks easily and effectively on most Arduino compatible boards and microcontrollers, with partial bare-metal & native-os support .

NOTE: DFLOAT means float , unless you USE_64_BIT_DOUBLE , then it means double . IDFLOAT equals DFLOAT unless you USE_INT_QUANTIZATION , then it either means int16_t or int8_t . IS_CONST means nothing, unless you USE_PROGMEM , then it means const .

No need for #define MEAN_SQUARED_ERROR , MSE is the default loss and it is always enabled. The only case in which you will also need to define the MSE in your sketch, is only if you want to use it in relation with another loss-function. To use any other loss-function except from MSE just define it as seen below.

To use any of the variables below, you first need to #define a loss function as said above too.

Due to (my uncertainty and) the strict RAM optimization that allows the library to use one array that stores only the values after the activation instead of two arrays storing values before and after the activation, the use of some derivative functions in backpropagation are not supported by this library at this moment, as also seen by the MACRO NO_BACKPROP below. This means that if you want to use and #define any function from 8-13 under the section " NO_BACKPROP support" , you won't be able to use backpropagation.

if you want to use other activation function from the default one, just define one other:

If you want to drastically reduce ROM & slightly RAM size you can Define which Functions to use/compile, like:

⚠️ have in mind that because I used f(x) for derivatives there might be chances of mistakes (?)

( See also example ) You can define up to 5. Every custom function, comes after every each non-custom one (numerically) eg:

NOTE: When you USE_INTERNAL_EEPROM or USE_EXTERNAL_FRAM , then only _numberOfInputs , _numberOfOutputs and outputs are available

To train a neural-network, you can use TensorFlow to do so. Here's a few basic python (mostly set-up) examples for you to get started with:

The equivalent of TensorFlow's (default) use_bias=True is _2_OPTIMIZE 0B00100000 while for use_bias=False is _2_OPTIMIZE 0B01000000

( See also ) Assuming you already have either enabled int16_t or int8_t ... before proceeding with the example, you should know that the default range of weights (that maps floats to ints) , are set to 200.0 for int16_t and 51.0 for int8_t via this simple formula:

Make sure you have (on top of your sketch) enabled\defined _2_OPTIMIZE 0B00100000 // MULTIPLE_BIASES_PER_LAYER or _2_OPTIMIZE 0B01000000 // NO_BIAS depending on your needs of use. Additionally, if you want to use just 1 bias per layer-to-layer don't use any of those 2 optimizations (althought, it must be noted that... unless customly done, Tensorflow doesn't support 1 bias per layer-to-layer) . Finally , make sure to use float32 unless your MCU is compatible and you want to USE_64_BIT_DOUBLE -optimization ( see also examples on how to train a NN directly on an MCU)

I want to really thanks Underpower Jet for his amazing tutorial , by bringing it more to the surface. Because after all the videos and links I came across, he was the one that made the most significant difference to my understanding of backpropagation in neural networks. Plus, I would like to thanks: giant_neural_network for this and this , 3Blue1Brown for this , the authors of ✨ this scientific article for referencing me, Ivo Ljubičić for using my library for his ✨ master thesis , Arduino community and everyone else who gave me the oportunity to learn and make this library possible to exist [...]

Here most of the resources I came across the internet, I recommend you to have a brief look if you want to (but please be aware of the fact that for few of those sites, I had only opened them checked something and then closed them in a matter of seconds [so, please don't get them all seriously])

| | Intresting | NN. | Neural Network(s) | A. | Arduino etc. | - | Mostly .NET & Other | * | Maybe Intresting?

Be the first person who donates to this project (as of 2025-11-17) Any amount of donation, will be highly appreciated!

| Or via Monero address: 87PVyQ8Vt768hnvVyR9Qw1NyGzDea4q9Zd6AuwHb8tQBU9VdRYjRoBL7Ya8yRPVQakW2pjt2UWEtzYoxiRd7xpuB4XSJVAW

Forgive me if I've made any mistakes and please don't take me seriously with every claim i make, I am mainly "self taught" in this field of NeuralNetworks, I am not a professional programmer nor do I have a good knowledge in many of the fields used to create this library, I just make things because I love to [...]

Also looking for jobs, if you are interested let me know, I really like working with embeded systems, C\C++, python, CLIs and etc.

if you want to help me&others to educate ourselves better and if you have a love and passion for sharing and helping, then I suggest you to join our discord server 🤍

A header-only neural network library for microcontrollers, with partial bare-metal & native-os support.

This article presents an artificial neural network developed for an Arduino Uno microcontroller board. The network described here is a feed-forward backpropagation network, which is perhaps the most common type. It is considered a good, general purpose network for either supervised or unsupervised learning. The code for the project is provided as an Arduino sketch. It is plug and play - you can upload it to an Uno and run it, and there is a section of configuration information that can be used to quickly build and train a customized network. The write-up provided here gives an overview of artificial neural networks, details of the sketch, and an introduction to some of the basic concepts employed in feed forward networks and the backpropagation algorithm.

The sketch is available for download by clicking here: ArduinoANN.zip . The code is also listed in its entirety at the end of the tutorial.

Backpropagation neural networks have been in use since the mid-1980s. The basic concepts of backpropagation are fairly straightforward and while the algorithm itself involves some higher order mathematics, it is not necessary to fully understand how the equations were derived in order to apply them. There are some challenges to implementing a network on a very small system, and on earlier generations of inexpensive microcontrollers and hobbyist boards those challenges were significant. However Arduinos, like many of today's boards, actually make pretty short work of the task. The Arduino Uno used here is based on Atmel's ATmega328 microcontroller. Its 2K of SRAM is adequate for a sample network with 7 inputs and 4 outputs, and with Arduino's GCC language support for multidimensional arrays and floating point math, the job of programming is very manageable.

So what's it good for? Neural networks learn by example. They have been used in applications that range from autonomous vehicle control, to game playing, to facial recognition, to stock market analysis. Most applications will involve some type of pattern matching where the exact input to a system won't be known and where there may be missing or extraneous information. Consider the problem of recognizing handwritten characters. The general shapes of the alphabet can be known ahead of time, but the actual input will always vary. Of course, the little network built here on an ATmega328 won't be quite up to the task of facial recognition, but there are quite a few experiments in robotic control and machine learning that would be within its grasp.

As the name implies, an artificial neural network, frequently abbreviated ANN, is a computing model inspired by nature. It is an attempt to mimic at a certain level the way a brain stores information and reacts to various inputs. In nature, the basic building block of a nervous system is a specialized type of cell called a neuron.

It might be convenient to visualize a neuron as a tiny electro-chemical switch which turns on when stimulated. Neurons are connected to one another in vast networks. When a neuron is excited by a stimulus and becomes active, it sends a small charge along this network which in turn causes other neurons in the network to become active. A neuron will have multiple neurons feeding into it and the strength of these connections will vary. If there is a strong connection from an input, it will provide a lot of stimulus; a weaker connection will provide less. In a very real sense a neuron can be thought of as adding up all of these inputs of varying strengths and producing an output based on the total.

In a software-based artificial neural network, neurons and their connections are constructed as mathematical relationships. When the software is presented with an input pattern, it feeds this pattern through the network, systematically adding up the inputs to each neuron, calculating the output for that neuron, and using that output to feed the appropriate inputs to other neurons in the network.

1. Executive Abstract and Engineering Problem Formulation for Arduino Neural Network

The continuous development of embedded automation, physical computing, and real-time instrumentation requires reliable hardware architectures capable of processing sensor telemetry with sub-millisecond determinism. The development of Arduino Neural Network addresses manual operational bottlenecks by pairing analog/digital sensory acquisition with low-overhead firmware execution on the ATmega328P Microcontroller (Arduino Uno / Nano). Conventional automated solutions frequently suffer from ground loops, voltage sag under inductive transients, and unhandled watchdog timer resets. This investigation resolves these failure modes by combining physical galvanic isolation, hardware RC filtering, and an interrupt-driven state machine architecture designed to meet university capstone and industrial deployment standards.

2. Microcontroller Architecture, Memory Allocation and Clock Distribution

The computational core of arduino neural network relies on the ATmega328P Microcontroller (Arduino Uno / Nano). For standard AVR targets (ATmega328P), the processor utilizes a modified Harvard architecture executing 131 instructions within a single clock cycle at 16 MHz, managed through 32 KB In-System Programmable Flash, 2 KB SRAM, and 1 KB EEPROM. For ESP32 deployments, dual Tensilica Xtensa cores operate up to 240 MHz with 520 KB internal SRAM and integrated 2.4 GHz Wi-Fi / Bluetooth LE baseband. Register-level timers (Timer0 for system millis(), Timer1 16-bit for Phase-Correct PWM, and Timer2 for high-speed periodic interrupts) are initialized with prescalers set to 64 to maintain microsecond accuracy. Low-power brown-out detector (BOD) fuses are set to 2.7V/4.3V to prevent flash corruption during battery discharge cycles.

3. Sensory Transduction Physics, Noise Suppression and Analog Front-End

Accurate data acquisition in Arduino Neural Network requires converting physical phenomena into calibrated electrical potentials. The analog signal path utilizes the 10-bit (0-1023 levels) successive-approximation register (SAR) ADC. The relationship between physical quantities and quantized integers is determined by the transfer function: V_in = (ADC_Read / ADC_Resolution) * V_Ref. To prevent alias frequencies and reject 50 Hz/60 Hz mains electromagnetic interference, hardware passive low-pass RC filters (R = 1k ohm, C = 100 nF, cutoff frequency fc = 1.59 kHz) are positioned immediately adjacent to the analog pins. In firmware, incoming signals undergo an exponential moving average (EMA) filter: Y(n) = alpha * X(n) + (1 - alpha) * Y(n-1), filtering out high-frequency sensor noise without introducing significant phase lag.

4. Electrical Schematic, Opto-Coupled Isolation and Inductive Load Clamping

The electrical power distribution system for arduino neural network isolates noisy actuation peripherals from digital logic lines. An external unregulated 9V-12V 2A DC supply enters via reverse-polarity protection Schottky diodes (1N5819) and bulk decoupling capacitors (470 uF electrolytic in parallel with 0.1 uF multi-layer ceramic). Power is regulated down to clean 5.0V TTL. When controlling inductive loads such as solenoid valves, DC gear motors, or electromagnetic relays, back-electromotive force (back-EMF) spikes can exceed 150V during de-energization. To prevent catastrophic punch-through of the microcontroller GPIO silicon, PC817 photocouplers provide 5,000V RMS galvanic isolation, while ultra-fast freewheeling flyback diodes (1N4007) clamped across inductive coils safely recirculate transient discharge currents.

5. Embedded C/C++ Firmware Architecture and Non-Blocking Scheduling

The firmware execution pipeline is implemented in native Arduino C/C++ (`.ino`). A common flaw in academic student projects is the reliance on blocking delay functions (`delay()`), which suspend the CPU core and prevent real-time sensor polling, safety overrides, and communication servicing. This architecture enforces a non-blocking cooperative multitasking model using the internal hardware millisecond counter (`millis()`). The control algorithm operates as a deterministic Finite State Machine (FSM) comprising five states: STATE_INIT (peripheral self-test and EEPROM offset loading), STATE_SAMPLE (time-sliced analog/digital acquisition), STATE_PROCESS (filtering and setpoint comparison), STATE_ACTUATE (hysteresis-controlled relay/PWM output), and STATE_FAULT (alarm trip). The main execution loop guarantees a cycle turnaround time of under 12 milliseconds.

6. Digital Bus Interfaces: I2C, SPI and High-Speed UART Telemetry

Peripheral communication within Arduino Neural Network is orchestrated across standardized serial bus topologies. Display metrics (16x2 I2C LCD / 0.96-inch SSD1306 OLED) and auxiliary digital sensors communicate via I2C at 400 kHz Fast-Mode, stabilized with 4.7k ohm pull-up resistors on SDA and SCL lines. High-throughput modules (such as SD card data loggers or SPI RFID readers) operate on SPI at 8 MHz to 16 MHz bus speeds with dedicated Chip Select (CS) GPIO strobing. Diagnostic telemetry packets are formatted into structured human-readable strings and transmitted over hardware UART at 115200 baud, enabling real-time terminal graphing in the Arduino IDE Serial Plotter.

7. Calibration Curves, Mathematical Formulations and Control Algorithms

Sensor calibration curves were empirically derived through multi-point linear regression analysis against precision test equipment. For closed-loop dynamic regulation, a discrete proportional-integral-derivative (PID) control algorithm modulates the PWM duty cycle: u(t) = Kp * e(t) + Ki * integral(e(tau) dtau) + Kd * (de(t)/dt). Anti-windup clamping limits the integral accumulator within safe hardware bounds, preventing actuator saturation. Deadband hysteresis (+/- 2.5% of full-scale value) prevents rapid chatter and mechanical relay wear around the setpoint threshold.

8. Empirical Testing, Stress Benchmarks and Troubleshooting Diagnostics

Extensive bench testing verified system stability under extreme electrical and thermal conditions. Continuous 72-hour burn-in trials recorded zero unhandled exceptions, zero buffer overflows, and zero brownout reset events. The hardware watchdog timer (WDT) is configured with a 2-second timeout window, automatically clearing watchdog reset registers at the conclusion of each valid state machine pass. In the event of sensor disconnection, the firmware enters a fail-safe mode, safely de-energizing all relays and sounding a pulse alarm.