基于STM32的智能家居系统设计与实现

科创工作室li

已于 2025-03-09 10:38:50 修改

阅读量1.4k

点赞数 18

分类专栏：咸鱼文章标签：毕业设计 stm32 单片机

于 2025-03-07 23:57:56 首次发布

本文链接：https://blog.csdn.net/qq_58404700/article/details/146108366

版权

咸鱼专栏收录该内容

16 篇文章

订阅专栏

基于STM32的智能家居系统设计与实现

摘要

随着物联网技术的快速发展，智能家居系统逐渐走进人们的生活。本文设计了一种基于STM32的智能家居系统，该系统集成了烟雾浓度检测、一氧化碳浓度检测、空气质量检测、光照强度检测、环境温湿度检测、大气压强检测等功能，并具备显示、控制、手动模式、自动模式、阈值调节、接入云平台及远程控制等特性。通过ESP8266 WIFI模块连接网络，系统能够接入机智云服务器，实现数据的远程监控和控制。

关键词

STM32；智能家居；传感器；ESP8266 WIFI；机智云服务器

Abstract

With the rapid development of Internet of Things technology, smart home systems are gradually entering people's lives. This paper designs a smart home system based on STM32, which integrates functions such as smoke concentration detection, carbon monoxide concentration detection, air quality detection, light intensity detection, environmental temperature and humidity detection, and atmospheric pressure detection. It also has display, control, manual mode, automatic mode, threshold adjustment, cloud platform access, and remote control features. By connecting to the network through the ESP8266 WIFI module, the system can access the Gizwits cloud server to achieve remote monitoring and control of data.

Keywords

STM32; Smart Home; Sensor; ESP8266 WIFI; Gizwits Cloud Server

一、引言

智能家居系统作为物联网技术的重要应用之一，近年来得到了广泛的关注和发展。本系统旨在通过集成多种传感器和控制设备，实现对室内环境的全面监测和智能控制，提高居住的舒适性和安全性。本文将详细介绍基于STM32的智能家居系统的设计与实现过程。

二、系统总体设计

2.1 系统架构

本系统主要由STM32微控制器、传感器模块、显示模块、控制模块、通信模块、按键模块及云平台等部分组成。STM32微控制器作为系统的核心，负责数据的采集、处理、显示及控制等任务。传感器模块用于检测室内环境的各种参数，如烟雾浓度、一氧化碳浓度、空气质量、光照强度、温湿度及大气压强等。显示模块采用OLED屏幕，用于实时显示检测到的数据。控制模块包括LED灯和步进电机，用于实现照明和窗户的控制。通信模块采用ESP8266 WIFI模块，用于实现系统与云平台的连接和数据传输。按键模块用于设置和调节传感器的阈值。

2.2 功能模块

检测功能：系统通过集成多种传感器，实现对室内环境的全面监测。烟雾传感器用于检测烟雾浓度，一氧化碳传感器用于检测一氧化碳浓度，空气质量传感器用于检测室内空气质量，光照传感器用于检测光照强度，温湿度传感器用于检测环境温湿度，气压传感器用于检测大气压强。
显示功能：系统采用OLED屏幕作为显示模块，实时显示检测到的各种环境参数，方便用户随时了解室内环境状况。
控制功能：系统通过控制LED灯和步进电机，实现对室内照明和窗户的智能控制。LED灯可根据光照强度自动调节亮度，步进电机可根据需要控制窗户的开关。
手动模式：系统提供手动模式，用户可通过APP远程控制LED灯和步进电机的运行，实现个性化的控制需求。
自动模式：系统具备自动模式，当检测到烟雾浓度、一氧化碳浓度或空气质量超出设定阈值时，蜂鸣器会进行持续的报警提醒，并自动开启窗户进行通风；当检测到光线低于设定阈值时，系统会自动开启LED灯进行照明。
阈值调节：系统提供阈值调节功能，用户可通过按键模块设置和调节传感器的阈值，以满足不同场景下的需求。
接入云平台：系统通过ESP8266 WIFI模块连接网络，接入机智云服务器，实现数据的远程监控和控制。用户可通过手机APP查看传感器数据、控制设备运行状态及接收报警信息等。
远程控制：用户可通过手机APP实现对系统的远程控制，包括查看传感器数据、控制LED灯和步进电机的运行等。

