21ic电子技术开发论坛 › 单片机与嵌入式系统 › 嵌入式操作系统论坛 › VSF然并卵 -- 动态加载
返回列表 发新帖我要提问

VSF然并卵 -- 动态加载

[复制链接]
1853|2
 楼主| Simon21ic 发表于 2015-8-6 11:09 | 显示全部楼层 |阅读模式
ST, App, LED, struct, TI
本帖最后由 Simon21ic 于 2015-8-6 11:23 编辑

最近有人提起了动态加载，自己也抽空评估了一下这个技术，虽然并没有什么卵用，不过还是玩了一下。

动态加载，顾名思义，就是动态加载应用，应用程序可以不在芯片内部的flash里，比如外接的U盘里，然后载入到内存中运行。然而，一般的嵌入式操作系统，都不具备这种能力。
由于编译器具备ropi选项，所以程序部分，比较容易实现地址无关（不管程序在哪个地址，都可以正常运行）。但是，即便编译器具备rwpi，也一般是通过R9寄存器，来设置rw段的基地址。这样虽然可行，但是会非常麻烦，所有应用中的函数，被调用时，都需要保证R9被正确设置。

VSF构架，由于给应用层的接口都是面向对象的，使得能够非常容易的解决这个问题，就是应用程序不需要静态内存，应用需要的内存资源都使用动态分配。VSF的进程，以及回调函数等等，都可以设置一个用户定义的指针，正好可以用来指向这个分配的内存。

系统代码：
复制
  1. #include "vsf.h"
    

  2. #include "app_hw_cfg.h"
    


  3. 

  4. struct vsfapp_t
    

  5. {
    

  6.         struct app_hwcfg_t hwcfg;
    

  7.         
    

  8.         uint8_t bufmgr_buffer[64 * 1024];
    

  9. } static app =
    

  10. {
    

  11.         {
    

  12.                 {
    

  13.                         {
    

  14.                                 2,                                        // uint8_t port;
    

  15.                                 13,                                        // uint8_t pin;
    

  16.                         },                                                // struct usb_pullup;
    

  17.                 },                                                        // struct usbd;
    

  18.         {
    

  19.             {3, 4, 3, 6},
    

  20.             {4, 1, 4, 0},
    

  21.             {3, 5, 3, 3},
    

  22.             {3, 9, 3, 10},
    

  23.             {4, 15, 3, 8},
    

  24.             {4, 13, 4, 14},
    

  25.             {4, 11, 4, 12},
    

  26.             {4, 9, 4, 10},
    

  27.             {4, 7, 4, 8},
    

  28.             {3, 0, 3, 1},
    

  29.             {3, 14, 3, 15},
    

  30.             {6, 13, 6, 14},
    

  31.             {4, 6, 4, 2},
    

  32.             {4, 4, 4, 5},
    

  33.             {3, 13, 4, 3},
    

  34.             {3, 11, 3, 12},
    

  35.             {6, 4, 6, 5},
    

  36.             {6, 2, 6, 3},
    

  37.             {6, 0, 6, 1},
    

  38.             {5, 14, 5, 15},
    

  39.             {5, 12, 6, 13},
    

  40.             {5, 4, 5, 5},
    

  41.             {5, 2, 5, 3},
    

  42.             {5, 0, 5, 1},
    

  43.         },                            // struct led_t led[24];
    

  44.         },                                                                // struct app_hwcfg_t hwcfg;
    

  45. };
    


  46. 

  47. // tickclk interrupt, simply call vsftimer_callback_int
    

  48. static void app_tickclk_callback_int(void *param)
    

  49. {
    

  50.         vsftimer_callback_int();
    

  51. }
    


  52. 

  53. int main(void)
    

  54. {
    

  55.         int (*app_main)(const struct vsf_t *vsf, struct app_hwcfg_t *hwcfg) = NULL;
    

  56.         
    

  57.         vsf_leave_critical();
    

  58.         
    

  59.         // system initialize
    

  60.         vsf_bufmgr_init(app.bufmgr_buffer, sizeof(app.bufmgr_buffer));
    

  61.         core_interfaces.core.init(NULL);
    

  62.         core_interfaces.tickclk.init();
    

  63.         core_interfaces.tickclk.start();
    

  64.         vsftimer_init();
    

  65.         core_interfaces.tickclk.set_callback(app_tickclk_callback_int, NULL);
    

  66.         
    

  67.         // load and call application
    

  68.         // TODO: try to load app_main address
    

  69.         app_main = (int (*)(const struct vsf_t *vsf, struct app_hwcfg_t *hwcfg))0x08008000;
    

  70.         if (app_main != NULL)
    

  71.         {
    

  72.                 app_main(&vsf, &app.hwcfg);
    

  73.         }
    

  74.         
    

  75.         while (1)
    

  76.         {
    

  77.                 vsfsm_poll();
    

  78.                 
    

  79.                 vsf_enter_critical();
    

  80.                 if (!vsfsm_get_event_pending())
    

  81.                 {
    

  82.                         // sleep, will also enable interrupt
    

  83.                         core_interfaces.core.sleep(SLEEP_WFI);
    

  84.                 }
    

  85.                 else
    

  86.                 {
    

  87.                         vsf_leave_critical();
    

  88.                 }
    

  89.         }
    

  90. }
