开启辅助访问

amobbs.com 阿莫电子技术论坛

登录 注册 找回密码
搜索
amobbs.com 阿莫电子技术论坛»论坛首页 › 开源已完成 › 开源PLC › 三菱梯型图转STM32 C语言,移植完成，所以指令使用汇编 ...
bottom↓
返回列表 发新帖
回复: 21

三菱梯型图转STM32 C语言,移植完成，所以指令使用汇编实现，执行速度非常快。逻辑指令

[复制链接]
21ele

出0入0汤圆
发表于 2009-8-3 14:29:36 | 显示全部楼层 |阅读模式
//-------------------------------------------------------//
//  基本指令，扩展指令 宏定义
//-------------------------------------------------------//
#define  _START                   _START_();
#define  _END                   _END_();
#define  _NOP                   _NOP_();

#define  _MPS                   _MPS_();
#define  _MRD                   _MRD_();
#define  _MPP                   _MPP_();

#define  _LD_GE(a,b)             _LD_GE_(a,b);
#define  _LD_LE(a,b)               _LD_LE_(a,b);
#define  _LD_GT(a,b)               _LD_GT_(a,b);
#define  _LD_LT(a,b)               _LD_LT_(a,b);
#define  _LD_NE(a,b)               _LD_NE_(a,b);
#define  _LD_EQ(a,b)               _LD_EQ_(a,b);
#define  _AND_GE(a,b)            _AND_GE_(a,b);
#define  _AND_LE(a,b)             _AND_LE_(a,b);
#define  _AND_GT(a,b)            _AND_GT_(a,b);
#define  _AND_LT(a,b)            _AND_LT_(a,b);
#define  _AND_NE(a,b)            _AND_NE_(a,b);
#define  _AND_EQ(a,b)            _AND_EQ_(a,b);
#define  _OR_GE(a,b)              _OR_GE_(a,b);
#define  _OR_LE(a,b)               _OR_LE_(a,b);
#define  _OR_GT(a,b)              _OR_GT_(a,b);
#define  _OR_LT(a,b)               _OR_LT_(a,b);
#define  _OR_NE(a,b)              _OR_NE_(a,b);
#define  _OR_EQ(a,b)               _OR_EQ_(a,b);

#define  _ANB                   _ANB_();
#define  _ORB                   _ORB_();

#define  _INV                    _INV_();
#define  _PLS(nl)                    _PLS_(nl);
#define  _PLF(nl)                    _PLF_(nl);

#define  _LD(n)                  _LD_(n);
#define  _LDI(n)                  _LDI_(n);
#define  _LDP(n)                  _LDP_(n);
#define  _LDF(n)                  _LDF_(n);

#define  _AND(n)                  _AND_(n);
#define  _ANI(n)                  _ANI_(n);
#define  _ANDP(n)                  _ANDP_(n);
#define  _ANDF(n)                  _ANDF_(n);

#define  _OR(n)                  _OR_(n);
#define  _ORI(n)                  _ORI_(n);
#define  _ORP(n)                  _ORP_(n);
#define  _ORF(n)                  _ORF_(n);

#define  _OUT(n)                  _OUT_(n);
#define  _SET(n)                  _SET_(n);
#define  _RST(n)                  _RST_(n);
#define  _CPL(n)                  _CPL_(n);

#define  _ADD(a,b,c)            _FNC_ADD(a,b,&##c);
#define  _SUB(a,b,c)            _FNC_SUB(a,b,&##c);
#define  _MUL(a,b,c)           _FNC_MUL(a,b,&##c);
#define  _DIV(a,b,c)           _FNC_DIV(a,b,&##c);
#define  _INC(a)                _FNC_INC(&##a);
#define  _DEC(a)                _FNC_DEC(&##a);
#define  _WAND(a,b,c)           _FNC_WAND(a,b,&##c);
#define  _WOR(a,b,c)            _FNC_WOR(a,b,&##c);
#define  _WXOR(a,b,c)           _FNC_WXOR(a,b,&##c);
#define  _NEG(a)                _FNC_NEG(a,&##a);
#define  _ALT(a)                _FNC_ALT(a);
#define  _MOV(a,b)              _FNC_MOV(a,&##b);
#define  _CML(a,b)              _FNC_CML(a,&##b);
#define  _XCH(a,b)              _FNC_XCH(&##a,&##b);
#define  _BCD(a,b)              _FNC_BCD(a,&##b);
#define  _BIN(a,b)              _FNC_BIN(a,&##b);

