Raspberry Pi Lesson 05

1- Introduction:

        Lesson 5  basically builds on the operating system of lesson4 and the objective of lesson 5 is to show how we can use the SOS, which is a Morse Code ,in order to flashing the ‘ACT’ LED. Morse Code (SOS) is a sequence of three dots, three slashes, then three dots (…---…). Generally, we classify data into a specific type such as text, image, and so, then we store different types of data into their related files. Actually, a computer deals with different types of data in the same manner; they are represented in binary numbers.  This data explanation is also true for Mores Code, so we are going to use a sequence of SOS Mores Code pattern in order to flash “ACT LED. The flashing pattern should be a sequence of three short pulses, three long pulses and finally three more shorts pulses, and after the required delay is over,   this sequence of flashing keeps on forever until disconnecting the Raspberry PI from a proper supply source.

2- Materials and Procedures:

In order to carry this assignment out, there are two types of requirements .The first type is the required equipment and the second one is the software and the operating system.

2.1Equipment:

   1-A Raspberry Pi board (it is a single circuit that considered as a computer which, primary runs on a version of Linux).

   2-A computer uses a Microsoft Windows-based Operating System.

   3- A SD card (it is a memory card).

   4- A power supply.

2.2Software:

1-     Using  the GNU compiler toolchain in order to deal with the architecture

2-     The OS Template File

 (It provides a Makefile script, a Linker script and no assembly code would be provided. Since the compiler needs required instructions in order to create Operating System for the Raspberry Pi, those instructions have been provided by the OS Template file )

2.3 Experimental Procedure

The ARM assembly code for Lesson 5:
main's:

.section .init .globl _start _start: .section .init and .globl _start are directives that instructs the assembler in order to put our assembly code in a section its name is ( .init ).  Because of that, we will be able to control the order of the code execution. Also, the GNU toolchain needs a entry point to work properly, so we need to include symbol _start. Then, we need global, which is required by the linker. Then ( _start:) to start the address of the new line. In order to branch to the actual main code, we use (b main) In order to put this code with the rest, we use this command (.section .text) tells the assembler. main: Now we are making the stack pointer to point to setting the 0x8000. mov sp,#0x8000 In order to set the function of GPIO port 16 to be ‘’ACT” LED with (001 base 2 or binary), we use a new SetGpioFunction function. mov r0,#16 set r0 to pin 16 mov r1,#1 set r1 to pin 1 bl SetGpioFunction In this block of instructions, our objective to load the pattern into flash and also storing the required position in the flaqsh sequence. ptrn .req r4 store ptrn in register r4 ldr ptrn,=pattern load the pattern in r4 ldr ptrn,[ptrn] seq .req r5 load register r0 in the  register  r5 with ability of always finding the sequence location mov seq,#0 loop$: If the pattern contains 0 then the LED will turn on, but if the pattern contains 1 then the LED will turn off.in order to do that, we use the new GPIO 16 base on the current bit. mov r0,#16   pin 16 in r0 mov r1,#1 pin 1 in ri lsl r1,seq Using logical-shift-left (lsl) to shift r1 to the left by sequence value. and r1,ptrn here is condition that states; if there exists 1 bl SetGPIO  ,then r1 holds nonzero value bl SetGpio. In order to achieve the delay, we load a value of 250000 micrseconds into the register r0 and that will make the processor busy by counting down from 250000 micrseconds to 0 second. ldr r0,=250000 bl Wait When the sequence counter reaches 32 its pattern holds 100000. Then by applying this loop over this process in order to increment the sequence counter  , its pattern holds 11111 makes it return to 0.But all of that has no effect on less than 32. add seq,#1 and seq,#0b11111 b loop$ .section .data In order to separate data from instructions, we put (.section .data) at the end of the code and keeping the data in it. So in the case of implementing some security on our operating system, we can control which part that need to be executed apart from the other. .align 2 In order to be sure that the address of the next line will be multiplied by 2^2, we use the (align 2). pattern: .int 0b11111111101010100010001000101010 I use this quote from http://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/ok05.html  to describe( pattern: .int 0b11111111101010100010001000101010);  “The .int command copies the constant after it into the output directly. That means that 111111111010101000100010001010102 will be placed into the output, and so the label pattern actually labels this piece of data as pattern.” From the previous description, if the output holds a zero values then the LED will be off ,and if the output holds one(1) value then  the LED will be on”ACT” ,or OK.                push {lr}                mov r2,pinNum                .unreq pinNum                pinNum .req r2                bl GetGpioAddress                gpioAddr .req r0

systemtimer's:

