A Wearable System for Real-Time Fall Detection on Resource-Constrained Devices

Abstract

In this study, we propose a wearable fall detection system that combines wearable sensors, TinyML model, and IoT-based communication for real-time monitoring and detection of falls. The system is designed for resource-constrained IoT devices where memory, power, and processing capacity are limited. The system works by collecting body motion data using accelerometer sensors placed on the human body. The data is then processed using a feedforward neural network trained on preprocessed signals. The trained model is quantized so that it can run on low-power embedded hardware with small memory size. The model performs inference directly on the device. This reduces latency and avoids sending raw sensor data to the cloud. When a fall is detected, the result is sent through Bluetooth to a gateway. The gateway forwards the data to a cloud server using the MQTT protocol. The cloud stores the data and supports monitoring and analysis. The experimental results show that the quantized TinyML model achieves 98.40% accuracy with more than 80% F1-score and more than 99% recall. The deployed model uses only ∼5 KB of RAM and ∼40 KB of flash memory. The inference time is 7 ms per class. These results show that wearable sensing with quantized TinyML models and IoT communication can provide fast and reliable fall detection for real-world safety monitoring systems.

1. Introduction

Human Activity Recognition is a growing research field that focuses on developing machine learning models to detect and classify different human activities. The activity recognition system is used in many domains such as healthcare, sports training, and child monitoring. Traditional activity detection systems use fixed sensors in the environment or sensors attached to different parts of the human body. These setups can be uncomfortable and inconvenient for the person who uses them. The progress in TinyML and embedded machine learning have now enabled machine learning models for activity recognition to run directly on resource-constrained microcontrollers, which as a result reduces latency, bandwidth for sending and receiving data, and dependence on cloud inference [1,2,3].

The motivation for this work comes from the need to improve human safety using practical and reliable technology. Fall detection is an important application in healthcare monitoring, especially for older adults, due to the high risk of injury, disability, and mortality associated with falls. The proposed approach may also be relevant for individuals with mobility impairments, neurological conditions, or balance disorders that increase the risk of falling. However, the present study does not include clinical validation for these populations and is limited to controlled experimental evaluation. Early detection helps in providing timely assistance, reducing the severity of injuries, and supporting better patient care. In healthcare, continuous monitoring with wearable systems also helps detect abnormal motion patterns and possible health events at an early stage, which may contribute to reducing long-term medical costs.

Conventional fall detection systems employ wearable technologies such as smartphones, chest straps, pendants, buttons, and smartwatches and are commonly based on inertial sensors embedded in these devices. These systems continuously monitor body movement and orientation, enabling real-time identification of abnormal motion patterns associated with falls. However, such devices can be uncomfortable or inconvenient, which may reduce user acceptance. In addition, fixed sensors placed on floors or walls may not work effectively in all situations, particularly in outdoor environments. Because of this, researchers are developing unobtrusive and effective fall detection systems.

Recent developments in IoT and machine learning models that run locally on-device have opened up new opportunities in applications such as activity tracking and fall detection. IoT enables communication and data flow between devices, while lightweight machine learning models can perform inference on resource-constrained hardware such as microcontrollers. In this work, a hybrid fall detection framework is proposed that combines supervised TinyML-based classification with K-means-based anomaly detection. The classification model identifies predefined activities such as falling, walking, and idle, while the anomaly detection module provides complementary information by identifying motion patterns that deviate from normal behavior [4,5,6,7,8,9].

IoT-enabled wearable devices are widely used in healthcare monitoring, sports and rehabilitation, smart homes, assisted living, and industrial safety. However, many existing IoT systems still depend on continuous transmission of raw sensor data to remote cloud servers for inference, which as a result increases inference latency and is also a privacy risk. Such systems also depend on continuous network connectivity, which can make them less reliable in case of poor or no-connectivity environments. These limitations highlight the importance of on-device intelligence, which makes the machine learning models run directly on edge devices such as microcontrollers, reducing cloud dependency, lowering latency, and preserving privacy.

TinyML models are executed on low-power and low-resource microcontroller devices and do not rely on cloud servers. This enables the processing of data in real time and is very important for fall detection and activity monitoring. Since the raw sensor data are process by these TinyML models locally on edge devices, it also reduces the overhead of sending data to cloud servers for inference and get back the result thus help in reducing cost and also improves privacy [10,11].

Previous research on fall detection has investigated both cloud-based and edge-based systems. Among these, edge-based approaches provide added benefits such as instant response, improved privacy, reduced network dependence, and lower data transmission requirements [12]. A wearable IoT system using a three-axis accelerometer and low-power wireless sensing combined with real-time analytics achieved high fall classification accuracy with edge computing support [13]. In a smart home environment, an accelerometer-based wearable device connected via Bluetooth Low Energy to a home automation platform demonstrated fall detection with low energy consumption and integration with smart home systems [14]. IoT-based fall detection systems have also been developed that combine wearable sensors with layered network architecture and artificial neural network classifiers to support near real-time processing [15]. Studies on smartphone-based fall detection highlight that built-in accelerometers in mobile devices can be effectively used for fall recognition in IoT-enabled environments, discussing practical challenges and sensor strategies [16].

These studies help explain the main challenges in building human activity recognition systems for low-resource devices. In this study, we propose a wearable smart garment, particularly a jacket, with embedded electronics that uses accelerometer data and a TinyML-based model to detect fall events and other human activities in real time. TinyML models can run on devices with limited memory and power, which makes them suitable for on-device activity detection with the following characteristics:

