六.面向对象的嵌入式底层开发-LED（C面向对象开发）

最新推荐文章于 2024-06-04 08:21:00 发布
最新推荐文章于 2024-06-04 08:21:00 发布
阅读量2.1k 收藏 24
点赞数 1
分类专栏： C面向对象开发 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trstary/article/details/109284343
版权

内容参考于《抽象接口技术和组件开发规范及其思想》、《面向ametal框架和接口的C编程》

六.面向对象的嵌入式底层开发-LED

Ametal中LED的实现

资源图
在这里插入图片描述

1. demo_std_led.c

demo属于应用层。am_led_on和am_led_off属于通用接口，通用接口的第一个参数表示要操作的具体对象。一个系统可能有多颗LED，为每一颗LED分配一个ID号。通过ID形式隐藏了底层的对象和指针，对APP层更加友好，不被非业务的逻辑所影响。通过ID能查找到对象，但是，ID和对象并非是一对一的，一个对象可以拥有几个ID，可以理解为，主设备号（对象）下拥有这多个次设备号（ID）。

#include "ametal.h"
#include "am_led.h"
#include "am_delay.h"

void demo_std_led_entry (int led_id)
{
    while (1) {
        am_led_on(led_id);
        am_mdelay(500);
        am_led_off(led_id);
        am_mdelay(500);
    }
}
2. am_led.h（LED标准接口）

demo_std_led.c依赖于am_led.h

#ifndef __AM_LED_H
#define __AM_LED_H

#ifdef __cplusplus
extern "C" {
#endif

#include "am_common.h"

int am_led_set(int led_id, am_bool_t state);
int am_led_on(int led_id);
int am_led_off(int led_id);
int am_led_toggle(int led_id);

#ifdef __cplusplus
}
#endif

#endif /* __AM_LED_H */
3. am_led_dev.c（通用LED设备管理器）

通用接口的实现

  1. 先看看int am_led_on (int led_id)和int am_led_off (int led_id)，发现其实整个的核心代码是int am_led_set (int led_id, am_bool_t state) 和 int am_led_toggle (int led_id)，这两个函数屏蔽了底层的差异，无论底层如何变化（GPIO或者HC595），其使用p_dev->p_funcs->pfn_led_set 和 p_dev->p_funcs->pfn_led_toggle即可，这部分下面再进行细讲。
  2. am_led_dev_t * __led_dev_find_with_id(int id)，其通过ID号查找到对象，将对象屏蔽在底层。
  3. 一般来说，在嵌入式底层，对象都是确定的，有几个LED，有几个UART，在硬件设计那一刻就确定了，代码通过宏进行声明。应用层启动前会对对象进程初始化，再进入应用。把LED对象，挂在 *static am_led_dev_t __gp_head 这个链表下面，这部分下面再进行细讲。
#include "ametal.h"
#include "am_led.h"
#include "am_led_dev.h"
#include "am_int.h"

static am_led_dev_t *__gp_head;

static am_led_dev_t * __led_dev_find_with_id (int id)
{
    am_led_dev_t *p_cur   = __gp_head;

    int key = am_int_cpu_lock();

    while (p_cur != NULL) {

        if ((id >= p_cur->p_info->start_id) &&
            (id <= p_cur->p_info->end_id)) {

            break;
        }

        p_cur = p_cur->p_next;
    }

    am_int_cpu_unlock(key);

    return p_cur;
}

static int __led_dev_add (am_led_dev_t *p_dd)
{
    int key = am_int_cpu_lock();

    /* add the device to device list */
    p_dd->p_next = __gp_head;
    __gp_head    = p_dd;

    am_int_cpu_unlock(key);

    return AM_OK;
}

