# #############################################################################
#
# Copyright (c) 2000-2001 by Wayne C. Gramlich & William T. Benson.
# All rights reserved.
#
# Permission to use, copy, modify, distribute, and sell this software
# for any purpose is hereby granted without fee provided that the above
# copyright notice and this permission are retained.  The author makes
# no representations about the suitability of this software for any purpose.
# It is provided "as is" without express or implied warranty.
#
# This is the code that implements the In8 RoboBrick.  Basically
# it just waits for commands that come in at 2400 baud and responds
# to them.  See:
#
#   http://web.gramlich.net/projects/robobricks/in8/index.html
#
# for more details.
#
# #############################################################################

processor pic12c509 cp=off wdte=on mclre=off fosc=intrc

# Define processor constants:
constant clock_rate 4000000						
constant clocks_per_instruction 4
constant instruction_rate clock_rate / clocks_per_instruction

# Define serial communication control constants:
constant baud_rate 2400
constant instructions_per_bit instruction_rate / baud_rate
constant delays_per_bit 3
constant instructions_per_delay instructions_per_bit / delays_per_bit

# Define some registers:
register osccal 5
constant osccal_unit 0x10

# Define port bit assignments:
port porta a bits_and_byte read_write_static
pin out0 porta 0 write_only
pin out1 porta 1 write_only
pin out2 porta 2 write_only
pin in3 porta 3 read_only
pin serial_in  porta 4 read_only
pin serial_out porta 5 write_only

string_constants {
    id = 1, 0, 10, 0, 0, 0, 0, 0, 0r'16', 4, 0s'In8A', 15, 0s'Gramlich&Benson'
}

# Define some globals:
global inputs byte
global complement byte

# Interrupt masks:
global interrupt_enable bit
global interrupt_pending bit
global receiving bit
global falling byte
global high byte
global low byte
global raising byte
    
# For now put all the smaller routines first so that they can live
# within the first 256 bytes of main memory.  The PIC12C5xx chips
# can only call routines that are within the first 256 bytes (i.e.
# the first half) of the code page.

procedure get_byte {
    arguments_none

    returns byte

    # Wait for a character and return it.

    # The get_byte() procedure only waits for 9-2/3 bits.  That
    # way the next call to get_byte() will sychronize on the start
    # bit instead of possibly starting a little later.

    variable count byte
    variable char byte

    # Wait for start bit:
    receiving := 1
    while (serial_in) {
	call delay()
    }

    # Clear any iterrupt being sent:
    serial_out := 1

    # Skip over start bit:
    call delay()
    call delay()
    call delay()

    # Sample in the middle third of each data bit:
    char := 0
    count_down count 8 {
	call delay()
        char := char >> 1
        if (serial_in) {
            char@7 := 1
        }
	call delay()
	call delay()
    }

    # Skip over 2/3's of stop bit:
    call delay()
    call delay()

    return char
}

procedure put_byte {
    argument char byte
    returns_nothing

    # This procedure will send {char} to {serial_out}.

    variable count byte

    # {receiving} will be 1 if the last get/put routine was a get.
    # Before we start transmitting a response back, we want to ensure
    # that there has been enough time to turn the line line around.
    # We delay the first 1/3 of a bit to pad out the 9-2/3 bits from
    # for get_byte to 10 bits.  We delay another 1/3 of a bit just
    # for good measure.  Technically, the second call to delay()
    # is not really needed.

    if (receiving) {
	receiving := 0
	call delay()
	call delay()
    }

    # Send the start bit:
    serial_out := 0
    call delay()
    call delay()
    call delay()

    # Send the data:
    count_down count 8 {
	serial_out := char@0
	char := char >> 1
	call delay()
	call delay()
	call delay() 
    }

    # Send the stop bit:
    serial_out := 1
    call delay()
    call delay()
    call delay()
}

procedure delay {
    arguments_none
    returns_nothing
    uniform_delay instructions_per_delay

    # This procedure delays for 1 third of a bit time.  It is responsible
    # for reading the inputs and dealing with interrupts.

    variable changed byte
    variable previous byte
    variable not_inputs byte
    variable counter byte

    watch_dog_reset

    # Clear the select bits:
    porta := porta & 0xf8

    inputs := 0
    if (in3) {
	inputs@7 := 1
    }
    out0 := 1
    if (in3) {
	inputs@6 := 1
    }
    out1 := 1
    if (in3) {
	inputs@4 := 1
    }
    out0 := 0
    if (in3) {
	inputs@5 := 1
    }
    out2 := 1
    if (in3) {
	inputs@1 := 1
    }
    out0 := 1
    if (in3) {
	inputs@0 := 1
    }
    out1 := 0
    if (in3) {
	inputs@2 := 1
    }
    out0 := 0
    if (in3) {
	inputs@3 := 1
    }
    out2 := 0

    # Deal with interrupts:
    not_inputs := inputs ^ 0xff
    changed := inputs ^ previous
    if ((low & not_inputs) | (high & inputs) | (changed & inputs & raising) | (changed & not_inputs & falling) != 0) {
	interrupt_pending := 1
    }
    # Remember current inputs for next time around:
    previous := inputs

    # Send an interrupt if interrupts are enabled:
    if (interrupt_pending && interrupt_enable) {
	# Shove serial out to low to indicate an interrupt:
	interrupt_enable := 0
	serial_out := 0
    }
}	     

# The main routine can span the 256 byte boundary:

