moto-an and BiBi,
Thank you for your input. I think we're closer to an answer.
I changed the main() code to include two 'framing' toggles.
- When the for(;;) is first executed (P0.0)
- When the if(systick - systick_prev) >= VDAC_STEP_TIME is true (P3.0)
int main(void)
{
CySysTickStart();
CySysTickSetCallback(0, &systick_isr);
CyGlobalIntEnable; /* Enable global interrupts. */
for(;;)
{
static tog = 0;
*(reg8 *)CYREG_PRT0_DR = tog;
tog = ~tog;
/* process virtual Tasks */
{
if((systick - systick_prev) >= VDAC_STEP_TIME)
{
static toggle = 0x00;
systick_prev = systick;
*(reg8 *)CYREG_PRT3_DR = toggle;
toggle = ~toggle;
}
}
}
}
As you can see from the scope plots, the if() toggles at 3 ms and then 7 ms ... repeat.
The for() toggle occurs every ~7us. So the (systick - systick_prev) >= VDAC_STEP_TIME uint32 processing is a fraction of 7us. The longer delay to the 7us toggle is due to the systick processing which occurs every 1 ms.
I'm confident that although it takes longer to process uint32 data for the compare, it's less than 7us.
When I take BiBi's suggestion of framing the CyGlobalIntDisable()/CyGlobalIntEnable() around the if() conditional, I consistently get the 300 ms toggle of the if() as intended!!!
/*************************************************************************************/
int main(void)
{
CySysTickStart();
CySysTickSetCallback(0, &systick_isr);
CyGlobalIntEnable; /* Enable global interrupts. */
for(;;)
{
static tog = 0;
*(reg8 *)CYREG_PRT0_DR = tog;
tog = ~tog;
/* process virtual Tasks */
{
CyGlobalIntDisable; /* Enable global interrupts. */
if((systick - systick_prev) >= VDAC_STEP_TIME)
{
static toggle = 0x00;
systick_prev = systick;
*(reg8 *)CYREG_PRT3_DR = toggle;
toggle = ~toggle;
}
CyGlobalIntEnable; /* Enable global interrupts. */
}
}
}
Why is the CyGlobalIntDisable()/CyGlobalIntEnable() framing working?
I disassembled the code and found a routine called ?C?ULCMP
It
0x000001A0 mov a, r3 ; VDAC_STEP_TIME[3] -> a
0x000001A1 subb a, r7 ; (systick[3]-systick_prev[3]) - a -> a
0x000001A2 mov b, a ; a -> b
0x000001A4 mov a, r2 ; VDAC_STEP_TIME[2] -> a
0x000001A5 subb a, r6 ; (systick[2]-systick_prev[2]) - a -> a
0x000001A6 orl b, a ; (a | b) -> b
0x000001A8 mov a, r1 ; VDAC_STEP_TIME[1] -> a
0x000001A9 subb a, r5 ; (systick[1]-systick_prev[1]) - a -> a
0x000001AA orl b, a ; (a | b) -> b
0x000001AC mov a, r0 ; VDAC_STEP_TIME[0] -> a
0x000001AD subb a, r4 ; (systick[0]-systick_prev[0]) - a -> a
0x000001AE orl a, b ; (a | b) -> b
0x000001B0 ret
I discerned:
if b == 0 then (systick-systick_prev) == VDAC_STEP_TIME
if C == 1 then (systick-systick_prev) > VDAC_STEP_TIME
Here is the disassembled code for the if() conditional:
; SOURCE LINE # 51
004D 900000 R MOV DPTR,#systick_prev ; move the ptr to systick_prev
0050 120000 E LCALL ?C?LLDXDATA0 ; long load of systick_prev into 4 registers
0053 900000 R MOV DPTR,#systick ; move the ptr to systick
0056 120000 E LCALL ?C?LLDXDATA ; long load of systick into 4 registers
0059 120000 E LCALL ?C?LSUB ; long subtract (systick - systick_prev)
005C 7B2C MOV R3,#02CH ; moving 300 (ms) into registers
005E 7A01 MOV R2,#01H
0060 7900 MOV R1,#00H
0062 7800 MOV R0,#00H
0064 D3 SETB C ; set the 'C' flag
0065 120000 E LCALL ?C?ULCMP ; Here is the long compare routine
0068 502F JNC ?C0004 ; This is the jump around if the carry flag 'C' is not set
; SOURCE LINE # 52
You can see that the 'C' flag is the only flag being checked to determine that the if() condition is true or not.
I suspect since the CyGlobalIntDisable()/CyGlobalIntEnable() works, that without this interrupt disabling the systick processing changes the 'C' flag to the WRONG state which causes the if() to be true at the wrong times.
It is my opinion that there is something wrong with the compiler or worse the CPU microcode. Normally during interrupt processing, the CPU registers are pushed on the stack entering the interrupt and pulled from the stack when exiting. This includes the CPU flag registers.
Here is the disassembled code of the systick isr:
; FUNCTION systick_isr (BEGIN)
0000 C0E0 PUSH ACC
0002 C0F0 PUSH B
0004 C083 PUSH DPH
0006 C082 PUSH DPL
0008 C085 PUSH DPH1
000A C084 PUSH DPL1
000C C086 PUSH DPS
000E 758600 MOV DPS,#00H
0011 C000 E PUSH ?C?XPAGE1SFR
0013 750000 E MOV ?C?XPAGE1SFR,#?C?XPAGE1RST
0016 C0D0 PUSH PSW
0018 75D000 MOV PSW,#00H
001B C000 PUSH AR0
001D C001 PUSH AR1
001F C002 PUSH AR2
0021 C003 PUSH AR3
0023 C004 PUSH AR4
0025 C005 PUSH AR5
0027 C006 PUSH AR6
0029 C007 PUSH AR7
; SOURCE LINE # 28
; SOURCE LINE # 30
002B 900000 R MOV DPTR,#systick
002E 120000 E LCALL ?C?LLDXDATA
0031 7B01 MOV R3,#01H
0033 7A00 MOV R2,#00H
0035 7900 MOV R1,#00H
0037 7800 MOV R0,#00H
0039 120000 E LCALL ?C?LADD
003C 900000 R MOV DPTR,#systick
003F 120000 E LCALL ?C?LSTXDATA
; SOURCE LINE # 31
0042 D007 POP AR7
0044 D006 POP AR6
0046 D005 POP AR5
0048 D004 POP AR4
004A D003 POP AR3
004C D002 POP AR2
004E D001 POP AR1
0050 D000 POP AR0
0052 D0D0 POP PSW
0054 D000 E POP ?C?XPAGE1SFR
0056 D086 POP DPS
0058 D084 POP DPL1
005A D085 POP DPH1
005C D082 POP DPL
005E D083 POP DPH
0060 D0F0 POP B
0062 D0E0 POP ACC
0064 32 RETI
; FUNCTION systick_isr (END)
I don't recognize the CPU flag register in the PUSHs or PULLs.
moto-san,
Thank you for the kind holiday wishes.
The issue I caused because of the differences in how the Keil DP8051 compiler treats interrupts compared to the GCC ARM compiler.
In my implementation, I used a 1KHz clock with a period of 1ms to drive an ISR.
My error is that when I initialized the CySysTick_isr with the pointer to CySysTickServiceCallbacks() I didn't assign it to CY_ISR().
(void) CySysTick_isr_StartEx(&CySysTickServiceCallbacks); /* init the
...
}
On the GCC ARM compiler, you don't need to.
However, on the Keil compiler you need to add the 'interrupt' keyword at the end of the function declaration. This is done by using the CY_ISR() assignment to the function.
Here's the CY_ISR() declaration:
#define CY_ISR(FuncName) void FuncName (void) interrupt 0
With the 'interrupt' keyword, the beginning of the function is coded to push the current PC registers to the stack. On return from the function, the registers are pulled back into the registers and finally ends with a RETI instead of an RET.
When I didn't use CY_ISR(CySysTickServiceCallbacks) it didn't push and pull registers or perform an RETI. Therefore the previous CPU state was not preserved on the CycSysTick_isr event losing the state of the 'C' flag for the if() conditional.
I also changed the systick_isr() from an CY_ISR() to just a function declaration for use with the CySysTickSetCallback(0, &systick_isr) call.
I see from your previous posts, you like challenges.
I have a couple more PSoC3 build issues if you're interested:
PSoC3-reentrant-issue-I-get-a-build-error
Keil-Issue-Receiving-L15-warning-from-Linker
I think the if() statement is relatively safe. As safe as any statement that performs a comparison.
I've found in my long engineering career that once you think you've conquered all the 'bugs' in a design, 90% of the remaining problems are asynchronous in nature where race conditions are the biggest culprits.
