;**********************************************************************
;                                                                     *
;    Filename:  sirc10fv15.asm                                        *
;    Date:                  04/02/2010                                *
;    File Version:          5                                         *
;                                                                     *
;    Author:                Pete Griffiths                            *
;    Company:               Picprojects                               *
;                                                                     * 
;**********************************************************************
;                                                                     *
;    Copyright 2010 Pete Griffiths
;
;    This program is free software: you can redistribute it and/or
;    modify it under the terms of the GNU General Public License as 
;    published by the Free Software Foundation, either version 3 of 
;    the License, or any later version.
;
;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.
;
;    You should have received a copy of the GNU General Public License
;    along with this program. If not, see http://www.gnu.org/licenses/
;                                                                     *
;**********************************************************************
;                                                                     *
;    Files Required: P10F20x.INC                                      *
;    Code will build for 10F200/10F202                                *
;                                                                     *
;    Datasheet:                                                       *
;    http://ww1.microchip.com/downloads/en/DeviceDoc/41239D.pdf       *
;**********************************************************************
;                                                                     *
;    Notes:                                                           *
;                                                                     *
;           n/c -|1   8|- GP3 irrx_in                                 *
;     +5V (Vdd) -|2   7|- Vss (Gnd)                                   *
;   rlyvbst GP2 -|3   6|- n/c                                         *
;   rl2     GP1 -|4   5|- GP0 rly                                     *
;                                                                     *
;                                                                     *
;**********************************************************************
; Operation                                                           *
; - One IR receiver input for 12-bit SIRC data format                 *
; - Two relay control outputs                                         *
; - One relay voltage boost                                           *
;                                                                     *
; When a relay output is turned on, the rlyvbst output is set high    *
; for a miniumum of 96mS. This can be used to turn on a voltage boost *
; while the relay turns on, then reduce the holding voltage to about  *
; 50% which reduces the total power consumde by the controller.       *
;                                                                     *
;                                                                     *
; Schematic and more information can be found at:                     *
;      http://picprojects.org.uk/projects/                            *
;**********************************************************************


; -------------------------------------------------------------------------------------
; IMPORTANT 
; TMR0 prescaler is 1:16 giving TMR0 clock of 16uS with 4MHz internal oscillator
; Timer load value is calculated as 256 - ( delay_uS / 16 )
; Since there is no interrupt on the 10F2xx PIC, the timer is polled to detect
; when it rolls over to zero.   The timer is clocked at 16uS so any polling loop
; must execute in less than 16uS or it may increment through zero before it is
; 'seen' in by the poller.  This must be taken into account before modifying any
; part of this code were the TMR is polled.
; -------------------------------------------------------------------------------------

                ifdef     __10F200
                list      p=10F200            ; list directive to define processor
                #include <p10F200.inc>        ; processor specific variable definitions
                endif

                ifdef     __10F202
                list      p=10F202            ; list directive to define processor
                #include <p10F202.inc>        ; processor specific variable definitions
                endif

                __CONFIG   _MCLRE_OFF & _CP_OFF & _WDT_OFF

; '__CONFIG' directive is used to embed configuration word within .asm file.
; The lables following the directive are located in the respective .inc file. 
; See respective data sheet for additional information on configuration word.


;*******************************************************************************************
; CONSTANT DEFINITIONS
;
; Constants for 12 bit SIRC
C.cmd.bits      equ             .7              ; Number of bits in the SIRC command
C.dev.bits      equ             .5              ; Number of bits in the SIRC device
;
;*******************************************************************************************
;
;  USER CONFIGURABLE PARAMETERS FOR 12 BIT SIRC DEVICE ID & COMMAND NUMBERS
;  edit the values here to suit application / sirc transmitter being used then
;  reassemble code.  This code does not support 15 or 20 bit SIRC
;
;  Defaults provided below are for Sony TV remote.
;  See http://www.sbprojects.com/knowledge/ir/sirc.htm for additional codes and SIRC FAQ.
;
;  device id:
;  Television       = 1
;  ~~~~~~~~~~~~~~~~~~~~
;  command codes:
;  keypad button #1 = 0
;  keypad button #2 = 1
;  keypad button #3 = 2
;  keypad button #4 = 3
;  keypad button #9 = 8
;  keypad button #0 = 9

                radix decimal ; set radix for decimal values

C.dev.value     equ             1              ; Controller responds to this SIRC device id

; Set any command value to 255 to disable that command.  For example if you only want momentary
; output action, set C.cmd0value thru C.cmd5.value == 255 then only C.cmd6.value and C.cmd7.value
; are active.
; e.g.  C.cmd0.value    equ             255    ; would disable Toggle Rly0.  

                                               ; Command number