static int __led_dev_del (am_led_dev_t *p_dd)
{
    int            ret     = -AM_ENODEV;
    am_led_dev_t **pp_head = &__gp_head;
    am_led_dev_t  *p_prev  = AM_CONTAINER_OF(pp_head, am_led_dev_t, p_next);
    am_led_dev_t  *p_cur   = __gp_head;
  
    int key = am_int_cpu_lock();

    while (p_cur != NULL) {
        if (p_cur == p_dd) {

            p_prev->p_next = p_dd->p_next;
            p_dd->p_next   = NULL;
            ret            = AM_OK;
            break;
        }

        p_prev = p_cur;
        p_cur  = p_cur->p_next;
    }

    am_int_cpu_unlock(key);

    return ret;
}

int am_led_dev_lib_init (void)
{
    __gp_head = NULL;

    return AM_OK;
}

int am_led_dev_add (am_led_dev_t             *p_dev,
                    const am_led_servinfo_t  *p_info,
                    const am_led_drv_funcs_t *p_funcs,
                    void                     *p_cookie)
{
    if ((p_dev == NULL) || (p_funcs == NULL) || (p_info == NULL)) {
        return -AM_EINVAL;
    }

    if (__led_dev_find_with_id(p_info->start_id) != NULL) {
        return -AM_EPERM;
    }

    if (__led_dev_find_with_id(p_info->end_id) != NULL) {
        return -AM_EPERM;
    }

    p_dev->p_info   = p_info;
    p_dev->p_funcs  = p_funcs;
    p_dev->p_next   = NULL;
    p_dev->p_cookie = p_cookie;

    return __led_dev_add(p_dev);
}

int am_led_dev_del (am_led_dev_t *p_dd)
{
    if (p_dd == NULL) {
        return -AM_EINVAL;
    }

    return __led_dev_del(p_dd);
}

int am_led_set (int led_id, am_bool_t state)
{
    am_led_dev_t *p_dev = __led_dev_find_with_id(led_id);

    if (p_dev == NULL) {
        return -AM_ENODEV;
    }

    if (p_dev->p_funcs->pfn_led_set) {
        return p_dev->p_funcs->pfn_led_set(p_dev->p_cookie, led_id, state);
    }

    return -AM_ENOTSUP;
}

int am_led_toggle (int led_id)
{
    am_led_dev_t *p_dev = __led_dev_find_with_id(led_id);

    if (p_dev == NULL) {
        return -AM_ENODEV;
    }

    if (p_dev->p_funcs->pfn_led_toggle) {
        return p_dev->p_funcs->pfn_led_toggle(p_dev->p_cookie, led_id);
    }

    return -AM_ENOTSUP;
}

int am_led_on (int led_id)
{
    return am_led_set(led_id, AM_TRUE);
}

int am_led_off (int led_id)
{
    return am_led_set(led_id, AM_FALSE);
}
4. am_led_dev.h（通用LED设备管理器）
  1. 让我们来看看led的抽象类。其实am_led_dev.h和am_led.h本该属于同一个H文件，这里分为2个文件，一个对内，一个对外，am_led.h是提供给应用层的，称为LED标准接口。am_led_dev是LED类的通用LED设备管理器，因为其不仅仅包含了抽象类，还包含了抽象类的链表。
  2. am_led_dev_t就是LED类，这里称为通用LED设备。
  3. am_led_dev_t第一个组成是抽象方法const am_led_drv_funcs_t，这里称为驱动函数，注意是const类型，驱动函数从硬件确定便已经确定了。
  4. am_led_dev_t第二个组成是成员void *p_cookie，驱动函数参数，通常指向对象本身，其作用下面再细讲。
  5. am_led_dev_t第三个组成是成员const am_led_servinfo_t *p_info，其记录着这个对象的基本消息，LED编号（一个LED设备下有几路LED）。
  6. am_led_dev_t第四个组成是成员struct am_led_dev *p_next，把所有的LED设备链起来，那么就能够统一管理所有的设备，具有设备管理器的功能。
#ifndef __AM_LED_DEV_H
#define __AM_LED_DEV_H

#include "ametal.h"
#include "am_led.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief LED驱动函数
 */
