C ARM programming - c

Question

I had two questions regarding writing into registers for ARM programming using C language.
1st: I'm trying to write to the Application Interrupt and Reset Control Register or AIRCR. It's a 32-bit register. I need two write 0x5FA values at bits 16 to 31 (the need of register). I also need to modify some other bits, but singularly. I meant, only bitwise (0 or 1). I know how to do this when it's only a bit. using *iser0 |= 0UL << 2; for example. But my question is that how can I write to a part of the register, namely, the AIRCR[31:16] while being able to manipulate other bits.
2nd: This issue is not my main issue, But when I compile my C program, It's return value is not 0. Is this abnormal? What has been my mistake?
#include <stdint.h>
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
int main()
{
//Multi drive register
uint32_t* muer=(uint32_t*) 0x400E0E50UL;
*muer |= 1UL << 8;
uint32_t* mudr=(uint32_t*) 0x400E0E54UL;
*mudr |= 0UL << 8;
//Pio controller register
uint32_t* per=(uint32_t*) 0x400E0E00UL;
*per |= 1UL << 8;
uint32_t* pdr=(uint32_t*) 0x400E0E04UL;
*pdr |= 0UL << 8;
//output register
uint32_t* oer=(uint32_t*) 0x400E0E10UL;
*oer |= 0UL << 8;
uint32_t* odr=(uint32_t*) 0x400E0E14UL;
*odr |= 1UL << 8;
//edge select
uint32_t* esr=(uint32_t*) 0x400E0EC0;
*esr |= 1UL << 8;
//level select
uint32_t* lsr=(uint32_t*) 0x400E0EC4;
*lsr |= 0UL << 8;
//Rising edge
uint32_t* rehlsr=(uint32_t*) 0x400E0ED4;
*rehlsr |= 1UL << 8;
//Falling edge edge
uint32_t* fellsr=(uint32_t*) 0x400E0ED8;
*fellsr |= 0UL << 8;
//Interrupt set-enable register
uint32_t* iser0=(uint32_t*) 0xE000E100;
*iser0 |= 1UL << 11;
//Interrupt clear-enable register
uint32_t* icer0=(uint32_t*) 0xE000E180;
*icer0 |= 0UL << 11;
//AIRCR
uint32_t* aircr=(uint32_t*) 0xFA050000;
//VECTKEY
*aircr |= 0x5FA << 16;
//ENDIANESS
*iser0 |= 0UL << 15;
//PRIGRIOUP
*iser0 |= 5UL << 8;
//SYSRESETREQ
*iser0 |= 0UL << 2;
//VECTCLRACTIVE
*iser0 |= 0UL << 1;
//SYSRESETREQ
*iser0 |= 0UL;
}
This is my code.
Update:
I understood that I cannot do |= 0UL, instead, I should use &= 1 << bits.
I tried this one for my other code. But it still doesn't return 0, and surprisingly, it takes 10 seconds to compile.
#include<stdint.h>
int main()
{
//Pull up register
volatile uint32_t* puer=(uint32_t*) 0x400E0E64UL;
*puer &= 1 << 8;
volatile uint32_t* pudr=(uint32_t*) 0x400E0E60UL;
*pudr |= 1UL << 8;
//Multi drive register
volatile uint32_t* muer=(uint32_t*) 0x400E0E50UL;
*muer &= 1 << 8;
volatile uint32_t* mudr=(uint32_t*) 0x400E0E54UL;
*mudr |= 1UL << 8;
//Pio controller register
volatile uint32_t* per=(uint32_t*) 0x400E0E00UL;
*per |= 1UL << 8;
volatile uint32_t* pdr=(uint32_t*) 0x400E0E04UL;
*pdr &= 1 << 8;
//ABSR register
volatile uint32_t* absr=(uint32_t*) 0x400E0E70UL;
*absr &= 1 << 8;
//output register
volatile uint32_t* oer=(uint32_t*) 0x400E0E10UL;
*oer |= 1UL << 8;
volatile uint32_t* odr=(uint32_t*) 0x400E0E14UL;
*odr &= 1 << 8;
}
Update
I have not connected my micro to my PC. One possible issue is that I don't have these addresses on my machine?

Answer 1

In order to clear a single bit of a variable, you don't use *register |= 0 << bit but instead *register &= ~(1 << bit). If you want to manipulate more than one bit, essentially what you have to do is erase the relevant part and then overwrite it with your desired pattern.
This for example will delete the bits 4 to 6, and then overwrite them with the contents of value:
*register &= 0x7 << 4
*register |= (value & 0x7) << 4;
As for your second question:
Never ever try to run code that tries to access random memory locations like that on a PC. This is something you only do to access registers on a microcontroller. Your PC doesn't have those registers and even if it did, your operating system hides the actual physical memory from you anyway.
DISCLAIMER:
As pointed out by Lundin, using bitfields is compiler/architecture-dependent and therefore non-portable. If you want to use them, you will have to check your compiler's documentation to make sure they work as expected. When in doubt, prefer the solution above. Continue reading at your own risk ;-)
With that out of the way, what you could also do, in order to avoid the bit manipulation is something like this:
union
{
struct
{
uint32_t vectreset :1;
uint32_t vectclractive :1;
uint32_t sysresetreq :1;
uint32_t :5;
uint32_t prigroup :3;
uint32_t :4;
uint32_t endianness :1;
uint32_t vectkey :0;
};
uint32_t u32;
} *aircr = (void*)0xFA050000;
And then in your code, access the bitfield like this: (*aircr).vectkey = 0x5FA;