S3C2440③ | GPIO Experiment

Experiment 1 - Lighting up an LED

1. Look at the schematic to determine how the hardware is connected

The schematic diagram shows the hardware circuit of the chip controlling the LED and how the chip pins are connected to the LED.

2. Check the main chip manual to determine how to control the pins

Specific: How to make GPF4 output high and low levels?

2.1. Configure GPF4 to output mode (GPFCON)

Set bits [9:8] of the GPFCON register = 0b01.

2.2.Configure GPF4 output high/low level (GPFDAT)

The 4th bit of GPFDAT is 0-low level, 1-high level. (Note: corresponding)

3. Assembler program accesses registers to control LED

3.1. Editing Program

Code language: javascript

@ brief: Light up the LED connected to GPF4

@ author: mculover666

@ date: 2019/3/1

.text

.global _start

_start:

@ Set GPFCON register, GPF4 is output mode

LDR R0,=0x56000050

LDR R1,=0x0100

STR R1,[R0]

@ Set the GPF DAT register, GPF4 outputs low level

LDR R0,=0X56000054

LDR R1,=0

STR R1,[R0]

@Program Pause

halt:

B halt

3.2. Compiling the Program

Assemble to binary object file

Code language: javascript

arm-linux-gcc -c led_on.s -Wall -o led_on.o

Link to executable file elf

Code language: javascript

arm-linux-ld -Ttext 0 led_on.o -o led_on.elf

Convert to bin file

Code language: javascript

arm-linux-objcopy -O binary -S led_on.elf led_on.bin

The entire compilation step can be written as a makefile:

Code language: javascript

TARGET = led_on

# Output all warnings

CFLAGS = -Wall

$(TARGET).bin:$(TARGET).elf

arm-linux-objcopy -O binary -S $(TARGET).elf $(TARGET).bin

$(TARGET).elf:$(TARGET).o

arm-linux-ld -Ttext 0 $(TARGET).o -o $(TARGET).elf

$(TARGET).o:$(TARGET).s

arm-linux-gcc -c $(TARGET).s $(CFLAGS) -o $(TARGET).o

clean:

rm -rf *.o *.elf *.bin

download_to_nand:

#Download to nand flash

oflash 0 1 0 0 0 $(TARGET).bin

3.3. Burning Program

Use oflash to burn the bin file to address 0 of Nand Flash:

Code language: javascript

oflash 0 1 0 0 0 .led_on.bin

3.4. Run the program

1. Set the boot switch to Nand boot;

2. Re-power on;

3. Experimental Results

4.C program accesses registers to control LED

4.1. Prerequisites for running C programs - startup files

• The C language entry function is the main() function, which is called by the startup file (the assembler program executed when power is just turned on);

• The stack will be pushed when calling, and the stack will be popped after the call is completed, so the stack top pointer SP needs to be set;

• After the main function is called, it returns to the startup file calling point.

Code language: javascript

Startup file start.s: Initialize the C language operating environment and introduce C programs

@ brief: S3C2440 startup file

@ author: mculover666

.text

.global _start

_start:

@ Disable watchdog

LDR R0,=0x53000000

MOV R1,#0

STR R1,[R0]

@ Set the stack top pointer SP (start from Nand)

LDR SP,=4096

@ Call the main function, save the return address, and transfer to the C program

BL main

@ The main function returns and the program pauses

halt:

B halt

4.2. Writing C Programs - Pointers + Bit Operations

Code language: javascript

int main(void)

{

/* Set the GPFCON register to configure the GPF4 pin as output mode*/

*(unsigned int *)0x56000050 &= ~(3<<(2*4));

*(unsigned int *)0x56000050 |= 1<<(2*4);

/* Set the GPF DAT register, GPF4 outputs low level, and lights up the LED */

*(unsigned int *)0x56000054 &= ~(1<<4);

/* Program pause */

while(1);

}

4.3. Compilation

Code language: javascript

TARGET = led_on

CFLAGS = -Wall # Output all warnings

$(TARGET).bin:$(TARGET).elf

arm-linux-objcopy -O binary -S $(TARGET).elf $(TARGET).bin

#Note: The startup file must be linked first

$(TARGET).elf:start.o $(TARGET).o

arm-linux-ld -Ttext 0 start.o $(TARGET).o -o $(TARGET).elf

$(TARGET).o:$(TARGET).c

arm-linux-gcc -c $(TARGET).c $(CFLAGS) -o $(TARGET).o

start.o:start.s

arm-linux-gcc -c start.s $(CFLAGS) -o start.o

clean:

rm -rf *.o *.elf *.bin

download_to_nand:

#Download to nand flash

oflash 0 1 0 0 0 $(TARGET).bin

4.4. Burn and run

Code language: javascript

copy

oflash 0 1 0 0 0 .led_on.bin

Experiment 2 - Key Detection

1. Look at the schematic to determine how the hardware is connected

2. Check the main chip manual to determine how to control the pins

2.1. Configure GPF0 to input mode (GPFCON)

2.2. Read the status of GPF0 (high/low level) (GPFDAT)

3.C program accesses register detection button

3.1. Programming

Code language: javascript

int main(void)

{

volatile int GPF0_state;

/* Set GPFCON register */

//Set GPF4 to output

*(unsigned int *)0x56000050 &= ~(3<<(2*4));

*(unsigned int *)0x56000050 |= (1<<(2*4));

//Set GPF0 as input

*(unsigned int *)0x56000050 &= ~(3<<(2*0));

/* Program infinite loop detection key */

while(1)

{

/* Read GPF DAT register */

GPF0_state = *(unsigned int *)0x56000054;

/* Check the status of GPF4 pin */

if(GPF0_state & 0x01)

{

//The button is not pressed, the pull-up resistor is pulled high, and the LED is turned off

*(unsigned int *)0x56000054 |= (1<<4);

}

else

{

//Button pressed, low level, light up the LED

*(unsigned int *)0x56000054 &= ~(1<<4);

}

}

}

3.2. Compiling the Program

Code language: javascript

TARGET = key_scan

CFLAGS = -Wall # Output all warnings

$(TARGET).bin:$(TARGET).elf

arm-linux-objcopy -O binary -S $(TARGET).elf $(TARGET).bin

#Note: The startup file must be linked first

$(TARGET).elf:start.o $(TARGET).o

arm-linux-ld -Ttext 0 start.o $(TARGET).o -o $(TARGET).elf

$(TARGET).o:$(TARGET).c

arm-linux-gcc -c $(TARGET).c $(CFLAGS) -o $(TARGET).o

start.o:start.s

arm-linux-gcc -c start.s $(CFLAGS) -o start.o

clean:

rm -rf *.o *.elf *.bin

download_to_nand:

#Download to nand flash

oflash 0 1 0 0 0 $(TARGET).bin

3.3. Burn the program and run it

Code language: javascript

oflash 0 1 0 0 0 .led_on.bin

Summary of Experiments 1 and 2

Through these two experiments:

1. 1. In terms of the S3C2440 processor, we have mastered:

• How to control the GPIO pins of S3C2440: output high and low levels and detect external input levels (GPFCON register and GPFDAT register)

• 5 commonly used ARM assembly instructions: MOV, LDR, STR, BL, B;

• The basic format for writing assembler programs;

1. 2. In terms of C language, I have mastered:

• How is assembly converted to C language in the startup file: BL calls the main function;

• Calling functions requires a lot of stack usage, which shows the importance of setting the stack pointer SP at startup;

• Use C language pointers to access registers and use C language bit operation syntax to change register data;

1. 3. In terms of development tools, we have mastered:

• Use of arm-linux-gcc series tools and makefile;