Problem in PIC 12F675 in wake from sleep

Discussion in 'Embedded Systems and Microcontrollers' started by yatindeshpande77, Dec 24, 2015.

  1. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    I am trying to make a security system at my house. I am using a rid switch at door which is connected to RF tx module.
    I want to send the data of door status every time it changes, but I don't want to spend power continuously so I am putting my micro controller in sleep mode. now my main problem is that in my PIC 12F675 I used below code to complete my task but I in practice 99 out of 100 times it wakes up and go to loop but one time it misses that inturupt which I can't afford to happen.

    my code is as follows where
    OP_TX GP0
    IP_REED_SW GP3
    IP_PANIC_SW GP1
    OP_LED GP2
    Code (C):
    1. #include <htc.h>
    2. #include <math.h>
    3. #include "HardwareProfile.h"
    4. #include "delay.h"
    5.  
    6.  
    7. // Configuration Bits
    8.  
    9. __CONFIG(FOSC_INTRCIO & WDTE_OFF & PWRTE_OFF & MCLRE_OFF & BOREN_OFF & CP_ON & CPD_ON);
    10.  
    11.  
    12. const char  Open =   0x31  ;  //1
    13. const char  Close  = 0x32   ; //2
    14.  
    15. const char First   = 0x41;    // A
    16. const char Second  = 0x31;    // 1
    17. const char Third   = 0x38;    // 8
    18.  
    19. const char  Header =   0x20;
    20. const char  Stop   =   0x21;
    21.  
    22. volatile unsigned char i,j;
    23. volatile unsigned int k=0,m=0, var=0;
    24. volatile unsigned char *data;
    25. static bit bit_once1=0,bit_once=0;
    26. unsigned char bit_door_open=0, bit_door_close=0;
    27. unsigned char buff[6];
    28.  
    29. void sw_open(void);
    30. void sw_close(void);
    31. void InitializeSystem();
    32.  
    33.  
    34. void interrupt isr()
    35. {
    36.     if(INTCONbits.GPIF==1)
    37.        {
    38.         INTCONbits.GPIF = 0;
    39.         if((GPIObits.GP3==0)&&(bit_door_open==1))
    40.         {
    41.             sw_close();
    42.             bit_door_close = 1;
    43.             bit_door_open = 0;
    44.         }
    45.         if((GPIObits.GP3==1)&&(bit_door_close==1))
    46.         {
    47.             sw_open();
    48.             bit_door_open = 1;
    49.             bit_door_close = 0;
    50.            }
    51.        }
    52. }
    53.  
    54.  
    55. void sw_open()
    56. {
    57.     //-------------------------------
    58.  
    59.        if(IP_REED_SW==1)         //on
    60.        {
    61.         for(k=0;k<10;k++)    
    62.           {
    63.             DelayMs(15);      
    64.           }
    65.           if(IP_REED_SW==1)         //on
    66.           {
    67.             for(k=0;k<10;k++)  
    68.              {
    69.                 DelayMs(15);    
    70.              }
    71.              if(IP_REED_SW==1)         //on
    72.              {
    73.                 OP_LED=1;
    74.        
    75.                 //---------------------------
    76.                 // 1st
    77.                 //------------------------------
    78. k1   :          
    79.                 buff[0]=Header;
    80.                 buff[1]=First;   // channel 1
    81.                 buff[2]=Second;
    82.                 buff[3]=Third;
    83.                 buff[4]=Open;
    84.                 buff[5]=Stop;
    85.                 data=&buff;
    86.          
    87.                 //------------------------
    88.          
    89.                 for (i=0;i<16;i++)        // send preamble 16 times
    90.                 {
    91.                        OP_TX=1;
    92.                        DelayBigUs(4890);    // 5 mS  (5.860ms)
    93.              
    94.                        OP_TX=0;
    95.                        DelayBigUs(4890);    // 5 mS
    96.                 }
    97.                 DelayBigUs(14738);          // syn bit
    98.          
    99.                 OP_LED = 0;                 // For less current led is zero early
    100.          
    101.          
    102.                 OP_TX=1;   // start bit
    103.                 DelayBigUs(4890);    // 5 mS
    104.          
    105.                 OP_TX=0;
    106.                 DelayBigUs(4890);    // 5 mS
    107.            
    108.                 for (j=0;j<6;j++)
    109.                 {
    110.                       for(i=0;i<8;i++)
    111.                       {
    112.                            if ((data[j] & 0x80) == 0x80)
    113.                            {
    114.                               OP_TX=1;
    115.                               DelayBigUs(4890);    // 5 mS
    116.        
    117.                               OP_TX=0;
    118.                               DelayBigUs(4890);    // 5 mS
    119.                            }
    120.                            else
    121.                            {
    122.                               OP_TX=0;
    123.                               DelayBigUs(4890);    // 5 mS
    124.                
    125.                               OP_TX=1;
    126.                               DelayBigUs(4890);    // 5 mS
    127.                            }
    128.                            data[j]=data[j]<<1;
    129.                       }
    130.                 }
    131.  
    132.                 //------ send stop bit -------
    133.  
    134.                 OP_TX=1;   // stop bit    
    135.                 DelayBigUs(4890);    // 5 mS
    136.          
    137.                 OP_TX=0;    
    138.                 DelayBigUs(4890);    // 5 mS  
    139.              
    140.        
    141.                 for(k=0;k<30;k++)    
    142.                 {
    143.                        DelayMs(15);
    144.                 }
    145.                 if(bit_once==0)
    146.                 {
    147.                        bit_once=1;
    148.                        goto k1;      
    149.                 }
    150.                 if(IP_REED_SW==0)         //on
    151.                 {
    152.                        OP_LED=0;
    153.                        DelayMs(15);
    154.                              
    155.                        if(IP_REED_SW==0)
    156.                        {
    157.                           OP_LED=1;
    158.                           bit_once=1;
    159.                        }          
    160.                 }
    161.                 bit_once=0;  
    162.                 OP_LED = 0;    
    163.              }
    164.           }
    165.        }
    166. }
    167.  
    168. ///////////////////   SW CLOSE   //////////////////////////
    169.  
    170. void sw_close()
    171. {
    172.     //-------------------------------
    173.        if(IP_REED_SW==0)         //on
    174.        {
    175.         for(k=0;k<10;k++)
    176.           {
    177.             DelayMs(15);  
    178.           }
    179.           if(IP_REED_SW==0)         //on
    180.           {
    181.             for(k=0;k<10;k++)
    182.              {
    183.                 DelayMs(15);
    184.              }
    185.        
    186.              if(IP_REED_SW==0)         //on
    187.              {
    188.                 OP_LED=1;
    189.          
    190.                 //---------------------------
    191.                 // 1st
    192.                 //------------------------------
    193. k2   :          
    194.                 buff[0]=Header;
    195.                 buff[1]=First;   // channel 1
    196.                 buff[2]=Second;
    197.                 buff[3]=Third;
    198.                 buff[4]=Close;
    199.                 buff[5]=Stop;
    200.                 data=&buff;
    201.  
    202.                 //------------------------
    203.  
    204.                 for(i=0;i<16;i++)   // send preamble 16 times
    205.                 {
    206.                        OP_TX=1;
    207.                        DelayBigUs(4890);    // 5 mS
    208.          
    209.                        OP_TX=0;
    210.                        DelayBigUs(4890);    // 5 mS
    211.                 }
    212.                 DelayBigUs(14738); // Delay 15000 uS  // syn bit
    213.          
    214.                 OP_LED = 0;                // For less current led is zero early
    215.          
    216.                 //-----------------
    217.                 OP_TX=1;   // start bit
    218.                 DelayBigUs(4890);    // 5 mS
    219.            
    220.                 OP_TX=0;
    221.                 DelayBigUs(4890);    // 5 mS
    222.            
    223.                 //-----------------
    224.          
    225.                 for(j=0;j<6;j++)
    226.                 {
    227.                       for(i=0;i<8;i++)
    228.                       {
    229.                            if((data[j] & 0x80) == 0x80)
    230.                            {
    231.                               OP_TX=1;
    232.                               DelayBigUs(4890);    // 5 mS
    233.                
    234.                               OP_TX=0;
    235.                               DelayBigUs(4890);    // 5 mS
    236.                            }
    237.                            else
    238.                            {
    239.                               OP_TX=0;
    240.                               DelayBigUs(4890);    // 5 mS
    241.                
    242.                               OP_TX=1;
    243.                               DelayBigUs(4890);    // 5 mS
    244.                            }
    245.                            data[j]=data[j]<<1;
    246.                      }
    247.                 }
    248.          
    249.                 //------ send stop bit -------
    250.          
    251.                 OP_TX=1;   // stop bit    
    252.                 DelayBigUs(4890);    // 5 mS
    253.          
    254.                 OP_TX=0;    
    255.                 DelayBigUs(4890);    // 5 mS
    256.                  
    257.              
    258.                 for(k=0;k<30;k++)      
    259.                 {
    260.                        DelayMs(15);    
    261.                 }
    262.                 if(bit_once1==0)
    263.                 {
    264.                        bit_once1=1;
    265.                        goto k2;      
    266.                 }
    267.                 if(IP_REED_SW==1)      
    268.                 {
    269.                        OP_LED=0;
    270.                        DelayMs(15);
    271.                              
    272.                        if(IP_REED_SW==1)
    273.                        {
    274.                           OP_LED=1;
    275.                           bit_once1=1;
    276.                        }          
    277.                 }
    278.                 bit_once1=0;          
    279.                 OP_LED=0;
    280.              }
    281.           }
    282.        }
    283. }
    284.  
    285. void main()
    286. {
    287.     InitializeSystem();
    288.  
    289.     bit_once=0;
    290.     bit_once1=0;
    291.     OP_LED=0;
    292.  
    293.     if(IP_REED_SW==1)
    294.     {
    295.         bit_door_open = 1;
    296.     }
    297.     if(IP_REED_SW==0)
    298.     {
    299.         bit_door_close = 1;
    300.     }
    301.  
    302.     while(1)
    303.     {
    304.         GPIE = 1;
    305.         SLEEP();                    // Controller goes into sleep mode (To reduce current in IDLE MODE)
    306.     }
    307. }
    308.  
    309. void InitializeSystem()
    310. {
    311.     OPTION_REG = 0XC0;
    312.     ANSEL  = 0x00;                             // Configure AN pins as digital I/O
    313.     INTCON = 0X88;
    314.     ADCON0 = 0X00;
    315.     CMCON  = 0X07;
    316.     VRCON  = 0X00;
    317.  
    318.     TRISIO = 0b00001000;   // Only GP3(REED SW) is input others are output
    319.     IOC    = 0b00001000;
    320.     GPIO   = 0X00;
    321.  
    Any suggestion on my code or any other way to forcefully wake him up? any suggestions will be help full,
    Thanks

    Mod edit: added 'C' to code tag
     
    Last edited by a moderator: Dec 24, 2015
  2. djsfantasi

    AAC Fanatic!

    Apr 11, 2010
    2,810
    834
    Your ISR routine is very long, due to the call to either sw_open or sw_close. Especially with the for loops therein. I'd just set a flag in the ISR and use it to call sw_open or sw_close in your main function.
     
  3. Picbuster

    Member

    Dec 2, 2013
    376
    50
    99 out of 100. please tell us more about your input circuit.
     
  4. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    Here is my schematic its quite simple nothing big in it! I am not adding tf link in it it is at txx, it is working on every time! when my circuit wont work my led dont get lighted so it means its not coming out of wake up thats what i get!
    OK theoretically ISR should be small i will make that change but i dont hope its problem because my whole controller is dedicated for that application only and my all code gets exicuted with 2 sec for each inturupt testing and execution and my door which is connected on that door i want to sence is what i want to sence only if change in position stays for more than 5 sec!
    But thanks for your time!
    PIC 16F886 in schematic is used for rx but it has no issue right now!
    So any other suggestion?
     
  5. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    I added my code in it only I guess in my first post itself!
    I am using MPLAB IDE V8.92, along with proteus!
    Yes I did this at hardware after running it on simulation, and i shred that 1 failure out of 100 attempts after 15 days observation!
     
  6. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    In my opinion problem is not in ISR if comes to it then it do everything properly but some times it goes in like deep sleep or something that he don't wake up as my led don't toggle in it too!
    1. Is there is any more registers of controller that i need to set other than this?
    2. IS watchdog timer could help in not letting him go in sleep for long ?(Is keeping controller in sleep for long time could create any problem?)
    3. Do I need to use some other interrupt than one I am using right now to force controller not to miss a single one wake up also?
     
  7. Picbuster

    Member

    Dec 2, 2013
    376
    50
    What happens if a door is closed or opend and an interrupt occurs?
    This could happen when a pulse arrives at input switch.
    to solve this place a input filter resistor + cap 100nF to signal called sw read.
    even better is to use a NC contact.

    Pwr consumption: how do you generate 5V ( type of chip) if a lm7805 is used then you loose 2-4 mA current.(quiescent current)
    More than the pic will draw at 32Khz
    I used a mcp1703 -50 3-4 micro amps. (quiescent current)
     
  8. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    Thanks for that 5V suggestion I will look for it soon!
    Yes I already using reed switch for sensing door and at every time it changes for open to close or opposite it alters the port pin causing interrupt!
    so no doubt it is getting switch on his port pin!
    is there any concept like deep sleep or something?
    If i use watchdog to make my controller wake up after specific interval will that resolve my problem?
    I am not understanding at all about why it don't get 100 out if 100 output, I am really stuck at it!
    please if any one have any better suggestion it will be appreciated!
     
  9. ErnieM

    AAC Fanatic!

    Apr 24, 2011
    7,392
    1,606
    Your schematic may seem simple but you have at least one error: you do not have a limiting resistor on U1 pin 5.
     
  10. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    Sorry, I have that resistor too but forgot to put that in schematic!!
    And I really don't think it is a hardware problem as it works 99 times in 100!
    Really don't understanding where I am doing wrong!
     
    Last edited: Dec 26, 2015
  11. Picbuster

    Member

    Dec 2, 2013
    376
    50
    Correct me if I am wrong but I think that you made it complicated.
    You want a signal when door opens or closed.
    the pic used a interrupt on change. ( assume door closed contact closed)
    now you do not care, at the first instance, if door goes open or is closing.
    an interrupt occurs when open or when closed.==> wake up
    door_flag=true;

    debounce in a other timer routine
    when valid for timer time
    door=pin4; // high open closed low
    Ready flag=true;

    in main test for ready flag. found it clear it and wait for the next one
    and door will give status pin4

    now you end up with a few lines of programming doing the same.

    but again I don't know all the ins and outs from your project.
     
    yatindeshpande77 likes this.
  12. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    Yes PICBUSTER you are correct about my door switch and the part of program i am using for it, other than this I am trying to communicate with my RF receiver using RF TX, by which it will send change of staus to rx at different end of my house which will process that signal after it got that on receiver, but as I am using 12F675 which is without USART I am using bit banking to transfer that data serially.
    Now the problem is some times even when my door gets open/close my controller don't get wake up and I miss that signal which i want to cover!
     
  13. Picbuster

    Member

    Dec 2, 2013
    376
    50
    It might want to wake up but with all delays it might run into a "from stack" return problem.
    I had that problem going 3+ deep in the routines. wend wrong so now and than.
    Took me one day to find out by reading the xc8 manual. Resulting picbuster = donkey so now and then.
     
  14. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    As per suggestion from this link I changed few things in program so is this OK or so I need to change anything else?
    I reduced the ISR routine and increase my main routine by setting flag from ISR.
    Transmitter code!
    Code (Text):
    1.  
    2. /*
    3. > Program For: Transmitter 1 (Data = "ABC")
    4. > IC Used: PIC 12F675
    5.  
    6. > Pin no. 1 - +ve (From battery +ve to this through diode-4.7k Resistor-diode)
    7. > Pin no. 2 -
    8. > Pin no. 3 -
    9. > Pin no. 4 - REED SWITCH ( Connect REED SW between pin no. 4 and ground),
    10.               Connect Resistor of 1M-Ohm to +ve(pin no.1)
    11. > Pin no. 5 - LED (Resistor of 22k)
    12. > Pin no. 6 - Connect to DATA pin of TX MODULE
    13. > Pin no. 7 -
    14. > Pin no. 8 - Ground
    15.  
    16. > This program is Proper working for both Transmitter 1 and Panic in ONE IC. (Checked On Hardware)
    17.  
    18. */
    19.  
    20. /////////////////////   In sleep mode current is 10 uA
    21.  
    22. #include <htc.h>
    23. #include <math.h>
    24. #include "HardwareProfile.h"
    25. #include "delay.h"
    26.  
    27.  
    28. // Configuration Bits
    29.  
    30. __CONFIG(FOSC_INTRCIO & WDTE_OFF & PWRTE_OFF & MCLRE_OFF & BOREN_OFF & CP_ON & CPD_ON);
    31.  
    32.  
    33. const char  Open =   0x31  ;  //1
    34. const char  Close  = 0x32   ; //2
    35.  
    36. const char First   = 0x41;    // A
    37. const char Second  = 0x33;    // 3
    38. const char Third   = 0x38;    // 8
    39.  
    40. const char  Header =   0x20;
    41. const char  Stop   =   0x21;
    42.  
    43. volatile unsigned char i,j;
    44. volatile unsigned int k=0,m=0, var=0,flag1=0,flag2=0;
    45. volatile unsigned char *data;
    46. static bit bit_once1=0,bit_once=0;
    47. unsigned char bit_door_open=0, bit_door_close=0;
    48. unsigned char buff[6];
    49.  
    50. void sw_open(void);
    51. void sw_close(void);
    52. void InitializeSystem();
    53.  
    54.  
    55. void interrupt isr()
    56. {
    57.     if(INTCONbits.GPIF==1)
    58.        {
    59.         INTCONbits.GPIF = 0;
    60.         if((GPIObits.GP3==0)&&(bit_door_open==1))
    61.         {
    62.             flag1 = 1;//switch close routine call flag
    63.            
    64.         }
    65.         if((GPIObits.GP3==1)&&(bit_door_close==1))
    66.         {  
    67.             flag2 = 1;//switch open routine call flag
    68.            
    69.            }
    70.        }
    71. }
    72.  
    73.  
    74. void sw_open()
    75. {
    76.     //-------------------------------
    77.  
    78.        if(IP_REED_SW==1)         //on
    79.        {
    80.         for(k=0;k<10;k++)    
    81.           {
    82.             DelayMs(15);        
    83.           }  
    84.           if(IP_REED_SW==1)         //on
    85.           {  
    86.             for(k=0;k<10;k++)    
    87.              {
    88.                 DelayMs(15);    
    89.              }
    90.              if(IP_REED_SW==1)         //on
    91.              {  
    92.                 OP_LED=1;
    93.        
    94.                 //---------------------------
    95.                 // 1st
    96.                 //------------------------------
    97. k1   :          
    98.                 buff[0]=Header;
    99.                 buff[1]=First;   // channel 1
    100.                 buff[2]=Second;
    101.                 buff[3]=Third;
    102.                 buff[4]=Open;
    103.                 buff[5]=Stop;
    104.                 data=&buff;
    105.            
    106.                 //------------------------
    107.            
    108.                 for (i=0;i<16;i++)        // send preamble 16 times
    109.                 {
    110.                        OP_TX=1;
    111.                        DelayBigUs(4890);    // 5 mS  (5.860ms)
    112.              
    113.                        OP_TX=0;
    114.                        DelayBigUs(4890);    // 5 mS
    115.                 }
    116.                 DelayBigUs(14738);          // syn bit
    117.                 OP_LED = 0;                 // For less current led is zero early
    118.            
    119.            
    120.                 OP_TX=1;   // start bit
    121.                 DelayBigUs(4890);    // 5 mS
    122.            
    123.                 OP_TX=0;
    124.                 DelayBigUs(4890);    // 5 mS
    125.            
    126.                 for (j=0;j<6;j++)
    127.                 {
    128.                       for(i=0;i<8;i++)
    129.                       {
    130.                            if ((data[j] & 0x80) == 0x80)
    131.                            {
    132.                               OP_TX=1;
    133.                               DelayBigUs(4890);    // 5 mS
    134.        
    135.                               OP_TX=0;
    136.                               DelayBigUs(4890);    // 5 mS
    137.                            }
    138.                            else
    139.                            {
    140.                               OP_TX=0;
    141.                               DelayBigUs(4890);    // 5 mS
    142.                  
    143.                               OP_TX=1;
    144.                               DelayBigUs(4890);    // 5 mS
    145.                            }
    146.                            data[j]=data[j]<<1;
    147.                       }
    148.                 }
    149.  
    150.                 //------ send stop bit -------
    151.    
    152.                 OP_TX=1;   // stop bit    
    153.                 DelayBigUs(4890);    // 5 mS
    154.            
    155.                 OP_TX=0;    
    156.                 DelayBigUs(4890);    // 5 mS    
    157.              
    158.          
    159.                 for(k=0;k<30;k++)      
    160.                 {
    161.                        DelayMs(15);  
    162.                 }
    163.                 if(bit_once==0)
    164.                 {
    165.                        bit_once=1;
    166.                        goto k1;        
    167.                 }
    168.                 if(IP_REED_SW==0)         //on
    169.                 {
    170.                        OP_LED=0;
    171.                        DelayMs(15);
    172.                              
    173.                        if(IP_REED_SW==0)
    174.                        {
    175.                           OP_LED=1;
    176.                           bit_once=1;
    177.                        }          
    178.                 }
    179.                 bit_once=0;    
    180.                 OP_LED = 0;      
    181.              }
    182.           }
    183.        }
    184. }
    185.  
    186. ///////////////////   SW CLOSE   //////////////////////////
    187.  
    188. void sw_close()
    189. {
    190.     //-------------------------------
    191.        if(IP_REED_SW==0)         //on
    192.        {
    193.         for(k=0;k<10;k++)  
    194.           {
    195.             DelayMs(15);    
    196.           }
    197.           if(IP_REED_SW==0)         //on
    198.           {  
    199.             //for(k=0;k<10;k++)
    200.              {
    201.                 //DelayMs(15);
    202.              }  
    203.        
    204.              if(IP_REED_SW==0)         //on
    205.              {  
    206.                 OP_LED=1;
    207.            
    208.                 //---------------------------
    209.                 // 1st
    210.                 //------------------------------
    211. k2   :          
    212.                 buff[0]=Header;
    213.                 buff[1]=First;   // channel 1
    214.                 buff[2]=Second;
    215.                 buff[3]=Third;
    216.                 buff[4]=Close;
    217.                 buff[5]=Stop;
    218.                 data=&buff;
    219.  
    220.                 //------------------------
    221.  
    222.                 for(i=0;i<16;i++)   // send preamble 16 times
    223.                 {
    224.                        OP_TX=1;
    225.                        DelayBigUs(4890);    // 5 mS
    226.            
    227.                        OP_TX=0;
    228.                        DelayBigUs(4890);    // 5 mS
    229.                 }
    230.                 DelayBigUs(14738); // Delay 15000 uS  // syn bit
    231.            
    232.                 OP_LED = 0;                // For less current led is zero early
    233.            
    234.                 //-----------------
    235.                 OP_TX=1;   // start bit
    236.                 DelayBigUs(4890);    // 5 mS
    237.            
    238.                 OP_TX=0;
    239.                 DelayBigUs(4890);    // 5 mS
    240.            
    241.                 //----------------
    242.                 for(j=0;j<6;j++)
    243.                 {
    244.                       for(i=0;i<8;i++)
    245.                       {
    246.                            if((data[j] & 0x80) == 0x80)
    247.                            {
    248.                               OP_TX=1;
    249.                               DelayBigUs(4890);    // 5 mS
    250.                
    251.                               OP_TX=0;
    252.                               DelayBigUs(4890);    // 5 mS
    253.                            }
    254.                            else
    255.                            {
    256.                               OP_TX=0;
    257.                               DelayBigUs(4890);    // 5 mS
    258.                  
    259.                               OP_TX=1;
    260.                               DelayBigUs(4890);    // 5 mS
    261.                            }
    262.                            data[j]=data[j]<<1;
    263.                      }
    264.                 }
    265.            
    266.                 //------ send stop bit -------
    267.            
    268.                 OP_TX=1;   // stop bit    
    269.                 DelayBigUs(4890);    // 5 mS
    270.          
    271.                 OP_TX=0;    
    272.                 DelayBigUs(4890);    // 5 mS
    273.                  
    274.              
    275.                 for(k=0;k<30;k++)        
    276.                 {
    277.                        DelayMs(15);    
    278.                 }
    279.                 if(bit_once1==0)
    280.                 {
    281.                        bit_once1=1;
    282.                        goto k2;        
    283.                 }
    284.                 if(IP_REED_SW==1)        
    285.                 {
    286.                        OP_LED=0;
    287.                        DelayMs(15);
    288.                              
    289.                        if(IP_REED_SW==1)
    290.                        {
    291.                           OP_LED=1;
    292.                           bit_once1=1;
    293.                        }          
    294.                 }
    295.                 bit_once1=0;          
    296.                 OP_LED=0;
    297.              }
    298.           }
    299.        }
    300. }
    301.  
    302. void main()
    303. {
    304.     InitializeSystem();
    305.  
    306.     bit_once=0;
    307.     bit_once1=0;
    308.     OP_LED=0;
    309.  
    310.     if(IP_REED_SW==1)
    311.     {
    312.         bit_door_open = 1;
    313.     }
    314.     if(IP_REED_SW==0)
    315.     {
    316.         bit_door_close = 1;
    317.     }
    318.  
    319.     while(1)
    320.     {
    321.         GPIE = 1;
    322.         if(flag1==1)
    323.         {  
    324.             sw_close();
    325.             bit_door_close = 1;
    326.             bit_door_open = 0;
    327.             flag1 = 0;
    328.         }
    329.         if(flag2==1)
    330.         {
    331.             sw_open();
    332.             bit_door_open = 1;
    333.             bit_door_close = 0;
    334.             flag2 = 0;
    335.         }
    336.         SLEEP();                    // Controller goes into sleep mode (To reduce current in IDLE MODE)
    337.        
    338.     }
    339. }  
    340.  
    341. void InitializeSystem()
    342. {
    343.     OPTION_REG = 0XC0;
    344.     ANSEL  = 0x00;                             // Configure AN pins as digital I/O
    345.     INTCON = 0X88;
    346.     ADCON0 = 0X00;
    347.     CMCON  = 0X07;
    348.     VRCON  = 0X00;
    349.  
    350.     TRISIO = 0b00001000;   // Only GP3(REED SW) is input others are output
    351.     IOC    = 0b00001000;
    352.     GPIO   = 0X00;
    353. }
     
  15. Picbuster

    Member

    Dec 2, 2013
    376
    50
    To send a byte you can do this easy
    Msg the byte you want to send
    int Msg=0bxxxxxyyddddddddS; // x don't care yy stopbits S startbit.

    for ( i=0;i<10;i++)
    {
    RC5=(Msg & (1 << i)) != 0; // get one bit and send it out to port
    __delay_ms(5); // bit time
    }
     
  16. yatindeshpande77

    Thread Starter Member

    Dec 20, 2015
    38
    0
    Thanks
     
Loading...