三、硬件设计

3.1 STM32微控制器

本系统采用STM32F103系列微控制器作为核心处理器，其具有丰富的外设接口和强大的处理能力，能够满足系统的需求。STM32F103系列微控制器支持多种通信协议，如USART、I2C、SPI等，方便与传感器模块、显示模块及通信模块等进行连接和通信。

3.2 传感器模块

烟雾传感器：采用MQ-2烟雾传感器，用于检测室内烟雾浓度。该传感器具有灵敏度高、响应速度快等特点，能够准确检测室内烟雾浓度。
一氧化碳传感器：采用MQ-7一氧化碳传感器，用于检测室内一氧化碳浓度。该传感器具有稳定性好、抗干扰能力强等特点，能够准确检测室内一氧化碳浓度。
空气质量传感器：采用MQ-135空气质量传感器，用于检测室内空气质量。该传感器能够检测多种有害气体，如氨气、硫化氢、苯等，具有广泛的应用范围。
光照传感器：采用光敏电阻或光敏二极管等光照传感器，用于检测室内光照强度。该传感器能够根据光照强度的变化输出不同的电压或电流信号，方便进行数据处理和控制。
温湿度传感器：采用DHT11或DHT22温湿度传感器，用于检测室内温湿度。该传感器具有数字信号输出，能够同时检测温度和湿度两个参数，具有高精度和稳定性好的特点。
气压传感器：采用MS5611气压传感器，用于检测大气压强。该传感器具有高精度、低功耗等特点，能够准确测量室内气压值。

3.3 显示模块

系统采用0.96寸OLED屏幕作为显示模块，用于实时显示检测到的各种环境参数。OLED屏幕具有色彩鲜艳、对比度高、视角广等特点，能够提供清晰的显示效果。同时，OLED屏幕还支持多种显示模式，如静态显示、动态显示等，方便用户进行选择和设置。

3.4 控制模块

LED灯：系统采用LED灯作为照明设备，通过STM32微控制器的GPIO引脚控制LED灯的亮灭和亮度调节。LED灯具有功耗低、寿命长等特点，能够满足室内照明的需求。
步进电机：系统采用步进电机作为窗户的控制设备，通过STM32微控制器的PWM信号控制步进电机的转动角度和速度。步进电机具有定位精度高、运行平稳等特点，能够实现窗户的精确控制。

3.5 通信模块

系统采用ESP8266 WIFI模块作为通信模块，用于实现系统与云平台的连接和数据传输。ESP8266 WIFI模块具有低功耗、高性能等特点，支持多种通信协议和加密方式，能够确保数据传输的安全性和可靠性。同时，ESP8266 WIFI模块还支持AT指令集和UART接口，方便与STM32微控制器进行连接和通信。

3.6 按键模块

系统采用独立按键或矩阵按键等按键模块，用于设置和调节传感器的阈值。按键模块具有结构简单、操作方便等特点，能够满足用户的不同需求。同时，按键模块还支持多种按键功能，如单击、双击、长按等，方便用户进行选择和设置。

四、软件设计

4.1 主程序设计

系统主程序主要负责初始化STM32微控制器的外设接口、配置传感器模块、显示模块、控制模块及通信模块等参数，并循环采集和处理传感器数据，将结果显示在OLED屏幕上，并根据需要控制LED灯和步进电机的运行。同时，主程序还负责处理按键输入和云平台通信等任务。

4.2 传感器数据采集与处理

