rtos & embedded lab record

INDEX

Sl.

No. Date Experiment Name Marks Signature

1 27-02-2014

Stepper motor interfacing

2 06-03-2014 ADC interfacing

3 13-03-2014

Keyboard display interfacing

4 13-03-2014

Serial port interfacing

5 10-04-2014 LCD interfacing

6 17-04-2014 CAN serial controller

VERILOG PROGRAMMING

7 24-04-2014

Design and implementation of simple

combinational and sequential circuits

8 24-04-2014

Design with programmable logic devices

using xilinx FPGA & CPLD

RTOS

9 02-05-2014

Intertask synchronization

using semaphore on ARM 7

10 02-05-2014

Implementation of event control

blocks on ARM 7

11 08-05-2014

Intertask communication

using mailbox

12 08-05-2014

Intertask synchronization

using mutex

ADSP 2181

13 22-5-2014 Vector addition

14 29-05-2014 ADSP program to blink a LED

15 29-05-2014 Convolution

Ex.No:01

Date: 27-02-2014

STEPPER MOTOR INTERFACING

AIM:

To write a C- Program to interface the stepper motor to LPC2148 processor through MCB2140

kit.

APPARATUS REQUIRED:

KEIL Software.

Keil MCB2140 Microcontroller board.

Stepper motor.

ALGORITHM:

Step 1: Initialize P1.16-19pin as output pins.

Step 2: Give 1000 to P1.19 to P1.16

Step 3: Call a software delay routine







Step 10: Go to Step 2

PROCEDURE :

Step 1: Open the keil software.

Step 2: Click on the project and create a new project.

Step 3: Create a new C file and type the program.

Step 4: Create the necessary header files and add to the project.

Step 5: Connect the Stepper Motor Interface to MCB 2140 using ESA Interface Adapter

for MCB 2140

Step 6: Download the Stepper Motor Interface Program usingKeil ULINK debugger.

Step 7: Compile the C file and debug the code.

Step 8: Run the program.

FLOWCHART:

Delay function: Variable count is taken as Argument

False

True

No

True

Start

Initialize i=0,j=0

Check

i

Main function:

Start

Initialize GPIO 16 to 19

of port1 as output

Make P1. =1000

Call delay function

Clear the Port1 pins

Make P1. =0100

Call delay function

A

B

Clear the port1 pins

Make P1. =0010


Make P1. =0001

Call the delay function

Call the delay function


A B

PROGRAM:

#include

void delay(unsigned int count)

{

unsignedinti ,j= 0;

for(i = 0; i

delay(1000);

IOCLR1 = 0x000F0000;

}

/* Anti clock rotation

while(1)

{

IOSET1 = 0x00110000;

delay(10000);

IOCLR1 = 0x00FF0000;

IOSET1 = 0x00220000;

delay(10000);


IOSET1 = 0x00440000;

delay(10000);


IOSET1 = 0x00880000;

delay(10000);


}*/

}

RESULT:

Thus the C program for interfacing stepper motor with LPC2148 Processor was written and

executed.

Ex.No:02

Date: 06-03-2014

ADC INTERFACING

AIM:

To write a C Program for ADC interfacing with LPC2148 processor by using MCB2140

evaluation board .

APPARATUS REQUIRED:

KEIL Software.


ULINK2 JTAG Debugger.

ALGORITHM:

Step 1: Select the pin functionality for UART1,TXD&RXD and analog channel1

Step 2:Initialize UART1 with 9600 baud rate,1stop bit,no parity,8 data bits.

Step 3:configure ADC channel as 1,ADC clock as 3MHz.

Step 4:Start ADC conversion

Step 5:.At the end of 10 bit ADC conversion get the result and calculate the analog input voltage.

Step 6: Transmit 10 bit ADC result and analog input voltage through UART1

Step 7: Go to step4

PROCEDURE:






Step 6: Now the LPC2148 device is to be connected to PC with the help of RS232 cable.

Step 7 : Open the HYPERTERMINAL window in PC.


FLOWCHART:

No

yes

Start

Select the UART1 TXD,RXD and analog

channel1 pin functionality

Configure UART1 with following baud

rate 9600,stop bit 1,data bits 8,no

parity

Configure ADC with following.ADC

channel1,ADC clock 3MHz

Start ADC conversion

Get 10 bit ADC result from ADDR&

calculate analog input voltage

Transmit 10 bit ADC result and analog

input voltage to UART 1

Is ADC

conversion

completed?

PROGRAM:

#include

#include

void wait (void) {

int d;

for (d = 0; d < 1000000; d++);

}

#define VREF 3

unsigned int val;