• Resource Efficiency: TinyML models are lightweight and optimized, ensuring efficient execution on the edge.
• Low Latency: This is essential for real-time performance and quick action in applications where immediate response is required.
• Optimized for Edge Devices: TinyML models are quantized and are an ideal choice for resource-constrained environments.

Despite significant progress in wearable fall detection systems, several limitations remain. Many existing approaches rely on cloud-based processing or smartphone-class hardware, which introduces latency, energy consumption, and dependency on network connectivity. Furthermore, a large number of studies focus primarily on classification accuracy without addressing the constraints of deployment on microcontroller-class devices, such as memory footprint, inference latency, and energy efficiency. In addition, only a limited number of works provide an end-to-end integration of wearable sensing, on-device TinyML inference, and real-time IoT-based alert mechanisms. These gaps highlight the need for a lightweight, embedded, and fully integrated fall detection system that operates efficiently on resource-constrained hardware while maintaining acceptable detection performance.

The main contributions of this work are as follows:

• A wearable fall detection system is designed using an IMU-based sensing approach integrated into a lightweight embedded platform.
• A TinyML-based classification model is developed for real-time activity recognition, focusing on three activity classes: falling, walking, and idle.
• The model is optimized for deployment on resource-constrained microcontroller hardware, and both floating-point and quantized implementations are evaluated.
• The system integrates on-device inference with an IoT-based communication pipeline to enable real-time alert transmission.
• The study provides detailed evaluation metrics along with deployment considerations, including memory usage, latency, and system feasibility.
• Limitations related to dataset size, validation strategy, and real-world generalization are discussed to guide future improvements.

The system proposed in this study is also useful outside healthcare applications. It can also be used in sports and physical training, where real-time movement analysis helps to evaluate performance. The rest of the paper is organized as follows. Section 2 reviews related work on wearable fall detection and activity monitoring. Section 3 explains the system design and methods. Section 4 presents the results and performance. Section 5 gives the conclusion and future work.

2. Related Work

Fall detection and Human Activity Recognition (HAR) have received strong research attention in recent years. These systems are applied in healthcare, sports, and security. Different techniques have been studied, including wearable sensors, ambient sensors, and computer vision systems. Wearable sensors are the most commonly used option among these. They are simple to use and easy to deploy. However, long-term use of wearable sensors can be uncomfortable. In some cases, the sensor data can also be noisy or unreliable.

Qaness et al. [17] examines how metaheuristic optimization algorithms can improve fall detection and HAR using sensor data. The authors have employed different metaheuristic feature selection techniques to improve classification performance. They have employed SVM and Random Forest techniques. They also applied preprocessing and segmentation techniques. Different strategies, like multi-class involving seven datasets and binary classification on the Sis-Fall dataset and the experimental results, have shown that these optimization techniques have improved the overall performance for both HAR and fall detection.

The top-performing technique from the Challenge: Up Multimodal Fall Detection competition was [18]. This work pertains to finding out what happens when someone falls, which is important because falls are a big cause of injuries in elderly individuals. In the proposed system, five wearable inertial measurement devices like gyroscopes and accelerometers are used. To find daily activities and falls, a machine learning technique that combines data from multiple sensors is used. Syed et al. [19] have suggested a system that takes into account both the direction and intensity of falls. The data from the inertial measurement units is split into windows that do not overlap. Then, an FNN is used to obtain features from the data. An extreme gradient boosting classifier is used to perform the final classification.

A different sensing approach based on millimeter wave sensing for human activity recognition is proposed [20]. Instead of using micro-Doppler features or large labeled datasets, the method uses five features with physical meaning. These features are used to build a feature-driven recognition system. For smart healthcare, a multimodal deep learning fusion approach is proposed, which combines visual data and multi-sensory data [21]. It uses convolutional long short-term memory (ConvLSTM) and self-attention mechanisms for activity recognition, a technique that combines motion data from IMUs with audio data from smartwatches for human activity detection using deep learning techniques [22]. The network design of a smartwatch-based monitoring system is described [23]. The system collects bio-signals and recognizes activities in a home environment. Bluetooth Low Energy is used for data transmission to reduce cost and remove the need for a smartphone. A central node selects the best gateway to receive data from the smartwatches. The system is applied to fall detection

Boutellaa et al. [24] have proposed a framework using tensors to represent data from wearable inertial sensors for fall detection and HAR. To reduce the data size while keeping important information, multilinear principal component analysis is applied. Results on a public dataset show that tensor-based data representation works better than simple concatenated vectors. Li et al. [25] have designed a multilayer bi-LSTM-based multimodal fusion model for the identification of human activity. The model is used to detect normal activities and high-risk events such as falls. The system uses data from FMCW radar and wearable sensors. Hard fusion and soft feature fusion methods are applied. These are then combined using a hybrid fusion approach. The method achieves 96% accuracy and performs well across many participants. Saleh et al. [26] have designed a low-cost and high-accuracy machine learning-based fall detection system for wearable devices. The system uses an online feature extraction method to capture time-related patterns of falls. The model is designed to balance accuracy and computational cost. The model requires less than 500 floating point operations per second. This allows it to run on low-power wearable devices. Tests on a large open dataset show accuracy above 99.9%.

