分享一个jlink的C#上位机软件

霸气侧漏

无意发现一个jlink的上位机调用组件，用C#编写的，方便做一下烧录。
大家可以一起玩玩

hackboymzw

谢谢分享，好像是调的Jlink的PAI

snowy

好像调用命令行做的，不是用的dll。

霸气侧漏

snowy 发表于 2019-10-9 18:14
好像调用命令行做的，不是用的dll。

你看看就知道了

霸气侧漏

hackboymzw 发表于 2019-10-9 18:04
谢谢分享，好像是调的Jlink的PAI

研究下代码，就知道实现方式

XIVN1987

应该是通过向JLink.exe进程发送命令字符串来实现功能的

其实可以不使用JLink.exe，，直接调用JLinkARM.dll实现功能，，这样更灵活，，毕竟JLink.exe也是通过调用JLinkARM.dll来实现功能的

有坛友分享过相关代码：c#的 JLINK API，自己用的

霸气侧漏

XIVN1987 发表于 2019-10-9 18:35
应该是通过向JLink.exe进程发送命令字符串来实现功能的

其实可以不使用JLink.exe，，直接调用JLinkARM.dl ...

他这没有工程，不好弄

你有C#的工程没有

justdomyself

这种方式刷一个100k的bin文件要多久，我掉dll要刷好半天

霸气侧漏

justdomyself 发表于 2019-10-9 20:15
这种方式刷一个100k的bin文件要多久，我掉dll要刷好半天

时间没测试过，你用什么上位机做的，放点资料上来

snowy

我是写了一个小BIN文件，放到RAM中运行，把大BIN写入FLASH，尤其对付SPI FLASH很有用。

XIVN1987

霸气侧漏 发表于 2019-10-9 19:53
他这没有工程，不好弄

你有C#的工程没有

没有，，我只搞过python控制JLinkARM.dll，，代码：https://github.com/XIVN1987/JMCUProg

sblpp

还不如写个批处理文件 双击跑一下就完事~~~

sblpp

感谢楼主分享~~~

霸气侧漏

XIVN1987 发表于 2019-10-9 21:07
没有，，我只搞过python控制JLinkARM.dll，，代码：https://github.com/XIVN1987/JMCUProg ...

python

我不会，，，尴尬

justdomyself

justdomyself 发表于 2019-10-9 20:15
这种方式刷一个100k的bin文件要多久，我掉dll要刷好半天

c ++  资料明天有空传

boboo

不如直接掉dll

霸气侧漏

justdomyself 发表于 2019-10-9 23:16
c ++  资料明天有空传

嗯嗯，传一下，最好是工程文件

cchwhk

XIVN1987 发表于 2019-10-9 21:07
没有，，我只搞过python控制JLinkARM.dll，，代码：https://github.com/XIVN1987/JMCUProg ...

感谢分享,还是python给力,全平台通用.

justdomyself

霸气侧漏 发表于 2019-10-9 20:20
时间没测试过，你用什么上位机做的，放点资料上来

jflash.cpp

#include "stdafx.h"
#include "windows.h"
#include "jlink.h"
#include "jflashAPI.h"

//use printf
#pragma comment(linker, "/subsystem:\"CONSOLE\" /entry:\"WinMainCRTStartup\"")



unsigned int jf_unlock(void)
{
    jlink.JLINKARM_WriteU32(FLASH_KR, FLASH_KR_KEY1);
    jlink.JLINKARM_WriteU32(FLASH_KR, FLASH_KR_KEY2);

    return 0;
}

unsigned int jf_lock(void)
{
    unsigned int read = jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_LOCK;
    jlink.JLINKARM_WriteU32(FLASH_CR, read);

    return 0;
}

unsigned int jf_wait_ready(void)
{
    unsigned int read;

    while ( (read = jlink.JLINKARM_ReadU32(FLASH_SR) & FLASH_SR_BUSY) )
    {
        Sleep(1);
    }

    return 0;
}

unsigned int jf_chip_erase(void)
{
    jf_unlock();

    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_CERASE);
    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_ESTART);
    jf_wait_ready();
    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) &~FLASH_CR_CERASE);

    jf_lock();

    return 0;
}


