Changeset 431 for EcnlProtoTool


Ignore:
Timestamp:
Jul 5, 2020, 3:48:53 PM (4 years ago)
Author:
coas-nagasima
Message:

タスク名などを変更、定義場所の移動など

Location:
EcnlProtoTool/trunk/ntshell/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/ntshell/src/main.c

    r427 r431  
    7979char command[NTOPT_TEXT_MAXLEN];
    8080ntstdio_t ntstdio;
     81ntshell_t ntshell;
     82
     83unsigned char ntstdio_xi(struct ntstdio_t *handle)
     84{
     85        char buf[1];
     86        if(serial_rea_dat(SIO_PORTID, buf, 1) != 1)
     87                return -EIO;
     88        return buf[0];
     89}
     90
     91void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
     92{
     93        char buf[1];
     94        buf[0] = c;
     95        serial_wri_dat(SIO_PORTID, buf, 1);
     96}
    8197
    8298const uint8_t mac_addr[6] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
    … …  
    90106};
    91107
    92 static void netif_link_callback(T_IFNET *ether);
    93 extern int execute_command(int wait);
     108int shell_uname(struct utsname *uts)
     109{
     110        memcpy(uts, &host_name, sizeof(host_name));
     111        return 0;
     112}
    94113
    95114enum main_state_t {
    … …  
    98117};
    99118
    100 struct main_t {
     119struct main_obj_t {
    101120        TMO timer;
    102121        enum main_state_t state;
    … …  
    106125        WS_FBS_ID sndmsg;
    107126};
    108 struct main_t main_obj;
    109 
     127struct main_obj_t main_obj;
     128
     129static void netif_link_callback(T_IFNET *ether);
    110130static void main_initialize();
    111131static TMO main_get_timer();
    112132static void main_progress(TMO interval);
    113133static void main_timeout();
     134extern int execute_command(int wait);
     135static int usrcmd_ntopt_callback(long *args, void *extobj);
     136
     137int shellcmd_exit_code;
     138volatile int shellcmd_state;
     139typedef void (*PowerOn_Reset_t)(long *args);
     140jmp_buf shellcmd_exit;
    114141
    115142int uart_read(char *buf, int cnt, void *extobj)
    … …  
    225252}
    226253
    227 unsigned char ntstdio_xi(struct ntstdio_t *handle)
    228 {
    229         char buf[1];
    230         if(serial_rea_dat(SIO_PORTID, buf, 1) != 1)
    231                 return -EIO;
    232         return buf[0];
    233 }
    234 
    235 void ntstdio_xo(struct ntstdio_t *handle, unsigned char c)
    236 {
    237         char buf[1];
    238         buf[0] = c;
    239         serial_wri_dat(SIO_PORTID, buf, 1);
    240 }
    241 
    242 ntshell_t ntshell;
    243 static int cmd_execute(const char *text, void *extobj);
     254static int cmd_execute(const char *text, void *extobj)
     255{
     256        if (text != NULL) {
     257                ntlibc_strlcpy(command, text, sizeof(command));
     258        }
     259        ER ret;
     260        ID tskid = 0;
     261
     262        ret = get_tid(&tskid);
     263        if (ret != E_OK) {
     264                syslog(LOG_ERROR, "get_tid %d", ret);
     265        }
     266
     267        return execute_command(tskid == MAIN_TASK);
     268}
    244269
    245270/*
    … …  
    363388        ER ret;
    364389
    365         ret = ref_tsk(MRUBY_TASK, &rtsk);
     390        ret = ref_tsk(SHELLCMD_TASK, &rtsk);
    366391        if ((ret != E_OK) || (rtsk.tskstat == TTS_DMT))
    367392                return;
    … …  
    372397}
    373398
    374 int shell_uname(struct utsname *uts)
    375 {
    376         return memcpy(uts, &host_name, sizeof(host_name));
    377 }
    378 
    379 static int usrcmd_ntopt_callback(long *args, void *extobj);
    380 int mruby_exit_code;
    381 volatile int mruby_state;
    382 typedef void (*PowerOn_Reset_t)(long *args);
    383 jmp_buf process_exit;
    384 
    385399/*
    386  *  mruby実行タスク
     400 *  shellcmdタスク
    387401 */
    388 void mruby_task(intptr_t exinf)
    389 {
    390         mruby_state = 1;
    391         mruby_exit_code = ntopt_parse(command, usrcmd_ntopt_callback, NULL);
    392         mruby_state = 2;
     402void shellcmd_task(intptr_t exinf)
     403{
     404        shellcmd_state = 1;
     405        shellcmd_exit_code = ntopt_parse(command, usrcmd_ntopt_callback, NULL);
     406        shellcmd_state = 2;
    393407}
    394408
    … …  
    424438                p++;
    425439        }
    426         if (setjmp(process_exit) == 0) {
     440        if (setjmp(shellcmd_exit) == 0) {
    427441                (*((PowerOn_Reset_t *)0x18220000))(args);
    428442        }
    … …  
    447461{
    448462        /* メインタスクの優先度より高くする */
    449         chg_pri(MRUBY_PRIORITY, MAIN_PRIORITY + 1);
     463        chg_pri(SHELLCMD_PRIORITY, MAIN_PRIORITY + 1);
    450464}
    451465
    452466void shellif_outof()
    453467{
    454         /* mruby実行タスクの優先度に戻す */
    455         chg_pri(MRUBY_PRIORITY, MRUBY_PRIORITY);
     468        /* shellcmdタスクの優先度に戻す */
     469        chg_pri(SHELLCMD_PRIORITY, SHELLCMD_PRIORITY);
    456470}
    457471
    … …  
    460474        asm("bkpt #0");
    461475
    462         mruby_exit_code = -1;
    463         longjmp(process_exit, 1);
     476        shellcmd_exit_code = -1;
     477        longjmp(shellcmd_exit, 1);
    464478}
    465479
    466480void shell_exit(int exitcd)
    467481{
    468         mruby_exit_code = exitcd;
    469         longjmp(process_exit, 1);
     482        shellcmd_exit_code = exitcd;
     483        longjmp(shellcmd_exit, 1);
    470484}
    471485
    472486void shell_exit_group(int exitcd)
    473487{
    474         mruby_exit_code = exitcd;
    475         longjmp(process_exit, 1);
     488        shellcmd_exit_code = exitcd;
     489        longjmp(shellcmd_exit, 1);
    476490}
    477491
    … …  
    480494        ER ret;
    481495
    482         ret = ter_tsk(MRUBY_TASK);
     496        ret = ter_tsk(SHELLCMD_TASK);
    483497        if ((ret != E_OK) && (ret != E_OBJ)) {
    484498                syslog(LOG_ERROR, "ter_tsk => %d", ret);
    … …  
    489503        clean_fd();
    490504
    491         mruby_state = 0;
    492         ret = act_tsk(MRUBY_TASK);
     505        shellcmd_state = 0;
     506        ret = act_tsk(SHELLCMD_TASK);
    493507        if (ret != E_OK) {
    494508                syslog(LOG_ERROR, "act_tsk => %d", ret);
    … …  
    500514        do {
    501515                tslp_tsk(100000);
    502         } while(mruby_state == 1);
    503 
    504         return mruby_exit_code;
    505 }
    506 
    507 static int cmd_execute(const char *text, void *extobj)
    508 {
    509         ntlibc_strlcpy(command, text, sizeof(command));
    510         return execute_command(1);
     516        } while(shellcmd_state == 1);
     517
     518        return shellcmd_exit_code;
     519}
     520
     521int shell_clock_getres(clockid_t clk_id, struct timespec *res)
     522{
     523        if (clk_id != CLOCK_REALTIME)
     524                return -EINVAL;
     525
     526        memset(&res->tv_sec, 0xFF, sizeof(res->tv_sec));
     527        res->tv_nsec = 0;
     528
     529        return 0;
     530}
     531
     532int shell_clock_gettime(clockid_t clk_id, struct timespec *tp)
     533{
     534        SYSTIM now = 0;
     535
     536        if (clk_id != CLOCK_REALTIME)
     537                return -EINVAL;
     538
     539        get_tim(&now);
     540        tp->tv_sec = now / 1000000;
     541        tp->tv_nsec = (now % 1000000) * 1000;
     542
     543        return 0;
     544}
     545
     546int shell_clock_settime(clockid_t clk_id, const struct timespec *tp)
     547{
     548        if (clk_id != CLOCK_REALTIME)
     549                return -EINVAL;
     550
     551        rtc_write(tp->tv_sec);
     552
     553        return 0;
     554}
     555
     556sigset_t g_sigmask;
     557
     558int shell_sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
     559{
     560        if (old != NULL)
     561                memcpy(old, &g_sigmask, sizeof(sigset_t));
     562
     563        switch (how) {
     564        case SIG_BLOCK:
     565                for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
     566                        g_sigmask.__bits[i] |= set->__bits[i];
     567                }
     568                break;
     569        case SIG_UNBLOCK:
     570                for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
     571                        g_sigmask.__bits[i] &= ~set->__bits[i];
     572                }
     573                break;
     574        case SIG_SETMASK:
     575                memcpy(&g_sigmask, set, sizeof(sigset_t));
     576                break;
     577        default:
     578                return -EINVAL;
     579        }
     580
     581        return 0;
     582}
     583
     584struct sigaction sigtable[6];
     585
     586int shell_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
     587{
     588        struct sigaction *sat;
     589
     590        switch(sig){
     591        case SIGALRM:
     592                sat = &sigtable[0];
     593                break;
     594        case SIGFPE:
     595                sat = &sigtable[1];
     596                break;
     597        case SIGILL:
     598                sat = &sigtable[2];
     599                break;
     600        case SIGSEGV:
     601                sat = &sigtable[3];
     602                break;
     603        case SIGBUS:
     604                sat = &sigtable[4];
     605                break;
     606        case SIGABRT:
     607                sat = &sigtable[5];
     608                break;
     609        default:
     610                return -EINVAL;
     611        }
     612
     613        if (old != NULL)
     614                memcpy(old, sat, sizeof(struct sigaction));
     615
     616        memcpy(sat, sa, sizeof(struct sigaction));
     617
     618        return 0;
     619}
     620
     621int shell_madvise(void *a, size_t b, int c)
     622{
     623        return 0;
    511624}
    512625
    … …  
    590703}
    591704
    592 int shell_clock_getres(clockid_t clk_id, struct timespec *res)
    593 {
    594         if (clk_id != CLOCK_REALTIME)
    595                 return -EINVAL;
    596 
    597         memset(&res->tv_sec, 0xFF, sizeof(res->tv_sec));
    598         res->tv_nsec = 0;
    599 
    600         return 0;
    601 }
    602 
    603 int shell_clock_gettime(clockid_t clk_id, struct timespec *tp)
    604 {
    605         SYSTIM now = 0;
    606 
    607         if (clk_id != CLOCK_REALTIME)
    608                 return -EINVAL;
    609 
    610         get_tim(&now);
    611         tp->tv_sec = now / 1000000;
    612         tp->tv_nsec = (now % 1000000) * 1000;
    613 
    614         return 0;
    615 }
    616 
    617 int shell_clock_settime(clockid_t clk_id, const struct timespec *tp)
    618 {
    619         if (clk_id != CLOCK_REALTIME)
    620                 return -EINVAL;
    621 
    622         rtc_write(tp->tv_sec);
    623 
    624         return 0;
    625 }
    626 
    627 sigset_t g_sigmask;
    628 
    629 int shell_sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
    630 {
    631         if (old != NULL)
    632                 memcpy(old, &g_sigmask, sizeof(sigset_t));
    633 
    634         switch (how) {
    635         case SIG_BLOCK:
    636                 for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
    637                         g_sigmask.__bits[i] |= set->__bits[i];
    638                 }
    639                 break;
    640         case SIG_UNBLOCK:
    641                 for (int i = 0; i < sizeof(g_sigmask.__bits) / sizeof(g_sigmask.__bits[0]); i++) {
    642                         g_sigmask.__bits[i] &= ~set->__bits[i];
    643                 }
    644                 break;
    645         case SIG_SETMASK:
    646                 memcpy(&g_sigmask, set, sizeof(sigset_t));
    647                 break;
    648         default:
    649                 return -EINVAL;
    650         }
    651 
    652         return 0;
    653 }
    654 
    655 struct sigaction sigtable[6];
    656 
    657 int shell_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
    658 {
    659         struct sigaction *sat;
    660 
    661         switch(sig){
    662         case SIGALRM:
    663                 sat = &sigtable[0];
    664                 break;
    665         case SIGFPE:
    666                 sat = &sigtable[1];
    667                 break;
    668         case SIGILL:
    669                 sat = &sigtable[2];
    670                 break;
    671         case SIGSEGV:
    672                 sat = &sigtable[3];
    673                 break;
    674         case SIGBUS:
    675                 sat = &sigtable[4];
    676                 break;
    677         case SIGABRT:
    678                 sat = &sigtable[5];
    679                 break;
    680         default:
    681                 return -EINVAL;
    682         }
    683 
    684         if (old != NULL)
    685                 memcpy(old, sat, sizeof(struct sigaction));
    686 
    687         memcpy(sat, sa, sizeof(struct sigaction));
    688 
    689         return 0;
    690 }
    691 
    692 int shell_madvise(void *a, size_t b, int c)
    693 {
    694         return 0;
    695 }
    696 

  • EcnlProtoTool/trunk/ntshell/src/main.cfg

    r331 r431  
    6161CRE_SEM(SEM_FILESYSTEM, { TA_TPRI, 1, 1 });
    6262
    63 CRE_TSK(MRUBY_TASK, { TA_NULL, 0, mruby_task, MRUBY_PRIORITY, MRUBY_STACK_SIZE, (void *)0x20100000 });
     63CRE_TSK(SHELLCMD_TASK, { TA_NULL, 0, shellcmd_task, SHELLCMD_PRIORITY, SHELLCMD_STACK_SIZE, (void *)0x20100000 });
    6464CRE_FLG(FLG_SELECT_WAIT, { TA_WMUL, 0x00 });

  • EcnlProtoTool/trunk/ntshell/src/main.h

    r331 r431  
    5353
    5454#define MAIN_PRIORITY   5               /* メインタスクの優先度 */
    55 #define MRUBY_PRIORITY  4               /* mruby実行タスクの優先度 */
     55#define SHELLCMD_PRIORITY       4               /* shellcmdタスクの優先度 */
    5656
    5757#define MAIN_STACK_SIZE         2048    /* メインタスクのスタック領域のサイズ */
    58 #define MRUBY_STACK_SIZE        0x00800000      /* mruby実行タスクのスタック領域のサイズ */
     58#define SHELLCMD_STACK_SIZE     0x00800000      /* shellcmdタスクのスタック領域のサイズ */
    5959
    6060#define NUM_MAIN_DATAQUEUE      1       /* メインタスクで待ち受けているデータキューのサイズ */
    61 #define NUM_MRUBY_DATAQUEUE     1       /* mruby実行タスクで待ち受けているデータキューのサイズ */
     61#define NUM_SHELLCMD_DATAQUEUE  1       /* shellcmdタスクで待ち受けているデータキューのサイズ */
    6262
    6363/*
    … …  
    6969extern void main_task(intptr_t exinf);
    7070
    71 /* mruby実行タスク */
    72 extern void mruby_task(intptr_t exinf);
     71/* shellcmdタスク */
     72extern void shellcmd_task(intptr_t exinf);
    7373
    7474/*
Note: See TracChangeset for help on using the changeset viewer.