typedef struct am_led_drv_funcs {

    /* 设置LED的状态 */
    int (*pfn_led_set)   (void *p_cookie, int id, am_bool_t on);

    /* 翻转LED的状态 */
    int (*pfn_led_toggle)(void *p_cookie, int id);

} am_led_drv_funcs_t;

/**
 * \brief 通用LED服务信息
 */
typedef struct am_led_servinfo {
    int         start_id;        /**< \brief 本设备提供的LED服务的起始编号 */
    int         end_id;          /**< \brief 本设备提供的LED服务的结束编号 */
} am_led_servinfo_t;

/**
 * \brief 通用LED设备
 */
typedef struct am_led_dev {
    const am_led_drv_funcs_t     *p_funcs;   /**< \brief 驱动函数            */
    void                         *p_cookie;  /**< \brief 驱动函数参数  */
    const am_led_servinfo_t      *p_info;    /**< \brief LED服务信息     */
    struct am_led_dev            *p_next;    /**< \brief 下一个LED设备 */
} am_led_dev_t;

/** 
 * \brief LED设备库管理初始化
 * \retval AM_OK : LED设备库管理初始化库初始化成功
 */
int am_led_dev_lib_init (void);

/**
 * \brief 添加一个LED设备
 *
 * \param[in] p_dev    : LED设备实例
 * \param[in] p_info   ：LED设备服务信息
 * \param[in] p_funcs  : LED设备的驱动函数
 * \param[in] p_cookie : 驱动函数的参数
 *
 * \retval AM_OK      : 添加成功
 * \retval -AM_EINVAL ：添加失败，参数存在错误
 * \retval -AM_EPERM  : 添加失败，该设备对应的LED编号已经存在
 */
int am_led_dev_add (am_led_dev_t             *p_dev,
                    const am_led_servinfo_t  *p_info,
                    const am_led_drv_funcs_t *p_funcs,
                    void                     *p_cookie);
/**
 * \brief 删除一个LED设备
 *
 * \param[in] p_dev     : LED设备实例
 *
 * \retval AM_OK      : 删除成功
 * \retval -AM_EINVAL ：删除失败，参数存在错误
 * \retval -AM_ENODEV : 删除失败，无此参数
 */
int am_led_dev_del (am_led_dev_t *p_dev);

/* @} */

#ifdef __cplusplus
}
#endif

#endif /* __AM_LED_DEV_H */
5. __gp_head
  1. 通过上面的代码，我们知道，最终操作的是static am_led_dev_t *__gp_head这个链表下的各个设备（对象），那么从am_led_dev_add开始入手。
  2. am_led_dev_add第一个参数要求输入一个设备（对象），第二个参数要求输入这个设备的信息（LED的ID范围，次设备号），第三个参数要求输入这个设备的驱动函数am_led_drv_funcs_t，第三个参数要求输入驱动函数的参数void *p_cookie。

以上描述了接口的使用、设备的抽象接口内容、设备管理器，下面描述其底层实现

通过gpio控制led的接口实现

6. am_led_gpio.h
  1. am_led_gpio_dev是实现接口后的类，其还包含自己的成员变量
    const am_led_gpio_info_t *p_info，方法（构造函数和析构函数） am_led_gpio_init 和 am_led_gpio_deinit。
  2. am_led_gpio_info_t成员包含着，gpio特有的一些数据。
#ifndef __AM_LED_GPIO_H
#define __AM_LED_GPIO_H

#include "ametal.h"
#include "am_led_dev.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief LED信息（GPIO驱动）
 */
typedef struct am_led_gpio_info {

    /** \brief LED基础服务信息 ，包含起始编号和结束编号     */
    am_led_servinfo_t  serv_info;

    /** \brief 使用的GPIO引脚，引脚数目应该为 （结束编号 - 起始编号 + 1）   */
    const int         *p_pins;

    /** \brief LED是否是低电平点亮  */
    am_bool_t          active_low;

} am_led_gpio_info_t;

