For this phase of the course project, you will research a bank to .docx

For this phase of the course project, you will research a bank to
use as the subject of your project. The bank that you select
should be a publicly traded bank, which means it will be traded
on one of the stock exchanges such as NASDAQ or NYSE.
Once you have chosen your publicly traded bank, you will write
the introduction to your plan. Be sure to address the following
in your introduction:
· Briefly describe the bank, its product and service offerings,
and components of your plan.
· What are the strategic, operational, finance, and compliance
risks associated with your bank and the banking industry in
general?
Write the introduction to the risk management plan exploring
the risks types and risk trends associated with the banking
industry with a particular emphasis on a publicly traded bank.
Examples: Wells Fargo Bank, Citigroup, or Bank of America.
Write 1 - 2 paragraphs that introduce the topics below:
· Risk Types
· Risk Trends
· Risk Mitigation
· Credit Risk
· Lending Practices
· Capitalization and Solvency
Requirements
Review the APA Citation Online Guide for assistance with
citing sources using APA format.
· Your introduction should be 1 - 2 paragraphs in length.
· Be sure to title the plan.
· Keep in mind that this will require some research; and, as
such, should be informed by research articles.
· Be sure to include APA citations to support your assertions
and to inform your plan.

THE BANK I CHOSE IS BANK OF AMERICA
Be sure to include URL’s where information was retrieved.
ECE 425L
Lab #9: LCD Display
Introduction:
In this lab, the use of branches will be greatly expanded and
used to create and call functions, for the purpose of setting up
and displaying text on the LCD display. Since the display
contains a controller of its own connected to 8 data pins plus 3
control pins, the pins must have the correct outputs written to
them and changed multiple times in order to have the controller
“remember” the values of the characters written to the data pins
and display multiple characters on the screen at the same time.
The values must also be manipulated on order to send
commands to the controller, such as erase, scroll, return, or
position cursor on the display. The diagram of the pins can be
seen in Figure 1 below.
Figure 1: Pin Schematic for LCD on education board.
All of these methods require writing to both ports on the
processor at the same time. After such writing, some delays and
more writing will be required. These routines will be called
multiple times. Therefore, they must be written as subroutines
that can have parametrized values passed to them. Repeated

calls of these subroutines will be used to write strings to the
board, and even send commands that will initialize the board
and scroll the text. With all of these writes to the LCD
controller, text can be easily displayed on the LCD.
Equipment Used:
Keil tools to compile and debug the code.
LPC2148 Education Board.
Procedure:
The process of setting up the board requires several different
steps, and each one is contained in its own function. So the first
function written is to initialize the ports on the board by setting
all pins connected to the display to GPIO on the function select
registers, then setting all those pins to output pins. All of the
registers are modified using the read-modify-write method. That
way, the remaining pins on each port are unaffected.
The second function is a simple delay function. R0 is used to
pass in a value containing the the number of microseconds that
the controller should wait. However, this is reliant on the clock
speed, and as a result, the delay value received was much
greater than the desired delay. However, due to the usage of the
function, a larger delay is okay for the display, and will not
cause any problems in making it operate.
LCD-cmd and LCD_char were the next two functions in line.
They are identical to each other except for the LCD_RS bit,
which is low when sending a command, and high when sending
a letter. These functions will be the main data feed into the
board.
LCD_init is the initialization function used on the board. It

passes a series of commands to the board, which will wake up
and initialize the LCD controller, then light the LED backlight
once the display controller is set up. This subroutine is
important because the LCD display will not work if its not set
up properly first. However, it can be wired into a main function
if code size is important, since the LCD only needs to be set up
once before it will just work. The subroutine is used for
simplicity.
LCD_String uses a loop along with a pointer passed in in order
to determine the text to display on the LCD. It will then write
the text to the display by using a loop to repeatedly call the
LCD_char function. In this lab, the function we wrote will cut
off on the last character of the active line in order to avoid
wrap-around to the second line on the display.
LCD_clear and LCD_home simply sent the commonly-used
functions to either clear the display or go to the first char
position and reset scrolling, and their main task is to simply
send the command to the LCD_cmd function and return once
that is done.
LCD_shift also sends a command to the board; however, this
function will be used to shift the display to either the right or
left. However, this function will be called many times when a
shifting loop is entered, so it is important that it works correctly
and can be called easily from a loop. This function shifts the
text to the right or left on the display, based upon a certain bit
sent to the command, but the text in the display memory will
not be changed. To undo such a shift, the LCD_home function
will be called.