Hnoohom et al. [27] have explored how multiple sensors in wearable devices can be used to detect complex human activities such as smoking, eating, and drinking. The authors show that using two inertial measurement units improves performance. These units include accelerometers and gyroscopes. The study also analyzes how different window sizes affect the performance of deep learning models for complex activity recognition. A CNN-based method for HAR using wearable inertial sensors is proposed [28]. The model uses a shallow CNN with cross-channel communication to capture more useful features from sensor data. To make the model lightweight for embedded systems, redundant cross-channel information is reduced, and graph neural networks are used so that one channel can communicate with others. Experiments on standard HAR datasets show better accuracy than baseline deep models and faster inference on embedded devices.

Several standard public datasets are widely used in wearable fall detection research, including SisFall, MobiFall, MobiAct, UniMiB SHAR, and KFall, which support fairer benchmarking of proposed methods [29,30,31,32,33,34].

Although prior studies demonstrate promising results in wearable fall detection and activity recognition, several limitations can be observed. Many approaches rely on high-performance computing platforms or do not explicitly consider deployment constraints such as memory usage and inference latency. In addition, only a limited number of works provide detailed reporting of embedded implementation metrics, including quantization effects and real-time performance on microcontrollers. Furthermore, some studies utilize complex multi-sensor setups that may not be suitable for wearable or low-power applications. These limitations motivate the present work, which focuses on a compact, wearable, and resource-efficient TinyML-based system with explicit evaluation of deployment feasibility.

Table 1. Comparison of existing solutions with the proposed system.

Reference	Approach	Techniques/Models	Dataset	Performance Summary
Al-Qaness et al. [17]	Metaheuristic optimization for feature selection	Deep learning, SVM, Random Forest	SisFall and multiple multiclass datasets	Promising results for fall detection and motion classification
Gjoreski et al. [18]	Multi-sensor data fusion using inertial sensors	Wearable inertial sensors, machine learning	Challenge Up multimodal fall detection dataset	Winning solution in fall detection competition
Syed et al. [19]	Direction- and severity-aware fall analysis	IMUs, CNN, XGBoost classifier	Custom dataset	Classification into multiple fall and motion classes
Shen et al. [20]	Feature-driven recognition using RF sensing	Millimeter-wave sensing, feature metrics	Custom dataset	Effective feature-based recognition approach
Islam et al. [21]	Deep learning-based multimodal fusion	ConvLSTM, self-attention	Multimodal image and sensor data	Improved multimodal motion understanding
Mollyn et al. [22]	Multimodal learning using motion and audio data	IMUs, audio signals, deep learning	Wearable device data	Enhanced recognition through multimodal fusion
Castillo-Sánchez et al. [23]	Smartwatch-based monitoring architecture	Bluetooth Low Energy, gateway selection	Home monitoring environment	Fall detection-focused monitoring system
Boutellaa et al. [24]	Tensor-based motion representation	Inertial sensors, tensor models, MPCA	Public HAR dataset	Robust tensor-based motion representation
Li et al. [25]	Multimodal temporal modeling	Wearable sensors, FMCW radar, bi-LSTM	Radar and wearable sensor data	Improved multimodal motion analysis
Saleh et al. [26]	Lightweight ML-based fall detection	Online feature extraction, ML classifiers	Large open dataset	Accurate and low-cost fall detection
Hnoohom et al. [27]	Complex motion analysis using heterogeneous sensors	Inertial sensors, deep learning	Complex activity dataset	Improved recognition of complex motions
Huang et al. [28]	CNN-based inertial motion modeling	Inertial sensors, CNN, graph neural networks	Benchmark HAR datasets	Faster inference and improved embedded performance
Proposed System	TinyML-based wearable fall detection	Wearable sensors, quantized CNN	Custom dataset	Low latency, low memory footprint, and high detection accuracy

summarizes the main approaches, datasets, and performance reported in these studies.

Numerous algorithms and system designs have been proposed to improve the accuracy of human motion monitoring systems while maintaining low computational complexity. Wearable sensors have emerged as a key modality in this domain due to their ability to continuously capture motion-related data. Machine learning techniques enable the identification and classification of complex human motions, including falls and daily activities such as eating, drinking, and smoking. However, achieving high accuracy while operating under strict computational and energy constraints remains a significant challenge, limiting the deployment of many existing approaches in real-world settings. In this study, we propose FNN-based TinyML model for fall detection on resource-constrained wearable devices. The system runs the model directly on the device. This reduces latency. We applied post-training quantization to reduce the memory footprint of the TinyML model without decreasing it accuracy. An anomaly detection method is also added to improve robustness and reliability of the TinyML model. This helps in detecting abnormal motion patterns. The proposed method is suitable for real-time fall detection and human motion analysis-based applications.

3. Materials and Methods

3.1. Dataset

Accelerometer data is used in this study to detect fall and non-fall events. The dataset is collected using wearable sensor nodes. These nodes continuously record acceleration, orientation, and body motion. The data collection includes fall events along with common daily activities such as walking and idle states. The sensor measurements produce time-series data. This data captures changes in movement and body orientation and represent different physical activities and behaviors.

Table 2. Dataset structure showing sample accelerometer readings.

Timestamp	${\mathit{A}}_{\mathit{x}}$	${\mathit{A}}_{\mathit{y}}$	${\mathit{A}}_{\mathit{z}}$
6921	−1829	639	3657
6931	−1833	655	3653
6941	−1855	629	3671
6951	−1857	611	3674
6961	−1854	593	3670