; Latching action command codes
C.cmd0.value    equ             0              ; Command 0      Toggle Rly0
C.cmd1.value    equ             1              ; Command 1      Toggle Rly1
C.cmd2.value    equ             3              ; Command 2      Turn off Rly0
C.cmd3.value    equ             4              ; Command 3      Turn off Rly1
C.cmd4.value    equ             9              ; Command 4      Turn on Rly0 + Rly1
C.cmd5.value    equ             8              ; Command 5      Turn off Rly0 + Rly1
; Momentary action command code
C.cmd6.value    equ             6              ; Command 6      Rly0 momentary on
C.cmd7.value    equ             7              ; Command 7      Rly1 momentary on

                radix hex ; set radix back to hex 
;*******************************************************************************************


;***** VARIABLE DEFINITIONS
; GPR starts at 0x0C for 10F202 / 10F206
; GPR starts at 0x10 for 10F200 / 10F204

                cblock 0x10
                 flag            ; application flag bits live here
                 now             ; port state used to detect high-to-low edge on IR data
                 last            ; port state used to detect high-to-low edge on IR data
                 shift.cnt       ; counter for SIRC bits received
                 ir.dev          ; received SIRC device id
                 ir.cmd          ; received SIRC command value
                 timerL          ; repeat receive hold down timer (low byte)
                 timerH          ; repeat receive hold down timer (high byte)
                 port.copy       ; work variable holds data to be output on physical I/O port 
                 dev.active
                 cmd.active
                endc

;**********************************************************************
; I/O port function specific names

irrx            = GP3           ; input:  ir receiver data in
rly0            = GP0           ; output: relay output 0 (active high)
rly1            = GP1           ; output: relay output 1 (active high)
rly.vboost      = GP2           ; output: relay voltage boost control (active high)


;**********************************************************************
; Flag bit definitions
F.error         equ             .0
F.momentary     equ             .1
F.newrx         equ             .2              

;**********************************************************************
                ORG     0x0FF             ; processor reset vector

; Internal RC calibration value is placed at location 0x1FF by Microchip
; as a movlw k, where the k is a literal value.

                ORG     0x000             ; coding begins here

                ; Initialise PIC

start           movwf   OSCCAL            ; update register with factory cal value 
                clrwdt

                ; options  1:16 prescaler to Tmr0, T0CS = Int Osc, Enable weak pull-ups
                ; weak pull holds GP3 high as it is set for internal MCLRE
                movlw           ~(1<<NOT_GPPU | 1<<T0CS | 1<<PSA | 1<<PS2) ;
                option
                movlw            1<<irrx        ; set irrx port to input, all others to output
                tris            GPIO

                ; initialise at start up
                clrf            GPIO            ; turn off all outputs
                clrf            port.copy       ; initialise port.copy variable
                clrf            flag            ; clear all application flag

                ;--------------------------------------------------------
                ; SIRC Receiver Code Function Description
                ;--------------------------------------------------------
                ; 
                ; START LOOP
                ;   loop until falling edge seen from IR receiver 
                ;
                ; start a 2.7mS timer
                ;   if falling edge seen before timeout do error
                ;
                ; prepare to receive 7 command bits
                ; COMMAND LOOP
                ;   wait for falling edge or do error if no edge in 1200mS
                ;   start 900uS timer
                ;   if falling edge seen do error
                ;   on timeout, test irrx: 0 shift in 1, 1 shift in 0
                ;   decrement command count, loop until zero

                ; prepare to receive 5 device bits
                ; DEVICE LOOP
                ;   wait for falling edge or do error if no edge in 1200mS
                ;   start 900uS timer
                ;   if falling edge seen do error
                ;   on timeout, test irrx: 0 shift in 1, 1 shift in 0
                ;   decrement device count, loop until zero
                ; 
                ; start 12mS timer
                ;   if falling edge do error
                ;   else process received data
                ;
                ; If no errors during receive
                ;   shift 7 bit command 1 bit  right to align in byte
                ;   shift 5 bit device  3 bits right to align in byte
                ;--------------------------------------------------------
                
                ; When a valid command has been received, set the hold down timer so we don't
                ; treat repeating data as new button press.
idle            clrf            timerL                          ; preset the hold down timer
                movlw           .75                             ; for ~ 96mS
                movwf           timerH

                ; IR receiver idles with output high, so wait until it goes low
                ; which marks the leading edge of the 2.4mS SIRC start pulse