/**
 * \brief LED设备（GPIO驱动）
 */
typedef struct am_led_gpio_dev {
    am_led_dev_t               isa;
    const am_led_gpio_info_t  *p_info;
} am_led_gpio_dev_t;

/**
 * \brief LED设备初始化（GPIO驱动）
 *
 * \param[in] p_dev  : LED设备
 * \param[in] p_info : LED设备信息
 *
 * \retval AM_OK      : 初始化成功
 * \retval -AM_EINVAL : 初始化失败
 */
int am_led_gpio_init (am_led_gpio_dev_t         *p_dev,
                      const am_led_gpio_info_t  *p_info);

/**
 * \brief LED设备解初始化（GPIO驱动）
 *
 * \param[in] p_dev  : LED设备
 *
 * \retval AM_OK      : 解初始化成功
 * \retval -AM_EINVAL : 解初始化失败
 */
int am_led_gpio_deinit (am_led_gpio_dev_t *p_dev);

#ifdef __cplusplus
}
#endif

#endif /* __AM_LED_GPIO_H */
7. am_led_gpio.c
#include "ametal.h"
#include "am_led_gpio.h"
#include "am_gpio.h"

static int __led_gpio_set (void *p_cookie, int led_id, am_bool_t state)
{
    am_led_gpio_dev_t *p_dev = (am_led_gpio_dev_t *)p_cookie;

    led_id = led_id - p_dev->p_info->serv_info.start_id;

    am_gpio_set(p_dev->p_info->p_pins[led_id], state ^ p_dev->p_info->active_low);

    return AM_OK;
}

static int __led_gpio_toggle (void *p_cookie, int led_id)
{
    am_led_gpio_dev_t *p_dev = (am_led_gpio_dev_t *)p_cookie;

    led_id = led_id - p_dev->p_info->serv_info.start_id;

    am_gpio_toggle(p_dev->p_info->p_pins[led_id]);

    return AM_OK;
}

static const am_led_drv_funcs_t __g_led_gpio_drv_funcs = {
    __led_gpio_set,
    __led_gpio_toggle
};

int am_led_gpio_init (am_led_gpio_dev_t         *p_dev,
                      const am_led_gpio_info_t  *p_info)
{
    int i;
    int num;

    if ((p_dev == NULL) || (p_info == NULL)) {
        return -AM_EINVAL;
    }

    num = p_info->serv_info.end_id - p_info->serv_info.start_id + 1;

    if (num <= 0) {
        return -AM_EINVAL;
    }

    p_dev->p_info = p_info;

    for (i = 0; i < num; i++) {
        if (p_info->active_low) {
            am_gpio_pin_cfg(p_info->p_pins[i], AM_GPIO_OUTPUT_INIT_HIGH);
        } else {
            am_gpio_pin_cfg(p_info->p_pins[i], AM_GPIO_OUTPUT_INIT_LOW);
        }
    }

    return am_led_dev_add(&p_dev->isa,
                          &p_info->serv_info,
                           &__g_led_gpio_drv_funcs,
                           p_dev);
}

int am_led_gpio_deinit (am_led_gpio_dev_t *p_dev)
{
    int i;
    int num;

    if (p_dev == NULL) {
        return -AM_EINVAL;
    }

    num = p_dev->p_info->serv_info.end_id - p_dev->p_info->serv_info.start_id + 1;

    if (num <= 0) {
        return -AM_EINVAL;
    }

    for (i = 0; i < num; i++) {
        am_gpio_pin_cfg(p_dev->p_info->p_pins[i], AM_GPIO_INPUT | AM_GPIO_FLOAT);
    }

    return am_led_dev_del(&p_dev->isa);
}
8. am_hwconf_xx.c

应用启动前的硬件初始化，这里我们称为板级初始化，姑且这么认为（涉及到框架），这个路径就很有趣board\am217_core\project_template\user_config\am_hwconf_usrcfg。