应用层序只是做了系统初始化，包括系统初始化，定时器管理初始化，内存管理初始化后，就可以调用应用程序了，这里假定应用程序位于0x08008000的位置。当然，应用程序可以是多个，也可以不在内部flash里（这个就需要先把应用程序复制到内存中）。应用程序的第一个32位数据，是放应用程序用，main函数的偏移。应用中的main函数，参数为vsf和硬件配置。vsf提供了可以使用的系统的所有接口，包括访问硬件的接口，简单的定义如下：
复制
  1. const struct vsf_t vsf =
    

  2. {
    

  3.         &core_interfaces,
    

  4.         
    

  5.         {
    

  6.                 vsfsm_init,
    

  7.                 vsfsm_pt_init,
    

  8.                 vsfsm_post_evt,
    

  9.                 vsfsm_post_evt_pending,
    

  10.                 vsfsm_enter_critical_internal,
    

  11.                 vsfsm_leave_critical_internal,
    

  12.                 vsfsm_sem_init_internal,
    

  13.                 vsfsm_sem_post_internal,
    

  14.                 vsfsm_sem_pend_internal,
    

  15.                 vsfsm_crit_init_internal,
    

  16.                 vsfsm_crit_enter_internal,
    

  17.                 vsfsm_crit_leave_internal,
    

  18.                 vsftimer_register,
    

  19.                 vsftimer_unregister,
    

  20.         },                                                // struct vsf_framework_t framework;
    

  21.         
    

  22.         {
    

  23.                 {
    

  24.                         vsf_fifo_init,
    

  25.                         vsf_fifo_push8,
    

  26.                         vsf_fifo_pop8,
    

  27.                         vsf_fifo_push,
    

  28.                         vsf_fifo_pop,
    

  29.                         vsf_fifo_get_data_length,
    

  30.                         vsf_fifo_get_avail_length,
    

  31.                 },                                        // struct fifo
    

  32.                 {
    

  33.                         vsf_bufmgr_malloc,
    

  34.                         vsf_bufmgr_malloc_aligned,
    

  35.                         vsf_bufmgr_free,
    

  36.                 },                                        // struct bufmgr;
    

  37.         },                                                // struct buffer;
    

  38. };
当然，这个还只是测试的代码，很多协议栈的接口还都没放进去。

