OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [CORTEX_LM3S102_KEIL/] [Demo1/] [main.c] - Blame information for rev 581

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 581 jeremybenn
/*
2
    FreeRTOS V6.1.1 - Copyright (C) 2011 Real Time Engineers Ltd.
3
 
4
    ***************************************************************************
5
    *                                                                         *
6
    * If you are:                                                             *
7
    *                                                                         *
8
    *    + New to FreeRTOS,                                                   *
9
    *    + Wanting to learn FreeRTOS or multitasking in general quickly       *
10
    *    + Looking for basic training,                                        *
11
    *    + Wanting to improve your FreeRTOS skills and productivity           *
12
    *                                                                         *
13
    * then take a look at the FreeRTOS books - available as PDF or paperback  *
14
    *                                                                         *
15
    *        "Using the FreeRTOS Real Time Kernel - a Practical Guide"        *
16
    *                  http://www.FreeRTOS.org/Documentation                  *
17
    *                                                                         *
18
    * A pdf reference manual is also available.  Both are usually delivered   *
19
    * to your inbox within 20 minutes to two hours when purchased between 8am *
20
    * and 8pm GMT (although please allow up to 24 hours in case of            *
21
    * exceptional circumstances).  Thank you for your support!                *
22
    *                                                                         *
23
    ***************************************************************************
24
 
25
    This file is part of the FreeRTOS distribution.
26
 
27
    FreeRTOS is free software; you can redistribute it and/or modify it under
28
    the terms of the GNU General Public License (version 2) as published by the
29
    Free Software Foundation AND MODIFIED BY the FreeRTOS exception.
30
    ***NOTE*** The exception to the GPL is included to allow you to distribute
31
    a combined work that includes FreeRTOS without being obliged to provide the
32
    source code for proprietary components outside of the FreeRTOS kernel.
33
    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT
34
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
35
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
36
    more details. You should have received a copy of the GNU General Public
37
    License and the FreeRTOS license exception along with FreeRTOS; if not it
38
    can be viewed here: http://www.freertos.org/a00114.html and also obtained
39
    by writing to Richard Barry, contact details for whom are available on the
40
    FreeRTOS WEB site.
41
 
42
    1 tab == 4 spaces!
43
 
44
    http://www.FreeRTOS.org - Documentation, latest information, license and
45
    contact details.
46
 
47
    http://www.SafeRTOS.com - A version that is certified for use in safety
48
    critical systems.
49
 
50
    http://www.OpenRTOS.com - Commercial support, development, porting,
51
    licensing and training services.
52
*/
53
 
54
/*
55
 * This demo application creates six co-routines and two tasks (three including
56
 * the idle task).  The co-routines execute as part of the idle task hook.
57
 *
58
 * Five of the created co-routines are the standard 'co-routine flash'
59
 * co-routines contained within the Demo/Common/Minimal/crflash.c file and
60
 * documented on the FreeRTOS.org WEB site.
61
 *
62
 * The 'LCD Task' rotates a string on the LCD, delaying between each character
63
 * as necessitated by the slow interface, and delaying between each string just
64
 * long enough to enable the text to be read.
65
 *
66
 * The sixth co-routine and final task control the transmission and reception
67
 * of a string to UART 0.  The co-routine periodically sends the first
68
 * character of the string to the UART, with the UART's TxEnd interrupt being
69
 * used to transmit the remaining characters.  The UART's RxEnd interrupt
70
 * receives the characters and places them on a queue to be processed by the
71
 * 'COMs Rx' task.  An error is latched should an unexpected character be
72
 * received, or any character be received out of sequence.
73
 *
74
 * A loopback connector is required to ensure that each character transmitted
75
 * on the UART is also received on the same UART.  For test purposes the UART
76
 * FIFO's are not utalised in order to maximise the interrupt overhead.  Also
77
 * a pseudo random interval is used between the start of each transmission in
78
 * order that the resultant interrupts are more randomly distributed and
79
 * therefore more likely to highlight any problems.
80
 *
81
 * The flash co-routines control LED's zero to four.  LED five is toggled each
82
 * time the string is transmitted on the UART.  LED six is toggled each time
83
 * the string is CORRECTLY received on the UART.  LED seven is latched on should
84
 * an error be detected in any task or co-routine.
85
 *
86
 * In addition the idle task makes repetative calls to
87
 * prvSetAndCheckRegisters().  This simply loads the general purpose registers
88
 * with a known value, then checks each register to ensure the held value is
89
 * still correct.  As a low priority task this checking routine is likely to
90
 * get repeatedly swapped in and out.  A register being found to contain an
91
 * incorrect value is therefore indicative of an error in the task switching
92
 * mechansim.
93
 *
94
 */