Once all these routines are written, the main function is written
in a separate file. It simply initializes the LCD, writes text to it,
and using a loop, it scrolls it. Other commands can also be
easily sent, but to simply display and scroll text, calls to the
subroutines written above will be easy and few because the
main function can reuse them and the subroutines do most of the
work. Using the loop, the scrolling can be performed
indefinitely (until the processor is reset, that is.
Results:
Task One:
Task one had seven different parts to it. The first part required a
certain delay to be produced. This was achieved by sending the
desired value through register 0 and multiplied to produce the
delay. The delay can be tested by using debug and checking the
seconds that the subroutine started and what it ended with.
Seconds can be found under the “Internal” section.
The next three task configure the LCD interface to make sure
that the LCD is on and that the correct command is being sent to
the pins. Each of these were done by separate subroutines called
“LCD_pins”, “LCD_init”, and “LCD_cmd”. LCD_pins clears or
sets different bits to make sure “00” is set for that bit for GPIO
or if a certain bit needs to be input/output. To make everything
easier to read the bits that controlled each pin were named such
as “LCD_RW” that controls whether to write to the LCD or read
to it. All these different bits were obtained from the Table 1
shown below. LCD_init make sure Enable, Register Select, and
Read Write bit are set to the proper bit. This will also turn the
LCD backlight on. LCD_cmd is called every time a command
needs to be sent to the education board.
Table 1: Pin Assignment of LCD module.
A subroutine was asked to be made to send a character to the
LCD. This was achieved by sending the ASCII value to the
subroutine and the desired bits were cleared and then moved to
the IOPIN. The result can be seen in Results Figure 1:

Result Figure 1: Character “H” displayed on LCD.
The next part to task one required a string to be displayed on
the first line of the LCD. This was accomplished by using the
subroutine LCD_String that would grab each character from the
string and follow the same procedure that the LCD_char did.
The counter would be incremented until the 0 at the end of the
string was reached. The result can be seen on Result Figure 2.
Result Figure 2: The String “Hello” displayed on the first line
of the LCD.
Task Two
Task two required the display of a string on both the top line of
the LCD and the bottom. This was achieved by using the same
subroutine LCD_String as the previous task but however this
time the starting cursor was changed to 0x80 for the second
string after the first string was finished. The result can be seen
in Result Figure 3.
Result Figure 3: A String is displayed on both lines of the LCD.
Task Three
Task Three required the strings on the LCD to scroll
continuously. This was achieved by writing the subroutine
LCD_Shift that would shift everything one to the left. This
function was called repeatedly using a continuous loop. The
result can be seen in Result Figure 4. This was then enhanced
by making it to that the string would reset back to home once
the string reach the send so that there would be no time where a
blank LCD was displayed.
Result Figure 4: Strings scrolling left in a continuous loop.
Questions:
No questions are presented in this lab
Conclusion:
This experiment introduced how to set up and send data to the
LCD on the education board. This was done by doing different
subroutines that each had its own purpose. Depending the task

required such as displaying a character or a string or even just
turning it on different subroutines needed to be executed. These
subroutine calls were initialed from main.s depending on the
task.
Throughout each task, pins from both Port 1 and Port 0 were
manipulated to what was required such as setting them to
outputs. Since some pins have multiple uses we had to make
sure we manipulated and had the correct delays set in-between.
This experiment showed how by making each part into a
different subroutine it is easier to keep track of everything that
is going on. Since everything was separated into subroutines
knowing what is going on at each part of the code is a lot easier
not only to read but also to edit. This will be useful in future
experiments as they become longer and more complicated. This
will make it easier to isolate problems when debugging.
ECE 425L
Lab #10: Interrupts
Introduction:
In this lab, different types of interrupts will be introduced that
can branch to different interrupt handlers to perform things such
as lighting certain LED patterns or flashing a display on the
LCD. The first interrupt that will be covered is the Software
Interrupt. As its name suggests it is an interrupt that is
generated by software. The Fast Interrupt (FIQ) and Normal
Interrupt (IRQ) are interrupts used by peripherals. These two
flags can be enabled and disabled as desired by setting or

clearing the F and I bits on the CPSR register. By configuring
the external interrupt inputs and the Vectored Interrupt
Controller, these interrupts can be triggered using the joystick
on the education board.
Equipment Used:
Keil tools to compile and debug the code.
LPC2148 Education Board.
Procedure:
The first procedure that must be taken care of are the stacks for
each of the modes. Each stack must have enough memory
associated to it so that it will not lead to overflows. Therefore
the processor will be switched to every possible mode during
initialization and the stacks will be configured while in each
mode. The interrupt bits must be disabled at this time so that
they do not interrupt this procedure. Once this is accomplished,
the next step can be started.
The Software Interrupt is generated by software unlike the other
two interrupts that will be discussed later. The instruction used
to call this interrupt is “SWI”. When this instruction is
executed, the processor will switch to Supervisor mode and
branch to the SWI handler. Here is where the procedure that the
programmer wants to be executed when the SWI is called is
placed. The interrupt handler must remember to save the
registers, flags, and the returning address so that the instruction
that was following before the interrupt was called can be
executed once done. The procedure that is done when the SWI is
executed is up to the programmer. For this experiment, a certain
LED combination was displayed on the board to indicate a
software interrupt had occurred.
The following tasks requires executing multiple software

interrupt calls. The SWI instruction has a number part to it that
allows programmers to use the same instruction to call different
subroutines through the same interrupt handler. Since the
number that is chosen is placed in the comment field of the SWI
instruction, this number can be obtained by grabbing it from
memory and masking the first couple bits. From here different
numbers can branch to different subroutines that can have
different displays such as all even LEDs or all odd LEDs. A
delay may be added in between the different SWI calls so that it
can be seen on the education board instead of it quickly flashing
all the interrupts. This comes in handy when trying to execute
different procedures using software interrupts.
The other two interrupts discussed in this experiments are the
Fast Interrupt and Normal Interrupt. These can be programmed
to be executed by using the joystick shown in Figure 1 below.
Figure 1: LPC2148 Education Board Schematic: Joystick-
switch.
This experiments requires that pin 0.16 (clicking the joystick)
and pin 0.20 (bottom right) to be used to execute an interrupt.
EINT0 is the external interrupt input for P0.16 and EINT3 is for
P0.20. These inputs can be programmed so that when clicked or
moved either FIQ or IRQ will execute. First the PINSEL1 must
be modified to select EINT0 and EINT3 for P0.16 and P0.20.
Next EXTMODE and EXTPOLAR must be modified to choose
between Level-sensitivity and falling/rising edge sensitive. And
last the EXTINT must be modified so that the corresponding
flags are cleared which would enable the IRQ and FIQ if the
correct bit combination is sent to the register. Once these are set
up the Vectored Interrupt Controllers must be set up before the
joystick can be used.

The Interrupt Select Register (VICIntSelect) will define whether
pin will trigger an IRQ or FIQ interrupt. Bit 14 controls EINT0
and bit 17 controls EINT3 and by setting one of them to “0” it
will set it to IRQ while a “1” will set it to FIQ. Once these are
assigned the Interrupt Enable Register (VICIntEnable) must be
set up so that it enables these interrupts. Once all these registers
have been set up, IRQ and FIQ handlers can be setup to execute
similar to the SWI handler that was done in the previous task.
However instead of being asserted through software these will
be asserted by clicking or moving the joystick. Once one is
triggered the interrupt handler starts to execute. Just like the
SWI certain procedures are done before the interrupt begins to
execute such as coping the CPR into the SPSR of the interrupt
and loading the address of the interrupt exception vector into
the PC.
Results:
Task One:
Task one required the startup code to be modified to initialize
the stacks for each mode. Since each mode has its own stack
pointer it is necessary to set up the stack pointer for each
processor mode. Each mode must be given enough space in
memory for the stack to be implemented so for this program to
make it simple each mode was given 0x100 space starting with
the supervisor mode at 0x40000100. The interrupt bits I and F
must be disabled so that an interrupt does not stop this
processes.
Task Two:
Task two required an assembly program that would call a single
Software Interrupt to light up all eight LEDs. This was done by
using the instruction “SWI”. By using this instruction it will
branch to the Software Interrupt vector which then branches to
the subroutine “SWI_Code”. This subroutine branches to
“LED_init” to make sure the pins are set to GPIO and as
outputs. After initialized it branches to the subroutine

“Eight_On” that will turn on all the LEDS on the board. Once
performed the LR is loaded back into PC as well as the copying
the flags back to the CPSPR using the instruction MOVS pc, lr.
The result can be seen in Result Figure 1 below.
Result Figure 1: ALL LEDs on using SWI.
Task Three:
Task three required an assembly program that would call three
different software interrupt calls using SWI numbers. Since the
instruction “SWI” is followed by a number that can be used to
identify each of the intendance called. The SWI instructions
branches to the SWI Handler no matter what number is
associated with it. The number associated with the SWI is the
first byte on the SVC instruction so by bit clearing everything
but the first byte the number can be obtained. Once obtained the
number was used to branch to the desired LED pattern. One of
the patterns is shown in Result Figure 2 below.
Results Figure 2: Odd LEDs on using SWI.
Task Four:
Task four required an assembly program that would configure
the joystick to generate an IRQ interrupt or a FIQ interrupt
depending if the joystick is pushed down or moved to the
bottom left direction. This was achieved by initializing the
registers: PINSEL1; EXTMODE; EXTPOLAR; EXTINTFLG;
VICIntSel, and VICIntEnable.
· PINSEL1 was initialized to be external interrupts instead of
GPIO by setting bit 1:0 to 01(EINT0) and bit 9:8 to be
11(EINT3).
· EXTMODE was set to be edge sensitive by setting bit 0 and 3
to be 1.
· EXTPOLAR was set to be falling edge sensitive by setting bit
0 and 3 to 0.

· EXTINTFLG clears the external interrupt flags for EINT0 and
EINT3.
· VICIntSelect register defines the interrupt type so bit
14(EINT0) was set to 1 making it the FIQ pin and bit
17(EINT0) was set to 0 making it the IRQ.
· VICIntEnable registers enables the interrupt by setting a 1 to
bit 14 and 17.
Once these settings are processed whenever the pin associated
with the desired interrupt, the handler is branched to and the
subroutine is executed. IRQ and FIQ subroutine do a similar
procedure as the SWI just with a different LED pattern. FIQ
had the pattern that the first 4 LEDs were turned on and is
shown in Result Figure 3 below.
Results Figure 3: First 4 LEDs on using FIQ interrupt triggered
by joystick.
Questions:
Question 1: What would happen if “MOV pc, lr” is used instead
of “MOVS pc, lr”?
The mode flags will not be updated, causing the processor to
remain in its interrupt mode after it has exited the interrupt
procedure and resumed execution of user code, and this will
cause errors when the user code tries to read the stack.
Question 2: What signal type will you select for the interrupt
inputs connected to the Joystick-switch in Figure 2?
External interrupts will be chosen, since these pins must link to
the Vectored Interrupt Controller in order to interrupt execution
when their state changes.
Question 3: What might happen if the EINT flags were not
cleared in the interrupt service routine?
The service routine will execute continuously when the mode is

returned to user. This will cause an infinite loop. Such loop
occurred during testing, and fixing this step fixed the problem
Question 4: What will happen to the Link Register if a
subroutine call is performed in the interrupt service routine?
The link register belonging to the interrupt mode will be
updated to reflect the last PC location before the call.
Therefore, the link register must always be saved at the
beginning of the interrupt procedure, since it contains
information needed to get back to User mode. However, the link
register belonging to User mode will not be modified.
Conclusion:
This experiment introduced interrupts. An interrupt breaks the
flow of a program and branches to a certain subroutine. There
are three different interrupts: SWI, FIQ, and IRQ. Software
Interrupts are called by the program while the Interrupt Request
and Fast Interrupt Request are called by an external input. The
SWI instruction is used to call the Software Interrupt which
branches to the SWI subroutine and performs the desired
operation and then branches back to whatever was being
executed before the SWI was called.
The FIQ and IRQ were triggered by an external interrupt input.
In this experiment the joystick was used to call the desired
interrupt. Certain registers such as EXTMODE and EXTPOLAR
must be set up correctly in order to use the joystick to signal the
FIQ or IRQ interrupt. Once triggered the desired interrupt
handler is branched to and the operation is executed.
This experiment also helped to set up different stacks for each
of the modes in the startup file that may be used for the last
experiment. This can prove helpful if operating in different
modes allowing the use of stacks without having it clash with

other modes stacks.
Write an essay about the cultural impact of popular music on
society, and how it reflects the social issues of its time of
production.
· Select a popular song from the era of your choice (1950's -
2000's), and discuss its cultural impact.
· Analyze the meaning of the lyrics, and discuss how this song
represents an element of popular culture/ American society.
· The main focus of your essay should be regarding symbolism,
and the symbolic nature of the song you have chosen.
· Give some background into the musician or musical group you
have chosen.
· Then, discuss some of the social and political issues present in
American and, if relevant, international culture that were going
on at the time of the song's release.
This paper should be 2-3 pages, in APA style, utilizing the
college's library resources. A minimum of one scholarly article
should be included in your essay.
The song I chose is Sting’s Russians- The song is a commentary
and plea that critiques the then-dominant Cold War foreign
policy and doctrine of mutually assured destruction by the
United States and the Soviet Union.

For this phase of the course project, you will research a bank to .docx

More Related Content

Similar to For this phase of the course project, you will research a bank to .docx (20)

More from hanneloremccaffery (20)

Recently uploaded (20)

For this phase of the course project, you will research a bank to .docx