#define  _OUT_T(a,k)                _OUT_T_(&a,k-1);
#define  _OUT_C(a,k)                _OUT_C_(&a,k-1);
#define  _SET_T(a)                  _SET_T_(&a);
#define  _RST_C(a)                  _RST_C_(&a);

/* 私有函数原型 -----------------------------------------------------*/
__asm void  _START_(void);
__asm void  _END_(void);
__asm void  _NOP_(void);

__asm void  _MPS_(void);
__asm void  _MRD_(void);
__asm void  _MPP_(void);

__asm void  _ANB_(void);
__asm void  _ORB_(void);

__asm void  _INV_(void);
__asm void  _PLS_(u32 nl);
__asm void  _PLF_(u32 nl);

__asm void  _LD_(u32 n);
__asm void  _LDI_(u32 n);
__asm void  _LDP_(u32 n);
__asm void  _LDF_(u32 n);

__asm void  _AND_(u32 n);
__asm void  _ANI_( u32 n);
__asm void  _ANDP_(u32 n);
__asm void  _ANDF_(u32 n);

__asm void  _OR_(u32 n);
__asm void  _ORI_(u32 n);
__asm void  _ORP_(u32 n);
__asm void  _ORF_(u32 n);

__asm void  _OUT_(u32 n);
__asm void  _SET_(u32 n);
__asm void  _RST_(u32 n);
__asm void  _CPL_(u32 n);

__asm void  _LD_GE_( s16 a,  s16 b );
__asm void  _LD_LE_( s16 a,  s16 b );
__asm void  _LD_GT_( s16 a,  s16 b );
__asm void  _LD_LT_( s16 a,  s16 b );
__asm void  _LD_NE_( s16 a,  s16 b );
__asm void  _LD_EQ_( s16 a,  s16 b );

__asm void  _AND_GE_( s16 a,  s16 b );
__asm void  _AND_LE_( s16 a,  s16 b );
__asm void  _AND_GT_( s16 a,  s16 b );
__asm void  _AND_LT_( s16 a,  s16 b );
__asm void  _AND_NE_( s16 a,  s16 b );
__asm void  _AND_EQ_( s16 a,  s16 b );

__asm void  _OR_GE_( s16 a,  s16 b );
__asm void  _OR_LE_( s16 a,  s16 b );
__asm void  _OR_GT_( s16 a,  s16 b );
__asm void  _OR_LT_( s16 a,  s16 b );
__asm void  _OR_NE_( s16 a,  s16 b );
__asm void  _OR_EQ_( s16 a,  s16 b );

__asm void  _FNC_ADD( s16 a, s16 b, s16* c );
__asm void  _FNC_SUB( s16 a, s16 b, s16* c );
__asm void  _FNC_MUL( s16 a, s16 b, s16* c );
__asm void  _FNC_DIV( s16 a, s16 b, s16* c );
__asm void  _FNC_INC( s16*  a);
__asm void  _FNC_DEC( s16*  a);
__asm void  _FNC_WAND( s16 a, s16 b, s16* c );
__asm void  _FNC_WOR( s16 a, s16 b, s16* c );
__asm void  _FNC_WXOR( s16 a, s16 b, s16* c );
__asm void  _FNC_NEG( s16 a, s16*  b);
__asm void  _FNC_MOV( s16 a, s16*  b);
__asm void  _FNC_CML( s16 a, s16*  b);
__asm void  _FNC_XCH( s16*  a, s16*  b);
__asm void  _FNC_BCD( s16 a, s16*  b);
__asm void  _FNC_BIN( s16 a, s16*  b);
__asm u8    _FNC_ALT( u8 a);

__asm void _OUT_T_( s16* a, s16 k );
__asm void _OUT_C_( s16* a, s16 k );
__asm void _RST_T_( s16* a );
__asm void _RST_C_( s16* a );