95
 
96
/* Scheduler include files. */
97
#include "FreeRTOS.h"
98
#include "task.h"
99
#include "queue.h"
100
#include "croutine.h"
101
 
102
/* Demo application include files. */
103
#include "partest.h"
104
#include "crflash.h"
105
 
106
/* Library include files. */
107
#include "LM3Sxxx.h"
108
#include "pdc.h"
109
 
110
/* The time to delay between writing each character to the LCD. */
111
#define mainCHAR_WRITE_DELAY            ( 2 / portTICK_RATE_MS )
112
 
113
/* The time to delay between writing each string to the LCD. */
114
#define mainSTRING_WRITE_DELAY          ( 400 / portTICK_RATE_MS )
115
 
116
/* The number of flash co-routines to create. */
117
#define mainNUM_FLASH_CO_ROUTINES       ( 5 )
118
 
119
/* The length of the queue used to pass received characters to the Comms Rx
120
task. */
121
#define mainRX_QUEUE_LEN                        ( 5 )
122
 
123
/* The priority of the co-routine used to initiate the transmission of the
124
string on UART 0. */
125
#define mainTX_CO_ROUTINE_PRIORITY      ( 1 )
126
 
127
/* Only one co-routine is created so its index is not important. */
128
#define mainTX_CO_ROUTINE_INDEX         ( 0 )
129
 
130
/* The time between transmissions of the string on UART 0.   This is pseudo
131
random in order to generate a bit or randomness to when the interrupts occur.*/
132
#define mainMIN_TX_DELAY                        ( 40 / portTICK_RATE_MS )
133
#define mainMAX_TX_DELAY                        ( ( portTickType ) 0x7f )
134
#define mainOFFSET_TIME                         ( ( portTickType ) 3 )
135
 
136
/* The time the Comms Rx task should wait to receive a character.  This should
137
be slightly longer than the time between transmissions.  If we do not receive
138
a character after this time then there must be an error in the transmission or
139
the timing of the transmission. */
140
#define mainCOMMS_RX_DELAY                      ( mainMAX_TX_DELAY + 20 )
141
 
142
/* The task priorites. */
143
#define mainLCD_TASK_PRIORITY           ( tskIDLE_PRIORITY )
144
#define mainCOMMS_RX_TASK_PRIORITY      ( tskIDLE_PRIORITY + 1 )
145
 
146
/* The LED's toggled by the various tasks. */
147
#define mainCOMMS_FAIL_LED                      ( 7 )
148
#define mainCOMMS_RX_LED                        ( 6 )
149
#define mainCOMMS_TX_LED                        ( 5 )
150
 
151
/* The baud rate used by the UART comms tasks/co-routine. */
152
#define mainBAUD_RATE                           ( 57600 )
153
 
154
/* FIFO setting for the UART.  The FIFO is not used to create a better test. */
155
#define mainFIFO_SET                            ( 0x10 )
156
 
157
/* The string that is transmitted on the UART contains sequentially the
158
characters from mainFIRST_TX_CHAR to mainLAST_TX_CHAR. */
159
#define mainFIRST_TX_CHAR '0'
160
#define mainLAST_TX_CHAR 'z'
161
 
162
/* Just used to walk through the program memory in order that some random data
163
can be generated. */
164
#define mainTOTAL_PROGRAM_MEMORY ( ( unsigned long * ) ( 8 * 1024 ) )
165
#define mainFIRST_PROGRAM_BYTES ( ( unsigned long * ) 4 )
166
 
167
/*-----------------------------------------------------------*/
168
 
169
/*
170
 * The task that rotates text on the LCD.
171
 */
