Problem with static variable initialization C

I am facing a problem with my static variable which take a random value at the startup of the program and not initialized to 0 as I am expecting it to work.

I have this function in a first
file 1:

void setInput()
{
	/*.... Code ...*/
	sysUpdate(SysOutput.u16_state);
	
	/*.... Code ...*/
}

which calls the sysUpdate function in another
file 2:

bool sysUpdate(uint16 state)
{
    static uint32 u32_Counter = 0;
	
	if (Condition)
	{
		u32_Counter += 30;
		if (u32_Counter > 30000)
		{
			u32_Counter = (uint32)0;
			/*.... Code ...*/
		}
	}

	/*.... Code ...*/
}

The problem is that my u32_Counter takes a random value despite of initializing it to 0, and my condition is always true the first time.

Do you have any idea on the reason of this problem?

Thank you for your help.

Update :
This problem was caused by a writing out of the boundries of another static array. This is what exactly caused the problem :

static uint8 state[xNUMBER][yNUMBER]; 
const uint8 state1[xNUMBER][yNUMBER] = {{0, 1, 0, 0}, {1, 0, 0, 0},{1, 1, 1, 1}}; 
const uint8 state2[xNUMBER][yNUMBER] = {{0, 1, 1, 1}, {1, 1, 0, 0},{1, 1, 1, 1}}; 
length = sizeof(state)/sizeof(state[0][0]);
for(i = 0; i < length; i++)
{
	for (j = 0; j < length; j++)
    {
   		if(condition)
	    {
   			state[i][j] = state1[i][j];
	    }
		else		   
		{
  			state[i][j] = state2[i][j];
	    }
	}
}

Unless your environment is seriously broken, the initial value of u32_Counter is guaranteed to be 0.

A likely explanation is this global variable is overwritten by code executed before the test that shows the problem.

You can try and investigate by looking at the map file or list of symbols and their addresses (using the nm or objdump utilities) to see what variable or array is laid out just before u32_Counter. A buffer overrun may cause what you observe.

You could move the definition outside the function so you can print the value of u32_Counter at different times during the execution of the initial code. Yet the problem might disappear if you do this as the variable may be laid out at a different place in the data segment, thus no longer overwritten, but some other variable may be overwritten then and the side effects may move somewhere else. Even just removing the = 0 initializer may have this effect.

If you have a debugger with watch capabilities, set a watch point on this variable to track where and how it gets modified.