//-------------------------------------------------------//
// Modbus  数据区分配
//-------------------------------------------------------//
#define S_Size        1024        //  S000-1023        (128 byte) ->0x000-3FF
#define X_Size        256        //  X000-377        (  32 byte) ->0x400-4FF
#define Y_Size        256        //  Y000-377        (  32 byte) ->0x500_5FF
#define T_Size        512        //  C000-511        (  64 byte) ->0x600-7FF
#define M_Size        1536        //  M000-1536        (192 byte) ->0x800-DFF
#define C_Size        256        //  C000-255        (  32 byte) ->0xE00-EFF
#define M8_Size        256        //  M8000-8255        (  32 byte) ->0xF00-FFF       
#define MH_Size        2560        //  M1536-4095        ( 320 byte) ->0xB000-FFF       

#define D_Size        2048        //  
//===========================================================//
// 杂类指令
//===========================================================//
__asm void _START_(void)
{
        //保护现场
        PUSH {R3-R12}

        // 备份栈指针
        MOV R6,SP

        // 上次值偏移地址
        LDR R5, = 512*8*4
        BX    lr  
}

__asm void _END_(void)
{
        // 恢复栈指针
        MOV SP,R6

        // 恢复现场
        POP {R3-R12}
              BX    lr
}

__asm void _NOP_(void)
{
              BX    lr
}

//=====================================//
// 栈指令xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//=====================================//


//=====================================//
// 块指令
//=====================================//
__asm void _ANB_( void )
{
        //  R1 出栈
        POP {R1}
       
        //  R7 <= ( R7 | R1 )
        AND R7,R1
       
              BX    lr
}

__asm void _ORB_( void )
{
        //  R1 出栈
        POP {R1}
       
        //  R7 <= ( R7 | R1 )
        ORR R7,R1
       
              BX    lr
}

//=====================================//
// 输出预处理指令
//=====================================//
__asm void _INV_( void )
{
        // R7 <= !R7
        EOR R7,R7,#1
       
              BX    lr
}

__asm void _PLS_( u32 nl )
{
        // R7 <=  (R7 ^ nl) & n
        MOV R1,R7
        LDR R2,[R0]
        EOR R7,R2
        AND R7,R1

              BX    lr
}

__asm void _PLF_( u32 nl )
{
        // R7 <=  (R7 ^ nl) & nl
        LDR R1,[R0]
        EOR R7,R1
        AND R7,R1

              BX    lr
}

//=====================================//
// 接入指令
//=====================================//
__asm void _LD_( u32 n)
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  n
        LDR R7,[R0]

              BX    lr
}

__asm void _LDI_( u32 n)
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  !R0
        LDR R1,[R0]
        EOR R7,R1,#1

              BX    lr
}

__asm void _LDP_( u32 n)
{

        // R7 压栈
        PUSH {R7}
       
        // R7 <=  (n ^ nl) & n
        LDR R1,[R0]
        LDR R7,[R0,R5]
        EOR R7,R1
        AND R7,R1

              BX    lr
}

__asm void _LDF_( u32 n)
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  (n ^ nl) & nl
        LDR R7,[R0]
        LDR R1,[R0,R5]
        EOR R7,R1
        AND R7,R1

              BX    lr
}

//=====================================//
// 串联指令
//=====================================//
__asm void _AND_( u32 n)
{
        //  R7 <= ( R7 & n )
        LDR R1,[R0]
        AND R7, R1
       
              BX    lr
}

__asm void _ANI_( u32 n)
{
        //  R7 <= ( R7 & (!R0) )
        LDR R1,[R0]
        EOR R2,R1,#1
        AND R7,R2
       
              BX    lr
}

__asm void _ANDP_( u32 n)
{
        // R2 <=  (n ^ nl) & n
        LDR R1,[R0]
        LDR R2,[R0,R5]
        EOR R2,R1
        AND R2,R1

        //  R7 <= ( R7 & R2 )
        AND R7,R2
       
              BX    lr
}

__asm void _ANDF_( u32 n)
{
        // R2 <=  (n ^ nl) & nl
        LDR R2,[R0]
        LDR R1,[R0,R5]
        EOR R2,R1
        AND R2,R1

        //  R7 <= ( R7 & R2 )
        AND R7,R2
       
              BX    lr
}

//=====================================//
// 并联指令
//=====================================//
__asm void _OR_( u32 n)
{
        //  R7 <= ( R7 | R0 )
        LDR R1,[R0]
        ORR R7,R1
       
              BX    lr
}

