ioports.c

   1 /*
   2  * OpenI2CRADIO
   3  * I/O Port Handler
   4  * Copyright (C) 2013-06-20 K.Ohta <whatisthis.sowhat ai gmail.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2,
   9  *  or (at your option) any later version.
  10  *  This library / program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  *  See the GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this library; see the file COPYING. If not, write to the
  17  *  Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
  18  *  MA 02110-1301, USA.
  19  *
  20  *  As a special exception, if you link this(includeed from sdcc) library
  21  *  with other files, some of which are compiled with SDCC,
  22  *  to produce an executable, this library does not by itself cause
  23  *  the resulting executable to be covered by the GNU General Public License.
  24  *  This exception does not however invalidate any other reasons why
  25  *  the executable file might be covered by the GNU General Public License.
  26  */
  27 #include "commondef.h"
  28 #include "ioports.h"
  29 #include <signal.h>
  30
  31 unsigned char statecount;
  32
  33 void set_amfmlamp(unsigned char f)
  34 {
  35     if(f == 0x00) {
  36         _AM_STATLAMP = 0;
  37         _FM_STATLAMP = 1;
  38     } else {
  39         _AM_STATLAMP = 1;
  40         _FM_STATLAMP = 0;
  41     }
  42 }
  43
  44
  45 void set_examp_mute(unsigned char f)
  46 {
  47     if(f == 0x00) {
  48         _PORT_MUTE = 1; // 20130709 Not Mute
  49         idle_time_ms(200);
  50     } else {
  51         _PORT_MUTE = 0;
  52         idle_time_ms(200);
  53     }
  54 }
  55
  56 void set_radiopower(unsigned char f)
  57 {
  58     if(f == 0x00) {
  59         _PORT_RADIOPOW = 0; // OFF
  60     } else {
  61         _PORT_RADIOPOW = 1; // ON
  62     }
  63 }
  64
  65 void set_powerlamp(unsigned char f)
  66 {
  67     if(f == 0x00) {
  68         _POW_STATLAMP = 0;
  69     } else {
  70         _POW_STATLAMP = 1;
  71     }
  72 }
  73
  74 void lcd_setbacklight(unsigned char flag, unsigned char level)
  75 {
  76     __bitops_t  b;
  77     __bitops_t d;
  78 #if 0
  79     d.byte = _LCD_BACKLIGHT_TRIS;
  80     d._LCD_BACKLIGHT_BIT = 0;
  81    _LCD_BACKLIGHT_TRIS = d.byte;
  82
  83     b.byte = _LCD_BACKLIGHT;
  84     b._LCD_BACKLIGHT_BIT = 0;
  85     if(flag != 0){
  86        b._LCD_BACKLIGHT_BIT = 1;
  87     }
  88     _LCD_BACKLIGHT = b.byte;
  89 #else
  90     if(flag == 0) {
  91         d.byte = _LCD_BACKLIGHT_TRIS;
  92         d._LCD_BACKLIGHT_BIT = 1;
  93         _LCD_BACKLIGHT_TRIS = d.byte;
  94         PSTRCONbits.STRA = 0;
  95         T2CONbits.TMR2ON = 0;
  96         TMR2 = 0x00;
  97         CCP2CON = 0x00;
  98         CCPR2L = 0;
  99         CCPR2H = 0;
 100     } else {
 101       unsigned char h,l;
 102 //      lv = level;
 103 //      lv <<= 2;
 104 //      level = (level * 25) / 10;
 105 //      level = 255;
 106       h = level >> 1;
 107       if(h == CCPR1L) return;
 108  //     l = 2 << 4; //(lv & 0x0300) >> 4;
 109       d.byte = _LCD_BACKLIGHT_TRIS;
 110       d._LCD_BACKLIGHT_BIT = 1;
 111       _LCD_BACKLIGHT_TRIS = d.byte;
 112       //PSTRCON = 0;
 113       CCPR2L = h;
 114       CCPR2H = h;
 115       b.b2 = 1;
 116       b.b3 = 1;
 117       CCP2CON = b.byte;
 118       PR2 = 50;
 119       PIR1bits.TMR2IF = 0;
 120       T2CON = 0b01111000; // Pre-scaler=1/1,Post-scaler = 1/16
 121       // -> Freq = 2.44KHz * 16 = 39.4KHz.
 122       TMR2 = 0x00;
 123       T2CONbits.TMR2ON = 1;
 124       do {
 125           idle_time_ms(1);
 126       } while(PIR1bits.TMR2IF ==0);
 127       d.byte = _LCD_BACKLIGHT_TRIS;
 128       d._LCD_BACKLIGHT_BIT = 0;
 129       _LCD_BACKLIGHT_TRIS = d.byte;
 130
 131 //      _LCD_PORT |= _LCD_BACKLIGHT;
 132     }
 133 #endif
 134 }
 135
 136 void TMR3_set(void)
 137 {
 138     TMR3L = 1000 & 0xff;
 139     TMR3H = 1000 >> 8;
 140     T3CONbits.TMR3ON = 1;
 141 }
 142
 143 void io_intcountinit(void)
 144 {
 145     statecount = 0;
 146     T3CON = 0b10001100; // TMR3 = 16bit, CCP is not use TMR3, Prescaler=1:2(1uS)
 147                         // DO-not-use SYNC, Internal clock, TMR3 temporally off.
 148     PIR2bits.TMR3IF = 0;
 149     PIE2bits.TMR3IE = 1;
 150     IPR2bits.TMR3IP = 0; // Low priority.
 151     INTCONbits.PEIE = 1;
 152     RCONbits.IPEN = 0;
 153     TMR3L = 0;
 154     TMR3H = 0;
 155     TMR3_set();
 156 }
 157
 158 void lcd_backlightinit(void)
 159 {
 160 #if 0
 161     PSTRCON = 0b00000001; // P1A = PWM, P1B~P1D=PORT, Steeling sync to PWM.
 162     CCP1CON = 0b00001100; // PWM, Low-Active.
 163     ECCP1AS = 0b10000111; // Auto shutdown is disabled
 164     // Use TMR2 as source.
 165     PIE1   &= ~0b00000010; // TMR2 Interrupt disabled.
 166     PIR1   &= ~0b00000010; // TMR2 Interrupt clear.
 167     IPR1   &= ~0b00000010; // Priority = LOW
 168     T2CON   = 0b00000011; // Prescaler/Postscaler = 1:1, Temporally disabled TMR2.
 169     TMR2 = 0x00; // Value;
 170     PR2 = 0x65; // 19.61KHz
 171     CCPR1L = 100; // Duty = 100;
 172 #endif
 173 }
 174
 175
 176 #if defined(pic18f23k22) || defined(pic18f24k22) || defined(pic18f25k22) || defined(pic18f26k22)
 177 /*
 178  * For 28Pin PIC(18F2xK22), I2C lcd using.
 179  */
 180
 181 void keyin_ioinit(void)
 182 {
 183     /* Initialize IOPORTS*/
 184     PORTA = 0x00;
 185     LATA = 0x00;
 186     ANSELA = AN_A_VAL;
 187     TRISA = TRIS_A_VAL;
 188
 189     PORTB = 0x00;
 190     LATB = 0x00;
 191     ANSELB = AN_B_VAL;
 192     TRISB = TRIS_B_VAL;
 193
 194     PORTC = 0x00;
 195     LATC = 0x00;
 196     ANSELC = AN_C_VAL;
 197     TRISC = TRIS_C_VAL_O;
 198     lcd_backlightinit();
 199     io_intcountinit();
 200 }
 201 #endif
 202
 203 #if defined(pic18f23k20) || defined(pic18f24k20) || defined(pic18f25k20) || defined(pic18f26k20)
 204 /*
 205  * For 28Pin PIC(18F2xK20), I2C lcd using.
 206  */
 207
 208 void keyin_ioinit(void)
 209 {
 210     /* Initialize IOPORTS*/
 211     PORTA = 0x00;
 212     LATA = 0x00;
 213     ANSEL = 0x01; // Use RA0 AS ADC, Another is not used.
 214     ANSELH = 0x00; //
 215     TRISA = TRIS_A_VAL;
 216
 217     PORTB = 0x00;
 218     LATB = 0x00;
 219     TRISB = TRIS_B_VAL;
 220
 221     PORTC = 0x00;
 222     LATC = 0x00;
 223     TRISC = TRIS_C_VAL_O;
 224     lcd_backlightinit();
 225     io_intcountinit();
 226 }
 227 #endif
 228
 229 #if defined(pic18f43k20) || defined(pic18f44k20) || defined(pic18f45k20) || defined(pic18f46k20)
 230 /*
 231  * For 40Pin PIC(18F4xK20), paralell or I2C lcd using.
 232  */
 233 void keyin_ioinit(void)
 234 {
 235     /* Initialize IOPORTS*/
 236     PORTA = 0x00;
 237     LATA = 0x00;
 238     ANSEL = 0x80; // Use RA7 AS ADC, Another is not used.
 239     ANSELH = 0x00; //
 240     TRISA = TRIS_A_VAL;
 241
 242     PORTB = 0x00;
 243     LATB = 0x00;
 244     TRISB = TRIS_B_VAL;
 245
 246     PORTC = 0x00;
 247     LATC = 0x00;
 248     TRISC = TRIS_C_VAL_O;
 249
 250     /*
 251      * You can use PORTD,RE0-RE2 extention, when using I2C lcd.
 252      */
 253     PORTD = 0x00;
 254     LATD = 0x00;
 255     TRISD = TRIS_D_VAL;
 256
 257     TRISE = TRIS_E_VAL;
 258     PORTE = 0b00000000; // Mute OK
 259
 260     // Interrupts
 261     INTCONbits.INT0IE = 0;
 262     INTCONbits.INT0IF = 0;
 263     INTCON3bits.INT1IF = 0;
 264     INTCON3bits.INT2IF = 0;
 265     INTCON3bits.INT1IE = 0;
 266     INTCON3bits.INT2IE = 0;
 267
 268     lcd_backlightinit();
 269     io_intcountinit();
 270 }
 271 #else
 272 void keyin_ioinit(void)
 273 {
 274     /* Initialize IOPORTS*/
 275     PORTA = 0x00;
 276     LATA = 0x00;
 277 //    ANSEL = 0x01; // Use RA0 AS ADC, Another is not used.
 278 //    ANSELH = 0x00; //
 279     TRISA = TRIS_A_VAL;
 280
 281     PORTB = 0x00;
 282     LATB = 0x00;
 283     TRISB = TRIS_B_VAL;
 284
 285     PORTC = 0x00;
 286     LATC = 0x00;
 287     TRISC = TRIS_C_VAL_O;
 288     lcd_backlightinit();
 289     io_intcountinit();
 290 }
 291 #endif
 292
 293 /*
 294  * Read IOPORTS for KEY. You should modify if you modify circuit.
 295  */
 296 void readkey_io(unsigned char state)
 297 {
 298     char i;
 299     __bitops_t portvar;
 300
 301     switch(state) {
 302         case 0:
 303             for(i = 0; i < 2; i++){
 304                 keyin_old[1].byte[i] = keyin_old[0].byte[i];
 305                 keyin_old[0].byte[i] = keyin_now.byte[i];
 306                 keyin_now.byte[i] = 0x00;
 307             }
 308             _KEY_SENDPORT |= _KEY_SENDPORTMASK; // Group1 DOWN.
 309             break;
 310         case 1:
 311             _KEY_SEND_GRP1 = 0; // Group1 DOWN.
 312             break;
 313         case 2:
 314             portvar.byte = _KEY_RECVPORT;
 315             if(!_KEY_POS1MASK(portvar)) {
 316                 keyin_now.BIT0A = 1;
 317             }
 318             if(!_KEY_POS2MASK(portvar)) {
 319                 keyin_now.BIT1A = 1;
 320             }
 321             if(!_KEY_POS3MASK(portvar)) {
 322                 keyin_now.BIT2A = 1;
 323             }
 324             if(!_KEY_POS4MASK(portvar)) {
 325                 keyin_now.BIT3A = 1;
 326             }
 327             _KEY_SENDPORT |= _KEY_SENDPORTMASK; // Group1 DOWN.
 328             break;
 329         case 3:
 330             _KEY_SEND_GRP2 = 0; // Group2 DOWN.
 331             break;
 332         case 4:
 333             portvar.byte = _KEY_RECVPORT;
 334             if(!_KEY_POS1MASK(portvar)) {
 335                 keyin_now.BIT0B = 1;
 336             }
 337             if(!_KEY_POS2MASK(portvar)) {
 338                 keyin_now.BIT1B = 1;
 339             }
 340             if(!_KEY_POS3MASK(portvar)) {
 341                 keyin_now.BIT2B = 1;
 342             }
 343             if(!_KEY_POS4MASK(portvar)) {
 344                 keyin_now.BIT3B = 1;
 345             }
 346             _KEY_SENDPORT |= _KEY_SENDPORTMASK; // Group1 DOWN.
 347             break;
 348         case 5:
 349             _KEY_SEND_GRP3 = 0; // Group1 DOWN.
 350             break;
 351         case 6:
 352             portvar.byte = _KEY_RECVPORT;
 353             if(!_KEY_POS1MASK(portvar)) {
 354                 keyin_now.BIT0C = 1;
 355             }
 356             if(!_KEY_POS2MASK(portvar)) {
 357                 keyin_now.BIT1C = 1;
 358             }
 359             if(!_KEY_POS3MASK(portvar)) {
 360                 keyin_now.BIT2C = 1;
 361             }
 362             if(!_KEY_POS4MASK(portvar)) {
 363                 keyin_now.BIT3C = 1;
 364             }
 365             _KEY_SENDPORT |= _KEY_SENDPORTMASK; // Group1 DOWN.
 366             break;
 367         case 7:
 368             _KEY_SEND_GRP4 = 0; // Group4 up
 369             break;
 370         case 8:
 371             portvar.byte = _KEY_RECVPORT;
 372             if(!_KEY_POS1MASK(portvar)) {
 373                 keyin_now.BIT0D = 1;
 374             }
 375             if(!_KEY_POS2MASK(portvar)) {
 376                 keyin_now.BIT1D = 1;
 377             }
 378             if(!_KEY_POS3MASK(portvar)) {
 379                 keyin_now.BIT2D = 1;
 380             }
 381             if(!_KEY_POS4MASK(portvar)) {
 382                 keyin_now.BIT3D = 1;
 383             }
 384             _KEY_SENDPORT |= _KEY_SENDPORTMASK; // Group1 DOWN.
 385             break;
 386         default:
 387             break;
 388     }
 389 }