SylixOS命令行下内存操作/测试工具

2023-05-16

源头

memAccessCmd是用于SylixOS下对内存/寄存器进行访问和测试的工具。

SylixOS下调测程序，无论是应用、驱动还是内核，如果能查看并操作指定内存/寄存器，将是一个非常有效的手段。作者在多年的SylixOS程序开发中积累了不少自己编写的调测软件工具，其中内存工具算的是上最基础使用频率最高的一个。

博客最后有发文时的最新版源码，使用者可以自行将其编译为app或内核模块来用，直接添加到bsp中也是可以的。本模块也会不定时更新优化，最新版本可从Git仓库拉取。
Git仓库地址：https://github.com/scilogyhunter/mem.git

用法

-h 用于显示命令用法
-i 用于显示命令参数值其他选项则都是对内存进行操作，默认是按字节（8位）进行，也可以按指定位数来操作，当前支持8位，16位和32位。
-r 用于读取并显示内存内容。
-w 用于向目标地址写入目标内容。
-s 用于将一段内存设置为目标值，类似PVOID lib_memset (PVOID pvDest, INT iC, size_t stCount)函数。
-g 从一个固定地址获取一段内存值，比如从一个FIFO寄存器读取一段数据。
-p 向一个固定地址写入一段内存值，比如向一个FIFO寄存器写入一段数据。
-c 把一段内存值拷贝到另一段内存。
-m 比较两段内存并打印出不相同的部分。
-t 对一段内存进行读写访问测试，如果目标内存/寄存器为只读或只写模式，测试就会报错；如果是非法空间或没有进行内存映射的空间则可能触发系统异常。
-e 对一段内存进行读写速度测试，输出读写速度。

具体操作实例如下：

[root@sylixos:/root]# /apps/mem/mem -h
Usage:  
mem  -h display help info.
mem  -i display arg  info.
mem  -r[8/16/32] <saddr> <length>         memory read
mem  -w[8/16/32] <daddr> <d0> [d1] [d2]...memory write
mem  -s[8/16/32] <daddr> <value> <length> memory set
mem  -g[8/16/32] <daddr> <saddr> <length> memory get
mem  -p[8/16/32] <daddr> <saddr> <length> memory put
mem  -c[8/16/32] <daddr> <saddr> <length> memory copy
mem  -m[8/16/32] <daddr> <saddr> <length> memory compare
mem  -t[8/16/32] <daddr> <length>         memory access test
mem  -e[8/16/32] <daddr> <length>         memory speed test
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -i
cOperate = r
uiFormat = 1
uiSaddr  = 00000000
uiDaddr  = 00000000
uiValue  = 00000000
uiLength = 64
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -r 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 1

[41765030] 2f 75 73 72 2f 62 69 6e 00 2f 62 69 6e 00 2f 75    /usr/bin`/bin`/u
[41765040] 73 72 2f 70 6b 67 2f 73 62 69 6e 00 2f 73 62 69    sr/pkg/sbin`/sbi
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -r8 0x41765030 32  
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 1

[41765030] 2f 75 73 72 2f 62 69 6e 00 2f 62 69 6e 00 2f 75    /usr/bin`/bin`/u
[41765040] 73 72 2f 70 6b 67 2f 73 62 69 6e 00 2f 73 62 69    sr/pkg/sbin`/sbi
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -r16 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 2

[41765030] 2f75 7372 2f62 696e 002f 6269 6e00 2f75    /usr/bin`/bin`/u
[41765040] 7372 2f70 6b67 2f73 6269 6e00 2f73 6269    sr/pkg/sbin`/sbi
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 2f757372 2f62696e 002f6269 6e002f75    /usr/bin`/bin`/u
[41765040] 73722f70 6b672f73 62696e00 2f736269    sr/pkg/sbin`/sbi
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -w 0x41765030 1 2 3 4
memory write.
uiDaddr = 41765030, uiLength = 00000004, uiFormat = 1

[41765030] 01 02 03 04                                        ````
[root@sylixos:/root]# /apps/mem/mem -r 0x41765030 32 
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 1

[41765030] 01 02 03 04 2f 62 69 6e 00 2f 62 69 6e 00 2f 75    ````/bin`/bin`/u
[41765040] 73 72 2f 70 6b 67 2f 73 62 69 6e 00 2f 73 62 69    sr/pkg/sbin`/sbi
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -w16 0x41765030 1 2 3 4
memory write.
uiDaddr = 41765030, uiLength = 00000004, uiFormat = 2

[41765030] 0001 0002 0003 0004                        `````````/bin`/u
[root@sylixos:/root]# /apps/mem/mem -r16 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 2

[41765030] 0001 0002 0003 0004 002f 6269 6e00 2f75    `````````/bin`/u
[41765040] 7372 2f70 6b67 2f73 6269 6e00 2f73 6269    sr/pkg/sbin`/sbi
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -w32 0x41765030 1 2 3 4
memory write.
uiDaddr = 41765030, uiLength = 00000004, uiFormat = 4

[41765030] 00000001 00000002 00000003 00000004    ````````````````
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 00000001 00000002 00000003 00000004    ````````````````
[41765040] 73722f70 6b672f73 62696e00 2f736269    sr/pkg/sbin`/sbi
[root@sylixos:/root]#

[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -s 0x41765030 0x55 16
memory set.
uiAddr = 41765030, uiValue = 00000055, uiLength = 00000010, uiFormat = 1
[root@sylixos:/root]# /apps/mem/mem -r 0x41765030 32  
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 1

[41765030] 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55    UUUUUUUUUUUUUUUU
[41765040] 73 72 2f 70 6b 67 2f 73 62 69 6e 00 2f 73 62 69    sr/pkg/sbin`/sbi
[root@sylixos:/root]# /apps/mem/mem -s16 0x41765030 0x66 16
memory set.
uiAddr = 41765030, uiValue = 00000066, uiLength = 00000010, uiFormat = 2
[root@sylixos:/root]# /apps/mem/mem -r16 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 2