__asm void _ORI_( u32 n)
{
        //  R7 <= ( R7 | (!R0) )
        LDR R1,[R0]
        EOR R2,R1,#1
        ORR R7,R2
       
              BX    lr
}

__asm void _ORP_( u32 n)
{
        // R2 <=  (n ^ nl) & n
        LDR R1,[R0]
        LDR R2,[R0,R5]
        EOR R2,R1
        AND R2,R1

        //  R7 <= ( R7 & R2 )
        ORR R7,R2
       
              BX    lr
}

__asm void _ORF_( u32 n)
{
        // R2 <=  (n ^ nl) & nl
        LDR R2,[R0]
        LDR R1,[R0,R5]
        EOR R2,R1
        AND R2,R1

        //  R7 <= ( R7 & R2 )
        ORR R7,R2
       
              BX    lr
}

//=====================================//
// 输出指令
//=====================================//
__asm void _OUT_( u32 n)
{
        // 恢复栈指针
        MOV SP,R6
       
        //  n <= R7
        STR R7,[R0]

              BX    lr
}

__asm void _SET_( u32 n)
{
        // 恢复栈指针
        MOV SP,R6
       
        //  n <= ( R7 | n )
        LDR R1,[R0]
        ORR R1,R7
        STR R1,[R0]
       
              BX    lr
}

__asm void _RST_( u32 n)
{
        // 恢复栈指针
        MOV SP,R6
       
        //  n <= ( R7 & (!n) )
        LDR R1,[R0]
        BIC R1,R7
        STR R1,[R0]
       
              BX    lr
}

__asm void _CPL_( u32 n)
{
        // 恢复栈指针
        MOV SP,R6
       
        //  n <= ( R7 ^ n )
        LDR R1,[R0]
        EOR R1,R7       
        STR R1,[R0]
       
              BX    lr
}

//=====================================//
// 比较指令
//=====================================//
__asm void _LD_GE_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  ( a>=b )
        CMP R0,R1
        ITE        GE
        MOVGE R7,#1
        MOVLT R7,#0
              BX    lr
}

__asm void _LD_LE_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  ( a<=b )
        CMP R0,R1
        ITE        LE       
        MOVLE R7,#1
        MOVGT R7,#0
              BX    lr
}

__asm void _LD_GT_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  ( a>b )
        CMP R0,R1
        ITE        GT
        MOVGT R7,#1
        MOVLE R7,#0
              BX    lr
}

__asm void _LD_LT_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R0 <=  ( a<b )
        ITE        LT
        MOVLT R7,#1
        MOVGE R7,#0
              BX    lr
}

__asm void _LD_NE_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  ( a==b )
        CMP R0,R1
        ITE        NE
        MOVNE R7,#1
        MOVEQ R7,#0
              BX    lr
}

__asm void _LD_EQ_( s16 a, s16 b )
{
        // R7 压栈
        PUSH {R7}
       
        // R7 <=  ( a!=b )
        CMP R0,R1
        ITE        EQ
        MOVEQ R7,#1
        MOVNE R7,#0
              BX    lr
}

__asm void _AND_GE_( s16 a, s16 b )
{
        // R7 &=  ( a>=b )
        CMP R0,R1
        ITE        GE
        ANDGE R7,#1
        ANDLT R7,#0
              BX    lr
}

__asm void _AND_LE_( s16 a, s16 b )
{
        // R7 &=  ( a<=b )
        CMP R0,R1
        ITE        LE       
        ANDLE R7,#1
        ANDGT R7,#0
              BX    lr
}

__asm void _AND_GT_( s16 a, s16 b )
{
        // R7 &=  ( a>b )
        CMP R0,R1
        ITE        GT       
        MOVGT R7,#1
        MOVLE R7,#0
              BX    lr
}

__asm void _AND_LT_( s16 a, s16 b )
{
        // R7 &=  ( a<b )
        CMP R0,R1
        ITE        LT       
        MOVLT R7,#1
        MOVGE R7,#0
              BX    lr
}

__asm void _AND_NE_( s16 a, s16 b )
{
        // R7 &=  ( a==b )
        CMP R0,R1
        ITE        NE       
        MOVNE R7,#1
        MOVEQ R7,#0
              BX    lr
}

__asm void _AND_EQ_( s16 a, s16 b )
{
        // R7 &=  ( a!=b )
        CMP R0,R1
        ITE        EQ       
        MOVEQ R7,#1
        MOVNE R7,#0
              BX    lr
}

