begriffs open source - cmsis-freertos/blob - Demo/RX600_RX62N-RDK_GNURX/RTOSDemo/ParTest.c

   1 /*
   2     FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
   3     All rights reserved
   4
   5     VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
   6
   7     This file is part of the FreeRTOS distribution.
   8
   9     FreeRTOS is free software; you can redistribute it and/or modify it under
  10     the terms of the GNU General Public License (version 2) as published by the
  11     Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
  12
  13     ***************************************************************************
  14     >>!   NOTE: The modification to the GPL is included to allow you to     !<<
  15     >>!   distribute a combined work that includes FreeRTOS without being   !<<
  16     >>!   obliged to provide the source code for proprietary components     !<<
  17     >>!   outside of the FreeRTOS kernel.                                   !<<
  18     ***************************************************************************
  19
  20     FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
  21     WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  22     FOR A PARTICULAR PURPOSE.  Full license text is available on the following
  23     link: http://www.freertos.org/a00114.html
  24
  25     ***************************************************************************
  26      *                                                                       *
  27      *    FreeRTOS provides completely free yet professionally developed,    *
  28      *    robust, strictly quality controlled, supported, and cross          *
  29      *    platform software that is more than just the market leader, it     *
  30      *    is the industry's de facto standard.                               *
  31      *                                                                       *
  32      *    Help yourself get started quickly while simultaneously helping     *
  33      *    to support the FreeRTOS project by purchasing a FreeRTOS           *
  34      *    tutorial book, reference manual, or both:                          *
  35      *    http://www.FreeRTOS.org/Documentation                              *
  36      *                                                                       *
  37     ***************************************************************************
  38
  39     http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading
  40     the FAQ page "My application does not run, what could be wrong?".  Have you
  41     defined configASSERT()?
  42
  43     http://www.FreeRTOS.org/support - In return for receiving this top quality
  44     embedded software for free we request you assist our global community by
  45     participating in the support forum.
  46
  47     http://www.FreeRTOS.org/training - Investing in training allows your team to
  48     be as productive as possible as early as possible.  Now you can receive
  49     FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
  50     Ltd, and the world's leading authority on the world's leading RTOS.
  51
  52     http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
  53     including FreeRTOS+Trace - an indispensable productivity tool, a DOS
  54     compatible FAT file system, and our tiny thread aware UDP/IP stack.
  55
  56     http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
  57     Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
  58
  59     http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
  60     Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS
  61     licenses offer ticketed support, indemnification and commercial middleware.
  62
  63     http://www.SafeRTOS.com - High Integrity Systems also provide a safety
  64     engineered and independently SIL3 certified version for use in safety and
  65     mission critical applications that require provable dependability.
  66
  67     1 tab == 4 spaces!
  68 */
  69
  70 /*-----------------------------------------------------------
  71  * Simple IO routines to control the LEDs.
  72  *-----------------------------------------------------------*/
  73
  74 /* Scheduler includes. */
  75 #include "FreeRTOS.h"
  76 #include "task.h"
  77
  78 /* Demo includes. */
  79 #include "partest.h"
  80
  81 /* Hardware specifics. */
  82 #include <iodefine.h>
  83
  84 #define partestNUM_LEDS ( 12 )
  85
  86 long lParTestGetLEDState( unsigned long ulLED );
  87
  88 /*-----------------------------------------------------------*/
  89
  90 void vParTestInitialise( void )
  91 {
  92         /* Port pin configuration is done by the low level set up prior to this
  93         function being called. */
  94 }
  95 /*-----------------------------------------------------------*/
  96
  97 void vParTestSetLED( unsigned long ulLED, signed long xValue )
  98 {
  99         if( ulLED < partestNUM_LEDS )
 100         {
 101                 if( xValue != 0 )
 102                 {
 103                         /* Turn the LED on. */
 104                         taskENTER_CRITICAL();
 105                         {
 106                                 switch( ulLED )
 107                                 {
 108                                         case 0: LED4 = LED_ON;
 109                                                         break;
 110                                         case 1: LED5 = LED_ON;
 111                                                         break;
 112                                         case 2: LED6 = LED_ON;
 113                                                         break;
 114                                         case 3: LED7 = LED_ON;
 115                                                         break;
 116                                         case 4: LED8 = LED_ON;
 117                                                         break;
 118                                         case 5: LED9 = LED_ON;
 119                                                         break;
 120                                         case 6: LED10 = LED_ON;
 121                                                         break;
 122                                         case 7: LED11 = LED_ON;
 123                                                         break;
 124                                         case 8: LED12 = LED_ON;
 125                                                         break;
 126                                         case 9: LED13 = LED_ON;
 127                                                         break;
 128                                         case 10:LED14 = LED_ON;
 129                                                         break;
 130                                         case 11:LED15 = LED_ON;
 131                                                         break;
 132                                 }
 133                         }
 134                         taskEXIT_CRITICAL();
 135                 }
 136                 else
 137                 {
 138                         /* Turn the LED off. */
 139                         taskENTER_CRITICAL();
 140                         {
 141                                 switch( ulLED )
 142                                 {
 143                                         case 0: LED4 = LED_OFF;
 144                                                         break;
 145                                         case 1: LED5 = LED_OFF;
 146                                                         break;
 147                                         case 2: LED6 = LED_OFF;
 148                                                         break;
 149                                         case 3: LED7 = LED_OFF;
 150                                                         break;
 151                                         case 4: LED8 = LED_OFF;
 152                                                         break;
 153                                         case 5: LED9 = LED_OFF;
 154                                                         break;
 155                                         case 6: LED10 = LED_OFF;
 156                                                         break;
 157                                         case 7: LED11 = LED_OFF;
 158                                                         break;
 159                                         case 8: LED12 = LED_OFF;
 160                                                         break;
 161                                         case 9: LED13 = LED_OFF;
 162                                                         break;
 163                                         case 10:LED14 = LED_OFF;
 164                                                         break;
 165                                         case 11:LED15 = LED_OFF;
 166                                                         break;
 167                                 }
 168
 169                         }
 170                         taskEXIT_CRITICAL();
 171                 }
 172         }
 173 }
 174 /*-----------------------------------------------------------*/
 175
 176 void vParTestToggleLED( unsigned long ulLED )
 177 {
 178         if( ulLED < partestNUM_LEDS )
 179         {
 180                 taskENTER_CRITICAL();
 181                 {
 182                         if( lParTestGetLEDState( ulLED ) != 0x00 )
 183                         {
 184                                 vParTestSetLED( ulLED, 0 );
 185                         }
 186                         else
 187                         {
 188                                 vParTestSetLED( ulLED, 1 );
 189                         }
 190                 }
 191                 taskEXIT_CRITICAL();
 192         }
 193 }
 194 /*-----------------------------------------------------------*/
 195
 196 long lParTestGetLEDState( unsigned long ulLED )
 197 {
 198 long lReturn = pdFALSE;
 199
 200         if( ulLED < partestNUM_LEDS )
 201         {
 202                 switch( ulLED )
 203                 {
 204                         case 0  :       if( LED4 != LED_OFF )
 205                                                 {
 206                                                         lReturn =  pdTRUE;
 207                                                 }
 208                                                 break;
 209                         case 1  :       if( LED5 != LED_OFF )
 210                                                 {
 211                                                         lReturn =  pdTRUE;
 212                                                 }
 213                                                 break;
 214                         case 2  :       if( LED6 != LED_OFF )
 215                                                 {
 216                                                         lReturn =  pdTRUE;
 217                                                 }
 218                                                 break;
 219                         case 3  :       if( LED7 != LED_OFF )
 220                                                 {
 221                                                         lReturn =  pdTRUE;
 222                                                 }
 223                                                 break;
 224                         case 4  :       if( LED8 != LED_OFF )
 225                                                 {
 226                                                         lReturn =  pdTRUE;
 227                                                 }
 228                                                 break;
 229                         case 5  :       if( LED9 != LED_OFF )
 230                                                 {
 231                                                         lReturn =  pdTRUE;
 232                                                 }
 233                                                 break;
 234                         case 6  :       if( LED10 != LED_OFF )
 235                                                 {
 236                                                         lReturn =  pdTRUE;
 237                                                 }
 238                                                 break;
 239                         case 7  :       if( LED11 != LED_OFF )
 240                                                 {
 241                                                         lReturn =  pdTRUE;
 242                                                 }
 243                                                 break;
 244                         case 8  :       if( LED12 != LED_OFF )
 245                                                 {
 246                                                         lReturn =  pdTRUE;
 247                                                 }
 248                                                 break;
 249                         case 9  :       if( LED13 != LED_OFF )
 250                                                 {
 251                                                         lReturn =  pdTRUE;
 252                                                 }
 253                                                 break;
 254                         case 10 :       if( LED14 != LED_OFF )
 255                                                 {
 256                                                         lReturn =  pdTRUE;
 257                                                 }
 258                                                 break;
 259                         case 11 :       if( LED15 != LED_OFF )
 260                                                 {
 261                                                         lReturn =  pdTRUE;
 262                                                 }
 263                                                 break;
 264                 }
 265         }
 266
 267         return lReturn;
 268 }
 269 /*-----------------------------------------------------------*/
 270