172
static void vLCDTask( void * pvParameters );
173
 
174
/*
175
 * The task that receives the characters from UART 0.
176
 */
177
static void vCommsRxTask( void * pvParameters );
178
 
179
/*
180
 * The co-routine that periodically initiates the transmission of the string on
181
 * the UART.
182
 */
183
static void vSerialTxCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex );
184
 
185
/*
186
 * Writes a string the the LCD.
187
 */
188
static void prvWriteString( const char *pcString );
189
 
190
/*
191
 * Initialisation routine for the UART.
192
 */
193
static void vSerialInit( void );
194
 
195
/*
196
 * Thread safe write to the PDC.
197
 */
198
static void prvPDCWrite( char cAddress, char cData );
199
 
200
/*
201
 * Function to simply set a known value into the general purpose registers
202
 * then read them back to ensure they remain set correctly.  An incorrect value
203
 * being indicative of an error in the task switching mechanism.
204
 */
205
void prvSetAndCheckRegisters( void );
206
 
207
/*
208
 * Latch the LED that indicates that an error has occurred.
209
 */
210
void vSetErrorLED( void );
211
 
212
/*
213
 * Sets up the PLL and ports used by the demo.
214
 */
215
static void prvSetupHardware( void );
216
 
217
/*-----------------------------------------------------------*/
218
 
219
/* Error flag set to pdFAIL if an error is encountered in the tasks/co-routines
220
defined within this file. */
221
unsigned portBASE_TYPE uxErrorStatus = pdPASS;
222
 
223
/* The next character to transmit. */
224
static char cNextChar;
225
 
226
/* The queue used to transmit characters from the interrupt to the Comms Rx
227
task. */
228
static xQueueHandle xCommsQueue;
229
 
230
/*-----------------------------------------------------------*/
231
 
232
int main( void )
233
{
234
        /* Create the queue used to communicate between the UART ISR and the Comms
235
        Rx task. */
236
        xCommsQueue = xQueueCreate( mainRX_QUEUE_LEN, sizeof( char ) );
237
 
238
        /* Setup the ports used by the demo and the clock. */
239
        prvSetupHardware();
240
 
241
        /* Create the co-routines that flash the LED's. */
242
        vStartFlashCoRoutines( mainNUM_FLASH_CO_ROUTINES );
243
 
244
        /* Create the co-routine that initiates the transmission of characters
245
        on the UART. */
246
        xCoRoutineCreate( vSerialTxCoRoutine, mainTX_CO_ROUTINE_PRIORITY, mainTX_CO_ROUTINE_INDEX );
247
 
248
        /* Create the LCD and Comms Rx tasks. */
249
        xTaskCreate( vLCDTask, "LCD", configMINIMAL_STACK_SIZE, NULL, mainLCD_TASK_PRIORITY, NULL );
250
        xTaskCreate( vCommsRxTask, "CMS", configMINIMAL_STACK_SIZE, NULL, mainCOMMS_RX_TASK_PRIORITY, NULL );
251
 
252
        /* Start the scheduler running the tasks and co-routines just created. */
253
        vTaskStartScheduler();
254
 
255
        /* Should not get here unless we did not have enough memory to start the
256
        scheduler. */
257
        for( ;; );
258
}
259
/*-----------------------------------------------------------*/
260
 
261
static void prvSetupHardware( void )
262
{
263
        /* Setup the PLL. */
264
        SysCtlClockSet( SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ );
265
 
266
        /* Initialise the hardware used to talk to the LCD, LED's and UART. */
267
        PDCInit();
268
        vParTestInitialise();
269
        vSerialInit();
270
}
271
/*-----------------------------------------------------------*/
272
 
273
void vApplicationIdleHook( void )
274
{
275
        /* The co-routines are executed in the idle task using the idle task
276
        hook. */
277
        for( ;; )
278
        {
279
                /* Schedule the co-routines. */
280
                vCoRoutineSchedule();
281
 
282
                /* Run the register check function between each co-routine. */
283
                prvSetAndCheckRegisters();
284
        }
285
}
286
/*-----------------------------------------------------------*/
287
 