__asm void _OR_GE_( s16 a, s16 b )
{
        // R7 |=  ( a>=b )
        CMP R0,R1
        ITE        GE
        ORRGE R7,#1
        ORRLT R7,#0
              BX    lr
}

__asm void _OR_LE_( s16 a, s16 b )
{
        // R7 |=  ( a<=b )
        CMP R0,R1
        ITE        LE       
        ORRLE R7,#1
        ORRGT R7,#0
              BX    lr
}

__asm void _OR_GT_( s16 a, s16 b )
{
        // R7 |=  ( a>b )
        CMP R0,R1
        ITE        GT       
        MOVGT R7,#1
        MOVLE R7,#0
              BX    lr
}

__asm void _OR_LT_( s16 a, s16 b )
{
        // R7 |=  ( a<b )
        CMP R0,R1
        ITE        LT       
        MOVLT R7,#1
        MOVGE R7,#0
              BX    lr
}

__asm void _OR_NE_( s16 a, s16 b )
{
        // R7 |=  ( a==b )
        CMP R0,R1
        ITE        NE       
        MOVNE R7,#1
        MOVEQ R7,#0
              BX    lr
}

__asm void _OR_EQ_( s16 a, s16 b )
{
        // R7 |=  ( a!=b )
        CMP R0,R1
        ITE        EQ       
        MOVEQ R7,#1
        MOVNE R7,#0
              BX    lr
}

//=====================================//
// 运算指令指令
//=====================================//
__asm void _FNC_ADD(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*c = a + b
        TST R7,#1
        ITT        NE       
        ADDNE         R0,R1       
        STRHNE         R0,[R2]
        BX    lr
}

__asm void _FNC_SUB(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*c = a - b
        TST R7,#1
        ITT        NE       
        SUBNE         R0,R1       
        STRHNE         R0,[R2]
        BX    lr
}

__asm void _FNC_MUL(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6


        // 检查R7 == 1  则*c = a * b
        TST R7,#1
        ITT        NE       
        MULNE         R0,R1       
        STRHNE         R0,[R2]
        BX    lr
}

__asm void _FNC_DIV(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6


        // 检查R7 == 1  则*c = a / b
        TST R7,#1
        ITT        NE       
        SDIVNE         R0,R1       
        STRHNE         R0,[R2]
        BX    lr
}

__asm void _FNC_INC(s16* a)
{
        // 恢复栈指针
        MOV SP,R6


        // 检查R7 == 1  则*a = a++
        TST R7,#1
        ITTT NE       
        LDRHNE         R1,[R0]
        ADDNE         R1,#1       
        STRHNE         R1,[R0]
        BX    lr
}

__asm void _FNC_DEC(s16* a)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*a = a--
        TST R7,#1
        ITTT NE       
        LDRHNE         R1,[R0]
        SUBNE         R1,#1       
        STRHNE         R1,[R0]
        BX    lr
}

__asm void _FNC_WAND(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*c = a & b
        TST R7,#1
        ITT NE       
        ANDNE         R1,R0
        STRHNE         R1,[R2]
        BX    lr
}

__asm void _FNC_WOR(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*c = a | b
        TST R7,#1
        ITT NE       
        ORRNE         R1,R0
        STRHNE         R1,[R2]
        BX    lr
}

__asm void _FNC_WXOR(s16 a, s16 b, s16* c)
{
        // 恢复栈指针
        MOV SP,R6
       
        // 检查R7 == 1  则*c = a ^ b
        TST R7,#1
        ITT NE       
        EORNE         R1,R0
        STRHNE         R1,[R2]
        BX    lr
}

__asm void _FNC_NEG(s16 a, s16* b)
{
       
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*b = ~a +1
        TST R7,#1
        ITT NE       
        ANDNE         R2,R0
        STRHNE         R2,[R1]
        BX    lr
}

__asm void _FNC_MOV(s16 a, s16* b)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*b = a
        TST R7,#1
        IT NE       
        STRHNE         R0,[R1]
        BX    lr
}

__asm void _FNC_CML(s16 a, s16* b)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则*b = ~a;;
        TST R7,#1
        ITT NE       
        MVNNE         R2,R0
        STRHNE         R2,[R1]
        BX    lr
}

