devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自己开发jlink烧录软件，烧录上位机， C#调用JLinkARM.dll实现软件烧录_c# jlink ob

作者：weixin_40725706 | 2024-04-17 21:35:34

赞

踩

c# jlink ob

最近需要写一个烧录软件，让工厂可以实现一键烧录。

1.命令行烧录

这里实现了运行一个bat文件进行一键烧录，不想看这部分的可以直接跳到第二部分，不受影响。

由于jlink的自带烧录软件JFlash.exe操作十分繁杂，需要自己开发一个简洁的烧录方法，一番操作发现，可以使用J-Link Commander 的命令行进行烧录，操作流程如下：

既然可以用这个命令行，那就可以用bat文件来执行，此间需要生成一个.jlink文件供命令行执行，总共需要两个文件，我这里是burn_hex.bat 和 burn_script.jlink，具体内容如下：

burn_hex.bat:

  1. @echo off
  2. set JLINK_PATH="C:\Program Files (x86)\SEGGER\JLink\JLink.exe"
  3. set HEX_FILE_PATH="Programmer.hex"
  4. set CHIP_MODEL=NRF52832
  5.  
  6. %JLINK_PATH% -device %CHIP_MODEL% -if SWD -speed 4000 -CommanderScript burn_script.jlink

burn_script.jlink:

  1. connect
  2. device NRF52832_XXAA
  3. speed 4000
  4. TIF SWD
  5. loadfile D:\Programmer.hex
  6. r
  7. g
  8. q

两个 文件放在同一目录下，将hex路径设置正确，点击bat文件即可进行烧录。

命令行衍生上位机

既然可以按如上的方式烧录，那用上位机生成*.jlink文件再执行bat即可实现上位机烧录，但是这种方式不够灵活。

2.C#调用JLinkARM.dll烧录

通过调查发现，jlink的烧录都有调用JLinkARM.dll里面的接口，那开发者也可以调用，但是SEGGER并未开源，需要花钱购买全部的接口。好在有大佬成功逆向了部分接口，原帖：c#的 JLINK API，自己用的 (amobbs.com 阿莫电子技术论坛)