[41765030] 0066 0066 0066 0066 0066 0066 0066 0066    `f`f`f`f`f`f`f`f
[41765040] 7372 2f70 6b67 2f73 6269 6e00 2f73 6269    sr/pkg/sbin`/sbi
[root@sylixos:/root]# /apps/mem/mem -s32 0x41765030 0x12345678 16
memory set.
uiAddr = 41765030, uiValue = 12345678, uiLength = 00000010, uiFormat = 4
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 73722f70 6b672f73 62696e00 2f736269    sr/pkg/sbin`/sbi
[root@sylixos:/root]# ```

```bash
[root@sylixos:/root]# /apps/mem/mem -g 0x41765040 0x41765030 16
memory get.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 1
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 12121212 12121212 12121212 12121212    ````````````````
[root@sylixos:/root]# /apps/mem/mem -g16 0x41765040 0x41765030 16
memory get.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 2
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 12341234 12341234 12341234 12341234    `4`4`4`4`4`4`4`4
[root@sylixos:/root]# /apps/mem/mem -g32 0x41765040 0x41765030 16
memory get.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 4
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -p 0x41765040 0x41765030 16
memory put.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 1
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 78345678 12345678 12345678 12345678    x4Vx`4Vx`4Vx`4Vx
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]# /apps/mem/mem -p16 0x41765040 0x41765030 16
memory put.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 2
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 56785678 12345678 12345678 12345678    VxVx`4Vx`4Vx`4Vx
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]# /apps/mem/mem -p32 0x41765040 0x41765030 16
memory put.
uiDaddr = 41765040, uiSaddr = 41765030, uiLength = 00000010, uiFormat = 4
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 5a5a5a5a 5a5a5a5a 5a5a5a5a 5a5a5a5a    ZZZZZZZZZZZZZZZZ
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -c 0x41765030 0x41765040 16  
memory copy.
uiDaddr = 41765030, uiSaddr = 41765040, uiLength = 00000010, uiFormat = 1
[root@sylixos:/root]# /apps/mem/mem -r32 0x41765030 32
memory read.
uiSaddr = 41765030, uiLength = 00000020, uiFormat = 4

[41765030] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[41765040] 12345678 12345678 12345678 12345678    `4Vx`4Vx`4Vx`4Vx
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -m 0x41765030 0x41765040 16
memory compare
uiDaddr = 41765030, uiSaddr = 41765040, uiLength = 00000010, uiFormat = 1
different count is 0
[root@sylixos:/root]# /apps/mem/mem -w32 0x41765030 0x5a5a5a5a   
memory write.
uiDaddr = 41765030, uiLength = 00000001, uiFormat = 4

[41765030] 5a5a5a5a                               ZZZZ`4Vx`4Vx`4Vx
[root@sylixos:/root]# /apps/mem/mem -m 0x41765030 0x41765040 16
memory compare
uiDaddr = 41765030, uiSaddr = 41765040, uiLength = 00000010, uiFormat = 1
[41765030 -- 41765040] 5a -- 12
[41765031 -- 41765041] 5a -- 34
[41765032 -- 41765042] 5a -- 56
[41765033 -- 41765043] 5a -- 78
different count is 4
[root@sylixos:/root]# /apps/mem/mem -m16 0x41765030 0x41765040 16
memory compare
uiDaddr = 41765030, uiSaddr = 41765040, uiLength = 00000010, uiFormat = 2
[41765030 -- 41765040] 5a5a -- 1234
[41765032 -- 41765042] 5a5a -- 5678
different count is 2
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -m32 0x41765030 0x41765040 16
memory compare
uiDaddr = 41765030, uiSaddr = 41765040, uiLength = 00000010, uiFormat = 4
[41765030 -- 41765040] 5a5a5a5a -- 12345678
different count is 1
[root@sylixos:/root]#

[root@sylixos:/root]# /apps/mem/mem -t 0x41765030 1024           
memory access test
uiDaddr = 41765030, uiLength = 00000400, uiFormat = 1
[root@sylixos:/root]# 
[root@sylixos:/root]# /apps/mem/mem -e 0x41765030 1024
memory speed test
uiDaddr = 41765030, uiLength = 00000400, uiFormat = 1
memspeed read        1024 byte by         47 us (  21.79MBps)
memspeed write       1024 byte by         29 us (  35.31MBps)
[root@sylixos:/root]#

源码

/*********************************************************************************************************
**
**                                    中国软件开源组织
**
**                                   嵌入式实时操作系统
**
**                                       SylixOS(TM)
**
**                               Copyright  All Rights Reserved
**
**--------------文件信息--------------------------------------------------------------------------------
**
** 文   件   名: mem.c
**
** 创   建   人: Hou.JinYu (侯进宇)
**
** 文件创建日期: 2017 年 10 月 17 日
**
** 描        述: 通用系统内存访问命令，可以直接读取或修改内存值，用于调试
*********************************************************************************************************/
#include "SylixOS.h"                                                    /*  操作系统                    */
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
/*********************************************************************************************************
  宏定义
*********************************************************************************************************/
#define   BUF_SIZE              (256)                                   /*  缓冲区大小                  */
/*********************************************************************************************************
  PRINT 打印宏函数
*********************************************************************************************************/
#define PRINT_INFO(fmt, ...)    do {printf(fmt, ##__VA_ARGS__);} while (0)
/*********************************************************************************************************
  读写宏函数
*********************************************************************************************************/
#if !defined(read8) && !defined(write8)
#define read8(a)                (*(volatile UINT8  *)(a))
#define read16(a)               (*(volatile UINT16 *)(a))
#define read32(a)               (*(volatile UINT32 *)(a))
#define read64(a)               (*(volatile UINT64 *)(a))