__asm void _FNC_XCH(s16* a, s16* b)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则
        TST R7,#1
        ITTTT NE       
        LDRHNE         R2,[R0]
        LDRHNE         R3,[R1]
        STRHNE         R3,[R0]
        STRHNE         R2,[R1]
        BX    lr
}

__asm void _FNC_BCD(s16 a, s16* b)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则
        TST R7,#1
        ITTTT NE       
        LDRHNE         R2,[R0]
        LDRHNE         R3,[R1]
        STRHNE         R3,[R0]
        STRHNE         R2,[R1]
        BX    lr
}

__asm void _FNC_BIN(s16 a, s16* b)
{
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则
        TST R7,#1
        ITTTT NE       
        LDRHNE         R2,[R0]
        LDRHNE         R3,[R1]
        STRHNE         R3,[R0]
        STRHNE         R2,[R1]
        BX    lr
}

__asm u8 _FNC_ALT(u8 a)
{
       
        // 恢复栈指针
        MOV SP,R6

        // 检查R7 == 1  则
        TST R7,#1
        ITT NE       
        MVNNE         R0,R0
        ANDNE         R0,#1
        BX    lr
}

//=====================================//
// 定时器指令
//=====================================//
__asm void _OUT_T_( s16* a, s16 k )
{
        // 恢复栈指针
        MOV SP,R6
       
        // 检查R7 == 0  则TCnt =0 ,  Tn =0
        TST                 R7,#1
        ITT                 EQ
        MOVEQ        R2,#0
        BEQ         _MOV_C_

        // 检查R7 == 1  
        // *a >= K ?
        LDRSH         R2,[R0]
        CMP         R1,R2
        ITT                 GE
        MOVGE        R2,#1                // Y, Tn =1
        BGE         _MOV_C_
        ADDLT         R2,#1                // N, TCnt  计时
        STRHLT         R2,[R0]
              BX    lr
}

__asm void _OUT_C_( s16* a, s16 k )
{
        // 恢复栈指针
        MOV SP,R6
       
        // 检查R7 == 0  则返回
        TST                 R7,#1
        IT                 EQ
        BXEQ        lr

        // 检查R7 == 1  
        // *a >= K ?
        LDRSH         R2,[R0]
        CMP         R2,R1
        ITTEE         GE
        MOVGE        R2,#1                // Y, Tn =1
        BGE         _MOV_C_
        ADDLT         R2,#1                // N,TCnt++
        STRHLT         R2,[R0]
              BX    lr
}

__asm void _RST_T_( s16* a )
{
        // 恢复栈指针
        MOV SP,R6
       
        // 检查R7 == 1  则TCnt =0
        TST                 R7,#1
        ITTE         NE
        MOVNE        R2,#0
        STRHNE         R2,[R0]
        BXEQ            lr
}
       
__asm void _MOV_T_( s16* a)
{
        // Tn =0
        MOV32         R3, # ABS_ADR_TCnt
        SUB         R0,R3
        LSL                 R0,#1
        MOV32         R3, # ABS_ADR_T_BB
        STRH         R2,[R3,R0]
              BX    lr
}

__asm void _RST_C_( s16* a )
{
        // 恢复栈指针
        MOV SP,R6
       
        // 检查R7 == 1  则CCnt =0
        TST                 R7,#1
        ITTE         NE
        MOVNE        R2,#0
        STRHNE         R2,[R0]
        BXEQ            lr
}

__asm void _MOV_C_( s16* a)
{
        //  Cn =0
        MOV32         R3, # ABS_ADR_CCnt
        SUB         R0,R3
        LSL                 R0,#1
        MOV32         R3, # ABS_ADR_C_BB
        STRH         R2,[R3,R0]
              BX    lr
}

阿莫论坛20周年了！感谢大家的支持与爱护！！

为众人抱薪者，不可使其冻毙于风雪。阿莫呼吁大家支持谭秦东医生！订单留言里面请备注：阿莫电子论坛，支持谭医生！
回复

   举报本楼层   

21ele

出0入0汤圆
 楼主| 发表于 2009-8-3 14:41:12 | 显示全部楼层