shows a sample of the collected dataset with accelerometer readings and their timestamps. The timestamp shows the time when each sensor value is recorded. This helps in analyzing the time-based change in motion. The sample in Table 2 is from one activity class. Similar datasets are collected for all activity classes. These include idle, walking, and falling. This data is used for supervised learning and classification.

Each row in the dataset consists of multiple attributes, including acceleration values along the three spatial axes ($A_x$, $A_y$, $A_z$). The data are sampled at regular intervals and capture variations in acceleration and angular velocity across different activity classes. This data is used to train the machine learning model to differentiate between motion patterns associated with falls and normal daily activities such as walking. The wearable sensor node, which integrates an accelerometer is embedded within the garment to collect motion data and processed using a TinyML-based model for on-device activity classification.

3.2. Data Collection

The dataset used in this study was collected from 20 participants of Indian origin under controlled experimental conditions. The participants performed three activity classes such as falling, walking, and idle for the motion patterns. The data were recorded using a wearable inertial sensor placed on a jacket below the neck near the chest region. This provides stable and consistent motion signals for fall detection. The accelerometer data along three axes ($A_x$, $A_y$, $A_z$) at a constant sampling frequency of 62.5 Hz were collected, and zero-padding was applied during preprocessing to ensure uniform input length.

Each trial consists of a 2 s window of sensor data, and approximately 2 h of data were collected in total. Based on this configuration, the dataset contains approximately 3600 trials (2 h = 7200 s, divided into 2 s windows). The annotation process was performed manually by labeling each segment, as shown in Figure 1, Figure 2 and Figure 3 according to the performed activity, ensuring correct alignment between sensor signals and activity classes.

The dataset was divided into training, validation, and testing sets using a split strategy of ratio 70:15:15. The samples from the same participants appear in both training and testing sets, which reflects a subject-dependent evaluation setting. While this setup allows the model to learn personalized motion patterns, future work will focus on subject-independent evaluation to further assess generalization performance across unseen individuals.

The acceleration magnitude can be computed from the three-axis accelerometer values:

$$\sqrt{a_x^2+a_y^2+a_z^2}$$

(1)

The raw sensor data were segmented into fixed-length windows using a sliding window approach. Each segment was labeled according to the performed activity. The dataset was then divided into training, validation, and testing subsets.

The data split was performed at the window level. Therefore, samples from the same participant may appear in both training and validation sets. This should be considered when interpreting the reported performance, as subject-independent generalization is not fully evaluated in the present study.

All participants provided informed consent prior to data collection.

3.3. Pre-Processing

The accelerometer data is normalized so that all sensor values are on the same scale. This helps the model learn better. The normalization is performed using the following formula.

Let X be a set of data points as denoted below.

$$X=[x_1,x_2,x_3,\dots ,x_n]$$

(2)

The mean of X, denoted as $mean\left(X\right)$, is calculated as:

$$mean\left(X\right)=\left({\displaystyle \frac{1}{n}}\right)·\sum \left(x_i\right)$$

(3)

Here, n represents the total number of data points. The standard deviation of X, denoted by $std\left(X\right)$, is computed as:

$$std\left(X\right)=\sqrt{\left({\displaystyle \frac{1}{n}}\right)·\sum \left({(x_i-mean\left(X\right))}^2\right)}$$

(4)

For a given data point $x_i$, the normalized value $x{n}_i$

$$x_{n_i}=\left({\displaystyle \frac{x_i-mean\left(X\right)}{std\left(X\right)}}\right)$$

(5)

This equation can be applied to each data point in X to normalize it. The dataset is then segmented into fixed window size to capture the temporal patterns.

Applying this formula to all values in X normalizes the full dataset. The data is then split into fixed-length time windows to capture patterns over time. The following notation explains the moving window method, where the window shifts forward by a fixed step size.

Let:

• D represent the original dataset
• $S_i$ represent the i-th data segment
• w be the window size (number of data points)
• s be the stride, which is how far the window moves each time

The moving window segmentation can be written as:

$$S_i=D[is:is+w]$$

(6)

where:

• $D[is:is+w]$ is a part of the original dataset D, starting at index $is$ and ending at $is+w$.
• i is the segment number, which shows the start of each window.

Using this formula, each segment $S_i$ contains a fixed-size window of data with length w. The window then moves forward by the stride s to create the next segment. Figure 4 shows the segmented data after normalization.

3.4. Feature Extraction

Feature engineering is carried out after sensor data collection and before the classification step. Most studies use orientation invariant features such as magnitude. This ensures that the results do not depend on how the device is worn or placed. This makes the system more flexible and user friendly. The main engineered features are explained below. These features are computed from the acceleration components $(ax,ay,az)$ collected over N time samples [35,36,37,38,39,40,41,42,43,44,45,46,47,48,49].

3.4.1. Magnitude Features

Acceleration magnitude:

$$a_t=\sqrt{a_{t,x}^2+a_{t,y}^2+a_{t,z}^2}$$

(7)

G-Force:

$$G_t={\displaystyle \frac{a_t}{9.8}}$$

(8)

3.4.2. Differential Features

Gravity cross-rate:

$$Z_g={\displaystyle \frac{1}{2N}}\sum _{i=0}^{N-1}sign(a_i-g_u)-sign(a_{i-1}-g_l)$$

(9)

where

$$\begin{array}{cc}\hfill g_u& =g_{upperbound}\hfill \\ \hfill g_l& =g_{lowerbound}\hfill \end{array}$$