系统通过STM32微控制器的ADC接口或I2C接口等采集传感器数据，并进行处理和分析。对于模拟信号输出的传感器，如烟雾传感器、一氧化碳传感器、光照传感器等，系统通过ADC接口将其转换为数字信号进行处理；对于数字信号输出的传感器，如温湿度传感器、气压传感器等，系统通过I2C接口读取其数据并进行处理。同时，系统还根据需要对传感器数据进行滤波和校准处理，以提高数据的准确性和稳定性。

4.3 显示模块程序设计

系统采用OLED屏幕作为显示模块，通过STM32微控制器的SPI接口或I2C接口等与其进行通信。显示模块程序主要负责将采集到的传感器数据格式化为字符串并显示在OLED屏幕上。同时，显示模块程序还支持多种显示模式和显示效果的选择和设置，如静态显示、动态显示、滚动显示等。

4.4 控制模块程序设计

系统通过STM32微控制器的GPIO引脚或PWM信号等控制LED灯和步进电机的运行。控制模块程序主要负责根据传感器数据和用户设置的控制策略来控制LED灯和步进电机的运行。例如，当检测到光线低于设定阈值时，系统自动开启LED灯进行照明；当检测到烟雾浓度或一氧化碳浓度超出设定阈值时，系统自动开启窗户进行通风等。

4.5 按键模块程序设计

系统采用按键模块来设置和调节传感器的阈值。按键模块程序主要负责检测按键输入并处理相应的按键事件。例如，当用户按下某个按键时，系统进入阈值设置模式，并根据用户的输入调整传感器的阈值。同时，按键模块程序还支持多种按键功能和按键组合的选择和设置，以满足用户的不同需求。

4.6 通信模块程序设计

系统采用ESP8266 WIFI模块作为通信模块，通过UART接口

与STM32微控制器进行通信。通信模块程序主要负责实现系统与云平台的数据传输和控制指令的接收。以下是通信模块程序设计的详细步骤：

初始化ESP8266 WIFI模块：在STM32微控制器上电后，首先通过UART接口向ESP8266 WIFI模块发送AT指令集，进行模块的初始化配置，包括设置工作模式（STA/AP/STA+AP）、连接指定的WIFI网络、获取IP地址等。
建立TCP连接：初始化完成后，系统通过发送AT指令与机智云服务器建立TCP连接。连接成功后，系统可以实时向云平台发送传感器数据，并接收云平台下发的控制指令。
数据封装与发送：在发送数据前，系统需要将传感器数据进行封装，包括添加数据头、数据长度、校验码等信息，以确保数据的完整性和正确性。封装完成后，系统通过UART接口向ESP8266 WIFI模块发送封装好的数据包，由模块将数据发送至云平台。
接收云平台指令：系统通过UART中断或轮询方式接收ESP8266 WIFI模块下发的云平台指令。接收到指令后，系统进行指令解析，并根据指令内容执行相应的控制操作，如调整LED灯亮度、控制步进电机转动等。
错误处理与重连机制：在通信过程中，可能会遇到网络不稳定、TCP连接断开等问题。为了确保系统的稳定性和可靠性，通信模块程序需要实现错误处理和重连机制。当检测到通信错误时，系统尝试重新连接WIFI网络和云平台；若连接失败，则进入错误处理流程，记录错误信息并提示用户。

4.7 云平台接入与APP开发

系统通过ESP8266 WIFI模块连接机智云服务器，实现数据的远程监控和控制。为了方便用户查看传感器数据和远程控制设备，需要开发一款与云平台配合使用的手机APP。以下是云平台接入与APP开发的步骤：