288
static void prvWriteString( const char *pcString )
289
{
290
        /* Write pcString to the LED, pausing between each character. */
291
        prvPDCWrite(PDC_LCD_CSR, LCD_CLEAR);
292
        while( *pcString )
293
        {
294
                vTaskDelay( mainCHAR_WRITE_DELAY );
295
                prvPDCWrite( PDC_LCD_RAM, *pcString );
296
                pcString++;
297
        }
298
}
299
/*-----------------------------------------------------------*/
300
 
301
void vLCDTask( void * pvParameters )
302
{
303
unsigned portBASE_TYPE uxIndex;
304
const unsigned char ucCFGData[] = {
305
                                                                                        0x30,   /* Set data bus to 8-bits. */
306
                                                                                        0x30,
307
                                                                                        0x30,
308
                                                                                        0x3C,   /* Number of lines/font. */
309
                                                                                        0x08,   /* Display off. */
310
                                                                                        0x01,   /* Display clear. */
311
                                                                                        0x06,   /* Entry mode [cursor dir][shift]. */
312
                                                                                        0x0C    /* Display on [display on][curson on][blinking on]. */
313
                                                                          };
314
 
315
/* The strings that are written to the LCD. */
316
const char *pcStringsToDisplay[] = {
317
                                                                                        "Stellaris",
318
                                                                                        "Demo",
319
                                                                                        "One",
320
                                                                                        "www.FreeRTOS.org",
321
                                                                                        ""
322
                                                                           };
323
 
324
        /* Configure the LCD. */
325
        uxIndex = 0;
326
        while( uxIndex < sizeof( ucCFGData ) )
327
        {
328
                prvPDCWrite( PDC_LCD_CSR, ucCFGData[ uxIndex ] );
329
                uxIndex++;
330
                vTaskDelay( mainCHAR_WRITE_DELAY );
331
        }
332
 
333
        /* Turn the LCD Backlight on. */
334
        prvPDCWrite( PDC_CSR, 0x01 );
335
 
336
        /* Clear display. */
337
        vTaskDelay( mainCHAR_WRITE_DELAY );
338
        prvPDCWrite( PDC_LCD_CSR, LCD_CLEAR );
339
 
340
        uxIndex = 0;
341
        for( ;; )
342
        {
343
                /* Display the string on the LCD. */
344
                prvWriteString( pcStringsToDisplay[ uxIndex ] );
345
 
346
                /* Move on to the next string - wrapping if necessary. */
347
                uxIndex++;
348
                if( *( pcStringsToDisplay[ uxIndex ] ) == 0x00 )
349
                {
350
                        uxIndex = 0;
351
                        /* Longer pause on the last string to be sent. */
352
                        vTaskDelay( mainSTRING_WRITE_DELAY * 2 );
353
                }
354
 
355
                /* Wait until it is time to move onto the next string. */
356
                vTaskDelay( mainSTRING_WRITE_DELAY );
357
        }
358
}
359
/*-----------------------------------------------------------*/
360
 
361
static void vCommsRxTask( void * pvParameters )
362
{
363
static char cRxedChar, cExpectedChar;
364
 
365
        /* Set the char we expect to receive to the start of the string. */
366
        cExpectedChar = mainFIRST_TX_CHAR;
367
 
368
        for( ;; )
369
        {
370
                /* Wait for a character to be received. */
371
                xQueueReceive( xCommsQueue, ( void * ) &cRxedChar, mainCOMMS_RX_DELAY );
372
 
373
                /* Was the character recived (if any) the expected character. */
374
                if( cRxedChar != cExpectedChar )
375
                {
376
                        /* Got an unexpected character.  This can sometimes occur when
377
                        reseting the system using the debugger leaving characters already
378
                        in the UART regsters. */
379
                        uxErrorStatus = pdFAIL;
380
 
381
                        /* Resync by waiting for the end of the current string. */
382
                        while( cRxedChar != mainLAST_TX_CHAR )
383
                        {
384
                                while( !xQueueReceive( xCommsQueue, ( void * ) &cRxedChar, portMAX_DELAY ) );
385
                        }
386
 
387
                        /* The next expected character is the start of the string again. */
388
                        cExpectedChar = mainFIRST_TX_CHAR;
389
                }
390
                else
391
                {
392
                        if( cExpectedChar == mainLAST_TX_CHAR )
393
                        {
394
                                /* We have reached the end of the string - we now expect to
395
                                receive the first character in the string again.   The LED is
396
                                toggled to indicate that the entire string was received without
397
                                error. */
398
                                vParTestToggleLED( mainCOMMS_RX_LED );
399
                                cExpectedChar = mainFIRST_TX_CHAR;
400
                        }
401
                        else
402
                        {
403
                                /* We got the expected character, we now expect to receive the
404
                                next character in the string. */
405
                                cExpectedChar++;
406
                        }
407
                }
408
        }
409
}
410
/*-----------------------------------------------------------*/
411
 