(10)

Tilt:

$$\begin{array}{c}\hfill \cos {\Theta }_{t1,t2}={\displaystyle \frac{{\overrightarrow{a}}_{t1}·{\overrightarrow{a}}_{t2}}{a_{t1}{a}_{t2}}}\end{array}$$

(11)

Velocity:

$$\begin{array}{c}\hfill {\overrightarrow{V}}_t={\overrightarrow{V}}_{t0}+\sum _{i=t0}^t{\overrightarrow{a}}_{i}dt\end{array}$$

(12)

Absolute Acceleration Magnitude Variation:

$$\begin{array}{c}\hfill AAM{V}_I={\displaystyle \frac{1}{\left|I\right|}}\sum _{i\in I}\left|a_{i+1}-a_i\right|\end{array}$$

(13)

3.4.3. Statistical Features

Standard deviation:

$$\begin{array}{c}\hfill {\sigma }_k=\sqrt{{\displaystyle \frac{1}{N-1}}\sum _{i=0}^{N-1}{(a_{i,k}-{\mu }_k)}^2}\end{array}$$

(14)

Skewness:

$$\begin{array}{c}\hfill {\mu }_k^{\left(3\right)}={\displaystyle \frac{1}{N-1}}\sum _{i=0}^{N-1}{\displaystyle \frac{{(a_{i,k}-{\mu }_k)}^3}{{\sigma }_k^3}}\end{array}$$

(15)

Kurtosis:

$$\begin{array}{c}\hfill {\mu }_k^{\left(4\right)}={\displaystyle \frac{1}{N-1}}\sum _{i=0}^{N-1}{\displaystyle \frac{{(a_{i,k}-{\mu }_k)}^4}{{\sigma }_k^4}}\end{array}$$

(16)

3.4.4. Time Domain Features

To capture how activities change over time, time duration features are often used in human activity recognition and fall detection. These features describe how long different body movements last, which helps the model tell activities apart and detect rare events such as falls. Some common examples of time duration features used in these tasks are given below:

• Fall Duration (FD): The time from the start of a fall to the moment of impact or landing.
• Activity Duration (AD): The time spent doing an activity such as walking, or idle. It shows how long the activity lasts.
• Transition Duration (TD): The time taken to move from one activity to another, for example from walking to idle, or from falling to idle.
• Post-Fall Recovery Duration (PFRD): The time taken to recover after a fall. It shows how long a person needs to regain balance or return to normal activity.

3.5. System Model

In this proposed system, a wearable jacket uses sensors and a TinyML model to detect activities such as falling, idle, and walking. The model based on a feedforward neural network (FNN) is used.

The proposed classification model is implemented as a lightweight feedforward neural network (multilayer perceptron). The network consists of two hidden layers with 40 and 20 neurons, respectively. Each hidden layer performs a linear transformation followed by a nonlinear activation function. The operation of the l-th hidden layer is defined as:

$$h^{\left(l\right)}=f\left(W^{\left(l\right)}{h}^{(l-1)}+b^{\left(l\right)}\right)$$

(17)

where $h^{(l-1)}$ represents the input to the layer, $W^{\left(l\right)}$ is the weight matrix, $b^{\left(l\right)}$ is the bias vector, and $f(·)$ denotes the ReLU activation function. To reduce overfitting, a dropout layer with a dropout rate of 0.5 is applied after the hidden layers. Additionally, L1 regularization is incorporated to encourage sparsity and improve generalization.

The final output layer uses the softmax function to produce class probabilities:

$$\widehat{y}=\mathrm{softmax}\left(W^{\left(o\right)}{h}^{\left(L\right)}+b^{\left(o\right)}\right)$$

(18)

where L denotes the last hidden layer and $\left(o\right)$ represents the output layer. The softmax function converts logits into normalized probability values as follows:

$$\sigma {\left(\mathbf{z}\right)}_i={\displaystyle \frac{e^{z_i}}{{\sum }_{j=1}^K{e}^{z_j}}}$$

(19)

Since this is a multi-class classification problem, the categorical cross-entropy loss function is used to measure the discrepancy between predicted and true labels:

$$\mathcal{L}=-{\displaystyle \frac{1}{N}}\sum _{n=1}^N\sum _{i=1}^C{y}_{n,i}\log \left({\widehat{y}}_{n,i}\right)$$

(20)

where N is the number of samples, C is the number of classes, $y_{n,i}$ is the ground-truth label, and ${\widehat{y}}_{n,i}$ is the predicted probability.

The network is trained using the Adam optimization algorithm, which computes adaptive learning rates based on the first and second moments of the gradients. The first moment estimate is given by:

$$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$$

(21)

The second moment estimate is defined as:

$$v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$$

(22)

To correct initialization bias, the bias-corrected estimates are computed as:

$${\widehat{m}}_t={\displaystyle \frac{m_t}{1-{\beta }_1^t}},{\widehat{v}}_t={\displaystyle \frac{v_t}{1-{\beta }_2^t}}$$

(23)

Finally, the network parameters are updated using:

$$w_{t+1}=w_t-\alpha {\displaystyle \frac{{\widehat{m}}_t}{\sqrt{{\widehat{v}}_t}+ϵ}}$$

(24)