云平台注册与设备创建：在机智云平台上注册账号并创建智能家居项目。在项目中添加设备类型，设置设备属性、事件和服务等。根据设备类型创建具体的设备实例，并获取设备的唯一标识（Device ID）和密钥（Device Secret）。
数据点配置：在云平台上为设备配置数据点，包括传感器数据的上报点和控制指令的下发点。每个数据点需要设置数据格式、单位、范围等信息。配置完成后，系统可以通过数据点与云平台进行数据交互。
APP开发：使用Android或iOS开发平台开发手机APP。APP需要实现用户登录、设备绑定、数据查看和控制指令下发等功能。通过与云平台建立TCP连接或HTTP请求等方式，APP可以实时获取设备数据并下发控制指令。同时，APP还需要提供友好的用户界面和交互体验，方便用户进行操作和设置。
测试与调试：在APP开发完成后，需要进行测试与调试工作。通过模拟不同的场景和条件，测试APP的功能和性能是否满足要求。对于发现的问题和错误，及时进行修复和优化，确保APP的稳定性和可靠性。

五、系统测试与优化

在系统设计和实现完成后，需要进行系统测试与优化工作。以下是系统测试与优化的步骤：

功能测试：对系统的各项功能进行测试，包括传感器数据采集与处理、显示模块显示、控制模块控制、按键模块设置、通信模块数据传输和控制指令接收等。确保各项功能能够正常工作和满足设计要求。
性能测试：对系统的性能进行测试，包括数据采集的准确性和稳定性、数据传输的实时性和可靠性、控制指令的响应速度等。通过测试数据和分析结果，评估系统的性能是否满足要求。
兼容性测试：测试系统在不同设备和网络环境下的兼容性和稳定性。包括在不同品牌、型号和操作系统的手机上测试APP的功能和性能；在不同WIFI网络和网络环境下测试通信模块的可靠性和稳定性等。
优化与改进：根据测试结果和分析结果，对系统进行优化和改进。对于发现的问题和错误，及时进行修复和优化；对于性能不足的部分，进行算法优化或硬件升级等工作。同时，还可以根据用户需求和反馈进行功能扩展和升级等工作。

六、结论与展望

本文设计了一种基于STM32的智能家居系统，该系统集成了多种传感器和控制设备，实现了对室内环境的全面监测和智能控制。通过ESP8266 WIFI模块连接机智云服务器，系统能够实时上传传感器数据并接收远程控制指令。经过测试与优化后，系统具有较高的稳定性和可靠性，能够满足用户的需求和期望。

展望未来，随着物联网技术的不断发展和智能家居市场的不断扩大，本系统还有很大的改进和升级空间。例如，可以引入更多的传感器和控制设备，扩展系统的功能和应用范围；可以采用更先进的通信技术和协议，提高数据传输的实时性和可靠性；可以开发更加智能化的控制算法和策略，提高系统的自动化水平和用户体验等。同时，还可以与智能家居生态系统中的其他设备和平台进行互联互通和协同工作，共同构建更加智能化、便捷化和舒适化的智能家居环境。

/**************************************************************************//**
 * @file     core_cm3.c
 * @brief    CMSIS Cortex-M3 Core Peripheral Access Layer Source File
 * @version  V1.30
 * @date     30. October 2009
 *
 * @note
 * Copyright (C) 2009 ARM Limited. All rights reserved.
 *
 * @par
 * ARM Limited (ARM) is supplying this software for use with Cortex-M 
 * processor based microcontrollers.  This file can be freely distributed 
 * within development tools that are supporting such ARM based processors. 
 *
 * @par
 * THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED
 * OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
 * ARM SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 ******************************************************************************/

#include <stdint.h>

/* define compiler specific symbols */
#if defined ( __CC_ARM   )
  #define __ASM            __asm                                      /*!< asm keyword for ARM Compiler          */
  #define __INLINE         __inline                                   /*!< inline keyword for ARM Compiler       */

#elif defined ( __ICCARM__ )
  #define __ASM           __asm                                       /*!< asm keyword for IAR Compiler          */
  #define __INLINE        inline                                      /*!< inline keyword for IAR Compiler. Only avaiable in High optimization mode! */