int main (void) {

PINSEL0 = 0x00050000;

PINSEL1 |= 0x01000000;

U1LCR = 0x83;

U1DLL = 97;

U1LCR = 0x03;

IODIR1 = 0x00FF0000;

printf ("ADC INTERFACING\n");

ADCR = 0x00210602;

while (1)

{

ADCR |= 0x01000000;

while ((ADDR & 0x80000000) == 0);

val = ((ADDR >> 6) & 0x03FF);

printf("Val is %d\r\n",val);

printf("Voltage is %f\r\n",(((float)val/1023.0)*3.3));

wait ();

wait ();

wait ();

wait ();

wait ();

}

}

RESULT:

Thus the C program for interfacing ADC with LPC2148 Processor has been executed.

Ex.No:03

Date: 13-03-2014

KEYBOARD DISPLAY INTERFACING

AIM:

To write a C Program for keyboard display interfacing with LPC2148 Processor by using

MCB2140 Evaluation board.

APPARATUS REQUIRED:

KEIL Software.


ULINK2 JTAG Debugger

ALGORITHM:

Step 1: Start the program.

Step 2: Configure four port 0 pins as output pins (P0.15-P0.18) and five port1 pins (P1.16-P1.20)

as input pins for keyboard interface.

Step 3: Configure P0.2 and P0.3 as output for display interfacing.

Step 4: Give serial input to shift register to clear all six 7-segment display.

Step 5: Scan the keyboard to get the number .

Step 6: If AC key has been pressed, then clear the display and go to step 4.

Step 7: otherwise display the number corresponding to key pressed.

Step 8: Go to step 4.

Step 13: Stop the program.

PROCEDURE:





Step 5: Connect the Key Board Display Interface to MCB 2140 using ESA Interface Adapter

for MCB 2140.

Step 6: Download the Key Board Display Program using Keil ULINK /LPC Flash

Programmer Utility.


Step 8: Press reset to Run the program / Enter debug mode and press run.

FLOWCHART:

NO

YES

NO

YES

NO

YES

START

Configure port pins input output functionality to

interface keyboard and display

Give six 0xff serially to shift

register to clear the display.

Clear all 7 segment Display

If any key has

been pressed?

If pressed key

is = AC?

If pressed key

is number

Display the number

PROGRAM:

#include

void DispChar(unsigned char ch);

void ClrLED(void);

void delay(unsigned int i);

unsigned char getkey(void);

unsigned char getnum(void);

main()

{

unsigned char n1;

unsigned char NumTab[10] = { 0x0c0,0x0f9,0x0a4,0xb0,0x99,0x92,0x82,0x0f8,0x80,0x90 };

PINSEL2 = PINSEL2 & 0xFFFFFFF7;

IODIR0 = 0x007F800C;

IODIR1 = 0x00000000;

ClrLED(); /* Clear the 7 segment display */

while(1)

{

n1=getnum(); /* Get the 1st number */

if(n1==0x13)

{

ClrLED(); /* If pressed key is "AC",then Clear LED */

continue;

}

DispChar(NumTab[n1]); /* Display the number */

delay(30000);

delay(30000);

delay(30000);

}

}

void DispChar(unsigned char ch) /* Function to display the charecter on 7 segment */