The proposed classification model is implemented as a lightweight FNN designed for deployment on resource-constrained devices. The input to the model consists of feature vectors extracted from segmented accelerometer data. The input layer receives a fixed-length feature vector, which is followed by two fully connected hidden layers with 40 and 20 neurons, respectively. Each hidden layer uses the Rectified Linear Unit (ReLU) activation function to introduce non-linearity. Dropout regularization is applied between layers to reduce overfitting. The final output layer uses a softmax activation function to classify the input into one of three activity classes: falling, walking, and idle. This architecture is selected due to its low computational complexity, making it suitable for real-time inference on embedded microcontroller platforms.

The model is trained for 50 epochs with a learning rate of 0.0005. The FNN is implemented using Keras [50]. After training, the model is converted to TensorFlow Lite using INT8 quantization [51,52] and also exported in Float32 format for deployment.

Figure 5 shows the FNN architecture used to extract and classify fall-related features from the input data. The selection of model parameters and activation functions helps improve classification accuracy.

3.6. Anomaly Detection

In addition to the supervised classification model, an unsupervised anomaly detection module is incorporated to enhance the robustness of the system. The anomaly detection approach learns the patterns of known activities in the feature space using a clustering-based representation, similar to approaches used in embedded machine learning frameworks for detecting out-of-distribution data [53]. During training, feature vectors corresponding to known motion patterns are used to form clusters that represent the normal operating behavior of the system.

Specifically, the anomaly detection module operates on feature vectors of dimensionality $D=9$. Before clustering, each feature is normalized using mean and scale parameters obtained during training so that all feature dimensions contribute consistently to the clustering process. The learned representation consists of multiple clusters, where each cluster is defined by a centroid $c_k$ and a maximum admissible reconstruction error or boundary radius $r_k$.

During inference, each incoming feature vector is compared against the learned clusters, and an anomaly score is computed based on its distance from the nearest cluster representation. This score reflects how well the input sample fits within the patterns observed during training. Unlike classification models, the anomaly detection module produces a continuous anomaly score rather than a discrete class label. The anomaly score is computed as the minimum distance between the input feature vector and the boundary of the nearest learned cluster:

$$\begin{array}{c}\hfill \begin{array}{c}\hfill d\left(x\right)=\underset{k}{\min }\left(\parallel x-c_k{\parallel }_2-r_k\right)\end{array}\end{array}$$

(25)

where x represents the input feature vector, $c_k$ denotes the centroid of the k-th cluster, and $r_k$ denotes the corresponding cluster boundary estimated during training. If a sample lies within the boundary of a learned cluster, the anomaly score is negative or close to zero, indicating that the sample is consistent with previously observed patterns. Positive anomaly scores indicate that the sample lies outside the learned clusters and therefore deviates from known activity patterns. To distinguish between known and unknown patterns, a threshold T is applied to the anomaly score.

In this work, the threshold is selected empirically from the anomaly score distribution obtained on validation data. Since known activity samples typically produce negative or near-zero anomaly scores, while unseen or out-of-distribution samples produce larger positive values, the threshold is chosen slightly above zero to balance false positives and anomaly sensitivity. This procedure improves reproducibility by explicitly linking threshold selection to the observed validation score distribution rather than to an arbitrary fixed value.

$$\begin{array}{c}\hfill \mathrm{Anomaly}\left(x\right)=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}d\left(x\right)>T\hfill \\ 0,\hfill & \mathrm{if}d\left(x\right)\le T\hfill \end{array}\right.\end{array}$$

(26)

In this framework, samples that fall within the learned clusters correspond to known activities such as walking, idle, or fall patterns observed during training. In contrast, samples that lie outside these clusters are treated as anomalous, indicating motion patterns that were not present in the training data, such as unseen gestures or unexpected movements. The anomaly detection module complements the supervised TinyML classifier by identifying patterns that cannot be confidently classified into predefined categories. This enables the detection of out-of-distribution motion patterns and improves system reliability by handling both known and previously unseen activities.

The clustering-based anomaly module therefore serves as a complementary safeguard to the supervised classifier. While the classifier predicts one of the predefined activity classes, the anomaly detector evaluates whether the input pattern is sufficiently similar to the data observed during training. This hybrid design improves robustness in practical deployment, especially when the system encounters motion patterns that were not explicitly represented in the labeled training set.

3.7. Data Pipeline

Although the hardware platform includes both accelerometer and gyroscope sensors, the present study utilizes only the three-axis accelerometer data ($A_x$, $A_y$, $A_z$) for model training and evaluation. The gyroscope data were not included in the current model to maintain simplicity and reduce computational overhead. Future work may explore multimodal sensor fusion to improve classification performance.

The built-in accelerometer is used to measure acceleration and changes in velocity along one or more directions. Its main objective is to monitor and identify physical activities of a person to detect and respond when fall has occurred. The accelerometer detects a change in velocity whenever a fall occurs. This information is then used by the TinyML model to identify the fall. In the proposed system, an algorithm is designed to determine if a fall has occurred and if emergency medical attention is required.

Accelerometers provide real-time data to detect falls and other physical activity of a person. This allows for early involvement in lowering the risk of fall-related injuries. Accelerometers and gyroscopes are used to train the TinyML model to improve detection of falls and help in taking necessary action by giving an alert about a fall. As a result, medical personnel can respond to falls and provide rapid help and the appropriate care.

Figure 6 shows the overall system architecture of the proposed fall detection system. The pipeline includes sensor data acquisition, preprocessing, feature extraction, and TinyML-based classification, followed by IoT-based alert transmission. This architecture highlights the integration of embedded inference with real-time communication.