/* GPIO形式 */
static am_led_gpio_dev_t  __g_miniport_led;
static const int __g_miniport_led_pins[] = {
    PIOB_7, PIOB_6, PIOB_15, PIOB_13, PIOC_10, PIOB_14, PIOB_12, PIOC_14
};

static const am_led_gpio_info_t __g_miniport_led_info = {
    {
        0,                            /* 起始编号0 */
        7                             /* 结束编号7，共计8个LED */
    },
    __g_miniport_led_pins,
    AM_TRUE
};

int am_miniport_led_inst_init (void)
{
    return am_led_gpio_init(&__g_miniport_led, &__g_miniport_led_info);
}

/* HC595形式 */
static am_led_hc595_dev_t  __g_miniport_led_595;
static uint8_t __g_miniport_led_595_buf[1];
static const am_led_hc595_info_t __g_miniport_led_595_info = {
    {
        8,                            /* 起始编号8 */
        9                             /* 结束编号9，共计2个LED */
    },
    1,
    __g_miniport_led_595_buf,
    AM_TRUE
};

int am_miniport_led_595_inst_init (void)
{

    return am_led_hc595_init(&__g_miniport_led_595,
                             &__g_miniport_led_595_info,
                              am_miniport_595_inst_init());
}

通过hc595控制led的接口实现

9. am_led_hc595.h
#ifndef __AM_LED_HC595_H
#define __AM_LED_HC595_H

#include "ametal.h"
#include "am_led_dev.h"
#include "am_hc595.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * \brief LED信息（HC595驱动）
 */
typedef struct am_led_hc595_info {

    /** \brief LED基础服务信息 ，包含起始编号和结束编号     */
    am_led_servinfo_t  serv_info;

    /** \brief HC595的级连个数  */
    int                hc595_num;

    /** \brief 数据缓存，大小与HC595的级连个数相同 */
    uint8_t           *p_buf;

    /** \brief LED是否是低电平点亮  */
    am_bool_t          active_low;

} am_led_hc595_info_t;

/**
 * \brief LED设备（GPIO驱动）
 */
typedef struct am_led_hc595_dev {
    am_led_dev_t                isa;
    am_hc595_handle_t           handle;
    const am_led_hc595_info_t  *p_info;
} am_led_hc595_dev_t;

/**
 * \brief LED设备初始化（HC595驱动）
 *
 * \param[in] p_dev  : LED设备
 * \param[in] p_info : LED设备信息
 * \param[in] handle : HC595句柄
 *
 * \retval AM_OK      : 初始化成功
 * \retval -AM_EINVAL : 初始化失败
 */
int am_led_hc595_init (am_led_hc595_dev_t         *p_dev,
                       const am_led_hc595_info_t  *p_info,
                       am_hc595_handle_t           handle);

/**
 * \brief LED设备解初始化（HC595驱动）
 *
 * \param[in] p_dev  : LED设备
 *
 * \retval AM_OK      : 解初始化成功
 * \retval -AM_EINVAL : 解初始化失败
 */
int am_led_hc595_deinit (am_led_hc595_dev_t *p_dev);

#ifdef __cplusplus
}
#endif

#endif /* __AM_LED_HC595_H */
10. am_led_hc595.c
#include "ametal.h"
#include "am_hc595.h"
#include "string.h"
#include "am_led_hc595.h"

static int __led_hc595_set (void *p_cookie, int led_id, am_bool_t state)
{
    am_led_hc595_dev_t *p_dev = (am_led_hc595_dev_t *)p_cookie;

    led_id = led_id - p_dev->p_info->serv_info.start_id;

    if (state ^ p_dev->p_info->active_low) {
        p_dev->p_info->p_buf[led_id >> 3] |= (1 << (led_id & 0x07));
    } else {
        p_dev->p_info->p_buf[led_id >> 3] &= ~(1 << (led_id & 0x07));
    }

    am_hc595_send(p_dev->handle,
                  p_dev->p_info->p_buf,
                  p_dev->p_info->hc595_num);

    return AM_OK;
}

