rlt.c

   1 /*****************************************************************************/
   2 /* THIS SAMPLE CODE IS PROVIDED AS IS AND IS SUBJECT TO ALTERATIONS. FUJITSU */
   3 /* MICROELECTRONICS ACCEPTS NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR */
   4 /* ELIGIBILITY FOR ANY PURPOSES.                                             */
   5 /*                 (C) Fujitsu Microelectronics Europe GmbH                  */
   6 /*****************************************************************************/
   7
   8 #include "rlt.h"
   9
  10 void RLT_InitializeTimer(unsigned char channel, unsigned char runmode, unsigned char clockmode, unsigned char triggermode, unsigned char outputmode)
  11 {
  12         unsigned short setvalue = 0x00;
  13
  14         /*      Prepare seting for the TMCSR Register   */
  15         setvalue |= ( (clockmode << 10) | (triggermode << 7) | ((outputmode & 0x01) << 5) | ((runmode & 0x01) << 4) | 0x02 /* CNTE */ );
  16
  17         /*      Set the corresponding RLT channel       */
  18         switch(channel)
  19         {
  20                 case 0:
  21                 {
  22                         TMCSR0 = setvalue;
  23                         break;
  24                 }
  25                 case 1:
  26                 {
  27                         TMCSR1 = setvalue;
  28                         break;
  29                 }
  30                 case 2:
  31                 {
  32                         TMCSR2 = setvalue;
  33                         break;
  34                 }
  35                 case 3:
  36                 {
  37                         TMCSR3 = setvalue;
  38                         break;
  39                 }
  40                 case 4:
  41                 {
  42                         TMCSR4 = setvalue;
  43                         break;
  44                 }
  45                 case 5:
  46                 {
  47                         TMCSR5 = setvalue;
  48                         break;
  49                 }
  50                 case 6:
  51                 {
  52                         TMCSR6 = setvalue;
  53                         break;
  54                 }
  55                 case 7:
  56                 {
  57                         TMCSR7 = setvalue;
  58                         break;
  59                 }
  60         }
  61 }
  62
  63 void RLT_SetReloadValue(unsigned char channel, unsigned short int value)
  64 {
  65         switch(channel)
  66         {
  67                 case 0:
  68                 {
  69                         TMRLR0 = value;
  70                         break;
  71                 }
  72                 case 1:
  73                 {
  74                         TMRLR1 = value;
  75                         break;
  76                 }
  77                 case 2:
  78                 {
  79                         TMRLR2 = value;
  80                         break;
  81                 }
  82                 case 3:
  83                 {
  84                         TMRLR3 = value;
  85                         break;
  86                 }
  87                 case 4:
  88                 {
  89                         TMRLR4 = value;
  90                         break;
  91                 }
  92                 case 5:
  93                 {
  94                         TMRLR5 = value;
  95                         break;
  96                 }
  97                 case 6:
  98                 {
  99                         TMRLR6 = value;
 100                         break;
 101                 }
 102                 case 7:
 103                 {
 104                         TMRLR7 = value;
 105                         break;
 106                 }
 107         }
 108 }
 109
 110 void RLT_TriggerTimer(unsigned char channel)
 111 {
 112         switch(channel)
 113         {
 114                 case 0:
 115                 {
 116                         TMCSR0_TRG = 1;
 117                         break;
 118                 }
 119                 case 1:
 120                 {
 121                         TMCSR1_TRG = 1;
 122                         break;
 123                 }
 124                 case 2:
 125                 {
 126                         TMCSR2_TRG = 1;
 127                         break;
 128                 }
 129                 case 3:
 130                 {
 131                         TMCSR3_TRG = 1;
 132                         break;
 133                 }
 134                 case 4:
 135                 {
 136                         TMCSR4_TRG = 1;
 137                         break;
 138                 }
 139                 case 5:
 140                 {
 141                         TMCSR5_TRG = 1;
 142                         break;
 143                 }
 144                 case 6:
 145                 {
 146                         TMCSR6_TRG = 1;
 147                         break;
 148                 }
 149                 case 7:
 150                 {
 151                         TMCSR7_TRG = 1;
 152                         break;
 153                 }
 154         }
 155 }
 156
 157 void RLT_EnableInterrupt(unsigned char channel, unsigned char enable)
 158 {
 159         switch(channel)
 160         {
 161                 case 0:
 162                 {
 163                         /*      Clear Pending Interrupt Flag    */
 164                         TMCSR0_UF = 0;
 165
 166                         /* Enable Interrupt     */
 167                         TMCSR0_INTE = enable;
 168                         break;
 169                 }
 170                 case 1:
 171                 {
 172                         /*      Clear Pending Interrupt Flag    */
 173                         TMCSR1_UF = 0;
 174
 175                         /* Enable Interrupt     */
 176                         TMCSR1_INTE = enable;
 177                         break;
 178                 }
 179                 case 2:
 180                 {
 181                         /*      Clear Pending Interrupt Flag    */
 182                         TMCSR2_UF = 0;
 183
 184                         /* Enable Interrupt     */
 185                         TMCSR2_INTE = enable;
 186                         break;
 187                 }
 188                 case 3:
 189                 {
 190                         /*      Clear Pending Interrupt Flag    */
 191                         TMCSR3_UF = 0;
 192
 193                         /* Enable Interrupt     */
 194                         TMCSR3_INTE = enable;
 195                         break;
 196                 }
 197                 case 4:
 198                 {
 199                         /*      Clear Pending Interrupt Flag    */
 200                         TMCSR4_UF = 0;
 201
 202                         /* Enable Interrupt     */
 203                         TMCSR4_INTE = enable;
 204                         break;
 205                 }
 206                 case 5:
 207                 {
 208                         /*      Clear Pending Interrupt Flag    */
 209                         TMCSR5_UF = 0;
 210
 211                         /* Enable Interrupt     */
 212                         TMCSR5_INTE = enable;
 213                         break;
 214                 }
 215                 case 6:
 216                 {
 217                         /*      Clear Pending Interrupt Flag    */
 218                         TMCSR6_UF = 0;
 219
 220                         /* Enable Interrupt     */
 221                         TMCSR6_INTE = enable;
 222                         break;
 223                 }
 224                 case 7:
 225                 {
 226                         /*      Clear Pending Interrupt Flag    */
 227                         TMCSR7_UF = 0;
 228
 229                         /* Enable Interrupt     */
 230                         TMCSR7_INTE = enable;
 231                         break;
 232                 }
 233         }
 234 }
 235
 236 __interrupt void RLT_Channel0_ISR()
 237 {
 238         /*      Clear Pending Interrupt Flag    */
 239         TMCSR0_UF = 0;
 240
 241         /*      Do what you have to do  */
 242         PDR14--; //since the pins are low active
 243 }
 244
 245 __interrupt void RLT_Channel1_ISR()
 246 {
 247         /*      Clear Pending Interrupt Flag    */
 248         TMCSR1_UF = 0;
 249
 250         /*      Do what you have to do  */
 251 }
 252
 253 __interrupt void RLT_Channel2_ISR()
 254 {
 255         /*      Clear Pending Interrupt Flag    */
 256         TMCSR2_UF = 0;
 257
 258         /*      Do what you have to do  */
 259 }
 260
 261 __interrupt void RLT_Channel3_ISR()
 262 {
 263         /*      Clear Pending Interrupt Flag    */
 264         TMCSR3_UF = 0;
 265
 266         /*      Do what you have to do  */
 267 }
 268
 269 __interrupt void RLT_Channel4_ISR()
 270 {
 271         /*      Clear Pending Interrupt Flag    */
 272         TMCSR4_UF = 0;
 273
 274         /*      Do what you have to do  */
 275 }
 276
 277 __interrupt void RLT_Channel5_ISR()
 278 {
 279         /*      Clear Pending Interrupt Flag    */
 280         TMCSR5_UF = 0;
 281
 282         /*      Do what you have to do  */
 283 }
 284
 285 __interrupt void RLT_Channel6_ISR()
 286 {
 287         /*      Clear Pending Interrupt Flag    */
 288         TMCSR6_UF = 0;
 289
 290         /*      Do what you have to do  */
 291 }
 292
 293 __interrupt void RLT_Channel7_ISR()
 294 {
 295         /*      Clear Pending Interrupt Flag    */
 296         TMCSR7_UF = 0;
 297
 298         /*      Do what you have to do  */
 299 }