The TinyML model detects the human activity or fall with the help of data from the accelerometer, and then the data is transferred to the gateway device via Bluetooth Low Energy (BLE). The data is further transmitted from the gateway device to an IoT cloud server using the MQTT protocol. Finally, a web application sends an alert to medical professionals if a fall has occurred, which allows them to respond quickly to take care of a person or patient. The proposed system enables a continuous flow of information and ensures effective communication between the sensor node, gateway device, cloud server, and healthcare experts. In this way, the system improves fall detection and response to falls.

The overall data processing pipeline of the system consists of the following steps:

• Raw accelerometer signals are acquired from the wearable device.
• The signals are normalized to reduce scale variations.
• The data are segmented into fixed-length overlapping windows.
• Feature extraction is performed on each segment to obtain a compact representation.
• The extracted feature vectors are provided as input to the TinyML classifier.
• The model performs real-time inference and outputs activity predictions.

The proposed system differentiate various human activities like falling, idle, and walking, with precise accuracy. The TinyML model is trained on labelled activity data to recognize such activities by analyzing patterns of body movement. Figure 6 and Figure 7 used in this section were created manually and later visually refined using AI-assisted graphic tools to improve clarity, layout alignment, and visual presentation.

4. Experimentation, Result, and Analysis

The wearable sensor-based application in this study aims to improve user safety by quickly and accurately recognizing human activities. Spectral features are used to achieve better accuracy in fall detection and activity recognition. This method applies the Fast Fourier Transform (FFT) to convert signals from the time domain to the frequency domain and then analyzes the frequency spectrum for classification [54].

Different filters are applied to the signals to focus on useful frequency ranges and extract spectral features. The Butterworth filter [55,56] is commonly used for this purpose. In this study, a low-pass Butterworth filter is applied with an 8 Hz cut-off frequency with one scale axis and eight poles.

FFT is used to convert the signal to the frequency domain to obtain spectral information. An FFT length of 64 is used. To improve the quality of spectral features, overlapping FFT frames are used to provide smoother and more stable frequency responses. The combination of filtering, overlapping FFT frames, and using the spectrum log improves the spectral features for fall detection and activity classification, as shown in Figure 8.

The TinyML model achieves high training accuracy for the three classes (falling, walking, and idle). This shows that the model has learned the patterns of these activities well from the training data. The following metrics are used to evaluate the model’s performance.

$$\begin{array}{c}\hfill Accuracy={\displaystyle \frac{TP+TN}{TP+TN+FP+FN}}\end{array}$$

(27)

$$\begin{array}{c}\hfill Precision={\displaystyle \frac{TP}{TP+FP}}\end{array}$$

(28)

$$\begin{array}{c}\hfill Recall={\displaystyle \frac{TP}{TP+FN}}\end{array}$$

(29)

$$\begin{array}{c}\hfill F1Score={\displaystyle \frac{2·Precision·Recall}{Precision+Recall}}\end{array}$$

(30)

Figure 9 illustrates the training and validation accuracy of the model over epochs. The model demonstrates stable convergence, as indicated by the close alignment between training and validation curves. This suggests that the model generalizes reasonably well within the experimental setup.

The confusion matrices in Figure 10 for the Float32 and INT8 models show that both model variants achieve highly reliable classification of falling, idle, and walking activities on the validation set. The Float32 model achieves an overall accuracy of 98.93%, correctly classifying all fall and walking samples, with only minor confusion observed for the idle class. The INT8 quantized model achieves a very similar accuracy of 98.40%, again perfectly classifying all falling samples and correctly identifying most of the walking samples, while slightly increasing the misclassification of idle samples. The small drop in accuracy after quantization is marginal (0.5%) and is mainly due to additional confusion between idle and neighboring activity classes, which exhibit similar inertial signal patterns during short transitions. Overall, the confusion matrices demonstrate that post-training INT8 quantization preserves the discriminative capability of the model while enabling efficient deployment on resource-constrained edge devices, making the trade-off between performance and efficiency highly favorable.

Table 3. Per-class performance metrics for the proposed model (Float32).

Class ID	Class Label	Precision	Recall	F1-Score
0	falling	0.9894	1.0000	0.9947
1	idle	0.9892	0.9786	0.9839
2	walking	0.9893	0.9893	0.9893
Overall Accuracy				98.93%

shows the class-wise precision, recall, and F1-score for the Float32 model. The results indicate strong and balanced performance across all three activity classes. The falling class achieves perfect recall, which means that all fall events in the evaluation set are correctly identified. The idle and walking classes also show high precision and recall, indicating stable recognition of normal daily activities. The Float32 model achieves an overall accuracy of 98.93%, demonstrating reliable classification performance under the controlled experimental setup.

Table 4. Per-class performance metrics for the proposed model (INT8).

Class ID	Class Label	Precision	Recall	F1-Score
0	falling	0.9842	1.0000	0.9920
1	idle	0.9837	0.9679	0.9757
2	walking	0.9840	0.9840	0.9840
Overall Accuracy				98.40%

presents the results for the INT8 quantized model. After quantization, a slight reduction in precision and F1-score is observed, particularly for the idle class. However, the falling class still achieves perfect recall, indicating that fall events remain reliably detected. The overall accuracy remains high at 98.40%, showing that quantization introduces only a minor performance loss while improving suitability for deployment on resource-constrained embedded devices.