{

unsigned char i,tmp;

IOCLR0 = 0x003F8000; /* For all bits */

for(i=0;i

unsigned char getkey()

{

unsigned char j,indx;

unsigned long i,s=00;

while(1)

{

indx = 0x00; /* Index for storing the first value of scanline */

for(i=0x00008000;i 0) /* If key press is true */

{

for(j=0; j>=1;

if(s==0) /* If get pressed key*/

{

return(indx+j); /* Return index of the key pressed */

}

}

}

indx += 5; /* If no key pressed increment index */

}

}

}

unsigned char getnum() /* Function to get the number */

{

unsigned char tmp;

while(1)

{

tmp = getkey();

if(tmp < 0x0a || tmp==0x13) /* If pressed key is number, return */

return(tmp);

}

}

void delay(unsigned int i)

{

unsigned int j;

for(j=0;j

Ex.No:04

Date: 13-03-2014

SERIAL PORT INTERFACING

AIM:

To write a C Program for serial port interfacing with LPC2148 controller by using ARM

processor.

APPARATUS REQUIRED:

KEIL Software.


ULINK2 JTAG debugger.

ALGORITHM:

Step 1:Initialize the UART1 with the following settings-

Baudrate-9600; 1stop bit; 8 data bits; no parity.

Step 2: Configure the TxD1, RxD1 pin.

Step 3: Wait for data input from PC to LPC2148s UART1.

Step 4: After getting the UART1 input, give that character as output through UART1.

Step 5: Go to step 3.

PROCEDURE:





Step 5: Connect the MCB 2140 to the PC using RS232 port.


Step 7: Download the serial port Interface Program using ULINK2 JTAG debugger to the

MCB2140 board.

Step 8: Run the program and check the required output using hyperterminal Connection.

FLOWCHART:

Configure TxD1, RxD1 pins.

Initialize UART1 with Baud Rate: 9600, 1 Stop

bit, 8 data bits, No Parity

Get the Received data from UART1 Receive

buffer

Transmit that data through UART1

Start

Is

U1LSRs

LSB =1?

No

Yes

PROGRAM:

#include

#include

#define CR 0x0D

int sendchar (int ch)

{

if (ch == '\n')

{

while (!(U1LSR & 0x20));

U1THR = CR;

}


return (U1THR = ch);

}

int getkey (void)

{


return (U1RBR);

}

int main (void)

{

char c;

PINSEL0 = 0x00050000;

U1LCR = 0x83;

U1DLL = 97;

U1LCR = 0x03;

while (1)

{

c =(char) getkey();

// printf ("The char is %c\n", c);

sendchar('v');

sendchar('a');

sendchar('l');

sendchar('=');

sendchar(c);

sendchar('\n');

}

}

RESULT:

Thus the C program for serial port interfacing with LPC2148 Processor has been

executed.

Ex.No:05

Date:-10-04-2014

LCD INTERFACING

AIM:

To write a C Program to interface LCD with LPC2919 processor through MCB2900 Evaluation

Kit.

APPARATUS REQUIRED:

KEIL Software.


ULINK2 JTAG Debugger

ALGORITHM:

1. Initialize LCD to work with 4 bit mode.

2. Initialize the serial port with the following settings. Baud rate-9600,stop bit-1,data bits-

8,parity-none.

3. Clear display & return the cursor to home in LCD.

4. Print two lines in LCD.

5. Get the input from USART0,until 0x0d has been given

6. Accumulate the input characters in a character array

7. Clear display & return the cursor to home

8. Display the character array content in the first line.

9. Go to step5.

PROCEDURE:





Step 5: Connect the MCB 2900 to the pc using RS232 port.


Step 7: Download the LCD Program using flash magic/JTAG Debugger to the MCB2900 board.

Step 8: Run the program and give input through hyper terminal and check the output in LCD.

FLOW CHART:-

no

Initialise LCD to 4 bit mode

Initialize serial port with BR=9600,stop

bit=1,data bits=8,no parity.

Clear the display& return cursor to home.

Print the 2 lines in LCD

Put Null Character at the end of the array

Clear the display & cursor of 1st line in home

Display the character array contents in 1st line

Start

Whether serial

I/P is given as

0x0D?

Accumulate the input

character in an array

Yes

PROGRAM:

#include

#include "LCD.h"

//- DB4 = P0.28 - DB5 = P0.29 - DB6 = P0.30 - DB7 = P0.31 - E = P0.3 - RW = P0.4 -

RS = P0.5 */

#define PIN_E (1

for (i = 0; i < 12000000; i++);

for (;;)

{

i=0;

do

{

c =(unsigned char)getkey();

str[i] =c;

i= (i+1)%16;

}

while(c != 0x0d);

str[i-1] =0x00;

lcd_write_cmd(0x01);

lcd_write_cmd(0x80);

LCD_print (0x80, str);

}

}

LCD.C

void lcd_write_4bit (unsigned char c)

{

LCD_RW(0)

LCD_E(1)

LCD_DATA_OUT(c&0x0F)

delay(10);

LCD_E(0)

delay(10);

}

void lcd_write_cmd (unsigned char c)

{

delay(1000);

LCD_RS(0)

lcd_write_4bit(c>>4);

lcd_write_4bit(c);

}

static void lcd_write_data (unsigned char c)

{

delay(1000);

LCD_RS(1)

lcd_write_4bit(c>>4);

lcd_write_4bit(c);

}

void LCD_init (void)

{

inti;

GPIO0_DR |= 0xF0000038;

delay (15000);

LCD_RS(0)

lcd_write_4bit(0x3); /* Select 4-bit interface */

delay (4100);

lcd_write_4bit(0x3);

delay (100);



lcd_write_cmd(0x28); /* 2 lines, 5x8 character matrix */

lcd_write_cmd(0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */

lcd_write_cmd(0x06); /* Entry mode: Move right, no shift */

lcd_write_cmd(0x80); /* Set DDRAM address counter to 0 */

}

void LCD_print (unsigned char DDRAM_addr_cmd, unsigned char *string)

{

lcd_write_cmd(DDRAM_addr_cmd);

while (*string)

lcd_write_data (*string++);

}

Serial.c

#include

#include

int getkey (void)

{


return (U1RBR);

}

RESULT:

Thus the C program for LCD interfacing with LPC2148 Processor has been executed.

Ex.No:06

Date:17-04-2014

CAN SERIAL CONTROLLER

AIM:

To write a C Program for CAN serial in LPC2919 by using MCB2900 Evaluation Board.

APPARATUS REQUIRED:

Keil software

MCB2900 Microcntroller board

ULINK2 JTAG debugger

ALGORITHM:

Step 1: Select the UART0 & CAN0 pin functionality.

Step 2: Configure the UART0 with baud rate: 9600; 1stop bit; 8 data bits; no parity.

Step 3: Initialize the TIMER0 which gives the interrupts at every 10ms.

Step 4: Start TIMER0.

Step 5: Enable CAN0 RX interrupt.

Step 6: Enable the serial port for transmitting the data.

Step 7: Wait for clock1S flag to be 1. (This flag is made as 1 for every 1sec in Timer0 ISR).

Step 8: Transmit the Tx data through CAN0.

Step 9: Transmit, transmitted & received data of CAN0 through UART0.

Step10: Increment ASCII value of Tx data from A to Z.

Step11: go to step No.7.

PROCEDURE:

Step 1: Open the Keil software.




Step 5: Connect the LPC2919 device to the PC using RS232 port.


Step 7: Download the CAN serial port Program to LPC2919 Processor with the help of ULINK2

JTAG Debugger.


Step9 : Check the required output using Hyperterminal window.

PROGRAM:

#include

#include

#define TMR_CLK 80000000

volatile unsigned char Clock1s;

volatile unsigned char Rx_Data;

volatile unsigned char Tx_Data;

extern void init_serial (void);

int main (void) {

int i;

GPIO1_DR |= (0x3F

CAN_AFMR = 2;

Tx_Data ='a';

for (;;) {

if (Clock1s) {

Clock1s = 0;

CAN0TFI1 = 1 'z')

Tx_Data ='a';

}

}

}

IRQ.C

#include

extern volatile unsigned char Clock1s;

extern volatile unsigned char Rx_Data;

__irq void Timer0_Handler (void) { /* Timer 0 Interrupt Handler */

static unsigned char cnt1s;

if (cnt1s++ >= 99) { /* Set Clock1s each 1 second */

cnt1s = 0;

Clock1s = 1;

}

TIM0_INT_CLR_STATUS = 1; /* Clear Timer 0 interrupt status */

}

__irq void CAN0_Rx_Handler (void) { /* CAN0 Rx Interrupt Handler */

volatile unsigned long dummy;

dummy = CAN0ICR; /* Read and clear interrupt status */

Rx_Data = CAN0RDA; /* Read Data Byte */

CAN0CMR = 4; /* Release receive buffer */

}

RESULT:

Thus the program for CAN SERIAL CONOTROLLER has been executed.

Ex:No: 7

Date :24-04-2014

DESIGN AND IMPLEMENTATION OF SIMPLE COMBINATIONAL AND

SEQUENTIAL CIRCUITS

Aim:

To Write verilog code for half adder, full adder, MUX, D Flip-Flop and simulate

and synthesis.

Required:

Xilinx software

Procedure:

1. write the Verilog codings for half adder, full adder, MUX in Xilinx.

2. Read the input values.

3. Check for the syntax errors.

4. Simulate the codings and assign input values for the wave form in test

bench.

5. Verify the output waveform.

PROGRAM:

HALF ADDER

module ha(a,b,s,c);

input a,b;

output s,c;

and(c,a,b);

xor(s,a,b);

end module

FULL ADDER

module ha(a,b,c,s,c);

input a,b,c;

output s,c;

wire d,e,f;

xor(d,a,b)

xor(s,d,c);

and(e,d,c);

and(f,a,b);

or(c,e,f);

end module

SIMULATION RESULTS:

HALF ADDER:

FULL ADDER:

PROGRAM :

MULTIPLEXER

module mux(i0,i1,i2,i3,y);

input i0,i1,i2,i3;

output y;

input s0,s1;

wire w1,w2,a,b,c,d;

and(a,i0,w1,w2);

and(b,i1,w1,s1);

and(c,i2,s0,w2);

and(d,i3,s0,s1);

end module;

SIMULATION RESULTS:

MULTIPLEXER:

D FLIP FLOP

module dff_sync_reset ( data , clk , reset, q );

input data, clk, reset ;

output q;

reg q;

always @ ( posedge clk)

if (~reset) begin

q

Ex:No: 8

Date : 24-04-2014

DESIGN WITH PROGRAMMABLE LOGIC DEVICES USING XILINX

FPGA & CPLD

Aim:

To design Programmable Logic Devices using xilinx FPGA & CPLD

Required :

Xilinx software, FPGA Kit.

Procedure:

1. Write the Verilog codings for Programmable Logic Devices in Xilinx.

2. Read the input values.

3. Check for the syntax errors.

4. Simulate the codings and assign input values for the wave form in test bench.

5. Verify the output waveform.

6. Download the coding to FPGA kit and check the logic.

Program :

module PAL(a,b,c,f0,f1,f2,f3);

input a,b,c;

output f0,f1,f2,f3;

wire d,e,f,g,h,i,j,k;

not (e,b);

not (f,c);

and (g,a,b);

and(h,e,c);

and(i,a,f);

and(j,e,f);

and(k,a,c);

or(f0,j,k);

or(f1,i,g);

or(f2,j,g);

or(f3,k,h);

end module

Result:

Thus the design and implement ion of PAL device using Xilinx FPGA & CPLD is

done.

Ex.No.9

Date : 2-05-2014

INTERTASK SYNCHRONIZATION USING SEMAPHORE ON ARM 7

Aim :

To write a program to perform intertask synchronization using semaphore using

RTX kernel on ARM7.

Requirement :

Keil uVision V4

Procedure :

1. Open keil Uvison V4.

2. Create a new project.

3. Type the program files.

4. Create the necessary header files and add to the project.

5. Save and build the file.

6. Debug and execute the program.

7. Check the results using UART2 serial windows.

Flow Chart :

Main :

init task :

START

INITIALIZE KERNAL

START INIT TASK

INITIALIZE SERIAL PORT

CREATE TASK 1 WITH PRIORITY 10


DELETE INIT TASK

STOP

START

Task 1:

START

WAIT FOR 30MS

WAIT 1 TICK FOR SEMAPHORE

PRINT TASK1

RELEASE SEMAPHORE

Task 2:

N

Y

Y

START

PRINT TASK2

RELEASE SEMAPHORE

WHETHER

SEMAPHORE

IS RECEVIED?

?

Program :

/* Semaphore.c */

/*----------------------------------------------------------------*/

#include /* RTX kernel functions & defines */

#include /* LPC21xx definitions */

#include

extern void init_serial (void); /* Initialize Serial Interface */

OS_TID tsk1, tsk2;

OS_SEM semaphore1;

__task void task1 (void)

{

OS_RESULT ret;

while (1)

{

/* Pass control to other tasks for 3 OS ticks */

os_dly_wait(3);

/* Wait 1 ticks for the free semaphore */

ret = os_sem_wait (semaphore1, 1);

if (ret != OS_R_TMO) {

/* If there was no time-out the semaphore was aquired */

printf ("Task 1\n");

/* Return a token back to a semaphore */

os_sem_send (semaphore1);

}

}

}


{

while (1)

{

/* Wait indefinetly for a free semaphore */

os_sem_wait (semaphore1, 0xFFFF);

/* OK, the serial interface is free now, use it. */

printf ("Task 2 \n");

/* Return a token back to a semaphore. */

os_sem_send (semaphore1);

}

}

__task void init (void)

{

/* Initialize the UART */

init_serial ();

/* Initialize the Semaphore before the first use */

os_sem_init (semaphore1, 1);

/* Create an instance of task1 with priority 10 */

tsk1 = os_tsk_create (task1, 10);

/* Create an instance of task2 with default priority 1 */


/* Delete the init task */

os_tsk_delete_self ();

}

int main (void) {

/* Initialize RTX and start init */

os_sys_init (init);

}

/*Serial.c */

/*----------------------------------------------------------------*/


#include

#define CR 0x0D

void init_serial (void) {

PINSEL0 = 0x00050000; /* Enable RxD1 and TxD1 */

U1LCR = 0x83; /* 8 bits, no Parity, 1 Stop bit */

U1DLL = 97; /* 9600 Baud Rate @ 15MHz VPB Clock */

U1LCR = 0x03; /* DLAB = 0 */

}

int fputc (int ch, FILE *f) {

if (ch == '\n') {


U1THR = CR; /* output CR */

}



}

SIMULATION OUTPUT:

Result :

Thus the program for intertask synchronization using semaphore is done and the

output is verified in UART window.

Ex.No:10

Date : 02-05-2014

IMPLEMENTATION OF EVENT CONTROL BLOCKS ON ARM7

Aim :

To write a program to implement a Event Control Blocks in ARM7

using RTX kernel.

Requirement :

Keil uVision V4

Procedure :







7. Check the results using PORT1 window.

Flow Chart :

Main :

START

INITIALIZE PORT 1 PINS 16 TO 23 AS OUTPUT PINS

START INITIAL TASK

TASK1

STOP

TASK 1:

N

Y

SET THE PORT 1.23 PIN

CLEAR THE PORT 1.23 PIN

Set the port 1.23

pin

WAIT FOR 50ms

START

SET EVENT FLAG 0X0004 FOR

TASK 2

CREATE TASK 2 WITH

PRIORITY 10

WHETHER EVENT

FLAG 0X0004 IS

SET BY TASK2?

Task 2 :

N

Y

START

SET THE PORT 1.16

CLEAR THE PORT 1.16

WAIT FOR 20ms

SET EVENT 0X0004

WHETHER EVENT

FLAG 0X0004 IS

SET?

Program :


#include

/* id1, id2 will contain task identifications at run-time */

OS_TID id1, id2;

/* Forward reference */

__task void task1 (void);

__task void task2 (void);


{

/* Obtain own system task identification number */

id1 = os_tsk_self ();

/* Assign system identification number of task2 to id2 */

id2 = os_tsk_create (task2, 10);

for (;;) { /* do-this */

/* Indicate to task2 completion of do-this */

os_evt_set (0x0004, id2);

/* Wait for completion of do-that (0xffff means no time-out)*/

IOSET1 =0x00800000;

os_evt_wait_or (0x0004, 0xffff);

IOCLR1 =0x00800000;

/* Wait now for 50 ms */

os_dly_wait (5);

}

}


{

//int i;

for (;;) {

/* Wait for completion of do-this (0xffff means no time-out) */

IOSET1 =0x00010000;

os_evt_wait_or (0x0004, 0xffff); /* do-that */

IOCLR1 =0x00010000;

/* Pause for 20 ms until signaling event to task1 */

os_dly_wait (2);

/* Indicate to task1 completion of do-that */

//i=5;

os_evt_set (0x0004, id1);

}

}

int main (void) {

IODIR1 = 0xFF0000; /* P1.16..22 defined as Outputs */

os_sys_init (task1);

}

SIMULATION OUTPUT:

Result:

Thus the program to implement an event control blocks is executed & output

is verified using PORT 1 from peripheral window.

Ex.No:11

Date :08-05-2014

INTERTASK COMMUNICATION USING MAILBOX

Aim :

To write a program for intertask communication using Mailbox on ARM7

using RTX kernel.

Requirement :

Keil uVision V4

Procedure :







7. Check the results using UART window.

Flow Chart :

MAIN :

START

INITIALISE THE KERNAL

INITIALISE THE PORT 1.16 TO PORT 1.23 AS OUTPUT PINS

INITIALISE THE SERIAL COMMUNICATION PORT

START THE SEND TASK

CREATE A MEMORY BLOCK

STOP

SEND_TASK :

START

DECLARE mptr AS STRUCTURE POINTER OF MESSAGE STRUCTURE

INITIALISE MAILBOX

CREATE res_task WITH PRIORTY 1

WAIT FOR 50ms

ALLOCATE MEMORY FOR MEMORY POOL & GET THE STARTING ADDRESSE AT mptr

INITALISE A MESSAGE VALUE TO MAILBOX

SEND MESSAGE TO MAILBOX

SET THE PIN PORT 1.16

WAIT FOR 1 SECOND

DELETE THE TASK

REC_TASK :

N

Y

START

DECLARE rptr AS STRUCTURE POINTER

PRINT VOLTAGE,CURRENT AND COUNTER VALUES

MAKE THE MAILBOX FREE

WHETHER

MAILBOX IS

RECEVIED?

Program :



#include

OS_TID tsk1; /* assigned identification for task 1 */

OS_TID tsk2; /* assigned identification for task 2 */

typedef struct { /* Message object structure */

float voltage; /* AD result of measured voltage */

float current; /* AD result of measured current */

U32 counter; /* A counter value */

} T_MEAS;

os_mbx_declare (MsgBox,16); /* Declare an RTX mailbox */

_declare_box (mpool,sizeof(T_MEAS),16);/* Dynamic memory pool */

__task void send_task (void);

__task void rec_task (void);

void init_serial () {




U1LCR = 0x03; /* DLAB = 0 */

}

__task void send_task (void) {

T_MEAS *mptr;

tsk1 = os_tsk_self (); /* get own task identification number */

tsk2 = os_tsk_create (rec_task, 0); /* start task 2 */

os_mbx_init (MsgBox, sizeof(MsgBox));/* initialize the mailbox */

os_dly_wait (5); /* Startup delay for MCB21xx */

mptr = _alloc_box (mpool); /* Allocate a memory for the message */

mptr->voltage = 223.72; /* Set the message content */

mptr->current = 17.54;

mptr->counter = 120786;

os_mbx_send (MsgBox, mptr, 0xffff); /* Send the message to the mailbox */

IOSET1 = 0x10000;

os_dly_wait (100);

os_tsk_delete_self (); /* We are done here, delete this task */

}

__task void rec_task (void) {

T_MEAS *rptr;

for (;;) {

os_mbx_wait (MsgBox, (void **)&rptr, 0xffff); /* wait for the message */

printf ("\nVoltage: %.2f V\n",rptr->voltage);

printf ("Current: %.2f A\n",rptr->current);

printf ("Number of cycles: %d\n",rptr->counter);

_free_box (mpool, rptr); /* free memory allocated for message */

}

}

int main (void) { /* program execution starts here */

IODIR1 = 0xFF0000; /* P1.16..22 defined as Outputs */

init_serial (); /* initialize the serial interface */

_init_box (mpool, sizeof(mpool), /* initialize the 'mpool' memory for */

sizeof(T_MEAS)); /* the membox dynamic allocation */

os_sys_init (send_task); /* initialize and start task 1 */

}

SIMULATION OUTPUT:

Result :

Thus the program to implement mailbox in tasks on ARM 7 is performed

and the output is verified using UART window.

Ex.No:12

Date : 15-05-2014

INTERTASK SYCHRONIZATION USING MUTEX

Aim :

To write a program to implement a Mutex in ARM7 using RTX kernel.

Requirement :

Keil uVision V4

Procedure :







7. Check the results using UART window.

Flow Chart :

Main :

Init Task :

START

INITIALIZE KERNAL

START INIT TASK

INITIALIZE SERIAL COMMUNICATION PORT

INITIALIZE MUTEX 1



DELETE THE TASK

STOP

START

Task 1:

N

Y

START

WAIT FOR 30MS

PRINT TASK1

RELEASE THE MUTEX

WHETHER

MUTEX IS

RELEASED ?

Task 2 :

N

Y

START

PRINT TASK2

RELEASE THE MUTEX

WHETHER

MUTEX IS

RELEASED BY

TASK1 ?

Program :

/* Mutex .c /*

/*----------------------------------------------------------------------------



#include

extern void init_serial (void); /* Initialize Serial Interface */

OS_TID tsk1, tsk2;

OS_MUT mutex1;

__task void task1 (void) {

while (1) {

/* Pass control to other tasks for 3 OS ticks */

os_dly_wait(3);

/* Wait indefinitely for mutex */

os_mut_wait (&mutex1, 0xffff);

printf ("Task 1\n");

/* Return a mutex */

os_mut_release (&mutex1);

}

}

__task void task2 (void) {

while (1) {

/* Wait indefinetly for a free mutex */

os_mut_wait (&mutex1, 0xFFFF);

/* OK, the serial interface is free now, use it. */

printf ("Task 2 \n");

/* Return a Mutex. */

os_mut_release (&mutex1);

}

}

__task void init (void) {

/* Initialize the UART */

init_serial ();

/* Initialize the Semaphore before the first use */

os_mut_init (&mutex1);

/* Create an instance of task1 with priority 10 */


/* Create an instance of task2 with default priority 1 */


/* Delete the init task */

os_tsk_delete_self ();

}

int main (void) {

/* Initialize RTX and start init */

os_sys_init (init);

}

/* serial.c /*

/*----------------------------------------------------------------------------


#include

#define CR 0x0D

void init_serial (void) {




U1LCR = 0x03; /* DLAB = 0 */

}

int fputc (int ch, FILE *f) {

if (ch == '\n') {


U1THR = CR; /* output CR */

}



}

SIMULATION OUTPUT:

Result :

Thus the program to implement mutex in ARM 7 is done using keil

uVision4 and the result is verified using UART window.

Ex.No: 13

Date : 22-05-2014

VECTOR ADDITION

Aim:

To perform addition of two arrays by writing an assembly language

program for ADSP 2181 using Visual DSP++ software.

Requirement :

Visual DSP++ software.

Procedure :

1. Open visual DSP++ version 3.5.

2. Choose the ADSP-2181 simulation session.


4. Type the program in a new file.

5. Save the file with .asm extension.

6. Add file to the project.

7. Bulid the project.

8. Debug and run the project.

9. Verify the output in the address location 0x100 in I/O memory.

Program :

#define n 10

#define z_out 0x100

.section/data data1;

.VAR x_input[n] = "xin.dat";

.section/pm pm_da;

.VAR y_input[n] = "yin.dat";

.section/pm interrupts;

__reset: JUMP start; nop; nop; nop; /* 0x0000: Reset vector*/

RTI; nop; nop; nop; /* 0x0004: IRQ2*/

RTI; nop; nop; nop; /* 0x0008: IRQL1*/

RTI; nop; nop; nop; /* 0x000C: IRQL0*/

RTI; nop; nop; nop; /* 0x0010: SPORT0 transmit*/

RTI; nop; nop; nop; /* 0x0014: SPORT0 receive*/

RTI; nop; nop; nop; /* 0x0018: IRQE*/

RTI; nop; nop; nop; /* 0x001C: BDMA*/



RTI; nop; nop; nop; /* 0x0028: Timer*/

RTI; nop; nop; nop /* 0x002C: Power down*/

.section/pm program;

start: I2=x_input; /*pointer to x input buffer*/

L2=0; /*noncircular buffer*/

I6=y_input; /*pointer to y input buffer*/

L6=0;

M0=1; L0=0;

M5=1; L5=0;

CNTR=n-1;

AX0=DM(I2,M0), AY0=PM(I6,M5); /*Get first data*/

DO add_loop UNTIL CE;

AR=AX0+AY0, AX0=DM(I2,M0), AY0=PM(I6,M5);

add_loop: io(z_out)=AR; /*Write output*/

AR=AX0+AY0;

io(z_out)=AR;

IDLE;

Flow chart :

START

STORE n WITH 10

DECLARE OUTPUT ADDRESS AS Z_OUT = 0X100

INITIALISE 16BIT DAT BUFFER AS X_INPUT[n]= XIN.DAT

Y DATA IS LOADED INTO Y_INPUT[n]

THE ADDRESS OF FIRST NUMBER IS LOADED INTO I2(THE INDEX REGISTER OF DAG1)

DECLARE LENGTH REGISTER L2 AS 0 TO INDICATE IT AS A LINEAR BUFFER

THE ADDRESS OF FIRST NUMBER FROM Y_INPUT IS LOADED INTO I6

(THE INDEX REGISTER OF DAG2)

DECLARE LENGTH REGISTER L6 AS 0 TO INDICATE IT AS A LINEAR BUFFER

DECLARE MODIFY REGISTER M0 & M3 TO GET AN OFFSET OF ONE

LOAD COUNTER(cntr) WITH VALUE 9

LOAD FIRST X_INPUT VALUE IN AX0 AND FIRST Y_INPUT VALUE IN AY0

Y

N

ADD AX0 AND AY0

THE RESULT IS SHARED IN I0 MEMORY 0X100

WHETHER

COUNTER(cntr)

EXPIRES ?

LOAD AX0 AND AY0 WITH NEXT DATA USING INDEX

AND MODIFY REGISTER

PROCESSOR GOES TO POWER DOWN MODE

STOP

Simulation Output :

Result :

The addition of two arrays has been perfomed using VDSP++ software and

the output verified.

Ex.No:14

Date :29-05-2014

ADSP Program to control a LED

Aim:

To write a program to simulate the blinking of a LED at regular intervals in

ADSP 2181 using Visual software.

Requirement :


Procedure :





5. Save the file with .asm extension.



8. Debug and run the project.

9. Verify the output in flag register.

Program :

.section/pm interrupts;

_reset: JUMP start; nop; nop; nop; /* 0x0000: Reset vector*/

RTI; nop; nop; nop; /* 0x0004: IRQ2*/

RTI; nop; nop; nop; /* 0x0008: IRQL1*/

RTI; nop; nop; nop; /* 0x000C: IRQL0*/



RTI; nop; nop; nop; /* 0x0018: IRQE*/

RTI; nop; nop; nop; /* 0x001C: BDMA*/



nop; nop; nop; nop; /* 0x0028: Timer*/

RTI; nop; nop; nop; /* 0x002C: Power down*/

.section/pm program;

start:

imask=0x001;

ena timer;

again:

toggle f11;

entr=0x2;

do loop1 until ce;

entr=0xfff;

do loop2 until ce;

nop;

loop2:nop;

loop1:nop;

jump again;

Flow chart :

FILL INTERRUPT VECTOR LOCATION WITH RTI

REMOVE MASK INTERRUPT FOR TIMER 1

ENABLE TIMER

TOGGLE FLAG 1

LOAD CNTR WITH 0X2

DELAY

LOAD CNTR WITH 0XFF

DELAY

Simulation Output :

Result :

A program has been written to blink a LED assumed to be a FL1 at

different ime intervals using visual DSP++ program.

Ex.No:15

Date : 29-05-2014

CONVOLUTION

Aim:

To write a program to perform convolution in ADSP2181 using visual

DSP++ software.

Requirement :


Procedure :





5. Save the file with .c extension.



8. Debug and run the project

9. Verify the output in data memory.

Program :

void main()

{

int m,n,i,j;

int x[10]={1,1,1,1};

int h[10] ={1,2,3};

static int y[20];

m =4;

n =3;

for(i=m;i

}

}

for(;;);

}

Flow chart :

Start

DECLARE M,N,I,J,AS INTEGER

CHECK WHETHER

i-j>=0

INITIALISE J=0

DECLARE X[10] SEQUENCE (INPUT)

INITIALISE i=0

DECLARE H[10] SEQUENCE (IMPULSE)

DECLARE OUTPUT SEQUENCE AS Y[20]

STORE M VALUE AS 4 & N AS 3

MAKE X[4] TO X[7] AS ZERO & H[3] TO

H[7] AS ZERO

Y[i]=0

CALCULATE Y[i] = Y[i]+X[j]+H[i-j]

A

B

C

NO

YES

NO

YES

INCREMENT

J & CHECK IF

j

Simulation Output :

Result :

The convolution program in ADSP 2181 in visual DSP is performed and

output verified.

rtos & embedded lab record

Documents

routine step

analog channel1 step

interfacing stepper

delay function

c program

c program

stepper motor interfacing

keil software