unsigned int jf_page_erase(unsigned int startAddr, unsigned int sec)
{
    jf_unlock();

    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_PERASE);

    for (unsigned int i = 0; i < sec; i++)
    {
        jlink.JLINKARM_WriteU32(FLASH_AR, startAddr + PAGE_SIZE * i);
        jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_ESTART);
        jf_wait_ready();
      

    }
    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) &~FLASH_CR_PERASE);
    jf_lock();

    return 0;
}


unsigned int jf_page_write(unsigned int addr, unsigned char *data)
{

    jf_unlock();

    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) | FLASH_CR_PWRITE);


    for (unsigned int i = 0; i < PAGE_SIZE/2; i++)
    {
        jlink.JLINKARM_WriteU16(addr + i * 2, data[i * 2] | (data[i * 2 + 1] << 8));
    }

    jf_wait_ready();
    jlink.JLINKARM_WriteU32(FLASH_CR, jlink.JLINKARM_ReadU32(FLASH_CR) &~FLASH_CR_PWRITE);
     
    jf_lock();


    return 0;
}



///???????????
unsigned int jf_chip_write(unsigned int startAddr, unsigned char * data, unsigned int len)
{
    unsigned int n_page = len / PAGE_SIZE;
    if ( len %PAGE_SIZE != 0)
    {
        jf_page_erase(startAddr, n_page + 1);
    }
    else
    {
        jf_page_erase(startAddr, n_page);
    }
   

    unsigned int i = 0;

    for (i = 0; i < n_page; i++)
    {
        jf_page_write(startAddr + i* PAGE_SIZE, data + i*PAGE_SIZE);

        printf("write sec i %d\r\n", i);
    }

    if ( len % PAGE_SIZE )
    {
        unsigned char buf[PAGE_SIZE] = {0};

        for (unsigned int j = 0; j < PAGE_SIZE; j++)
        {
            buf[j] = 0xff;
        }

        memcpy(buf, data + i*PAGE_SIZE, len%PAGE_SIZE);

        jf_page_write(startAddr + i* PAGE_SIZE, buf);
        
    }

    return 0;
}

jlink.cpp
#include "stdafx.h"
#include "windows.h"
//#include <iostream>
#include "jlink.h"

#pragma  comment(lib, "JLinkARM.dll")

dsJlink jlink;

unsigned char JLINKARM_ReadU8(unsigned int addr)
{
    unsigned char ret;
    unsigned char st;

    jlink.JLINKARM_ReadMemU8(addr, 1, &ret, &st);
    return ret;
}

unsigned short JLINKARM_ReadU16(unsigned int addr)
{
    unsigned short ret;
    unsigned char st;

    jlink.JLINKARM_ReadMemU16(addr, 1, &ret, &st);

    return ret;
}

unsigned int JLINKARM_ReadU32(unsigned int addr)
{
    unsigned int ret;
    unsigned char st;

    jlink.JLINKARM_ReadMemU32(addr, 1, &ret, &st);

    return ret;
}