#elif defined   (  __GNUC__  )
  #define __ASM            __asm                                      /*!< asm keyword for GNU Compiler          */
  #define __INLINE         inline                                     /*!< inline keyword for GNU Compiler       */

#elif defined   (  __TASKING__  )
  #define __ASM            __asm                                      /*!< asm keyword for TASKING Compiler      */
  #define __INLINE         inline                                     /*!< inline keyword for TASKING Compiler   */

#endif


/* ###################  Compiler specific Intrinsics  ########################### */

#if defined ( __CC_ARM   ) /*------------------RealView Compiler -----------------*/
/* ARM armcc specific functions */

/**
 * @brief  Return the Process Stack Pointer
 *
 * @return ProcessStackPointer
 *
 * Return the actual process stack pointer
 */
__ASM uint32_t __get_PSP(void)
{
  mrs r0, psp
  bx lr
}

/**
 * @brief  Set the Process Stack Pointer
 *
 * @param  topOfProcStack  Process Stack Pointer
 *
 * Assign the value ProcessStackPointer to the MSP 
 * (process stack pointer) Cortex processor register
 */
__ASM void __set_PSP(uint32_t topOfProcStack)
{
  msr psp, r0
  bx lr
}

/**
 * @brief  Return the Main Stack Pointer
 *
 * @return Main Stack Pointer
 *
 * Return the current value of the MSP (main stack pointer)
 * Cortex processor register
 */
__ASM uint32_t __get_MSP(void)
{
  mrs r0, msp
  bx lr
}

/**
 * @brief  Set the Main Stack Pointer
 *
 * @param  topOfMainStack  Main Stack Pointer
 *
 * Assign the value mainStackPointer to the MSP 
 * (main stack pointer) Cortex processor register
 */
__ASM void __set_MSP(uint32_t mainStackPointer)
{
  msr msp, r0
  bx lr
}

/**
 * @brief  Reverse byte order in unsigned short value
 *
 * @param   value  value to reverse
 * @return         reversed value
 *
 * Reverse byte order in unsigned short value
 */
__ASM uint32_t __REV16(uint16_t value)
{
  rev16 r0, r0
  bx lr
}

/**
 * @brief  Reverse byte order in signed short value with sign extension to integer
 *
 * @param   value  value to reverse
 * @return         reversed value
 *
 * Reverse byte order in signed short value with sign extension to integer
 */
__ASM int32_t __REVSH(int16_t value)
{
  revsh r0, r0
  bx lr
}


#if (__ARMCC_VERSION < 400000)

/**
 * @brief  Remove the exclusive lock created by ldrex
 *
 * Removes the exclusive lock which is created by ldrex.
 */
__ASM void __CLREX(void)
{
  clrex
}

/**
 * @brief  Return the Base Priority value
 *
 * @return BasePriority
 *
 * Return the content of the base priority register
 */
__ASM uint32_t  __get_BASEPRI(void)
{
  mrs r0, basepri
  bx lr
}

/**
 * @brief  Set the Base Priority value
 *
 * @param  basePri  BasePriority
 *
 * Set the base priority register
 */
__ASM void __set_BASEPRI(uint32_t basePri)
{
  msr basepri, r0
  bx lr
}

/**
 * @brief  Return the Priority Mask value
 *
 * @return PriMask
 *
 * Return state of the priority mask bit from the priority mask register
 */
__ASM uint32_t __get_PRIMASK(void)
{
  mrs r0, primask
  bx lr
}

/**
 * @brief  Set the Priority Mask value
 *
 * @param  priMask  PriMask
 *
 * Set the priority mask bit in the priority mask register
 */
__ASM void __set_PRIMASK(uint32_t priMask)
{
  msr primask, r0
  bx lr
}

/**
 * @brief  Return the Fault Mask value
 *
 * @return FaultMask
 *
 * Return the content of the fault mask register
 */