考虑到将来为了实现plc内部编译执行，已经将资源绝对定位，再将实现指令功能的汇编子程序定位，就可通过简单固定的几条汇编指令实现单步指令。只要研究下机器码中操作数的位置和存放方式，编写程序替换即可。下位plc编译执行的plc实现指日可待。
回复

   举报本楼层   

heky

出0入0汤圆
发表于 2009-8-3 15:17:12 | 显示全部楼层
这个开发速度太慢了，稳定性也没法保证啊。
回复

   举报本楼层   

cqfeiyu

出0入0汤圆
发表于 2009-8-3 23:43:47 | 显示全部楼层
顶一下,希望早日成功,期待开源
回复

   举报本楼层   

4758866

出0入0汤圆
发表于 2009-8-4 00:02:40 | 显示全部楼层
不知能解决组和位元件吗？
回复

   举报本楼层   

21ele

出0入0汤圆
 楼主| 发表于 2009-8-4 09:08:37 | 显示全部楼层
组和位元件舒是指什么？ 基本上大部分指令都可以实现。只是在汇编中调用C没有成功，所以对于一些特别复杂的指令，需要用C的复杂呀运算比如浮点，或pid什么的不好弄。但是即使不可以调用，也可以先执行一条汇编，执行一条C函数来变相替代。关键是要搞清楚调用的参数和返回值的传递办法，就是R0,R1,R2，就都可以搞定了。
回复

   举报本楼层   

gpfrank

出0入0汤圆
发表于 2011-1-19 11:41:38 | 显示全部楼层
mark
回复

   举报本楼层   

jianchangd

出0入0汤圆
发表于 2011-1-23 13:30:02 | 显示全部楼层
mark
回复

   举报本楼层   

freebird

出0入0汤圆
发表于 2012-4-18 11:55:45 | 显示全部楼层
好东西，最近在研究ARM的C语言和汇编，研究下你的程序。
回复

   举报本楼层   

mvpican

出0入0汤圆
发表于 2012-7-8 20:00:23 | 显示全部楼层
标记一下，楼主辛苦
回复

   举报本楼层   

depv

出0入0汤圆
发表于 2013-2-17 20:26:07 | 显示全部楼层
Thanks for sharing!
回复

   举报本楼层   

szmachine

出0入0汤圆
发表于 2013-3-27 14:21:25 | 显示全部楼层
这样的话，编程就很灵活了，就不知道能不能发脉冲！
回复

   举报本楼层   

wtliu

出0入0汤圆
发表于 2013-11-27 22:31:04 | 显示全部楼层
最近在研究三菱PLC
回复

   举报本楼层   

goldrained

出0入0汤圆
发表于 2013-11-28 00:36:59 | 显示全部楼层
顶一下！！！
回复

   举报本楼层   

XFZH999

出0入0汤圆
发表于 2014-1-2 21:29:50 | 显示全部楼层
这一定要顶
回复

   举报本楼层   

lgtomlgam

出0入0汤圆
发表于 2014-4-29 11:22:24 | 显示全部楼层
真是很大的贡献，好！
回复

   举报本楼层   

wenchm2015

出0入0汤圆
发表于 2015-9-16 15:14:38 | 显示全部楼层
一个好帖，顶
回复

   举报本楼层   

wenchm2015

出0入0汤圆
发表于 2015-9-17 13:36:52 | 显示全部楼层
楼主的工作十分有用，但是公布的代码不全吧？能否全部公布出来？
回复

   举报本楼层   

AsuMotion

出0入0汤圆
发表于 2016-8-17 09:13:42 | 显示全部楼层
牛牛 哈哈哈！
回复

   举报本楼层   

qm9698

出0入0汤圆
发表于 2016-8-17 12:54:59 | 显示全部楼层
牛，源码呢！
回复

   举报本楼层   

返回列表 发新帖
回帖提示： 反政府言论将被立即封锁ID 。在按“提交”前，请自问一下：我这样表达会给举报吗，会给自己惹麻烦吗？ 另外：尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片，浪费大家下载带宽和论坛服务器空间，请压缩后（图片小于1兆）才上传。压缩方法可以在微信里面发给自己（不要勾选“原图），然后下载，就能得到压缩后的图片】。另外，手机版只能上传图片，要上传附件需要切换到电脑版（不需要使用电脑，手机上切换到电脑版就行，页面底部）。
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有：东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案：44190002001997 ) )

GMT+8, 2024-4-19 15:05

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表