idle.loop       btfss           GPIO, irrx                      ; is irrx low?
                goto            start.validate                  ; yes, check start pulse

                decfsz          timerL,F                        ; timerL--, skip next if 0
                goto            idle.loop                       ; else keep waiting
                decfsz          timerH,F                        ; timerH--, skip next if 0
                goto            idle.loop                       ; else keep waiting
                bsf             flag, F.newrx                   ; set F.newrx flag at end of hold down period

                btfsc           flag, F.momentary
                clrf            port.copy                       ; turn off relay outputs and voltage boost
                bcf             port.copy, rly.vboost           ; turn off relay voltage boost only
                bcf             flag, F.momentary


                movfw           port.copy                       ; transfer port.copy value
                movwf           GPIO                            ; to physical I/O port
                goto            idle.loop                       ; keep waiting

                ; we've seen the IR receiver output go active (low)
                ; now wait for 2.4mS + 300uS  (4T + 1/2T)
start.validate  movlw           .256 - (.2700/.16)              ; wait for 2.4mS + ( 600uS / 2 )
                call            waitTmr                         ; call waitTmr function 
                btfsc           flag, F.error                   ; test error flag on return
                goto            rxError                         ; if set jump to error handler
              
                ; Command Code Receive 
                movlw           ir.cmd                          ; point indirection register to ir.cmd 
                movwf           FSR             
                movlw           C.cmd.bits                      ; load Wreg with number of bits to receive
                call            receive.data                    ; call receive data function
                btfsc           flag, F.error                   ; test error flag on return
                goto            rxError                         ; and do error handler if error flag set
         
                ; Device Code Receive
                movlw           ir.dev                          ; point indirection register to ir.dev 
                movwf           FSR                             ;
                movlw           C.dev.bits                      ; load Wreg with number of bits to receive
                call            receive.data                    ; call receive data function
                btfsc           flag, F.error                   ; test error flag on return
                goto            rxError                         ; and do error handler if error flag set

                ;---------------------------
                ; Now wait 3 x 4mS = 12mS to ensure no further falling edges are detected
                ; If we received 12bit SIRC data there will be none, if it was 15 or 20 bit we'll see an
                ; edge and can discard the data.
                movlw           .3                              ; number of iterations
                movwf           shift.cnt                       ; reuse shift.cnt for counter
pause.loop      movlw           .256 - (.4000 /.16)             ; 4mS
                call            waitTmr                         ; wait for timer, or error if falling edge detected
                btfsc           flag, F.error                   ; test error flag on return
                goto            rxError                         ; if set jump to error handler
                decfsz          shift.cnt,F                     ; shift.cnt--, skip next if 0
                goto            pause.loop                      ; repeat loop


                ; SIRC command is 7 bits so we shift 1 bit right to align the data in the byte
                ; 
                clrc                                            ; clear carry
                rrf             ir.cmd,F                        ; shift ir.cmd one bit right

                ; SIRC device is 5 bits (for 12bit SIRC) so we shift 3 bits right to align the data in the byte
                rrf             ir.dev,F                        ; shift 1 bit right into ir.dev
                rrf             ir.dev,F                        ; shift 2 bits right into ir.dev
                rrf             ir.dev,W                        ; shift 3 bits right into W reg
                andlw           0x1F                            ; now force three most significant bits to 0
                movwf           ir.dev                          ; and save back to ir.dev

                xorlw           C.dev.value                     ; now compare with the device address constant
                skpz                                            ; if it matches skip next
                goto            discard                         ; else this packet not for me, so discard it


                ;------------------------------
                btfss           flag,F.newrx                    ; is this a new packet or a repeating packet?
                goto            discard                         ; if it's repeating discard it.
                ;------------------------------

                ; Compare the ir.cmd value with the command constants, if we get a match execute the 
                ; relevant command

                movfw           ir.cmd                          ; load ir.cmd received into W
                xorlw           C.cmd0.value                    ; XOR with command0 constant
                skpnz                                           ; skip next if not same
                goto            do.Toggle0                      ; else do command0
                
                movfw           ir.cmd
                xorlw           C.cmd1.value
                skpnz
                goto            do.Toggle1

                movfw           ir.cmd
                xorlw           C.cmd2.value
                skpnz
                goto            do.Off0

                movfw           ir.cmd
                xorlw           C.cmd3.value
                skpnz
                goto            do.Off1

                movfw           ir.cmd
                xorlw           C.cmd4.value
                skpnz
                goto            do.OnAll

                movfw           ir.cmd
                xorlw           C.cmd5.value
                skpnz
                goto            do.OffAll

                movfw           ir.cmd                          
                xorlw           C.cmd6.value                    
                skpnz                                           
                goto            do.momentary0                   
                
                movfw           ir.cmd
                xorlw           C.cmd7.value   
                skpnz
                goto            do.momentary1

