8-bit MicrocontrollersのトピックRe: HCS08C: Software watchdog and detecting last routine

HCS08C: Software watchdog and detecting last routine

BasePointer — Mon, 24 Mar 2008 13:46:13 GMT

Hi,

I'm using software watchdog method and internal COP unit.

I want to detect when the reset was occured (which line of my main routine) without using BDM.

I'm not sure this is possible for COP but I thing it is possible for software watchdog.

Code:

void main(void){  ..  ..  while(1) // main loop  {    SOFTWARE_WATCHDOG = 0; // clear soft watchdog    func1();    func2();    func3();    func4();    func5();  }}interrupt VectorNumber_Vtpm1ovf void intTPM1OVF(void){  TPM1SC_TOF = 0;   // software watchdog for 5sec  if(++SOFTWARE_WATCHDOG > 200) asm("dcb 0x8D"); // illegal opcode  ...}

Can I save interrupt return address to a register before executing illegal opcode? How can I obtain this address in interrupt routine?

Is there any way to detect similar address that COP reset was occured?

Thanks,

BP.

Re: HCS08C: Software watchdog and detecting last routine

bigmac — Mon, 24 Mar 2008 16:30:01 GMT

Hello BP,

I assume that you wish to store the previous PC address reached prior to the ISR being entered. This is directly available from the stack.

word PC_location @0x0100; // Non-initialised global variable

#pragma NO_ENTRY

#pragma NO_EXIT

#pragma NO_FRAME

interrupt VectorNumber_Vtpm1ovf void intTPM1OVF(void)
{
__asm pshh;

TPM1SC_TOF = 0;

// software watchdog for 5sec
if(++SOFTWARE_WATCHDOG > 200) {

__asm ldhx 5,sp; // Return address on stack

__asm sthx PC_location;

__asm ("dcb 0x8D" ); // Illegal opcode reset

}

__asm pulh;
}

Note that the global variable must not undergo ANSI initialisation.

This method relies on the TPM module remaining operational. If this were to cease for any reason, the COP timeout would fail. Perhaps you might additionally use the normal COP module to protect against this event, and add a COP reset within the ISR.

Regards,

Mac

Message Edited by bigmac on 2008-03-24 08:55 PM

Re: HCS08C: Software watchdog and detecting last routine

Denn — Mon, 24 Mar 2008 17:43:15 GMT

Hello Mac,

Once the reset has occured, I feel PC_location @0x0100 would be reset to 0x00 since its in the RAM.To save Program Counter content before a reset (SW reset- before ilegal opcode), I feel one can write into non-volatile memory rather than in RAM space.

Regards,

Denn.

Re: HCS08C: Software watchdog and detecting last routine

BasePointer — Mon, 24 Mar 2008 18:48:13 GMT

Hi Mac,

That is exactly what I want to do.

I will store PC_Counter in NO_INIT area to prevent ansi-c initialization at start-up. This is OK.

Actually, my timer1 overflow interrupt routine is a little bit more complex than I implemented before.

If I declare a new local variables in the ISR routine, will your implementation change?

I didn't understand assembler codes that you used at all. Isn't there a C way?

I also wonder about your pragma directives NO_ENTRY, NO_EXIT, NO_FRAME. They may be a problem for my routine?

Code:

interrupt VectorNumber_Vtpm1ovf void intTPM1OVF(void){  char tmp_button_menu, tmp_button;    TPM1SC_TOF = 0;    ++counter_25ms;  ++seq_timeout;    if(++SOFTWARE_WATCHDOG > 200) asm("dcb 0x8D"); // illegal opcode  ...  ...  func1();  func5(&ptr, func2());  ...  ...}

I'm also using COP module as additional to soft method. But not using it like you suggested.

It seems as if it was more functional than my method. I will think it.

10x,

BP.

Re: HCS08C: Software watchdog and detecting last routine

Denn — Mon, 24 Mar 2008 20:26:52 GMT

Hi BP,

Code:

interrupt VectorNumber_Vtpm1ovf void intTPM1OVF(void){  __asm pshh;  TPM1SC_TOF = 0;  // software watchdog for 5sec  if(++SOFTWARE_WATCHDOG > 200) {    __asm ldhx 5,sp;     // Return address on stack    __asm sthx PC_location;    __asm ("dcb 0x8D" ); // Illegal opcode reset  }  __asm pulh;}

Macs ISR is right. Once the ISR is entered Stack Pointer is decremented by 5 counts(5 bytes automatically pushed by MCU in the order of PCL,PCH,Index Reg- X,Accumulator and finally Condition Code Register CCR. Refer figure "Interrupt stack frame" in datasheet

You can see he is pushing Index Reg- H. Its necessary because the CPU register H contents will be lost if not saved after it starts executing the code after returning from ISR.Normally compilers take care of pushing H register .If its not doing then programmer has to do it.

SP(afetr interrupt)--> SP( before interrupt)+6 after this push H

Since you wanted the address of the code in main function to be stored before the reset he is taking the contents of PC from the stack.It is located in location SP( before interrupt)-1 location

__asm ldhx 5,sp; // Return address on stack
here he is loading H:X register with the contents of location pointed by [SP+5] which is nothing but PCH : PCL in the stack.

__asm sthx PC_location;

Next he is storing the contents of H:X to the locationPC_location.Now PC_location contains the PC value(16 bit program memory address executed just before the interrupt has come)

BasePointer wrote:
If I declare a new local variables in the ISR routine, will your implementation change?

Yes it will change in terms of stack usage. You need to change line __asm ldhx 5,sp; // Return address on stack

If you are using 2 local variables then offset in the above line is incremented by 2

i.e. __asm ldhx 7,sp;

Thats all.

I really doubt you can implement these on C because here one needs to touch CPU registers and that could be done only by assembly language.

Regards,

Denn.

Re: HCS08C: Software watchdog and detecting last routine

JimDon — Mon, 24 Mar 2008 22:16:47 GMT

You should have no troubles doing this in "C".
Make the local variable static, so it is just in ram, not on the stack.
This is not a re-entrant routine so this should not be a problem.

Re: HCS08C: Software watchdog and detecting last routine

bigmac — Tue, 25 Mar 2008 02:05:29 GMT

Hello BP,

With the method that I proposed, this requires that the address be read directly from the contents of the stack. Therefore the exact position of the address on the stack needs to be totally predictable. The purposed of the pragmas is to prevent the compiler from manipulating the stack of its own accord, which would affect the stack position read if it were to do so. I don't know of any alternative to the use of inline assembly.

Any variables referenced by the ISR should be either global or static so that they will not utilize the stack. Even if local variables were to be declared after the address value was read, the presence of the pragmas would mean that the stack pointer would require to be manually adjusted at the conclusion of the ISR. To avoid this complication is is better to use variables that do not use the stack.

I would probably do the timeout test first, when the ISR was first entered, and then continue with the other requirements of the ISR.

Regards,

Mac

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 12:35:18 GMT

Hello Jim,

JimDon wrote:
You should have no troubles doing this in "C".

How will you read the contents of stack (we are interested in Program counter -PC values )in "C" ?

JimDon wrote:
Make the local variable static, so it is just in ram, not on the stack.
This is not a re-entrant routine so this should not be a problem.

When one can acheive the objective by using local variables, why try unnessarily put variables in RAM by making it as static.

All one needs to do is increment the offset by the number of local variables used in the ISR.

__asm ldhx offset,sp; // offset=5+(number of local variables used in ISR.)

In our case Offset=5+2=7

Hello Mac,

Isn't storing the contents of PC to non-volatile memory location(flash or any other nonvolatile memory) necessary rather than RAM (0x100)before reset ?

Regards,

Denn.

Edit- Bold font size

Message Edited by Denn*** on 2008-03-25 05:48 AM

Re: HCS08C: Software watchdog and detecting last routine

CompilerGuru — Tue, 25 Mar 2008 14:10:39 GMT

I would just use Macs routine as it is, with all the #pragmas ahead and add a single function call to a C-only routine after the return address has been assigned in inline assembly.
Probably counting the locals and adding that as offset works too, but you can never be really sure, as the compiler will eventually not allocate some locals if they are not actually accessed on the stack, and the compiler may also allocate more space for temporaries. So placing the C code into a function of their own avoids all such problems. Using statics instead of locals causes that the memory of those variables is not shared, also I prefer to use stack space even for such special functions (or main, or functions which do not return, or..).
Anyway, what is best probably also depends on how much else there is to do in C and if you can do that in assembly too.
If you are storing the found PC in RAM or in flash depends on what you do with it. Storing it in a variable allocated in a NO_INIT segment is good enough to have it available after the next reset. If it has to be available even after unplugging the power, then store it in flash, but I doubt that this is really necessary.

Daniel

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 16:01:16 GMT

Hello Mac,

Sorry !!! The RAM data is lost only after POR/LVD resets. We are looking for PC values stored(in RAM) after an illegal opcode reset.

Datasheet says "At power-on, the contents of RAM are uninitialized. RAM data is unaffected by any reset provided that the supply voltage does not drop below the minimum value for RAM retention."

Hello Daniel,

You are right when you say unused local variables doesnot get stored in stack.They are simply ignored by the compiler.

CompilerGuru wrote:
the compiler may also allocate more space for temporaries.

But why do compiler assign more memory in stack in case of local variable ? I think the memory allocated for locals is deteministic.

Best Regards,

Denn

Re: HCS08C: Software watchdog and detecting last routine

BasePointer — Tue, 25 Mar 2008 16:06:57 GMT

Hi,

I found the PC return address in stack by debuging it. If I add or remove a local variable to the routine, place of the address is changing. I have to take care that, before changing the routine.

Code:

interrupt VectorNumber_Vtpm1ovf void intTPM1OVF(void){  // timer1 overflow interrupt routine  char val1, val2;    TPM1SC_TOF = 0;    ++counter_25ms;  ++seq_timeout;    if(++SOFTWARE_WATCHDOG > 200)   {    NV.Statistic.LAST_PROGRAM_COUNTER = *(unsigned int*)(&val2 + 6);    asm("dcb 0x8D"); // illegal opcode  }...

Thank you so much for the helps!

BP.

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 16:28:06 GMT

Hello BP,

Glad to see that you fixed the problem.

But make sure that Index register is pushed to the stack at the entry of ISR(similarly popped from stack at exit of ISR) by the compiler.If itsnot doing then you need to do that manually as in Mac's ISR.

I feel the compiler is pushing [H] register by its own. Now the stack is something like this in increasing address order

Val2

Val1

[H]

[CCR]

[Accumulator]

[X]

PCH

PCL

(&val2 + 6) =location where PCH is stored.

Then you read two bytes since typecasted to int and hence entire PC value (16 bits)

Regards,

Denn.

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 16:34:21 GMT

Hello BP,

Instead of reading address of 2nd local variable, I would suggest you to read address of 1st local variable and hence the adding/ removing local variables has no effect on your routine.The only necessity is that you shouldn't remove the 1st local (i.e. routine without locals) and it should be used somewhere in the routine.

(&val1 + 5) =location where PCH is stored. // here 1st local is used

Regards,

Denn.

Message Edited by Denn*** on 2008-03-25 09:35 AM

Re: HCS08C: Software watchdog and detecting last routine

BasePointer — Tue, 25 Mar 2008 16:55:06 GMT

Hi Denn,

If I use val2, here is the stack list:

[val2]

[val1]

[H]

[CCR]

[Accumulator]

[X]

[PCH]

[PCL]

--------------------------------------------

If I use val1 instead of val2 and, (&val1+5), I think the compiler optimizing the code and changes stack list:

[val1]

[val2]

[H]

[CCR]

[Accumulator]

[X]

[PCH]

[PCL]

So, (&val1+6) and (&val2+6) are working, others not.

10x,

BP.

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 17:01:06 GMT

Hi BP,

Have changed the order of local's declaration from First case char val1, val2; to char val2, val1; the second case.

Regards,

Denn.

Re: HCS08C: Software watchdog and detecting last routine

BasePointer — Tue, 25 Mar 2008 17:10:05 GMT

No, of course I have not But the compiler changed the stack list.

Re: HCS08C: Software watchdog and detecting last routine

Denn — Tue, 25 Mar 2008 17:16:00 GMT

Interesting !!!!

Re: HCS08C: Software watchdog and detecting last routine

BasePointer — Tue, 25 Mar 2008 17:35:20 GMT

Hi Denn,

The compiler may place first used variable to the top of stack. If I use &val1, it places first. If I use &val2, it places first. If I add more variables, it will be more complex to handle.

So if there were a way to make it independent from the local variables in the code like you suggested, it would be excellent. But if it is not possible, the code above is also working for me. I placed a note to the code as a reminder that if you have to change the code here in the future, take care for stack list to obtain program counter and check it with BDM.

Regards,

BP.

Message Edited by BasePointer on 2008-03-25 12:36 PM

Re: HCS08C: Software watchdog and detecting last routine

CompilerGuru — Tue, 25 Mar 2008 21:45:47 GMT

The compiler reorders locals so that often used ones can be more efficiently accessed, for example the top of stack one can be accessed with 0,X offset (after a TSX). Don't count on the order of locals. For this case I would suggest to place the C code into its own function and read the pc from a pure HLI method (as Macs) calling the C function afterwards.

Daniel

Re: HCS08C: Software watchdog and detecting last routine

CompilerGuru — Tue, 25 Mar 2008 21:50:44 GMT

Even used variables may not get allocated on the stack if the compiler only needs them in a register ever. Not very often, but this happens.
Also for normal C code the compiler does sometimes need some storage to store intermediate values, he usually allocates them by just decreasing the SP, but sometimes the intermediate has to live a bit longer and then he can also use "static spills", the space for those is allocated like the space for locals in the entry code. In the end, if you are only using simple C code snippets, then you probably do not see this often, but it does exist.

Daniel