|
//-------------------------------------------------------//
// 基本指令,扩展指令 宏定义
//-------------------------------------------------------//
#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周年了!感谢大家的支持与爱护!!
你熬了10碗粥,别人一桶水倒进去,淘走90碗,剩下10碗给你,你看似没亏,其实你那10碗已经没有之前的裹腹了,人家的一桶水换90碗,继续卖。说白了,通货膨胀就是,你的钱是挣来的,他的钱是印来的,掺和在一起,你的钱就贬值了。
|