discard         ; Here we want to see if the last received SIRC data is the same as the
                ; device/command that was first seen.  If it's not it means the original
                ; button was released so we need to start the hold down count.  If we don't
                ; do this, once we start receiving data, any sirc data received will be 
                ; treated as the original button being held down which is not valid.  Whilst 
                ; it's unlikely to happen, since it can we are prepared for it.

                movfw           ir.cmd          ; compare received command 
                xorwf           cmd.active,W    ; with original received command code
                skpz                            
                goto            idle.loop       ; if not the same don't reload holddown timer
                movfw           ir.dev          ; compare received device id
                xorwf           dev.active,W    ; with original received device id
                skpz
                goto            idle.loop       ; if not the same don't reload holddown timer
                goto            idle            ; else, same button active so reload holddown timer

;------------------------------------------------------------------------------------
; Relay Output Control Functions

                ; When an output is set high (relay on) the voltage boost is enabled.  It will remain high
                ; for at least 96mS after the IR command is received or as long as the IR signal is being
                ; received without a break of at least 96uS
                ; Relay voltage boost is turned off in the IR idle code block

                ; Momentary commands turn on output while button is pressed and turn it
                ; off when button is released.
do.momentary0   movlw           1<<rly0 | 1<<rly.vboost
                movwf           port.copy
                bsf             flag, F.momentary
                goto            command.done

do.momentary1   movlw           1<<rly1 | 1<<rly.vboost
                movwf           port.copy
                bsf             flag, F.momentary
                goto            command.done
            
                ; toggle relay 0
do.Toggle0      movlw           1<<rly0                         ; load W with rly0 bit set to 1
                xorwf           port.copy,F                     ; XOR with port copy (toggles rly0 bit)
                btfsc           port.copy,rly0                  ; is rly0 bit now set to 1 (relay on)?
                bsf             port.copy,rly.vboost            ; if so set bit to turn on relay voltage boost
                goto            command.done

                ; toggle relay 1
do.Toggle1      movlw           1<<rly1                         ; load W with rly1 bit set to 1
                xorwf           port.copy,F                     ; XOR with port copy (toggles rly1 bit)
                btfsc           port.copy,rly1                  ; is rly1 bit now set to 1 (relay on)?
                bsf             port.copy,rly.vboost            ; if so set bit to turn on relay voltage boost
                goto            command.done

                ; turn off relay 0
do.Off0         bcf             port.copy,rly0                  ; turn off relay 0
                goto            command.done

                ; turn off relay 1
do.Off1         bcf             port.copy,rly1                  ; turn off relay 1
                goto            command.done

                ; turn on relay 0               
do.On0          movlw           1<<rly0 | 1<<rly.vboost         ; turn on relay 0 + v.boost
                movwf           port.copy                       
                goto            command.done

                ; turn on relay 1
do.On1          movlw           1<<rly1 | 1<<rly.vboost         ; turn on relay 1 + v.boost
                movwf           port.copy
                goto            command.done

                ; turn off relay 0 and 1
do.OffAll       clrf            port.copy                       ; turn off all relays
                goto            command.done

                ; turn on relays 0 and 1
do.OnAll        movlw           1<<rly1 | 1<<rly0 | 1<<rly.vboost ; turn on relays
                movwf           port.copy
                goto            command.done
                
;------------------------------------------------------------------------------------
                ; Output data to physical I/O port
                ; tidy up and go back to waiting for another transmission

command.done    movfw           port.copy       ; transfer port.copy working variable
                movwf           GPIO            ; to physical I/O port
                bcf             flag, F.newrx   ; clear the F.newrx flag . This prevents repeating IR data from a 
                                                ; single button press being reused within the hold down time period.

                movfw           ir.dev          ; copy first new ir.dev value to 
                movwf           dev.active      ; to dev.active
                movfw           ir.cmd          ; and do same for ir.cmd
                movwf           cmd.active
                                                
                goto            idle            ; jump back to wait for received data

;------------------------------------------------------------------------------------
; Function called with number of bits to receive in W.
; FSR register must be set with address of variable to receive data into 
; before calling. ir.dev or ir.cmd 
; 
; If error detected, receive is aborted and returns with F.error flag set
; Watch the stack depth if modifying the code - this function + it's own calls uses all the stack

receive.data    movwf           shift.cnt                       ; save number of bits to receive to counter variable

                ; wait for falling edge (use 1200mS to force error if no edge seen)