Table 5. Overall performance comparison between Float32 and INT8 models.

Model ID	Model Type	Accuracy	ROC-AUC	Loss
0	Float32	0.9893	0.9996	0.2145
1	INT8	0.9840	0.9970	0.2793

compares both models. The Float32 model shows slightly better ROC-AUC and lower loss than the INT8 model. This confirms a small trade-off between performance and deployment efficiency. The results show that the INT8 model provides a good balance between accuracy and computational efficiency for deployment on resource-constrained devices. The results indicate that the proposed TinyML-based model provides competitive performance while maintaining low computational complexity, making it suitable for embedded deployment.

The Data Explorer plot in Figure 11 shows how the training samples cluster in feature space after being learned by the model. Each dot is one sensor window; nearby dots represent similar motion patterns. The clear separation between idle, walking, and the small falling cluster explains the high accuracy, while the few red/orange points at cluster edges indicate ambiguous transition samples where misclassifications occur.

The anomaly detection results are shown in Figure 12, which illustrates the distribution of extracted features in the feature space. The clustering behavior shows that the learned activity patterns form distinct regions, while samples that fall outside these regions can be treated as anomalous. In addition, the anomaly detection module provides an anomaly score that indicates how far an input sample lies from the learned clusters.

The combined use of classification and anomaly detection highlights the hybrid nature of the system, where classification provides direct recognition of known activities while anomaly detection supports the identification of previously unseen or out-of-distribution motion patterns [57,58,59,60].

The model is deployed as an Arduino library and uploaded to the Nicla device [61]. Figure 13 shows the prototype of the system consisting of a wearable jacket embedded with a sensor device that runs the TinyML model. Figure 14 demonstrates that the model correctly identifies all three classes with high confidence scores.

Both of these figures present the hardware prototype of the wearable fall detection system. This demonstrates the practical feasibility of deploying the proposed approach on a wearable platform.

Table 6. Quantitative comparison of representative fall detection and edge-oriented systems.

Reference	Accuracy (%)	Recall	F1-Score	Latency/Compute	Memory
Li et al. [25]	96.0	NR	NR	NR	NR
Saleh et al. [26]	>99.9	NR	NR	<500 FLOPS	NR
Tseng et al. [62]	99.7	97.9	NR	NR	NR
Alshuhail et al. [63]	95.4	NR	NR	0.045 s	NR
Booranawong et al. [64]	95.6	NR	NR	NR	NR
Wang et al. [65]	98.3/92.0/96.1	NR	NR	NR	NR
Fernández-Bermejo et al. [66]	89.99	97.29	NR	NR	NR
Proposed (Float32)	98.93	1.0000	0.9839–0.9947	11 ms	∼80 KB Flash, ∼6 KB RAM
Proposed (INT8)	98.40	1.0000	0.9757–0.9920	7 ms	∼40 KB Flash, ∼5 KB RAM

Note: The recall reported for the proposed system corresponds to the falling class, as accurate detection of fall events is the primary objective. The F1-score is reported as the range across all classes.

presents a quantitative comparison between the proposed system and representative fall detection approaches reported in the literature. The comparison focuses on key performance metrics, including accuracy, recall, F1-score, computational cost, and memory footprint, which are essential for evaluating both recognition performance and suitability for embedded deployment. Only explicitly reported values are included, while unavailable metrics are denoted as NR (Not Reported) to maintain consistency.

As observed, several existing approaches achieve high detection accuracy, with some methods reporting performance above 99%. However, most of these studies do not provide complete information regarding deployment-related characteristics such as inference latency and memory usage, which are critical for real-time wearable and TinyML-based systems. In contrast, the proposed approach provides a comprehensive evaluation by reporting both classification performance and embedded implementation metrics. The proposed Float32 and INT8 models achieve competitive accuracy while maintaining low inference time (11 ms and 7 ms, respectively) and a compact memory footprint, demonstrating the practicality and efficiency of the system for resource-constrained wearable fall detection applications.

The results indicate that the proposed system achieves strong classification performance under the controlled experimental setup. However, the findings should be interpreted as a proof-of-concept rather than a fully validated real-world deployment. The limited number of fall samples and the absence of subject-independent validation may affect generalization to unseen users and real-world conditions.

5. Conclusions and Future Scope

This study presents a wearable TinyML-based fall detection system designed for resource-constrained embedded platforms. The proposed approach demonstrates the feasibility of performing real-time activity classification using a lightweight neural network deployed on a microcontroller. The results show that the system achieves promising performance for detecting falling, walking, and idle activities under controlled experimental conditions. The use of model optimization techniques, including quantization, enables efficient deployment with low memory usage and reduced inference latency. However, the current study has several limitations. The dataset size is relatively limited, particularly for fall events, and the evaluation does not include subject-independent validation. As a result, the findings should be interpreted as a proof-of-concept rather than a fully generalized real-world solution.

Future work will focus on collecting larger and more diverse datasets, including evaluation of standard benchmark datasets such as SisFall, MobiFall, MobiAct, UniMiB SHAR, and KFall to enable broader comparison with prior studies. Additional directions include subject-independent evaluation, incorporation of additional sensor modalities such as gyroscope data, and validation of the system in real-world scenarios with continuous monitoring. Furthermore, future studies should provide a more comprehensive dataset description, including participant count, demographic summary, exact sampling frequency, and detailed trial information.