#define write8(d, a)            (*(volatile UINT8  *)(a) = (d))
#define write16(d, a)           (*(volatile UINT16 *)(a) = (d))
#define write32(d, a)           (*(volatile UINT32 *)(a) = (d))
#define write64(d, a)           (*(volatile UINT64 *)(a) = (d))
#endif
/*********************************************************************************************************
  操作宏
*********************************************************************************************************/
#define MEMTEST(xx)                                                                               \
    t[0] = getTimeUs();                                                                           \
    for (i = 0; i < uiCount; i++) {                                                               \
        read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);                      \
        read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);                      \
        read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);                      \
        read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);read##xx(ulAddr);                      \
    }                                                                                             \
    t[1] = getTimeUs();                                                                           \
    time[0] = t[1] - t[0];                                                                        \
    v = read##xx(ulAddr);                                                                         \
    t[0] = getTimeUs();                                                                           \
    for (i = 0; i < uiCount; i++) {                                                               \
        write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);      \
        write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);      \
        write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);      \
        write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);write##xx(v, ulAddr);      \
    }                                                                                             \
    t[1] = getTimeUs();                                                                           \
    time[1] = t[1] - t[0];
/*********************************************************************************************************
  参数结构体
*********************************************************************************************************/
typedef struct {
    CHAR         cOperate;                                              /*  操作类型r w s c t           */
    UINT32       uiFormat;                                              /*  1:u8 2:u16 4:u32            */
    UINT32       uiSaddr;                                               /*  源地址                      */
    UINT32       uiDaddr;                                               /*  目的地址                    */
    UINT32       uiValue;                                               /*  数值                        */
    UINT32       uiLength;                                              /*  数据长度                    */
    UINT32       uiBuf[BUF_SIZE];                                       /*  缓冲区                      */
} ARG_ST;
/*********************************************************************************************************
** 函数名称: getTimeUs
** 功能描述: 获取系统运行时间，单位微秒
** 输    入: 无
** 输    出: 系统运行时间
*********************************************************************************************************/
static UINT64  getTimeUs (VOID)
{
    struct timespec  tv;

    lib_clock_gettime(CLOCK_MONOTONIC, &tv);

    return  (tv.tv_sec * 1000000 + tv.tv_nsec / 1000);
}
/*********************************************************************************************************
** 函数名称: memoryHelp
** 功能描述: 帮助信息
** 输　  入: NONE
** 输    出: NONE
*********************************************************************************************************/
static VOID  memoryHelp (VOID)
{
    PRINT_INFO("Usage:  \n"
       "mem  -h display help info.\n"
       "mem  -i display arg  info.\n"
       "mem  -r[8/16/32] <saddr> <length>         memory read\n"
       "mem  -w[8/16/32] <daddr> <d0> [d1] [d2]...memory write\n"
       "mem  -s[8/16/32] <daddr> <value> <length> memory set\n"
       "mem  -g[8/16/32] <daddr> <saddr> <length> memory get\n"
       "mem  -p[8/16/32] <daddr> <saddr> <length> memory put\n"
       "mem  -c[8/16/32] <daddr> <saddr> <length> memory copy\n"
       "mem  -m[8/16/32] <daddr> <saddr> <length> memory compare\n"
       "mem  -t[8/16/32] <daddr> <length>         memory access test\n"
       "mem  -e[8/16/32] <daddr> <length>         memory speed test\n");
}
/*********************************************************************************************************
** 函数名称: memoryInfo
** 功能描述: 参数信息
** 输　  入: pArg  参数
** 输    出: NONE
*********************************************************************************************************/
static VOID  memoryInfo (ARG_ST  *pArg)
{
    UINT32   i;

    PRINT_INFO("cOperate = %c\n",   pArg->cOperate);
    PRINT_INFO("uiFormat = %d\n",   pArg->uiFormat);
    PRINT_INFO("uiSaddr  = %08x\n", pArg->uiSaddr);
    PRINT_INFO("uiDaddr  = %08x\n", pArg->uiDaddr);
    PRINT_INFO("uiValue  = %08x\n", pArg->uiValue);
    PRINT_INFO("uiLength = %d\n",   pArg->uiLength);

    if (pArg->uiLength && (pArg->cOperate == 'w')) {
        for (i = 0; i < pArg->uiLength; i++) {
            if ((i % 16) == 0) {
                PRINT_INFO("\n[%08x] ", i);
            }

            PRINT_INFO(" %02x", pArg->uiBuf[i]);
        }

        PRINT_INFO("\n");
    }
}
/*********************************************************************************************************
** 函数名称: memoryParseArg
** 功能描述: 参数解析
** 输　入  : pArg  参数
**           iArgC
**           ppcArgV
** 输　出  : ERROR_CODE
*********************************************************************************************************/
static INT  memoryParseArg (ARG_ST  *pArg, INT  iArgC, PCHAR  ppcArgV[])
{
    UINT32  i;

    if (iArgC < 2) {
        return  (PX_ERROR);
    }

    if (ppcArgV[1][0] != '-') {
        return  (PX_ERROR);
    }

    pArg->cOperate = ppcArgV[1][1];

    if (strlen(ppcArgV[1]) > 2) {
        pArg->uiFormat = strtoul(&ppcArgV[1][2], NULL, 10) / 8;
    } else {
        pArg->uiFormat = 1;
    }


    if (pArg->cOperate == 'r') {
        if (iArgC < 4) {
            return  (PX_ERROR);
        }

        pArg->uiSaddr  = strtoul(ppcArgV[2], NULL, 0);
        pArg->uiLength = strtoul(ppcArgV[3], NULL, 0);


    } else if (pArg->cOperate == 'w') {
        if (iArgC < 4) {

            return  (PX_ERROR);
        }

        pArg->uiDaddr = strtoul(ppcArgV[2], NULL, 0);
        pArg->uiLength = ((iArgC - 3) < BUF_SIZE) ? (iArgC - 3) : BUF_SIZE;

        for (i = 0; i < pArg->uiLength; i++) {
            pArg->uiBuf[i] = strtoul(ppcArgV[3 + i], NULL, 0);
        }

    } else if (pArg->cOperate == 's') {
        if (iArgC < 5) {

            return  (PX_ERROR);
        }

        pArg->uiDaddr  = strtoul(ppcArgV[2], NULL, 0);
        pArg->uiValue  = strtoul(ppcArgV[3], NULL, 0);
        pArg->uiLength = strtoul(ppcArgV[4], NULL, 0);

    } else if ((pArg->cOperate == 'g') || (pArg->cOperate == 'p') || (pArg->cOperate == 'c') ||
               (pArg->cOperate == 'm')) {
        if (iArgC < 5) {

            return  (PX_ERROR);
        }

        pArg->uiDaddr  = strtoul(ppcArgV[2], NULL, 0);
        pArg->uiSaddr  = strtoul(ppcArgV[3], NULL, 0);
        pArg->uiLength = strtoul(ppcArgV[4], NULL, 0);
    } else if ((pArg->cOperate == 't') || (pArg->cOperate == 'e')) {
        if (iArgC < 4) {
            return  (PX_ERROR);
        }

        pArg->uiDaddr  = strtoul(ppcArgV[2], NULL, 0);
        pArg->uiLength = strtoul(ppcArgV[3], NULL, 0);
    } else {
        return  (PX_ERROR);
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memRead
** 功能描述: 读取并打印内存
** 输    入: uiSaddr        源地址
**           uiLength       长度
**           uiFormat       格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memRead (UINT32  uiSaddr, UINT32  uiLength, UINT32  uiFormat)
{
    CHAR     c;
    UINT32   i;
    UINT32   j;
    UINT32   n;
    UINT32   l;
    UINT32   uiCount;

    volatile  UINT8  *pData08;
    volatile  UINT16 *pData16;
    volatile  UINT32 *pData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pData08 = (UINT8  *)uiSaddr;
        for (i = 0; i < uiCount; i+= 16) {
            if ((i % 16) == 0) {
                PRINT_INFO("\n[%08x]", i * uiFormat + uiSaddr);
            }
            n = i;

            if ((uiCount - n) >= 16) {
                l = 16;
            } else {
                l = uiCount - n;
            }

            for (j = 0; j < l; j++) {
                PRINT_INFO(" %02x", pData08[n + j]);
            }
            for (; j < 16; j++) {
                PRINT_INFO("   ");
            }

            PRINT_INFO("    ");
            for (j = 0; j < l; j++) {
                c = pData08[n + j];
                if (isprint(c)) {
                    PRINT_INFO("%c", c);
                } else {
                    PRINT_INFO("`");
                }
            }
            for (; j < 16; j++) {
                PRINT_INFO(" ");
            }
        }
    } else if (uiFormat == 2) {
        uiCount = (uiLength + 1) / 2;
        pData08 = (UINT8  *)uiSaddr;
        pData16 = (UINT16 *)uiSaddr;
        for (i = 0; i < uiCount; i+= 8) {
            if ((i % 8) == 0) {
                PRINT_INFO("\n[%08x]", i * uiFormat + uiSaddr);
            }
            n = i;

            if ((uiCount - n) >= 8) {
                l = 8;
            } else {
                l = uiCount - n;
            }

            for (j = 0; j < l; j++) {
                PRINT_INFO(" %04x", pData16[n + j]);
            }
            for (; j < 8; j++) {
                PRINT_INFO("     ");
            }

            PRINT_INFO("    ");
            for (j = 0; j < 16; j++) {
                c = pData08[n * 2 + j];
                if (isprint(c)) {
                    PRINT_INFO("%c", c);
                } else {
                    PRINT_INFO("`");
                }
            }
            for (; j < 16; j++) {
                PRINT_INFO(" ");
            }
        }

    } else if (uiFormat == 4) {
        uiCount = (uiLength + 3) / 4;
        pData08 = (UINT8  *)uiSaddr;
        pData32 = (UINT32 *)uiSaddr;
        for (i = 0; i < uiCount; i+= 4) {
            if ((i % 4) == 0) {
                PRINT_INFO("\n[%08x]", i * uiFormat + uiSaddr);
            }
            n = i;

            if ((uiCount - n) >= 4) {
                l = 4;
            } else {
                l = uiCount - n;
            }

            for (j = 0; j < l; j++) {
                PRINT_INFO(" %08x", pData32[n + j]);
            }
            for (; j < 4; j++) {
                PRINT_INFO("         ");
            }

            PRINT_INFO("    ");
            for (j = 0; j < 16; j++) {
                c = pData08[n * 4 + j];
                if (isprint(c)) {
                    PRINT_INFO("%c", c);
                } else {
                    PRINT_INFO("`");
                }
            }
            for (; j < 16; j++) {
                PRINT_INFO(" ");
            }
        }
    } else {
        memoryHelp();
    }

    PRINT_INFO("\n");


    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memWrite
** 功能描述: 写内存
** 输    入: uiDaddr      目的地址
**           uiLength     长度
**           uiBuf        缓存
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memWrite (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiBuf[], UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pData08;
    volatile  UINT16 *pData16;
    volatile  UINT32 *pData32;

    uiCount = uiLength;
    if (uiFormat == 1) {
        pData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData08[i] = uiBuf[i];
        }

    } else if (uiFormat == 2) {
        pData16 = (UINT16 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData16[i] = uiBuf[i];
        }
    } else if (uiFormat == 4) {
        pData32 = (UINT32 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData32[i] = uiBuf[i];
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memSet
** 功能描述: 设置内存
** 输    入: uiDaddr      目的地址
**           uiLength     长度
**           uiValue      值
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memSet (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiValue, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pData08;
    volatile  UINT16 *pData16;
    volatile  UINT32 *pData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData08[i] = uiValue;
        }

    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pData16 = (UINT16 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData16[i] = uiValue;
        }
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pData32 = (UINT32 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData32[i] = uiValue;
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memGet
** 功能描述: 设置内存，从一个固定地址读并设置目标内存段
** 输    入: uiDaddr      目的地址
**           uiLength     长度
**           uiSaddr      源地址
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memGet (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiSaddr, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pData08;
    volatile  UINT16 *pData16;
    volatile  UINT32 *pData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData08[i] = *(volatile  UINT8  *)uiSaddr;
        }

    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pData16 = (UINT16 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData16[i] = *(volatile  UINT16  *)uiSaddr;
        }
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pData32 = (UINT32 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pData32[i] = *(volatile  UINT32  *)uiSaddr;
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memPut
** 功能描述: 设置内存，从一段内存向一个固定地址设置数据
** 输    入: uiDaddr      目的地址
**           uiLength     长度
**           uiSaddr      源地址
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memPut (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiSaddr, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pData08;
    volatile  UINT16 *pData16;
    volatile  UINT32 *pData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            *(volatile  UINT8  *)uiSaddr = pData08[i];
        }

    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pData16 = (UINT16 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            *(volatile  UINT16  *)uiSaddr = pData16[i];
        }
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pData32 = (UINT32 *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            *(volatile  UINT32  *)uiSaddr = pData32[i];
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memCopy
** 功能描述: 内存拷贝
** 输    入: uiDaddr      目的地址
**           uiSaddr      源地址
**           uiLength     长度
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memCopy (UINT32  uiDaddr, UINT32  uiSaddr, UINT32  uiLength, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pSrcData08;
    volatile  UINT16 *pSrcData16;
    volatile  UINT32 *pSrcData32;
    volatile  UINT8  *pDstData08;
    volatile  UINT16 *pDstData16;
    volatile  UINT32 *pDstData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pSrcData08 = (UINT8  *)uiSaddr;
        pDstData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData08[i] = pSrcData08[i];
        }

    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pSrcData16 = (UINT16  *)uiSaddr;
        pDstData16 = (UINT16  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData16[i] = pSrcData16[i];
        }
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pSrcData32 = (UINT32  *)uiSaddr;
        pDstData32 = (UINT32  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData32[i] = pSrcData32[i];
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memCompare
** 功能描述: 内存比较
** 输    入: uiDaddr      目的地址
**           uiSaddr      源地址
**           uiLength     长度
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memCompare (UINT32  uiDaddr, UINT32  uiSaddr, UINT32  uiLength, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;
    UINT32   uiCountDif = 0;

    volatile  UINT8  *pSrcData08;
    volatile  UINT16 *pSrcData16;
    volatile  UINT32 *pSrcData32;
    volatile  UINT8  *pDstData08;
    volatile  UINT16 *pDstData16;
    volatile  UINT32 *pDstData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pSrcData08 = (UINT8  *)uiSaddr;
        pDstData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            if (pDstData08[i] != pSrcData08[i]) {
                uiCountDif++;
                PRINT_INFO("[%08x -- %08x] %02x -- %02x\n",
                            (UINT)&pDstData08[i], (UINT)&pSrcData08[i], pDstData08[i], pSrcData08[i]);
            }
        }
        PRINT_INFO("different count is %u\n", uiCountDif);
    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pSrcData16 = (UINT16  *)uiSaddr;
        pDstData16 = (UINT16  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            if (pDstData16[i] != pSrcData16[i]) {
                uiCountDif++;
                PRINT_INFO("[%08x -- %08x] %04x -- %04x\n",
                            (UINT)&pDstData16[i], (UINT)&pSrcData16[i], pDstData16[i], pSrcData16[i]);
            }
        }
        PRINT_INFO("different count is %u\n", uiCountDif);
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pSrcData32 = (UINT32  *)uiSaddr;
        pDstData32 = (UINT32  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            if (pDstData32[i] != pSrcData32[i]) {
                uiCountDif++;
                PRINT_INFO("[%08x -- %08x] %08x -- %08x\n",
                            (UINT)&pDstData32[i], (UINT)&pSrcData32[i], pDstData32[i], pSrcData32[i]);
            }
        }
        PRINT_INFO("different count is %u\n", uiCountDif);
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memTest
** 功能描述: 内存可读写测试
** 输    入: uiDaddr      目的地址
**           uiLength     长度
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static INT  memTest (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiFormat)
{
    UINT32   i;
    UINT32   uiCount;

    volatile  UINT8  *pDstData08;
    volatile  UINT16 *pDstData16;
    volatile  UINT32 *pDstData32;

    if (uiFormat == 1) {
        uiCount = uiLength;
        pDstData08 = (UINT8  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData08[i] = 0;
            if (pDstData08[i] != 0) {
                PRINT_INFO("test write 0x00 fault at %08x\n", (UINT)&pDstData08[i]);
            }
            pDstData08[i] = 0xff;
            if (pDstData08[i] != 0xff) {
                PRINT_INFO("test write 0xff fault at %08x\n", (UINT)&pDstData08[i]);
            }
        }

    } else if (uiFormat == 2) {
        uiCount = uiLength / 2;
        pDstData16 = (UINT16  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData16[i] = 0;
            if (pDstData16[i] != 0) {
                PRINT_INFO("test write 0x0000 fault at %08x\n", (UINT)&pDstData16[i]);
            }
            pDstData16[i] = 0xffff;
            if (pDstData16[i] != 0xffff) {
                PRINT_INFO("test write 0xffff fault at %08x\n", (UINT)&pDstData16[i]);
            }
        }
    } else if (uiFormat == 4) {
        uiCount = uiLength / 4;
        pDstData32 = (UINT32  *)uiDaddr;
        for (i = 0; i < uiCount; i++) {
            pDstData32[i] = 0;
            if (pDstData32[i] != 0) {
                PRINT_INFO("test write 0x00000000 fault at %08x\n", (UINT)&pDstData32[i]);
            }
            pDstData32[i] = 0xffffffff;
            if (pDstData32[i] != 0xffffffff) {
                PRINT_INFO("test write 0xffffffff fault at %08x\n", (UINT)&pDstData32[i]);
            }
        }
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memSpeed
** 功能描述: 内存读写速度测试
** 输    入: uiDaddr      目的地址
**           uiSaddr      源地址
**           uiLength     长度
**           uiFormat     格式
** 输    出: ERROR_CODE
*********************************************************************************************************/
static  INT  memSpeed (UINT32  uiDaddr, UINT32  uiLength, UINT32  uiFormat)
{
    addr_t   ulAddr;
    UINT32   i;
    UINT32   v;
    UINT32   uiCount;
    UINT64   t[2];
    UINT32   time[2];

    ulAddr  = uiDaddr;
    if (uiFormat == 1) {
        uiCount = uiLength / (16 * 1);
        MEMTEST(8);
    } else if (uiFormat == 2) {
        uiCount = uiLength / (16 * 2);
        MEMTEST(16);
    } else if (uiFormat == 4) {
        uiCount = uiLength / (16 * 4);
        MEMTEST(32);
    } else {
        memoryHelp();
        return  (PX_ERROR);
    }

    printf("memspeed read  %10d byte by %10u us (%7.2fMBps)\r\n",
           uiLength, time[0], uiLength * 1.0 / time[0]);
    printf("memspeed write %10d byte by %10u us (%7.2fMBps)\r\n",
           uiLength, time[1], uiLength * 1.0 / time[1]);

    return  (ERROR_NONE);
}
/*********************************************************************************************************
** 函数名称: memAccessCmd
** 功能描述: 内存访问命令
** 输    入: iArgC
**           ppcArgV
** 输    出: ERROR_CODE
*********************************************************************************************************/
INT  memAccessCmd (INT  iArgC, PCHAR  ppcArgV[])
{
    static ARG_ST  _S_args = {
        .cOperate  = 'r',
        .uiFormat  = 1,
        .uiSaddr   = 0,
        .uiDaddr   = 0,
        .uiValue   = 0,
        .uiLength  = 64,
    };
    ARG_ST  *pArg = &_S_args;

    if (strcmp(ppcArgV[1], "-i") == 0) {
        memoryInfo(pArg);
        return  (ERROR_NONE);
    }

    if (ERROR_NONE != memoryParseArg(pArg, iArgC, ppcArgV)) {
        memoryHelp();

        return  (PX_ERROR);
    }

    if (pArg->cOperate == 'r') {
        PRINT_INFO("memory read.\n");
        PRINT_INFO("uiSaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);
        memRead (pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);

    } else if (pArg->cOperate == 'w') {
        PRINT_INFO("memory write.\n");
        PRINT_INFO("uiDaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiLength, pArg->uiFormat);
        memWrite(pArg->uiDaddr, pArg->uiLength, pArg->uiBuf, pArg->uiFormat);
        memRead (pArg->uiDaddr, pArg->uiLength * pArg->uiFormat, pArg->uiFormat);
    } else if (pArg->cOperate == 's') {
        PRINT_INFO("memory set.\n");
        PRINT_INFO("uiAddr = %08x, uiValue = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiValue, pArg->uiLength, pArg->uiFormat);
        memSet(pArg->uiDaddr, pArg->uiLength, pArg->uiValue, pArg->uiFormat);

    } else if (pArg->cOperate == 'g') {
        PRINT_INFO("memory get.\n");
        PRINT_INFO("uiDaddr = %08x, uiSaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);
        memGet(pArg->uiDaddr, pArg->uiLength, pArg->uiSaddr, pArg->uiFormat);

    } else if (pArg->cOperate == 'p') {
        PRINT_INFO("memory put.\n");
        PRINT_INFO("uiDaddr = %08x, uiSaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);
        memPut(pArg->uiDaddr, pArg->uiLength, pArg->uiSaddr, pArg->uiFormat);

    } else if (pArg->cOperate == 'c') {
        PRINT_INFO("memory copy.\n");
        PRINT_INFO("uiDaddr = %08x, uiSaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);
        memCopy(pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);

    } else if (pArg->cOperate == 'm') {
        PRINT_INFO("memory compare\n");
        PRINT_INFO("uiDaddr = %08x, uiSaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);
        memCompare(pArg->uiDaddr, pArg->uiSaddr, pArg->uiLength, pArg->uiFormat);

    } else if (pArg->cOperate == 't') {
        PRINT_INFO("memory access test\n");
        PRINT_INFO("uiDaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiLength, pArg->uiFormat);
        memTest(pArg->uiDaddr,pArg->uiLength, pArg->uiFormat);
    } else if (pArg->cOperate == 'e') {
        PRINT_INFO("memory speed test\n");
        PRINT_INFO("uiDaddr = %08x, uiLength = %08x, uiFormat = %d\n",
                    pArg->uiDaddr, pArg->uiLength, pArg->uiFormat);
        memSpeed(pArg->uiDaddr,pArg->uiLength, pArg->uiFormat);
    } else {
        memoryHelp();
    }

    return  (ERROR_NONE);
}
/*********************************************************************************************************
  END
*********************************************************************************************************/

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

SylixOS命令行下内存操作/测试工具的相关文章

c语言实现udp广播和组播

目录 1 UDP广播通信 2 UDP组播通信 1 UDP广播通信单播 xff1a 数据包发送方式只有一个接受方广播 xff1a 同时发给局域网中的所有主机只有用户数据报套接字 xff08 使用UDP协议 xff09 才能广播以192
Odoo10 中常见的 Widget 整理

Widget是什么是odoo中字段的显示形式 Odoo内置的widget widget 61 34 mail thread 34 xff1a 消息标签 widget 61 34 html 34 xff1a html相关标签 widget
C语言入门篇——介绍篇

目录 1 什么是C语言 1 C语言的优点 3 语言标准 4 使用C语言的步骤 5 第一个C语言程序 6 关键字 1 什么是C语言 1972年 xff0c 贝尔实验室的丹尼斯里奇和肯汤普逊在开发UNIX操作系统时设计了C语言 xff0c
力扣刷题——双数之和

很多人去力扣刷题都是数组的第一题 xff0c 也就是双数之和 xff0c 相信这也是很多人劝退题目 xff0c 甚至对自己学过的知识产生了怀疑 xff0c 这真的是我学完C语言 xff0c Java xff0c Python或C 43 43
C语言入门篇——自定义数据篇

目录 1 结构体 1 2 匿名结构体 1 3 结构体的自引用 1 4 结构体的声明和初始化 1 5 结构体的内存对齐 1 6 修改默认对齐数 1 7 结构体传参 2 枚举 3 共用体 xff08 联合体 xff09 1 结构体设计程序时
C语言入门篇——文件操作篇

目录 1 为什么使用文件 2 什么是文件 2 1程序文件 2 2数据文件 2 3文件名 3 文件的打开和关闭 3 1文件指针 3 2文件的打开和关闭 4 文件的顺序读写 5 文件的随机读写 5 1fseek 5 2ftell 5 3rewi
【C】模拟实现strlen，strcpy，strcat，strcmp，strncpy，syrcat，strnact，strncmp，strstr等字符串函数

目录字符串函数模拟实现 1 strlen模拟实现 2 strcpy模拟实现 3 strncpy模拟实现 4 strcat模拟实现 5 strncat模拟实现 6 strcmp模拟实现 7 strncmp模拟实现 8 strstr模拟实现
【C】模拟实现memcpy，memmove内存函数

目录内存函数模拟实现 1 memcpy模拟实现 2 memmove模拟实现 3 测试案例代码内存函数模拟实现 C 库函数 memcpy 从存储区 str2 复制 n 个字节到存储区 str1 这个函数在遇到 39 0 39 的时候并不会
【C】模拟实现atoi，atof函数

目录 atoi函数 atof函数模拟实现atoi xff0c atof函数 1 atoi模拟实现 2 atof模拟实现 3 测试案例代码 atoi函数 atoi函数是将字符串转换成整数函数头文件 xff1a include lt std
英伟达JETSON XAVIER NX使用小记

1 输入法问题安装谷歌拼音 xff08 支持ARM64位系统 xff09 系统设置 gt 语言支持 gt 键盘输入法系统 gt 选择 fcitx gt 关闭在终端中进行安装和部分卸载工作 xff1a sudo apt get insta
Spark | Stage进度条展示(showConsoleProgress)

spark version 61 2 4 4 在执行Spark任务中 xff0c 经常会看到以下类似的Stage进度日志信息 xff0c 如下 xff1a Stage 0 gt 0 43 0 1753 Stage 0 gt 0 43 65
Ubuntu 安装odoo10 环境搭建

安装时 xff0c 默认用户名为 odoo ubuntu 16开始使用 systemd 管理服务 xff0c 但是systemd 兼容 sysv init 脚本下载 odoo源码从 http nightly odoo com 10 0
无人机自动悬停的秘密

无人机自动悬停的秘密 http www icpcw com Information Tech News 3244 324449 all htm 正文我来说两句已有0 人参与 2014 11 11 10 36 18类型 xff1a 原创来源
ubuntu终端输入命令启动chrom浏览器

文章目录一阻塞式打开一阻塞式打开打开一个空白网页 google chrome 浏览指定网址 google chrome www baidu com google chrome https blog csdn net sandalp
C++之vector与指针

文章目录一指向vector的指针1 amp xff1a 指向栈上的vector xff08 1 xff09 形式 xff08 2 xff09 局部变量自动释放 xff08 3 xff09 区分误区 2 new xff1a 指向堆上的ve
《ROS机器人开发实践》第6.2.4节“在rviz中显示模型”问题总结

输入 roslaunch mbot description display mbot base urdf launch后 xff0c 出现以下错误解决方法 xff1a 在终端输入 source catkin ws devel setup
FreeRTOS堆栈溢出检查

FreeRTOS堆栈溢出检查 RTOS任务都需要分配堆栈 xff0c 堆栈大小不合理 xff0c 会造成内存越界或者资源的浪费如果在没有把握堆栈大小 xff0c 尽量将堆栈往大的方向设置 xff0c 这样能保证任务堆栈上下文切换不会溢出
PTZ云台开发过程中PELCO-D、PELCO-P协议遇到的问题

最近学习了云台的一些东西 xff0c 比如云台的协议阿 xff0c 云台的调试什么 xff0c 通过这段时间努力终于把几个问题解决了 xff0c 一个是对于某个厂商 A 的云台出现的 pelco p 协议在波特率 2400 xff0c 48
apt-get 源和常识

本文内容 xff1a 1 apt get的源换成阿里或163的 2 atp get的源的常识一概述安装好Ubuntu它自带源是国外的 xff0c 访问较慢 xff0c 经常会出现连接失败的情况所以建议将它替换为国内的 xff08 如
ROS安装rosdep update出现ERROR: unable to process source

sudo gedit etc hosts 在最下面添加一句这个 xff1a 151 101 84 133 raw githubusercontent com sudo mkdir p etc ros rosdep sources list

随机推荐

基于NavMesh寻路、漏斗寻路、RVO动态避障自创的服务器大规模寻路+动态避障算法的实现

一描述 TW项目是一个拥有较广阔野外空间的SLG游戏 xff0c 玩家的军队方阵可以在野外进行长距离行军短距离自由行军占领要塞驻扎形成战斗阵型战斗等行为其中 xff0c 野外的山脉河流等会产生静态阻挡 xff1b 而由玩家迁城
Python 日期的加减操作

获取当前时间 coding 61 utf 8 import datetime now 61 datetime datetime now print now 日期输出格式化所有日期时间的api都在datetime模块内 datetime
基于A*和势场寻路的快速小队伍动态势场避障寻路

前言先把本算法的适用场景和优缺点写在前面 xff0c 需要的可以继续看 xff0c 不适用的就可以直接略过了然后在循序渐进介绍本算法演示效果在最后本算法适用场景每次寻路以小队伍为单位 xff08 几个至几十个队员 xff09 队员
STM32 keil5 报错：flash download failed-cortex M3解决方法

起因因为之前自己使用的STM32都是使用的F4 xff0c 自己打了一块STM32F1C8T6板子 xff0c 焊好之后 xff0c 打开以前正点原子的例程的时候 xff0c 出现无法烧录的情况 xff0c 总是报这样的错误 xff0c
HTTP中的GET和POST方法详解

一般来说GET是获取数据 xff0c POST是提交数据的但是因为GET和POST都是HTTP的方法 xff0c HTTP又是基于TCP IP的关于数据在万维网中如何让通讯的协议从本质上讲 xff0c GET和POST都是HTTP请求
使用SocketTask，弃用wx

经验总结微信小程序websocket的注意事项 xff1a 使用SocketTask xff0c 弃用wx 示例代码 socketTask的示例代码如下引用在微信小程序的一个页面中开启多个websocket连接的代码 var ws1 6
SimpleNES的编译与运行

前言如题 xff0c 最近搜索一些C 43 43 项目无意中看到它 xff0c 然后就动手构建了一把 xff0c 当然过程肯定会遇到一些问题的了不然也不会写这篇文章跟大家分享了呀 xff0c 是吧 xff01 来来来 xff0c 先给大
【注意/切记】 Android JIN开发过程中不要把long当jlong使用

遇到问题 C C 43 43 调Java方法时直接把long类型的变量 xff0c 传给CallStaticVoidMethod导致对应的Java静态方法接收到了错误的long值 PS 实际的业务场比较复杂浪费了好多时间去分析才定位到是这
Man手册常用快捷键之万事找h键

最强最核心最根本的快捷键是 gt gt gt gt gt h 最核心 look everything you want to know is here 基本与常用 p 上翻一屏 control 43 p 上滚一行 n下播一屏 control
2023年clang12编译问题与解决的记录

最近编译clang12以及尝试基于clang开发一个C 43 43 的静态代码分析工具 xff0c 如下是遇到的环境相关的编译问题与解决方案在此做个记录 xff0c 同时供可能会遇到同样问题的同学参考环境说明注 xff1a 如下是最终
Clang dump AST需要注意的事项

Clang dump AST本质上是对一个OC C C 43 43 源文件编译单元执行编译 xff0c 即跟编译相关的配置都是要注意相关的参数 xff0c 比如依赖的头文件的路径 xff0c 特别编译的源文件依赖的其它路径下的头文件 xff
URI与URL的区别

xff08 原网址 xff1a http zhidao baidu com question 38764759 html xff09 Web上可用的每种资源 HTML文档图像视频片段程序等由一个通过通用资源标志符 xff08 Uni
Python datetime 和 str 相互转化

datetime 转化为 str now 61 datetime datetime now now strftime 39 Y m d H M S 39 print now 输出2012 03 05 16 26 23 870105 strf
BASE64编码规则

Base64编码要求把3个8位字节 xff08 3 8 61 24 xff09 转化为4个6位的字节 xff08 4 6 61 24 xff09 xff0c 之后在6位的前面补两个0 xff0c 形成8位一个字节的形式例如字符串张3 x
Cygwin基本命令的使用方法

原文链接 xff1a http blog chinaunix net space php uid 61 25580079 amp do 61 blog amp id 61 190413 基本操作命令 ls 以默认方式显示当前目录文件列表 l
正确设置了charles，使用charles抓包某些app，无法抓到的原因（Android手机）

Charles配置绝对正确 xff0c 还是使终抓不到包的可能的一种情况是 xff01 xff01 xff01 应用使用的网络库不支持代理 xff0c 所有的网络请求没有走代理 xff0c 而是走的正常wifi直连当时的情况如下 xff1
拉起抖音APP视频页的scheme

拉起scheme地协议 snssdk1128 span class hljs regexp aweme span span class hljs regexp detail span span class hljs number 65344
1. Windows下使用Mingw-w64 GCC编译安装Lua5.1.5

除了一些游戏开发的脚本领域 xff0c 在以OpenResty作为Web框架的后端开发中 xff0c Lua也会大量的使用 xff0c 这就难免要对在Shell中测试验证Lua语法为此 xff0c 小编写了一篇在Windows环境下编译
VSCode Python3 三方库

Mac VSCode python3 配置 setting 默认已经安装VSCode背景操作默认已经安装VSCode 网上已经有好多教程安装使用Python3 这里只记录python3 的配置问题背景从想学Python 到实际操刀来
SylixOS命令行下内存操作/测试工具

源头 memAccessCmd是用于SylixOS下对内存寄存器进行访问和测试的工具 SylixOS下调测程序 xff0c 无论是应用驱动还是内核 xff0c 如果能查看并操作指定内存寄存器 xff0c 将是一个非常有效的手段作者在

SylixOS命令行下内存操作/测试工具

源头

用法

源码

SylixOS命令行下内存操作/测试工具 的相关文章

随机推荐

热门标签

SylixOS命令行下内存操作/测试工具的相关文章