receive.loop    movlw           .256 - (.1200 /.16)             ; set timer for 1200uS
                call            waitEdge                        ; call waitEdge function 
                btfsc           flag, F.error                   ; test error flag on return
                retlw           0x00                            ; if error flag set abort receive

                ; detected falling edge so now wait for 900uS (1.5T), if falling edge detected force error
                movlw           .256 - (.900 /.16)              ; set timer for 900uS 
                call            waitTmr                         ; call waitTmr function 
                btfsc           flag, F.error                   ; test error flag on return
                retlw           0x00                            ; if error flag set abort receive
                
                ; The output from the IR receiver IC is active low so we invert the detected level before shifting
                ; if input low  == data bit is 1
                ; if input high == data bit is 0
                clrc                                            ; carry flag = 0
                btfss           GPIO, irrx                      ; test level on irrx GPIO input, skip next if high (1)
                setc                                            ; carry flag = 1

                ; IR data is sent LSB first so we so we shift right to maintain correct bit order
                rrf             INDF,F                          ; shift carry into MSB 

                decfsz          shift.cnt,F                     ; shift.cnt--, skip when 0 (all command bits shifted in)
                goto            receive.loop                    ; else repeat for next command bit
                retlw           0                               ; shift in expected number of bits, return when done

;------------------------------------------------------------------------------------
                ; wait for a falling edge (high-to-low)
                ; return F.error == 0 if edge seen
                ; return F.error == 1 if timeout occured before high-to-low edge
                ;
waitEdge        movwf           TMR0            ; start timer 
                movfw           GPIO            ; initialise edge detect variable
                andlw           1<<irrx
                movwf           last            ; initialise last
                bcf             flag, F.error   ; initialise error flag to 'No Error'
                
                ; wait for a high-to-low edge
waitEdgeLoop    movfw           GPIO            ; read GPIO
                andlw           1<<irrx         ; mask all but IR RXD
                movwf           now             ; save W in now
                xorwf           last,W          ; XOR now with last, W=1 if now != last
                andwf           last,W          ; AND result with last, W=1 if high-to-low detected
                skpz                            ; skip next if no edge seen
                retlw           0               ; else we're done
                movfw           now             ; copy now var
                movwf           last            ; into last var for next pass
                movfw           TMR0            ; read TMR0
                skpz                            ; skip next if it rolled over
                goto            waitEdgeLoop    ; else wait
                bsf             flag, F.error   ; Timed our waiting for edge so set error flag
                retlw           0               ; return 
                
;------------------------------------------------------------------------------------
                ; wait for timerout
                ; return F.error == 0 if timeout occured
                ; return F.error == 1 if high-to-low edge seen before timeout
                ;
waitTmr         movwf           TMR0            ; start timer 
                movfw           GPIO            ; initialise edge detect variable
                andlw           1<<irrx         ; 
                movwf           last            ; initialise last
                bcf             flag, F.error   ; initialise error flag to 'No Error'
                
                ; wait for a high-to-low edge
waitTmrLoop     movfw           GPIO            ; read GPIO
                andlw           1<<irrx         ; mask off all bits except irrf
                movwf           now             ; save to now
                xorwf           last,W          ; XOR with last  W==1 if last != now
                andwf           last,W          ; AND W with last
                skpz                            ; skip next if no high-to-low edge seen
                goto            waitTmrError    ; else we have an error

                movfw           now             ; copy now var
                movwf           last            ; to last var
                movfw           TMR0            ; read TMR0
                skpnz                           ; skip next if not 0
                retlw           0               ; Timer period expired without any edge, return 
                goto            waitTmrLoop     ; keep waiting for timer out

waitTmrError    bsf             flag, F.error   ; Edge occured during timer period, set error flag
                retlw           0               ; return

;------------------------------------------------------------------------------------
; If we have a receive error, wait for one complete timer0 period (4.096ms)
; before restarting the receiver code. This a nominal timeout and isn't critical
; 
rxError         movlw           .1              ; set timer0 to 1                        
                movwf           TMR0            ; 
                movfw           TMR0            ; load timer into W
                skpz                            ; skip if zero
                goto            $-2             ; go back 2 instructions (loop) if not zero
                goto            idle.loop       ; restart ir receiver code
                                                ; we goto idle.loop rather than idle, since idle
                                                ; reloads the holddown timer.  We don't want to 
                                                ; do this since if some random IR signal is received
                                                ; while a valid button was pressed, it would continue
                                                ; to reset the holddown timer, keeping the output action
                                                ; active even though a valid button isn't being pressed.
;------------------------------------------------------------------------------------


                dt "picprojects.org.uk (C) 2010 v1.5"
     

                END                       ; directive 'end of program'