static int __led_hc595_toggle (void *p_cookie, int led_id)
{
    am_led_hc595_dev_t *p_dev = (am_led_hc595_dev_t *)p_cookie;

    led_id = led_id - p_dev->p_info->serv_info.start_id;

    p_dev->p_info->p_buf[led_id >> 3] ^= (1 << (led_id & 0x07));

    am_hc595_send(p_dev->handle,
                  p_dev->p_info->p_buf,
                  p_dev->p_info->hc595_num);

    return AM_OK;
}

static const am_led_drv_funcs_t __g_led_hc595_drv_funcs = {
    __led_hc595_set,
    __led_hc595_toggle
};

int am_led_hc595_init (am_led_hc595_dev_t         *p_dev,
                       const am_led_hc595_info_t  *p_info,
                       am_hc595_handle_t           handle)
{
    if ((p_dev == NULL) || (p_info == NULL)) {
        return -AM_EINVAL;
    }

    p_dev->p_info = p_info;

    if (p_info->active_low) {
        memset(p_info->p_buf, 0xFF, p_info->hc595_num);
    } else {
        memset(p_info->p_buf, 0x00, p_info->hc595_num);
    }

    am_hc595_send(handle, p_info->p_buf, p_info->hc595_num);

    return am_led_dev_add(&p_dev->isa,
                          &p_info->serv_info,
                          &__g_led_hc595_drv_funcs,
                           p_dev);
}