412
static void vSerialTxCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )
413
{
414
portTickType xDelayPeriod;
415
static unsigned long *pulRandomBytes = mainFIRST_PROGRAM_BYTES;
416
 
417
        /* Co-routine MUST start with a call to crSTART. */
418
        crSTART( xHandle );
419
 
420
        for(;;)
421
    {
422
                /* Was the previously transmitted string received correctly? */
423
                if( uxErrorStatus != pdPASS )
424
                {
425
                        /* An error was encountered so set the error LED. */
426
                        vSetErrorLED();
427
                }
428
 
429
                /* The next character to Tx is the first in the string. */
430
                cNextChar = mainFIRST_TX_CHAR;
431
 
432
                UARTIntDisable( UART0_BASE, UART_INT_TX );
433
                {
434
                        /* Send the first character. */
435
                        if( !( HWREG( UART0_BASE + UART_O_FR ) & UART_FR_TXFF ) )
436
                        {
437
                                HWREG( UART0_BASE + UART_O_DR ) = cNextChar;
438
                        }
439
 
440
                        /* Move the variable to the char to Tx on so the ISR transmits
441
                        the next character in the string once this one has completed. */
442
                        cNextChar++;
443
                }
444
                UARTIntEnable(UART0_BASE, UART_INT_TX);
445
 
446
                /* Toggle the LED to show a new string is being transmitted. */
447
        vParTestToggleLED( mainCOMMS_TX_LED );
448
 
449
                /* Delay before we start the string off again.  A pseudo-random delay
450
                is used as this will provide a better test. */
451
                xDelayPeriod = xTaskGetTickCount() + ( *pulRandomBytes );
452
 
453
                pulRandomBytes++;
454
                if( pulRandomBytes > mainTOTAL_PROGRAM_MEMORY )
455
                {
456
                        pulRandomBytes = mainFIRST_PROGRAM_BYTES;
457
                }
458
 
459
                /* Make sure we don't wait too long... */
460
                xDelayPeriod &= mainMAX_TX_DELAY;
461
 
462
                /* ...but we do want to wait. */
463
                if( xDelayPeriod < mainMIN_TX_DELAY )
464
                {
465
                        xDelayPeriod = mainMIN_TX_DELAY;
466
                }
467
 
468
                /* Block for the random(ish) time. */
469
                crDELAY( xHandle, xDelayPeriod );
470
    }
471
 
472
        /* Co-routine MUST end with a call to crEND. */
473
        crEND();
474
}
475
/*-----------------------------------------------------------*/
476
 
477
static void vSerialInit( void )
478
{
479
        /* Enable the UART.  GPIOA has already been initialised. */
480
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
481
 
482
        /* Set GPIO A0 and A1 as peripheral function.  They are used to output the
483
        UART signals. */
484
        GPIODirModeSet( GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_DIR_MODE_HW );
485
 
486
        /* Configure the UART for 8-N-1 operation. */
487
        UARTConfigSet( UART0_BASE, mainBAUD_RATE, UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE );
488
 
489
        /* We dont want to use the fifo.  This is for test purposes to generate
490
        as many interrupts as possible. */
491
        HWREG( UART0_BASE + UART_O_LCR_H ) &= ~mainFIFO_SET;
492
 
493
        /* Enable both Rx and Tx interrupts. */
494
        HWREG( UART0_BASE + UART_O_IM ) |= ( UART_INT_TX | UART_INT_RX );
495
        IntEnable( INT_UART0 );
496
}
497
/*-----------------------------------------------------------*/
498
 