应用部分：
应用程序，只需要知道芯片是什么类型的，用来指定编译用的指令集。比如，本例程中芯片使用stm32，所以应用程序的工程可以选择CortexM3的芯片。当然，如果选择CortexM0，那就各种CortexM的处理器都可以兼容。简单的说就是硬件可以使用stm32f1，也可以用新塘的M0，或者atmel的M4，应用程序的二进制文件都不用修改。上代码吧：
复制
  1. #include "vsf.h"
    

  2. #include "app_hw_cfg.h"
    


  3. 

  4. #define LED_EVT_CARRY                                        (VSFSM_EVT_USER_LOCAL + 0)
    


  5. 

  6. struct vsfapp_t
    

  7. {
    

  8.         struct
    

  9.         {
    

  10.                 struct vsf_t const *vsf;
    

  11.         } sys;
    

  12.         
    

  13.         struct vsfsm_t sm;
    

  14.         struct vsftimer_timer_t timer;
    

  15.         
    

  16.         // Application
    

  17.         uint8_t led_num;
    

  18.         struct app_led_t
    

  19.         {
    

  20.                 struct led_t const *hw;
    

  21.                 bool on;
    

  22.                 
    

  23.                 struct vsfsm_pt_t pt;
    

  24.                 struct vsfsm_t *sm_carry;
    

  25.                 
    

  26.                 struct vsfsm_t sm;
    

  27.                 struct vsfapp_t *app;
    

  28.         } led[24];
    

  29. };
    


  30. 

  31. static vsf_err_t app_led_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt)
    

  32. {
    

  33.         struct app_led_t *led = (struct app_led_t *)pt->user_data;
    

  34.         struct vsfapp_t *app = led->app;
    

  35.         struct interfaces_info_t const *ifs = app->sys.vsf->ifs;
    

  36.         struct vsf_framework_t const *framework = &app->sys.vsf->framework;
    

  37.         
    

  38.         vsfsm_pt_begin(pt);
    

  39.         
    

  40.         while (1)
    

  41.         {
    

  42.                 vsfsm_pt_wfe(pt, LED_EVT_CARRY);
    

  43.                 
    

  44.                 if (led->on)
    

  45.                 {
    

  46.                         ifs->gpio.clear(led->hw->hport, 1 << led->hw->hpin);
    

  47.                         if (led->sm_carry != NULL)
    

  48.                         {
    

  49.                                 framework->post_evt(led->sm_carry, LED_EVT_CARRY);
    

  50.                         }
    

  51.                 }
    

  52.                 else
    

  53.                 {
    

  54.                         ifs->gpio.set(led->hw->hport, 1 << led->hw->hpin);
    

  55.                 }
    

  56.                 led->on = !led->on;
    

  57.         }
    

  58.         
    

  59.         vsfsm_pt_end(pt);
    

  60.         return VSFERR_NONE;
    

  61. }
    


  62. 

  63. static struct vsfsm_state_t *
    

  64. app_evt_handler(struct vsfsm_t *sm, vsfsm_evt_t evt)
    

  65. {
    

  66.         struct vsfapp_t *app = (struct vsfapp_t *)sm->user_data;
    

  67.         struct interfaces_info_t const *ifs = app->sys.vsf->ifs;
    

  68.         struct vsf_framework_t const *framework = &app->sys.vsf->framework;
    

  69.         struct app_led_t *led;
    

  70.         struct led_t const *hwled;
    

  71.         uint8_t i;
    

  72.         
    

  73.         switch (evt)
    

  74.         {
    

  75.         case VSFSM_EVT_INIT:
    

  76.                 // Application
    

  77.                 for (i = 0; i < app->led_num; i++)
    

  78.                 {
    

  79.                         led = &app->led[i];
    

  80.                         hwled = led->hw;
    

  81.                         
    

  82.                         led->on = false;
    

  83.                         led->pt.thread = app_led_thread;
    

  84.                         led->pt.user_data = led;
    

  85.                         led->sm_carry = (i < (app->led_num - 1)) ? &app->led[i + 1].sm : NULL;
    

  86.                         led->app = app;
    

  87.                         
    

  88.                         ifs->gpio.init(hwled->lport);
    

  89.                         ifs->gpio.clear(hwled->lport, 1 << hwled->lpin);
    

  90.                         ifs->gpio.config_pin(hwled->lport, hwled->lpin, ifs->gpio.constants.OUTPP);
    

  91.                         ifs->gpio.init(hwled->hport);
    

  92.                         ifs->gpio.clear(hwled->hport, 1 << hwled->hpin);
    

  93.                         ifs->gpio.config_pin(hwled->hport, hwled->hpin, ifs->gpio.constants.OUTPP);
    

  94.                         
    

  95.                         framework->pt_init(&led->sm, &led->pt);
    

  96.                 }
    

  97.                 
    

  98.                 app->timer.interval = 1;
    

  99.                 app->timer.evt = LED_EVT_CARRY;
    

  100.                 app->timer.sm = sm;
    

  101.                 framework->timer_register(&app->timer);
    

  102.                 break;
    

  103.         case LED_EVT_CARRY:
    

  104.                 framework->post_evt(&app->led[0].sm, LED_EVT_CARRY);
    

  105.                 break;
    

  106.         }
    

  107.         return NULL;
    

  108. }
    


  109. 

  110. vsf_err_t __iar_program_start(struct vsf_t const *vsf, struct app_hwcfg_t const *hwcfg)
    

  111. {
    

  112.         int i;
    

  113.         struct vsfapp_t *app = vsf->buffer.bufmgr.malloc(sizeof(struct vsfapp_t));
    

  114.         
    

  115.         if (NULL == app)
    

  116.         {
    

  117.                 return VSFERR_NOT_ENOUGH_RESOURCES;
    

  118.         }
    

  119.         
    

  120.         memset(app, 0, sizeof(*app));
    

  121.         app->sys.vsf = vsf;
    

  122.         app->led_num = dimof(hwcfg->led);
    

  123.         for (i = 0; i < app->led_num; i++)
    

  124.         {
    

  125.                 app->led[i].hw = &hwcfg->led[i];
    

  126.         }
    

  127.         
    

  128.         app->sm.init_state.evt_handler = app_evt_handler;
    

  129.         app->sm.user_data = app;
    

  130.         vsf->framework.sm_init(&app->sm);
    

  131.         return VSFERR_NONE;
    

  132. }