origin 0x200
bank 1

procedure main {
    arguments_none
    returns_nothing

    # This is the main program that is responsible for processing commands
    # from the master.

    variable command byte
    variable glitch byte
    variable id_index byte
    variable result byte

    # Let ROOT=http://web.gramlich.com/projects/robobricks.
    # For Threshold4A specific commands see:
    #   ROOT/threshold4/rev_a/index.html
    # For shared commands see:
    #   ROOT/specifications.html#Software_Protocol
    # For shared interruptcommands see:
    #   ROOT/specifications.html#Interrupts

    complement := 0
    interrupt_enable := 0
    interrupt_pending := 0
    falling := 0
    high := 0
    low := 0
    raising := 0
    glitch := 0
    id_index := 0
    loop_forever {
	command := get_byte()
	switch (command >> 6) {
	  case 0 {
	    # Command = 00xx xxxx:
	    switch (command >> 3) {
	      case 0 {
		# Command = 0000 0xxx:
		switch (command & 7) {
		  case 0 {
		    # Read Inputs (Command = 0000 0000):
		    call put_byte(inputs ^ complement)
		  }
		  case 1 {
		    # Read Complement Mask (Command = 0000 0001):
		    call put_byte(complement)
		  }
		  case 2 {
		    # Read Low Mask (Command = 0000 0010):
		    call put_byte(low)
		  }
		  case 3 {
		    # Read High Mask (Command = 0000 0011):
		    call put_byte(high)
		  }
		  case 4 {
		    # Read Raising Mask (Command = 0000 0100):
		    call put_byte(raising)
		  }
		  case 5 {
		    # Read Falling Mask (Command = 0000 0101):
		    call put_byte(falling)
		  }
		  default 7 {
		    # Do Nothing (Command = 0000 011x):
		  }
		}
	      }
	      case 1 {
		# Command = 0000 1xxx:
		switch (command & 7) {
		  case 0 {
		    # Read Raw (Command = 0000 1000):
		    call put_byte(inputs)
		  }
		  case 1 {
		    # Read Complement (Command = 0000 1001):
		    complement := get_byte()
		  }
		  case 2 {
		    # Read Low (Command = 0000 1010):
		    low := get_byte()
		  }
		  case 3 {
		    # Read High (Command = 0000 1011):
		    high := get_byte()
		  }
		  case 4 {
		    # Read Raising (Command = 0000 1100):
		    raising := get_byte()
		  }
		  case 5 {
		    # Read Falling (Command = 0000 1101):
		    falling := get_byte()
		  }
		  default 7 {
		    # Do Nothing (Command = 0000 111x):
		  }
		}
	      }
	      default 7 {
		# Undefine command; do nothing:
	      }
	    }
	  }
	  case 1 {
	    # do nothing (Command = 01xx xxxx):
	  }
	  case 2 {
	    # Do nothing (Command = 10xx xxxx):
	  }
	  case 3 {
	    # Command = 11xx xxxx:
	    switch ((command >> 3) & 7) {
	      case 0, 1, 2, 3, 4 {
		# Command = 1100 xxxx or 1110 0xxx:
		# Do nothing:
	      }
	      case 5 {
		# Read Interrupt Bits (Command = 1110 1111):
		if ((command & 7) = 7) {
		    # Return Interrupt Bits:
		    result := 0
		    if (interrupt_enable) {
			result := result | 2
		    }
		    if (interrupt_pending) {
			result := result + 1
		    }
		    call put_byte(result)
		}
	      }
	      case 6 {
		# Shared Interrupt commands (Command = 1111 0xxx):
		switch (command & 7) {
		  case 0, 1, 2, 3 {
		    # Set interrupt bits (Command = 1111 00ep):
		    interrupt_enable := command@1
		    interrupt_pending := command@0
		  }
		  case 4, 5 {
		    # Set Interrupt Pending (Command = 1111 010p):
		    interrupt_pending := command@0
		  }
		  case 6, 7 {
		    # Set Interrupt Enable (Command = 1110 011e):
		    interrupt_enable := command@0
		  }
		}
	      }
	      case 7 {
		# Shared commands (Command = 1111 1xxx):
		switch (command & 7) {
		  case 0 {
		    # Clock Decrement (Command = 1111 1000):
		    osccal := osccal - osccal_unit 
		  }
		  case 1 {
		    # Clock Increment (Command = 1111 1001):
		    osccal := osccal + osccal_unit
		  }
		  case 2 {
		    # Clock Read (Command = 1111 1010):
		    call put_byte(osccal)
		  }
		  case 3 {
		    # Clock Pulse (Command = 1111 1011):
		    call put_byte(0)
		  }
		  case 4 {
		    # ID Next (Command = 1111 1100):
		    if (id_index >= id.size) {
			id_index := 0
		    }
		    call put_byte(id[id_index])
		    id_index := id_index + 1
		    if (id_index >= id.size) {
			id_index := 0
		    }
		  }
		  case 5 {
		    # ID Reset (Command = 1111 1101):
		    id_index := 0
		  }
		  case 6 {
		    # Glitch Read (Command = 1111 1110):
		    call put_byte(glitch)
		    glitch := 0
		  }
		  case 7 {
		    # Glitch (Command = 1111 1111):
		    if (glitch != 0xff) {
			glitch := glitch + 1
		    }
		  }
		}
	      }
	    }
	  }
	}
    }
}