499
void vUART_ISR(void)
500
{
501
unsigned long ulStatus;
502
char cRxedChar;
503
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
504
 
505
        /* What caused the interrupt. */
506
        ulStatus = UARTIntStatus( UART0_BASE, pdTRUE );
507
 
508
        /* Clear the interrupt. */
509
        UARTIntClear( UART0_BASE, ulStatus );
510
 
511
        /* Was an Rx interrpt pending? */
512
        if( ulStatus & UART_INT_RX )
513
        {
514
                if( ( HWREG(UART0_BASE + UART_O_FR ) & UART_FR_RXFF ) )
515
                {
516
                        /* Get the char from the buffer and post it onto the queue of
517
                        Rxed chars.  Posting the character should wake the task that is
518
                        blocked on the queue waiting for characters. */
519
                        cRxedChar = ( char ) HWREG( UART0_BASE + UART_O_DR );
520
                        xQueueSendFromISR( xCommsQueue, &cRxedChar, &xHigherPriorityTaskWoken );
521
                }
522
        }
523
 
524
        /* Was a Tx interrupt pending? */
525
        if( ulStatus & UART_INT_TX )
526
        {
527
                /* Send the next character in the string.  We are not using the FIFO. */
528
                if( cNextChar <= mainLAST_TX_CHAR )
529
                {
530
                        if( !( HWREG( UART0_BASE + UART_O_FR ) & UART_FR_TXFF ) )
531
                        {
532
                                HWREG( UART0_BASE + UART_O_DR ) = cNextChar;
533
                        }
534
                        cNextChar++;
535
                }
536
        }
537
 
538
        /* If a task was woken by the character being received then we force
539
        a context switch to occur in case the task is of higher priority than
540
        the currently executing task (i.e. the task that this interrupt
541
        interrupted.) */
542
        portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
543
}
544
/*-----------------------------------------------------------*/
545
 
546
static void prvPDCWrite( char cAddress, char cData )
547
{
548
        vTaskSuspendAll();
549
        {
550
                PDCWrite( cAddress, cData );
551
        }
552
        xTaskResumeAll();
553
}
554
/*-----------------------------------------------------------*/
555
 
556
void vSetErrorLED( void )
557
{
558
        vParTestSetLED( mainCOMMS_FAIL_LED, pdTRUE );
559
}
560
/*-----------------------------------------------------------*/
561
 
562
__asm void prvSetAndCheckRegisters( void )
563
{
564
        extern vSetErrorLED
565
 
566
        /* Fill the general purpose registers with known values. */
567
        mov r11, #10
568
        add r0, r11, #1
569
        add r1, r11, #2
570
        add r2, r11, #3
571
        add r3, r11, #4
572
        add r4, r11, #5
573
        add r5, r11, #6
574
        add r6, r11, #7
575
        add r7, r11, #8
576
        add r8, r11, #9
577
        add r9, r11, #10
578
        add r10, r11, #11
579
        add r12, r11, #12
580
 
581
        /* Check the values are as expected. */
582
        cmp r11, #10
583
        bne set_error_led
584
        cmp r0, #11
585
        bne set_error_led
586
        cmp r1, #12
587
        bne set_error_led
588
        cmp r2, #13
589
        bne set_error_led
590
        cmp r3, #14
591
        bne set_error_led
592
        cmp r4, #15
593
        bne set_error_led
594
        cmp r5, #16
595
        bne set_error_led
596
        cmp r6, #17
597
        bne set_error_led
598
        cmp r7, #18
599
        bne set_error_led
600
        cmp r8, #19
601
        bne set_error_led
602
        cmp r9, #20
603
        bne set_error_led
604
        cmp r10, #21
605
        bne set_error_led
606
        cmp r12, #22
607
        bne set_error_led
608
        bx lr
609
 
610
set_error_led;
611
        push {r14}
612
        ldr r1, =vSetErrorLED
613
        blx r1
614
        pop {r14}
615
        bx lr;
616
}
617
/*-----------------------------------------------------------*/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.