应用程序里，定义了struct vsfapp_t结构，但是并没有使用静态分配的内存，所以应用程序编译后，只占用flash，不占用ram。运行应用程序的main后，调用vsf提供的内存管理接口，分配app的内存，并设置给相应的结构。应用中，并没有实现main函数，而是实现了__iar_program_start，这个是iar的程序入口，如果实现这个的话，IAR就不会自己添加调用main的代码（因为main是在系统里调用的，不需要程序自己调用），这里可以认为__iar_program_start就是应用的main函数。应用中的其他部分，都只是访问指向app内存的指针，来访问内存资源。当然，还有一个，就是编译后的镜像的第一个32为，需要是main函数的指针，IAR下可以这么实现，在startup.s文件中：
复制
  1.         SECTION .entry:CODE:ROOT(4)
    

  2.         EXTERN  __iar_program_start
    

  3.         DATA
    

  4.         DCD     __iar_program_start
    

  5.         END
并且，在linker文件中，把这个放在地址0。

回复

收藏2 举报

相关帖子
mmuuss586 发表于 2015-8-6 12:32 | 显示全部楼层

似乎和ST版块没啥关系
回复

收藏2 举报

 楼主| Simon21ic 发表于 2015-8-6 12:39 | 显示全部楼层
mmuuss586 发表于 2015-8-6 12:32
似乎和ST版块没啥关系

不知道应该发那个板块，帮我移一下吧
回复

收藏2 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Simon21ic
个人签名：www.versaloon.com --- under construction

266

主题

2597

帖子

104

粉丝
快速回复 在线客服 返回列表 返回顶部