int am_led_hc595_deinit (am_led_hc595_dev_t *p_dev)
{
    const am_led_hc595_info_t  *p_info;

    if (p_dev == NULL) {
        return -AM_EINVAL;
    }

    p_info = p_dev->p_info;

    if (p_info->active_low) {
        memset(p_info->p_buf, 0xFF, p_info->hc595_num);
    } else {
        memset(p_info->p_buf, 0x00, p_info->hc595_num);
    }

    am_hc595_send(p_dev->handle, p_info->p_buf, p_info->hc595_num);

    return am_led_dev_del(&p_dev->isa);
}
Trstary
关注
  • 1
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
嵌入式C语言面向对象编程 --- 继承
EmbedIoT Studio
12-27 799
继承就是基于一个已有的类（一般称作父类或基类），再去重新声明或创建一个新的类，这个类可以称为子类或派生类。子类或派生类可以访问父类的数据和函数，然后子类里面又添加了自己的属性和数据。
LED-Lattice-screen.rar_单片机开发_C/C++_
08-11
LED8*8动态显示，显示内容为“I O U”
五.抽象接口与依赖反转（C面向对象开发）
Trstary的博客
10-26 541
内容参考于《抽象接口技术和组件开发规范及其思想》 四.抽象接口与依赖反转 基于多态可以实现“与硬件无关”的应用程序。 在 C 编程中，多态的核心解决方法是充分利用“函数指针”，抽象接口就是只包含函数指针的类， 它们非常抽象，不包含任何具体的实现，仅定义了函数的调用规则。应用不在依赖具体的实现，根据接口去编写应用。实际上之前的综合示例最后一个示例已经完全体现。 1. 示例： 时间示例 接口与应用程序（与底层无关） itime.h struct tm { int tm_sec; // 秒， 0 .
一文了解嵌入式软件开发的“对象”
最新发布
strongerHuang
06-04 57
关注+星标公众号，不错过精彩内容转自 | 嵌入式系统以前应用场景很单一，嵌入式开发可能谈不上面向对象开发。但现在，做嵌入式开发，没有面向对象开发，你就有点落伍了。本文结合个人经验和周立功《抽象接口技术和组件开发规范及其思想》，循序渐进的用代码范例说明嵌入式软件开发的对象，前提你最好有一点点C++基础。间接说明理论指导实践的意义。纸上得来终觉浅，绝知此事要躬行。1 面向对象编程基础面向对象编程涉及到...
嵌入式软件底层开发的框架陈述
strongerHuang
11-29 1760
关注+星标公众号，不错过精彩内容转自|羽林君在底层代码编写中，初始的框架设计总会面临选择，针对实际的硬件使用环境，大家对于使用的软件框架有很多选择，今天我简单描述一些比较常用的架构，...
《深入浅出嵌入式底层软件开发》—1. ARM汇编编程基础
weixin_30314631的博客
08-08 349
1.1 ARM CPU寄存器 ARM的汇编编程，本质上就是针对CPU寄存器的编程，所以要搞清楚ARM有哪些寄存器；ARM寄存器分为两类：普通寄存器和状态寄存器；普通寄存器一共有16个，分别为R0——R15，状态寄存器有2个，分别为CPSR和SPSR。 R15别名PC（program Counter），中文称程序计数器，它的值是当前正在执行的指令在内存中的位置，而当指令执行结束后，CPU硬件会自...
一.封装（C面向对象开发）
Trstary的博客
10-25 667
内容参考于《抽象接口技术和组件开发规范及其思想》 一.封装 在C语言中，可以使用一个C文件（.c 文件）和H文件完（*.h 文件）成“类”的定义，将所有需要封装的东西都存于C 文件中，H 文件中只展现那些对外可见、无需封装（重点）的内容。 1. 示例1： 一个栈对象的例子。 stack.h #ifndef __STACK_H #define __STACK_H struct stack; /* 类型声明，无需关心类定义的具体细节 */ struct stack * stack_create (int .
嵌入式底层开发的软件框架简述
良知犹存的博客
02-21 3554
在底层代码编写中，在初始的框架设计总会面临选择，针对实际的硬件使用环境大家对于使用的软件框架有些难以选择，今天我简单描述一些比较常用的架构。 1.简单的顺序执行程序：这类写法是大多数人使用的方法，不需用思考程序的具体架构，直接通过执行顺序编写应用程序即可。 2.前后台执行程序：在顺序执行的情况上增添中断前台处理机制，配置顺序执行的后台大循环程序，组合成可以实时相应的程序。...
AVR-Menu-control-ledon.rar_单片机开发_C/C++_
08-12
C语言提供了底层硬件访问的能力，而C++则引入了面向对象的编程概念，使得代码更易于管理和复用。在这个项目中，开发者可能使用了结构体来定义菜单项，类来封装LED控制逻辑，并利用指针和函数来实现菜单的层次结构。 ...
ch08-KB-LED-LCD.rar_单片机开发_C/C++_
08-11
C++则提供了面向对象的编程特性，增强了代码的可维护性和复用性。 3. **GPIO应用**：GPIO（General Purpose Input/Output）是单片机中用于输入输出的通用引脚。通过编程，我们可以控制GPIO的电平高低，实现对LED的...
16x64dianzhen.zip_嵌入式/单片机/硬件编程_Objective-C_
08-12
尽管在嵌入式领域中，C语言更常见，但这个项目使用Objective-C可能是因为其需要与苹果的开发环境（如Xcode）配合，或者是为了实现更复杂的数据结构和面向对象的设计。 在压缩包内的文件“16x64dianzhen”，可能是...
LED-XinxingLED.rar_单片机开发_C/C++_
08-11
C语言提供了简洁的语法和对硬件资源的直接控制，而C++则引入了面向对象的编程概念，为复杂的系统设计提供了便利。 AT89C51是美国Atmel公司生产的8051系列微控制器，拥有4KB的ROM、128B的RAM和32个I/O口线。这个微...
好书推荐之周立功《抽象接口技术和组件开发规范及其思想》
吴甜甜的技术博客
06-14 1768
layout: post title: “好书推荐之周立功《抽象接口技术和组件开发规范及其思想》” date: 2019-06-14 21:42:25 +0800 好书推荐之周立功《抽象接口技术和组件开发规范及其思想》 最近，2019年5月，《抽象接口技术和组件开发规范及其思想 V0.2》电子书在朋友圈传开，和大家分享下。 周立功推荐语句：这本书解决了我最头痛的问题，因为我一直不知道如...
二.继承（C面向对象开发）
Trstary的博客
10-25 274
内容参考于《抽象接口技术和组件开发规范及其思想》 一.继承 在一个系统中，可能具有多个栈， 为便于区分，每个栈可以具有不同的名称（系统栈、数据栈、符号栈……）。基于该需求，可以实现一个带名称的栈（为便于和普通栈区分，后文将其称之为“命名栈” ）， 即在普通栈的基础上， 增加一个“名称” 属性。 1. 示例1：（强制转换，不是最优解） #ifndef __STACK_NAMED_H #define __STACK_NAMED_H #include "stack.h" /* 包含基类头文件 */ str.
什么是嵌入式开发？
热门推荐
weixin_45389997的博客
10-27 1万+
本文对嵌入式软件开发以及嵌入式Linux进行了系统的概述，通过网上查阅资料阐述了操作系统、内核、处理器等相关概念，还分别从底层开发和应用层开发的角度总结了嵌入式Linux软件开发内容，顺便丰富了系统调用、交叉编译、ARM、驱动框架、设备树、内核源码等知识。
嵌入式 C 语言的高级用法，面向对象
weixin_39911617的博客
06-27 589
不知道有多少人去了解过语言的发展史，早期C语言的语法功能其实比较简单。随着应用需求和场景的变化，C语言的语法功能在不断升级变化。虽然我们的教材有这么一个结论：C语言是面向过程的语言，C++是面向对象的编程语言，但面向对象的概念是在C语言阶段就有了，而且应用到了很多地方，比如某些操作系统内核、通信协议等。面向对象编程，也就是大家说的OOP（Object Oriented Programming）并不是一种特定的语言或者工具，它只是一种设计方法、设计思想，它表现出来的三个最基本的特性就是封装、继承与多态。阅读文
嵌入式培训经验分享——面向对象语言C++
x2751961352的博客
09-19 224
嵌入式培训经验分享——面向对象语言C++
【UML+OOPC嵌入式C语言开发】使用C语言实现一个面向对象语言才能够实现的类
黑心萝卜三条杠的博客
03-03 1236
C语言也能够使用面向对象搞开发！本文使用C语言设计面向对象程序，根据UML+OOPC嵌入式C语言开发精讲一书讲解了类、接口等相关知识以及实现。
嵌入式C语言面向对象编程 --- 封装
EmbedIoT Studio
12-22 1103
大部分使用 C 语言进行开发的工程师，在接触更高级的编程语言之前，都认为 C 语言是面向过程的。事实也是如此，对于一些小规模的单片机应用程序，一般都是使用“面向过程”的思维进行单片机C语言编程开发。
c语言面向对象嵌入式开发
09-05
C语言是一种面向过程的编程语言，它不直接支持面向对象编程（OOP）。然而，在嵌入式开发中，可以使用一些技巧来实现面向对象的编程风格。 一种常见的方法是通过结构体（struct）和函数指针来模拟类和方法。结构体可以用来封装数据，并通过函数指针来操作数据。 例如，可以定义一个结构体来表示一个对象，结构体的成员变量用来存储对象的状态，成员函数指针用来表示对象的方法。通过传递结构体指针和调用相应的函数指针，就可以实现对对象的操作。 另外，可以使用函数指针作为回调函数，将函数作为参数传递给其他函数，从而实现类似于多态的效果。 总的来说，虽然C语言本身不直接支持面向对象编程，但在嵌入式开发中可以利用结构体和函数指针等技巧来模拟面向对象的编程风格。这种方式可以实现封装、继承和多态等面向对象的特性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值