__ASM uint32_t  __get_FAULTMASK(void)
{
  mrs r0, faultmask
  bx lr
}

/**
 * @brief  Set the Fault Mask value
 *
 * @param  faultMask  faultMask value
 *
 * Set the fault mask register
 */
__ASM void __set_FAULTMASK(uint32_t faultMask)
{
  msr faultmask, r0
  bx lr
}

/**
 * @brief  Return the Control Register value
 * 
 * @return Control value
 *
 * Return the content of the control register
 */
__ASM uint32_t __get_CONTROL(void)
{
  mrs r0, control
  bx lr
}

/**
 * @brief  Set the Control Register value
 *
 * @param  control  Control value
 *
 * Set the control register
 */
__ASM void __set_CONTROL(uint32_t control)
{
  msr control, r0
  bx lr
}

#endif /* __ARMCC_VERSION  */ 



#elif (defined (__ICCARM__)) /*------------------ ICC Compiler -------------------*/
/* IAR iccarm specific functions */
#pragma diag_suppress=Pe940

/**
 * @brief  Return the Process Stack Pointer
 *
 * @return ProcessStackPointer
 *
 * Return the actual process stack pointer
 */
uint32_t __get_PSP(void)
{
  __ASM("mrs r0, psp");
  __ASM("bx lr");
}

/**
 * @brief  Set the Process Stack Pointer
 *
 * @param  topOfProcStack  Process Stack Pointer
 *
 * Assign the value ProcessStackPointer to the MSP 
 * (process stack pointer) Cortex processor register
 */
void __set_PSP(uint32_t topOfProcStack)
{
  __ASM("msr psp, r0");
  __ASM("bx lr");
}

/**
 * @brief  Return the Main Stack Pointer
 *
 * @return Main Stack Pointer
 *
 * Return the current value of the MSP (main stack pointer)
 * Cortex processor register
 */
uint32_t __get_MSP(void)
{
  __ASM("mrs r0, msp");
  __ASM("bx lr");
}

/**
 * @brief  Set the Main Stack Pointer
 *
 * @param  topOfMainStack  Main Stack Pointer
 *
 * Assign the value mainStackPointer to the MSP 
 * (main stack pointer) Cortex processor register
 */
void __set_MSP(uint32_t topOfMainStack)
{
  __ASM("msr msp, r0");
  __ASM("bx lr");
}

/**
 * @brief  Reverse byte order in unsigned short value
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse byte order in unsigned short value
 */
uint32_t __REV16(uint16_t value)
{
  __ASM("rev16 r0, r0");
  __ASM("bx lr");
}

/**
 * @brief  Reverse bit order of value
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse bit order of value
 */
uint32_t __RBIT(uint32_t value)
{
  __ASM("rbit r0, r0");
  __ASM("bx lr");
}

/**
 * @brief  LDR Exclusive (8 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 8 bit values)
 */
uint8_t __LDREXB(uint8_t *addr)
{
  __ASM("ldrexb r0, [r0]");
  __ASM("bx lr"); 
}

/**
 * @brief  LDR Exclusive (16 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 16 bit values
 */
uint16_t __LDREXH(uint16_t *addr)
{
  __ASM("ldrexh r0, [r0]");
  __ASM("bx lr");
}

/**
 * @brief  LDR Exclusive (32 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 32 bit values
 */
uint32_t __LDREXW(uint32_t *addr)
{
  __ASM("ldrex r0, [r0]");
  __ASM("bx lr");
}

/**
 * @brief  STR Exclusive (8 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 8 bit values
 */
uint32_t __STREXB(uint8_t value, uint8_t *addr)
{
  __ASM("strexb r0, r0, [r1]");
  __ASM("bx lr");
}

/**
 * @brief  STR Exclusive (16 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 16 bit values
 */