稍全的接口如下（C++）：

  1. //arm.h，裡面的API list 如下
  2. /*********************************************************************
  3. *
  4. *       API functions
  5. */
  6. void         JLINKARM_Close(void);
  7. void         JLINKARM_ClrBP(unsigned BPIndex);
  8. void         JLINKARM_ClrError(void);
  9. void         JLINKARM_EnableLog2File(void);
  10. const char * JLINKARM_GetCompileDateTime(void);
  11. U16          JLINKARM_GetEmbeddedFWVersion(void);
  12. void         JLINKARM_GetHWStatus(JTAG_HW_STATUS * pStat);
  13. U32          JLINKARM_GetId(void);
  14. void         JLINKARM_GetIdData(JTAG_ID_DATA * pIdData);
  15. U16          JLINKARM_GetSelDevice(void);
  16. int          JLINKARM_GetVoltage(void);
  17. U16          JLINKARM_GetSpeed(void);
  18. void         JLINKARM_Go(void);
  19. void         JLINKARM_GoIntDis(void);
  20. char         JLINKARM_Halt(void);
  21. char         JLINKARM_HaltNoSave(void);
  22. char         JLINKARM_IsConnected(void);
  23. char         JLINKARM_IsHalted(void);
  24. const char * JLINKARM_Open(void);
  25. int          JLINKARM_ReadDCC(U32 * pData, U32 NumItems, int TimeOut);
  26. void         JLINKARM_ReadDCCFast(U32 * pData, U32 NumItems);
  27. U32          JLINKARM_ReadICEReg(int RegIndex);
  28. int          JLINKARM_ReadMem (U32 addr, U32 count, void * p);
  29. void         JLINKARM_ReadMemU8 (U32 Addr, U32 NumItems, U8 * pData, U8* pStatus);
  30. void         JLINKARM_ReadMemU16(U32 Addr, U32 NumItems, U16* pData, U8* pStatus);
  31. void         JLINKARM_ReadMemU32(U32 Addr, U32 NumItems, U32* pData, U8* pStatus);
  32. U32          JLINKARM_ReadReg (ARM_REG RegIndex);
  33. void         JLINKARM_Reset(void);
  34. void         JLINKARM_ResetPullsTRST (U8 OnOff);
  35. void         JLINKARM_ResetPullsRESET(U8 OnOff);
  36. void         JLINKARM_SelDevice(U16 DeviceIndex);
  37. void         JLINKARM_SetBP(unsigned BPIndex, U32 Addr);
  38. int          JLINKARM_SetEndian(int v);
  39. int          JLINKARM_SetInitRegsOnReset(int v);
  40. void         JLINKARM_SetMaxSpeed(void);
  41. void         JLINKARM_SetResetDelay(int ms);
  42. int          JLINKARM_SetResetPara(int Value);
  43. void         JLINKARM_SetSpeed(int Speed);
  44. char         JLINKARM_Step(void);
  45. int          JLINKARM_Test(void);
  46. U16          JLINKARM_UpdateFirmware(void);
  47. U32          JLINKARM_UpdateFirmwareIfNewer(void);
  48. int          JLINKARM_WaitDCCRead(int TimeOut);
  49. int          JLINKARM_WriteDCC(const U32 * pData, U32 NumItems, int TimeOut);
  50. void         JLINKARM_WriteDCCFast(const U32 * pData, U32 NumItems);
  51. void         JLINKARM_WriteICEReg(int RegIndex, U32 Value, int AllowDelay);
  52. char         JLINKARM_WriteReg(ARM_REG RegIndex, U32 Data);
  53. void         JLINKARM_WriteMem(U32 addr, U32 count, const void * p);
  54. void         JLINKARM_WriteMemDelayed(U32 Addr, U32 Count, const void * p);
  55. void         JLINKARM_WriteU8 (U32 addr, U8 Data);
  56. void         JLINKARM_WriteU16(U32 addr, U16 Data);
  57. void         JLINKARM_WriteU32(U32 addr, U32 Data);
  58.  
  59. void          JLINKARM_EnableLogCom(void (*DebugFunc)(const char *));

 C#接口如下：

  1.  
  2.         /// <summary>
  3.         /// 打开JLINK设备
  4.         /// </summary>
  5.         /// <remarks></remarks>
  6.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  7.         public static extern void JLINKARM_Open();
  8.  
  9.  
  10.         /// <summary>
  11.         /// 关闭JLINK设备
  12.         /// </summary>
  13.         /// <remarks></remarks>
  14.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  15.         public static extern void JLINKARM_Close();
  16.  
  17.         /// <summary>
  18.         /// 连接设备
  19.         /// </summary>
  20.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  21.         public static extern void JLINKARM_Connect();
  22.  
  23.         /// <summary>
  24.         /// 开启RTT
  25.         /// </summary>
  26.         /// <param name="terminal"></param>
  27.         /// <param name="size"></param>
  28.         [DllImport("JLinkARM.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  29.         public static extern UInt32 JLINK_RTTERMINAL_Control(UInt32 CMD, UInt32 size);
  30.  
  31.         /// <summary>
  32.         /// 从RTT回读数据
  33.         /// </summary>
  34.         /// <param name="terminal"></param>
  35.         /// <param name="rxBuffer"></param>
  36.         /// <param name="len"></param>
  37.         [DllImport("JLinkARM.dll", CharSet = CharSet.Auto, SetLastError = true, ExactSpelling = true)]
  38.         public static extern void JLINK_RTTERMINAL_Read(int terminal, [Out(), MarshalAs(UnmanagedType.LPArray)] byte[] rxBuffer, UInt32 size);
  39.  
  40.  
  41.         static string gbk_ansi(string str)
  42.         {
  43.             string keyword;
  44.             byte[] buffer = Encoding.GetEncoding("GB2312").GetBytes(str);
  45.             keyword = Encoding.UTF8.GetString(buffer);
  46.             return keyword;
  47.         }
  48.  
  49.         public static string JLINKARM_ReadRTT_String()
  50.         {
  51.             try
  52.             {
  53.                 byte[] aa = new byte[1000];
  54.                 JLINK_RTTERMINAL_Read(0, aa,1000);
  55.  
  56.                ASCIIEncoding kk = new ASCIIEncoding();
  57.                 //使用UTF-8编码
  58.                 UTF8Encoding uu = new UTF8Encoding();
  59.                 string ss = uu.GetString(aa);
  60.                 if(ss.Length>1)
  61.                 {
  62.                     Console.Write(ss);
  63.                 }
  64.                 return ss;
  65.             }
  66.             catch(Exception ex)
  67.             {
  68.  
  69.             }
  70.             return String.Empty;
  71.  
  72.         }
  73.  
  74.  
  75.         /// <summary>
  76.         /// 写数据到RTT
  77.         /// </summary>
  78.         /// <param name="terminal"></param>
  79.         /// <param name="txBuffer"></param>
  80.         /// <param name="len"></param>
  81.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  82.         public static extern void JLINK_RTTERMINAL_Write(int terminal, [In(), MarshalAs(UnmanagedType.LPArray)] byte[] txBuffer, UInt32 size);
  83.  
  84.  
  85.  
  86.  
  87.         /// <summary>
  88.         /// 系统复位
  89.         /// </summary>
  90.         /// <remarks></remarks>
  91.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  92.         public static extern void JLINKARM_Reset();
  93.  
  94.  
  95.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  96.         public static extern void JLINKARM_GoAllowSim();
  97.  
  98.  
  99.         /// <summary>
  100.         /// 执行程序
  101.         /// </summary>
  102.         /// <remarks></remarks>
  103.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  104.         public static extern void JLINKARM_Go();
  105.  
  106.  
  107.         /// <summary>
  108.         /// 中断程序执行
  109.         /// </summary>
  110.         /// <returns></returns>
  111.         /// <remarks></remarks>
  112.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  113.         public static extern bool JLINKARM_Halt();
  114.  
  115.         /// <summary>
  116.         /// 单步执行
  117.         /// </summary>
  118.         /// <returns></returns>
  119.         /// <remarks></remarks>
  120.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  121.         public static extern bool JLINKARM_Step();
  122.  
  123.  
  124.         /// <summary>
  125.         /// 清除错误信息
  126.         /// </summary>
  127.         /// <remarks></remarks>
  128.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  129.         public static extern void JLINKARM_ClrError();
  130.  
  131.  
  132.         /// <summary>
  133.         /// 设置JLINK接口速度
  134.         /// </summary>
  135.         /// <param name="speed"></param>
  136.         /// <remarks>0为自动调整</remarks>
  137.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  138.         public static extern void JLINKARM_SetSpeed(int speed);
  139.  
  140.  
  141.         /// <summary>
  142.         /// 设置JTAG为最高速度
  143.         /// </summary>
  144.         /// <remarks></remarks>
  145.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  146.         public static extern void JLINKARM_SetMaxSpeed()
  147.         ;
  148.  
  149.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  150.         public static extern UInt16 JLINKARM_GetSpeed()
  151.        ;
  152.  
  153.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  154.         public static extern UInt32 JLINKARM_GetVoltage()
  155.     ;
  156.  
  157.         /// <summary>
  158.         /// 当前MCU是否处于停止状态
  159.         /// </summary>
  160.         /// <returns></returns>
  161.         /// <remarks></remarks>
  162.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  163.         public static extern bool JLINKARM_IsHalted()
  164.         ;
  165.  
  166.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  167.         public static extern bool JLINKARM_IsConnected()
  168.        ;
  169.  
  170.         /// <summary>
  171.         /// JLINK是否已经可以操作了
  172.         /// </summary>
  173.         /// <returns></returns>
  174.         /// <remarks></remarks>
  175.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  176.         public static extern bool JLINKARM_IsOpen()
  177.         ;
  178.  
  179.         /// <summary>
  180.         /// 取消程序断点
  181.         /// </summary>
  182.         /// <param name="index">断点序号</param>
  183.         /// <remarks>配合JLINKARM_SetBP()使用</remarks>
  184.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  185.         public static extern void JLINKARM_ClrBP(UInt32 index)
  186.        ;
  187.  
  188.         /// <summary>
  189.         /// 设置程序断点
  190.         /// </summary>
  191.         /// <param name="index">断点序号</param>
  192.         /// <param name="addr">目标地址</param>
  193.         /// <remarks>建议使用JLINKARM_SetBPEx()替代</remarks>
  194.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  195.         public static extern void JLINKARM_SetBP(UInt32 index, UInt32 addr)
  196.         ;
  197.  
  198.         /// <summary>
  199.         /// 设置程序断点
  200.         /// </summary>
  201.         /// <param name="addr">目标地址</param>
  202.         /// <param name="mode">断点类型</param>
  203.         /// <returns>Handle,提供给JLINKARM_ClrBPEx()使用</returns>
  204.         /// <remarks></remarks>
  205.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  206.         public static extern int JLINKARM_SetBPEx(UInt32 addr, BP_MODE mode)
  207.       ;
  208.         /// <summary>
  209.         /// 取消程序断点
  210.         /// </summary>
  211.         /// <param name="handle"></param>
  212.         /// <remarks>配合JLINKARM_SetBPEx()使用</remarks>
  213.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  214.         public static extern void JLINKARM_ClrBPEx(int handle)
  215.         ;
  216.  
  217.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  218.         private static extern int JLINKARM_SetWP(UInt32 addr, UInt32 addrmark, UInt32 dat, UInt32 datmark, byte ctrl, byte ctrlmark)
  219.         ;
  220.  
  221.         /// <summary>
  222.         /// 取消数据断点
  223.         /// </summary>
  224.         /// <param name="handle"></param>
  225.         /// <remarks>配合JLINKARM_SetWP()使用</remarks>
  226.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  227.         public static extern void JLINKARM_ClrWP(int handle)
  228.         ;
  229.  
  230.         /// <summary>
  231.         /// 设置寄存器
  232.         /// </summary>
  233.         /// <param name="index"></param>
  234.         /// <param name="dat"></param>
  235.         /// <remarks></remarks>
  236.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  237.         public static extern void JLINKARM_WriteReg(ARM_REG index, UInt32 dat)
  238.        ;
  239.  
  240.         /// <summary>
  241.         /// 读取寄存器
  242.         /// </summary>
  243.         /// <param name="index"></param>
  244.         /// <returns></returns>
  245.         /// <remarks></remarks>
  246.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  247.         public static extern UInt32 JLINKARM_ReadReg(ARM_REG index)
  248.         ;
  249.  
  250.         /// <summary>
  251.         /// 写入一段数据
  252.         /// </summary>
  253.         /// <param name="addr"></param>
  254.         /// <param name="size"></param>
  255.         /// <param name="buf"></param>
  256.         /// <remarks></remarks>
  257.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  258.         public static extern void JLINKARM_WriteMem(UInt32 addr, UInt32 size, byte[] buf)
  259.         ;
  260.  
  261.         /// <summary>
  262.         /// 读取一段数据
  263.         /// </summary>
  264.         /// <param name="addr"></param>
  265.         /// <param name="size"></param>
  266.         /// <param name="buf"></param>
  267.         /// <remarks></remarks>
  268.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  269.         public static extern void JLINKARM_ReadMem(UInt32 addr, UInt32 size, [Out(), MarshalAs(UnmanagedType.LPArray)] byte[] buf)
  270.         ;
  271.  
  272.         /// <summary>
  273.         /// 从调试通道获取一串数据
  274.         /// </summary>
  275.         /// <param name="buf"></param>
  276.         /// <param name="size">需要获取的数据长度</param>
  277.         /// <remarks></remarks>
  278.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  279.         public static extern void JLINKARM_ReadDCCFast([Out(), MarshalAs(UnmanagedType.LPArray)] UInt32[] buf, UInt32 size)
  280.        ;
  281.  
  282.         /// <summary>
  283.         /// 从调试通道获取一串数据
  284.         /// </summary>
  285.         /// <param name="buf"></param>
  286.         /// <param name="size">希望获取的数据长度</param>
  287.         /// <param name="timeout"></param>
  288.         /// <returns>实际获取的数据长度</returns>
  289.         /// <remarks></remarks>
  290.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  291.         public static extern UInt32 JLINKARM_ReadDCC([Out(), MarshalAs(UnmanagedType.LPArray)] UInt32[] buf, UInt32 size, int timeout)
  292.         ;
  293.  
  294.         /// <summary>
  295.         /// 向调试通道写入一串数据
  296.         /// </summary>
  297.         /// <param name="buf"></param>
  298.         /// <param name="size">需要写入的数据长度</param>
  299.         /// <remarks></remarks>
  300.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  301.         public static extern void JLINKARM_WriteDCCFast(UInt32[] buf, UInt32 size)
  302.         ;
  303.  
  304.         /// <summary>
  305.         /// 向调试通道写入一串数据
  306.         /// </summary>
  307.         /// <param name="buf"></param>
  308.         /// <param name="size">希望写入的数据长度</param>
  309.         /// <param name="timeout"></param>
  310.         /// <returns>实际写入的数据长度</returns>
  311.         /// <remarks></remarks>
  312.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  313.         public static extern UInt32 JLINKARM_WriteDCC(UInt32[] buf, UInt32 size, int timeout)
  314.         ;
  315.  
  316.         /// <summary>
  317.         /// 获取JLINK的DLL版本号
  318.         /// </summary>
  319.         /// <returns></returns>
  320.         /// <remarks>使用10进制数表示</remarks>
  321.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  322.         public static extern UInt32 JLINKARM_GetDLLVersion()
  323.        ;
  324.  
  325.         /// <summary>
  326.         /// 执行命令
  327.         /// </summary>
  328.         /// <param name="oBuffer"></param>
  329.         /// <param name="a"></param>
  330.         /// <param name="b"></param>
  331.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  332.         public static extern void JLINKARM_ExecCommand([In(), MarshalAs(UnmanagedType.LPArray)] byte[] oBuffer,int a,int b);
  333.  
  334.         /// <summary>
  335.         /// 选择接口,0是JTAG 1是SWD
  336.         /// </summary>
  337.         /// <param name="type"></param>
  338.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  339.         public static extern void JLINKARM_TIF_Select(int type);
  340.  
  341.  
  342.  
  343.  
  344.  
  345.         /// <summary>
  346.         /// 获取JLINK的固件版本号
  347.         /// </summary>
  348.         /// <returns></returns>
  349.         /// <remarks></remarks>
  350.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  351.         public static extern UInt32 JLINKARM_GetHardwareVersion()
  352.         ;
  353.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  354.         private static extern void JLINKARM_GetFeatureString([Out(), MarshalAs(UnmanagedType.LPArray)] byte[] oBuffer)
  355.        ;
  356.  
  357.         [DllImport("JLinkARM.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  358.         private static extern void JLINKARM_GetOEMString([Out(), MarshalAs(UnmanagedType.LPArray)] byte[] oBuffer)
  359.         ;
  360.  
  361.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  362.         public static extern void JLINKARM_SetLogFile([In(), MarshalAs(UnmanagedType.LPArray)] byte[] oBuffer)
  363. ;
  364.  
  365.  
  366.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  367.         public static extern StringBuilder JLINKARM_GetCompileDateTime()
  368.         ;
  369.  
  370.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  371.         public static extern UInt32 JLINKARM_GetSN()
  372.         ;
  373.  
  374.         /// <summary>
  375.         /// 获取当前MCU的ID号
  376.         /// </summary>
  377.         /// <returns></returns>
  378.         /// <remarks></remarks>
  379.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  380.         public static extern UInt32 JLINKARM_GetId()
  381.         ;
  382.  
  383.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  384.         private static extern void JLINKARM_ReadMemU32(UInt32 addr, UInt32 leng, ref UInt32 buf, ref byte status)
  385.        ;
  386.  
  387.         /// <summary>
  388.         /// 写入32位的数据
  389.         /// </summary>
  390.         /// <param name="addr"></param>
  391.         /// <param name="dat"></param>
  392.         /// <remarks></remarks>
  393.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  394.         public static extern void JLINKARM_WriteU32(UInt32 addr, UInt32 dat)
  395.       ;
  396.  
  397.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  398.         private static extern void JLINKARM_ReadMemU16(UInt32 addr, UInt32 leng, ref UInt16 buf, ref byte status)
  399.        ;
  400.         /// <summary>
  401.         /// 写入16位的数据
  402.         /// </summary>
  403.         /// <param name="addr"></param>
  404.         /// <param name="dat"></param>
  405.         /// <remarks></remarks>
  406.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  407.         public static extern void JLINKARM_WriteU16(UInt32 addr, UInt16 dat)
  408.   ;
  409.  
  410.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  411.         private static extern void JLINKARM_ReadMemU8(UInt32 addr, UInt32 leng, ref byte buf, ref byte status)
  412. ;
  413.  
  414.         /// <summary>
  415.         /// 写入8位的数据
  416.         /// </summary>
  417.         /// <param name="addr"></param>
  418.         /// <param name="dat"></param>
  419.         /// <remarks></remarks>
  420.         [DllImport("JLinkARM.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
  421.         public static extern void JLINKARM_WriteU8(UInt32 addr, byte dat)
  422.        ;

有了这个接口便可以调用连接jlink了，例如：

  1.             Console.WriteLine("Jlink操作演示");
  2.             JLinkHandler.JLINKARM_SetLogFile(System.Text.Encoding.UTF8.GetBytes("this_log.txt"));
  3.             JLinkHandler.JLINKARM_Open();
  4.             var ver = JLinkHandler.JLINKARM_GetDLLVersion();
  5.             Console.WriteLine("DLL 版本: "+ver);
  6.             Console.WriteLine("SN:" + JLinkHandler.JLINKARM_GetSN());
  7.             Console.WriteLine("硬件版本: " + JLinkHandler.JLINKARM_GetHardwareVersion());
  8.             JLinkHandler.JLINKARM_ExecCommand(System.Text.Encoding.UTF8.GetBytes("device = STM32H743VI"), 0, 0);
  9.             JLinkHandler.JLINKARM_TIF_Select(1);
  10.             JLinkHandler.JLINKARM_SetSpeed(4000);
  11.             Console.WriteLine("CPU ID: "+JLinkHandler.JLINKARM_GetId());

可惜的是，并没有直接下载hex文件的接口，这就需要先了解hex文件的结构，进行进一步解析，再调用接口写到对应的地址下。这里有参考文章：

STM32的烧录和Hex/bin烧录文件解析、烧录文件是被如何存储到MCU中的？_stm32 bin文件解析-CSDN博客

hex文件内含有地址和数据，软件解析地址并烧录数据，烧录完毕之后，调用：JLINKARM_Go();，程序成功执行，搞了好几天终于成功了，记录一下。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/442350
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号