We need code to deal with the system timer, which is a counter that runs at 1MHz, and that system timer is used to count the difference between two measurements. In order to return the value of the base address of the System Timer region into register r0, we use GetSystemTimerBase. .globl GetTimeStamp GetSystemTimerBase:                ldr r0,=0x20003000                mov pc,lr Loading the address of the system timer (0x20003000) in r0, then move the pc to the value of the lr. In order to get the current timestamp of the system timer, we use the GetTimeStamp. Then the return will be in register r0 and r1, while r1 is the most significant 32 bits. .globl GetTimeStamp GetTimeStamp:                push {lr}                bl GetSystemTimerBase                ldrd r0,r1,[r0,#4]                pop {pc} Pushing the ( lr ),then we call the function (GetSystemTimerBase).since the value of  counter is  8 byte  and a register is 4byte,we need to store the value of the counter which is 8 byte into two registers. After that, we pop the pc. .globl Wait Wait:                delay .req r2                mov delay,r0                     push {lr}                bl GetTimeStamp                start .req r3                mov start,r0 In order to make a delay, we need to store a specified number of microseconds in r2, and then copy this waiting value from r2 into r0. Pushing the lr, then call the function of (GetTimeStamp).after assigned the register r3, copy the value of r0 into r3.                loop$:                               bl GetTimeStamp                               elapsed .req r1                               sub elapsed,r0,start                               cmp elapsed,delay                               .unreq elapsed                               bls loop$                                              .unreq delay                .unreq start                pop {pc} Calling the function of (GetTimeStamp), then subtract r3 from r0. Now, we have a condition that compares if the delay not equals elapsed then continue, otherwise, stop. if the elapsed is less than delay ,then continue and delete alias. Finally, pop pc.

GPIO's:

In order to return the base address of the GPIO region in register r0, we use GetGpioAddress. .globl GetGpioAddress GetGpioAddress:                gpioAddr .req r0                ldr gpioAddr,=0x20200000                mov pc,lr                .unreq gpioAddr Assigned gpioAddr to register r0, and then loading GPIO address in r0. 0x20200000 will be copied into program counter (pc), and then deleting stored GPIO address. In order to set the function of the GPIO register addressed by r0 to the low 3 bits of r1, we use SetGpioFunction. .globl SetGpioFunction SetGpioFunction:     pinNum .req r0     pinFunc .req r1 Assigned pinNumt to register r0 and pinFunc to r1.                cmp pinNum,#53                cmpls pinFunc,#7 since range is  (from 0 to 53 pins) of GPIO, then using the comparing r0 in order  to set the range In this the condition; 1-comparing r0 with #53 and if the value is less or equal to 53.                                        2- r1 with 7 in order to verify if r1 within the 8 function pins .                movhi pc,lr In this condition. If the both (1)&(2) are satisfied then do not run, otherwise runs.                push {lr} Copy the value in lr into r0.                mov r2,pinNum Move GPIO address from r0 to r2.                .unreq pinNum Delete the assigned.                pinNum .req r2 Assigned pinNum to register r2.                bl GetGpioAddress Call the function.                gpioAddr .req r0 Assigned gpioAddr register r0. functionLoop$: cmp pinNum,#9 Comparing pinNum, to #9. subhi pinNum,#10 If the value is greater than 9 then subtract 10 from the pin. addhi gpioAddr,#4 bhi functionLoop$  Add 4 to GPIO,then run add pinNum, pinNum,lsl #1 Logical-left-shift by 1 is equivalent to multiplication by 2 then add the value of r2 (r2*2+r2) . lsl pinFunc,pinNum The function value will be shifted by the value of r2.                mask .req r3 Assigned mask to r3,.                mov mask,#7      r3 takes the value of 7,   r3 = 111 (base2).                                              lsl mask,pinNum Shifting r3 left by the value of r2. Where r3 and the function in r1 have the same position 111.                                                        .unreq pinNum Deleting assigned. mvn mask,mask  r3 = 11..1100011..11 and the function in r1 have the same position 000 .                oldFunc .req r2  oldFunc  is assigned to register r2. ldr oldFunc,[gpioAddr]    Loading the GPIO address into r2.                .unreq mask Deleting assigned. .unreq oldFunc Deleting assigned.                str pinFunc,[gpioAddr] store the value of GPIO in pinFunc. .unreq pinFunc Deleting assigned. unreq gpioAddr Deleting assigned. pop {pc} /* NEW In order to set the GPIO pin addressed (in r0) as high if r1 is not equal to 0 , otherwise, set the GPIO pin addressed as low .we use  SetGpio. .globl SetGpio SetGpio:                   pinNum .req r0 Assinged pinNum  to register r0 .     pinVal .req r1 Assinged pinVal to register r1. cmp pinNum,#53 by comparing r0 with 53 ,we set the range  from(0 to 53 pins in GPIO)                movhi pc,lr The return is done when r0 is greater than 53. push {lr} mov r2,pinNum  miving the value from r0 to r2.     .unreq pinNum Delete assigned.                    pinNum .req r2 Assigned pinNum to register r2.                bl GetGpioAddress Call function.     gpioAddr .req r0 Assigned gpioAddr to register r0. pinBank .req r3 Assigned pinBank to register r3. lsr pinBank,pinNum,#5 Since GPIO has two sets of 4 bytes, we divide the pins numbers by 32 in order to turn pins on and off (32 and 22). lsl pinBank,#2 Logical-shift-left by 2 is equivalent to multiplication by 4 ,(4 bytes will be multiplied by 4). add gpioAddr,pinBank The pin will be on if the 28-10 is added, and the pin will be off if 40-10 is added. .unreq pinBank Delete assigned. and pinNum,#31 pinNum is divided by 32  then the remainder will never be greater than 0-31.                setBit .req r3 Assigned   setBit to r3.                mov setBit,#1 setBit takes value of 1.                lsl setBit,pinNum Logical-shift-left by 1 for the value of pinNum.                .unreq pinNum Delete assigned. teq pinVal,#0 Test if the value of pinVal equals to zero. .unreq pinVal Delete assigned.                streq setBit,[gpioAddr,#40] Store setBit at 40 away from GPIO if the value of pinVal is equal to zero. As result of that, the pin will be off, and the LED will be on. strne setBit,[gpioAddr,#28] Store setBit at 28 away from GPIO if the value of pinVal is not equal to zero. As result of that, the pin will be on, and the LED will be off. .unreq setBit .unreq gpioAddr Delete the two assigned.                pop {pc} The value of pc will set back to the value of the lr.

3. Results:

http://youtu.be/SBckiv9iFjA