uint32_t __STREXH(uint16_t value, uint16_t *addr)
{
  __ASM("strexh r0, r0, [r1]");
  __ASM("bx lr");
}

/**
 * @brief  STR Exclusive (32 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 32 bit values
 */
uint32_t __STREXW(uint32_t value, uint32_t *addr)
{
  __ASM("strex r0, r0, [r1]");
  __ASM("bx lr");
}

#pragma diag_default=Pe940


#elif (defined (__GNUC__)) /*------------------ GNU Compiler ---------------------*/
/* GNU gcc specific functions */

/**
 * @brief  Return the Process Stack Pointer
 *
 * @return ProcessStackPointer
 *
 * Return the actual process stack pointer
 */
uint32_t __get_PSP(void) __attribute__( ( naked ) );
uint32_t __get_PSP(void)
{
  uint32_t result=0;

  __ASM volatile ("MRS %0, psp\n\t" 
                  "MOV r0, %0 \n\t"
                  "BX  lr     \n\t"  : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Process Stack Pointer
 *
 * @param  topOfProcStack  Process Stack Pointer
 *
 * Assign the value ProcessStackPointer to the MSP 
 * (process stack pointer) Cortex processor register
 */
void __set_PSP(uint32_t topOfProcStack) __attribute__( ( naked ) );
void __set_PSP(uint32_t topOfProcStack)
{
  __ASM volatile ("MSR psp, %0\n\t"
                  "BX  lr     \n\t" : : "r" (topOfProcStack) );
}

/**
 * @brief  Return the Main Stack Pointer
 *
 * @return Main Stack Pointer
 *
 * Return the current value of the MSP (main stack pointer)
 * Cortex processor register
 */
uint32_t __get_MSP(void) __attribute__( ( naked ) );
uint32_t __get_MSP(void)
{
  uint32_t result=0;

  __ASM volatile ("MRS %0, msp\n\t" 
                  "MOV r0, %0 \n\t"
                  "BX  lr     \n\t"  : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Main Stack Pointer
 *
 * @param  topOfMainStack  Main Stack Pointer
 *
 * Assign the value mainStackPointer to the MSP 
 * (main stack pointer) Cortex processor register
 */
void __set_MSP(uint32_t topOfMainStack) __attribute__( ( naked ) );
void __set_MSP(uint32_t topOfMainStack)
{
  __ASM volatile ("MSR msp, %0\n\t"
                  "BX  lr     \n\t" : : "r" (topOfMainStack) );
}

/**
 * @brief  Return the Base Priority value
 *
 * @return BasePriority
 *
 * Return the content of the base priority register
 */
uint32_t __get_BASEPRI(void)
{
  uint32_t result=0;
  
  __ASM volatile ("MRS %0, basepri_max" : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Base Priority value
 *
 * @param  basePri  BasePriority
 *
 * Set the base priority register
 */
void __set_BASEPRI(uint32_t value)
{
  __ASM volatile ("MSR basepri, %0" : : "r" (value) );
}

/**
 * @brief  Return the Priority Mask value
 *
 * @return PriMask
 *
 * Return state of the priority mask bit from the priority mask register
 */
uint32_t __get_PRIMASK(void)
{
  uint32_t result=0;

  __ASM volatile ("MRS %0, primask" : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Priority Mask value
 *
 * @param  priMask  PriMask
 *
 * Set the priority mask bit in the priority mask register
 */
void __set_PRIMASK(uint32_t priMask)
{
  __ASM volatile ("MSR primask, %0" : : "r" (priMask) );
}

/**
 * @brief  Return the Fault Mask value
 *
 * @return FaultMask
 *
 * Return the content of the fault mask register
 */
uint32_t __get_FAULTMASK(void)
{
  uint32_t result=0;
  
  __ASM volatile ("MRS %0, faultmask" : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Fault Mask value
 *
 * @param  faultMask  faultMask value
 *
 * Set the fault mask register
 */
void __set_FAULTMASK(uint32_t faultMask)
{
  __ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) );
}

/**
 * @brief  Return the Control Register value
* 
*  @return Control value
 *
 * Return the content of the control register
 */
uint32_t __get_CONTROL(void)
{
  uint32_t result=0;

  __ASM volatile ("MRS %0, control" : "=r" (result) );
  return(result);
}

/**
 * @brief  Set the Control Register value
 *
 * @param  control  Control value
 *
 * Set the control register
 */
void __set_CONTROL(uint32_t control)
{
  __ASM volatile ("MSR control, %0" : : "r" (control) );
}


/**
 * @brief  Reverse byte order in integer value
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse byte order in integer value
 */
uint32_t __REV(uint32_t value)
{
  uint32_t result=0;
  
  __ASM volatile ("rev %0, %1" : "=r" (result) : "r" (value) );
  return(result);
}

/**
 * @brief  Reverse byte order in unsigned short value
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse byte order in unsigned short value
 */
uint32_t __REV16(uint16_t value)
{
  uint32_t result=0;
  
  __ASM volatile ("rev16 %0, %1" : "=r" (result) : "r" (value) );
  return(result);
}

/**
 * @brief  Reverse byte order in signed short value with sign extension to integer
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse byte order in signed short value with sign extension to integer
 */
int32_t __REVSH(int16_t value)
{
  uint32_t result=0;
  
  __ASM volatile ("revsh %0, %1" : "=r" (result) : "r" (value) );
  return(result);
}

/**
 * @brief  Reverse bit order of value
 *
 * @param  value  value to reverse
 * @return        reversed value
 *
 * Reverse bit order of value
 */
uint32_t __RBIT(uint32_t value)
{
  uint32_t result=0;
  
   __ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );
   return(result);
}

/**
 * @brief  LDR Exclusive (8 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 8 bit value
 */
uint8_t __LDREXB(uint8_t *addr)
{
    uint8_t result=0;
  
   __ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) );
   return(result);
}

/**
 * @brief  LDR Exclusive (16 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 16 bit values
 */
uint16_t __LDREXH(uint16_t *addr)
{
    uint16_t result=0;
  
   __ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) );
   return(result);
}

/**
 * @brief  LDR Exclusive (32 bit)
 *
 * @param  *addr  address pointer
 * @return        value of (*address)
 *
 * Exclusive LDR command for 32 bit values
 */
uint32_t __LDREXW(uint32_t *addr)
{
    uint32_t result=0;
  
   __ASM volatile ("ldrex %0, [%1]" : "=r" (result) : "r" (addr) );
   return(result);
}

/**
 * @brief  STR Exclusive (8 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 8 bit values
 */
uint32_t __STREXB(uint8_t value, uint8_t *addr)
{
   uint32_t result=0;
  
   __ASM volatile ("strexb %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );
   return(result);
}

/**
 * @brief  STR Exclusive (16 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 16 bit values
 */
uint32_t __STREXH(uint16_t value, uint16_t *addr)
{
   uint32_t result=0;
  
   __ASM volatile ("strexh %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );
   return(result);
}

/**
 * @brief  STR Exclusive (32 bit)
 *
 * @param  value  value to store
 * @param  *addr  address pointer
 * @return        successful / failed
 *
 * Exclusive STR command for 32 bit values
 */
uint32_t __STREXW(uint32_t value, uint32_t *addr)
{
   uint32_t result=0;
  
   __ASM volatile ("strex %0, %2, [%1]" : "=r" (result) : "r" (addr), "r" (value) );
   return(result);
}


#elif (defined (__TASKING__)) /*------------------ TASKING Compiler ---------------------*/
/* TASKING carm specific functions */

/*
 * The CMSIS functions have been implemented as intrinsics in the compiler.
 * Please use "carm -?i" to get an up to date list of all instrinsics,
 * Including the CMSIS ones.
 */

#endif