unsigned int InitJLink(void)
{
    #define BUF_MAX_SIZE                  600
    unsigned char buf[BUF_MAX_SIZE];

    //加载动态库
    HMODULE hMod = LoadLibrary("JLinkARM.dll");

    ///根据函数名获取函数指针
    jlink.JLINKARM_TIF_Select = (pFunc_TIF_Select)GetProcAddress(hMod, TEXT("JLINKARM_TIF_Select"));
    jlink.JLINKARM_ExecCommand = (pFunc_ExecCommand)GetProcAddress(hMod, TEXT("JLINKARM_ExecCommand"));
    jlink.JLINKARM_GetId = (pFunc_GetId)GetProcAddress(hMod, TEXT("JLINKARM_GetId"));
    jlink.JLINKARM_IsConnected = (pFunc_IsConnected)GetProcAddress(hMod, TEXT("JLINKARM_IsConnected"));
    jlink.JLINKARM_Reset = (pFunc_Reset)GetProcAddress(hMod, TEXT("JLINKARM_Reset"));

    jlink.JLINKARM_ReadMem = (pFunc_ReadMem)GetProcAddress(hMod, TEXT("JLINKARM_ReadMem"));
    jlink.JLINKARM_WriteMem = (pFunc_WriteMem)GetProcAddress(hMod, TEXT("JLINKARM_WriteMem"));
   
    jlink.JLINKARM_SetSpeed = (pFunc_SetSpeed)GetProcAddress(hMod, TEXT("JLINKARM_SetSpeed"));
    jlink.JLINKARM_GetSpeed = (pFunc_GetSpeed)GetProcAddress(hMod, TEXT("JLINKARM_GetSpeed"));

    jlink.JLINKARM_ReadMemU32 = (pFunc_ReadMemU32)GetProcAddress(hMod, TEXT("JLINKARM_ReadMemU32"));
    jlink.JLINKARM_ReadMemU16 = (pFunc_ReadMemU16)GetProcAddress(hMod, TEXT("JLINKARM_ReadMemU16"));
    jlink.JLINKARM_ReadMemU8 = (pFunc_ReadMemU8)GetProcAddress(hMod, TEXT("JLINKARM_ReadMemU8"));



    jlink.JLINKARM_WriteU32 = (pFunc_WriteU32)GetProcAddress(hMod, TEXT("JLINKARM_WriteU32"));
    jlink.JLINKARM_ReadU32 = (pFunc_ReadU32)GetProcAddress(hMod, TEXT("JLINKARM_ReadU32"));

    jlink.JLINKARM_WriteU16 = (pFunc_WriteU16)GetProcAddress(hMod, TEXT("JLINKARM_WriteU16"));
    jlink.JLINKARM_ReadU16 = (pFunc_ReadU16)GetProcAddress(hMod, TEXT("JLINKARM_ReadU16"));

    jlink.JLINKARM_WriteU8 = (pFunc_WriteU8)GetProcAddress(hMod, TEXT("JLINKARM_WriteU8"));
    jlink.JLINKARM_ReadU8 = (pFunc_ReadU8)GetProcAddress(hMod, TEXT("JLINKARM_ReadU8"));

    jlink.JLINKARM_WriteReg = (pFunc_WriteReg)GetProcAddress(hMod, TEXT("JLINK_WriteReg"));
    jlink.JLINKARM_ReadReg = (pFunc_ReadReg)GetProcAddress(hMod, TEXT("JLINK_ReadReg"));

    //以下三个函数上面没有一次封装，这里进行二次封装一下
    jlink.JLINKARM_ReadU32 = JLINKARM_ReadU32;
    jlink.JLINKARM_ReadU16 = JLINKARM_ReadU16;
    jlink.JLINKARM_ReadU8 = JLINKARM_ReadU8;


    //选择设备
    if (jlink.JLINKARM_TIF_Select != NULL)
    {
        jlink.JLINKARM_TIF_Select(1);
    }
    //设置芯片型号
    if (jlink.JLINKARM_ExecCommand != NULL)
    {
        unsigned int ret = 0;
        //选择芯片类型
        ret = jlink.JLINKARM_ExecCommand("Device = Cortex-M3", buf, 64);
    }
    //判断jlink是否连接上
    if (jlink.JLINKARM_IsConnected != NULL)
    {
        unsigned int ret = 0;
        ret = jlink.JLINKARM_IsConnected();
        printf("isConnected is %d\r\n", ret);
    }
    //设置jlink速度
    if (jlink.JLINKARM_SetSpeed != NULL)
    {
        jlink.JLINKARM_SetSpeed(12000);
        printf("set jlink speed ok\r\n");
    }
    //获取jlink速度
    if (jlink.JLINKARM_GetSpeed != NULL)
    {
        unsigned int speed = jlink.JLINKARM_GetSpeed();
        printf("get speed is %d khz\r\n", speed);
    }

    if (jlink.JLINKARM_WriteMem != NULL)
    {
        printf("jlink write mem func not null!\r\n");
    }


    return 0;
}


调用这个就可以刷程序， jf_chip_write

这种方式应该没有你直接用exe来的快  

JLINKARM_WriteMem  可以直接对内存进行操作

这个dll的使用在另外一个贴子中提到过，其实也是参照python那个程序修改的

霸气侧漏

justdomyself 发表于 2019-10-10 19:59
jflash.cpp

#include "stdafx.h"

没有工程文件？？？

mcuprogram

谢谢分享！              

liang16888

需要引用 j-link sdk ??

justdomyself

谢谢分享………能提供下工程么？

piaoran1314

你好,我这边尝试jlink.exe是不能够通过管道访问的,但是你的却可以,这是什么原因呢