"""Manipulates CodeBug over a USB serial connection."""

def __init__(self, serial_port=DEFAULT_SERIAL_PORT):

super(CodeBug, self).__init__(serial.Serial(serial_port, timeout=2))

def _int_input_index(self, input_index):

"""Returns an integer input index."""

# 'A' is 8, 'B' is 9

if isinstance(input_index, str):

input_index = 8 if 'a' in input_index.lower() else 9

return input_index

def get_input(self, input_index):

"""Returns the state of an input. You can use 'A' and 'B' to

input_index = self._int_input_index(input_index)

if input_index > 7:

channel_index = CHANNEL_INDEX_BUTTON_INPUT

input_index -= 8

else:

channel_index = CHANNEL_INDEX_LEG_INPUT

return self.get_bit(channel_index, input_index)

def read_analogue(self, leg_index):

"""Reads the analogue value of the leg at leg_index. The leg must

# set which leg to read (and do the read)

self.set(CHANNEL_INDEX_ANALOGUE_CONF, leg_index)

# return the value

analogue_value = self.get(CHANNEL_INDEX_ANALOGUE_INPUT)

return struct.unpack('B', analogue_value)[0]

def set_pullup(self, input_index, state):

"""Sets the state of the input pullups. Turn off to enable touch

input_index = self._int_input_index(input_index)

self.set_bit(CHANNEL_INDEX_PULLUPS, input_index, state)

def set_output(self, output_index, state):

"""Sets the output index to state."""

self.set_bit(CHANNEL_INDEX_OUTPUT, output_index, state)

def get_output(self, output_index):

"""Returns the state of the output at index."""

return self.get_bit(CHANNEL_INDEX_OUTPUT, output_index)

def set_leg_io(self, leg_index, direction):

"""Sets the I/O direction of the leg at index. For example:

if leg_index < 4:

clear_mask = 0xff ^ (0b11 << leg_index * 2)

direction_mask = (0b11 & direction) << leg_index * 2

self.and_mask(CHANNEL_INDEX_IO_DIRECTION_LEGS, clear_mask)

self.or_mask(CHANNEL_INDEX_IO_DIRECTION_LEGS, direction_mask)

else:

ext_index = leg_index - 4

clear_mask = 0b11 << ext_index * 2

direction_mask = (0b11 & direction) << ext_index * 2

self.and_mask(CHANNEL_INDEX_IO_DIRECTION_EXT, clear_mask)

self.or_mask(CHANNEL_INDEX_IO_DIRECTION_EXT, direction_mask)

def pwm_on(self, t2_prescale, full_period, on_period):

"""Turns on the PWM generator with the given settings.

# full period

self.set(CHANNEL_INDEX_PWM_CONF_0, full_period)

self.set(CHANNEL_INDEX_PWM_CONF_1, on_period & 0xff)

go_busy = 1

top_two_bit_on_period = (on_period >> 8) & 0b11

conf = go_busy << 4 | t2_prescale << 2 | top_two_bit_on_period

self.set(CHANNEL_INDEX_PWM_CONF_2, conf)

def pwm_freq(self, frequency):

"""Turns on the PWM generator with the given frequency. For example:

# calculate pwm settings

# 12MHz / 16 = 750k ticks per second

full_period = int(750000 / frequency) - 1

# for 50% duty cycle: shift up by 2 then /(2 i.e. 50% duty cycle)

# on_period = (full_period << 2) / 2;

# this is quicker

on_period = full_period << 1

self.pwm_on(T2_PS_1_16, full_period, on_period)

def pwm_off(self):

"""Turns off the PWM generator."""

go_busy_off_mask = 0xff ^ (1 << 4)

self.and_mask(CHANNEL_INDEX_PWM_CONF_2, go_busy_off_mask)

def servo_set(self, servo_index, pulse_length):

"""Set the servo at servo_index to pulse_length. Make sure that

pulse_length_msb = 0xff & (pulse_length >> 8)

pulse_length_lsb = 0xff & pulse_length

conf_msb = ((servo_index & 0xf) << 4) | 0x01

conf_lsb = ((servo_index & 0xf) << 4) | 0x00

self.set_bulk(CHANNEL_INDEX_SERVO_PULSE_LENGTH,

bytes([pulse_length_msb, conf_msb]))

self.set_bulk(CHANNEL_INDEX_SERVO_PULSE_LENGTH,

bytes([pulse_length_lsb, conf_lsb]))

def clear(self):

"""Clears the pixels on CodeBug.

self.set_bulk(0, bytes([0]*5))

def fill(self):

"""Sets all pixels on.

self.set_bulk(0, bytes([0x1f]*5))

def set_row(self, row, val):

"""Sets a row of PIXELs on CodeBug.

self.set(row, val)

def get_row(self, row):

"""Returns a row of pixels on CodeBug.

row = self.get(min(row, 5)) # only row channels

return struct.unpack('B', row)[0]

def set_col(self, col, val):

"""Sets an entire column of PIXELs on CodeBug.

rows = struct.unpack('B'*5, self.get_bulk(0, 5))

# clear col

rows = [rows[i] & (0xff ^ (1 << (4-col))) for i in range(5)]

# set cols

val_bits = [(val >> i) & 1 for i in reversed(range(5))]

rows = [rows[i] | (bit << (4-col)) for i, bit in enumerate(val_bits)]

self.set_bulk(0, bytes(rows))

def get_col(self, col):

"""Returns an entire column of PIXELs on CodeBug.

rows = struct.unpack('B'*5, self.get_bulk(0, 5))

c = 0

for row in rows:

c <<= 1

col_bit = 1 & (row >> (4 - col))

c |= col_bit

return c

def set_pixel(self, x, y, state):

"""Sets an PIXEL on CodeBug.

channel = min(y, 5) # only row channels

bit_index = 4 - x

self.set_bit(channel, bit_index, state)

def get_pixel(self, x, y):

"""Returns the state of an PIXEL on CodeBug.

channel = min(y, 5)

bit_index = 4 - x

return self.get_bit(channel, bit_index)

def draw_sprite(self, x, y, sprite, clear_first=True):

"""Draws a sprite at (x, y) on CodeBug's 5x5 display."""

cb_display_sprite = sprite.get_sprite(-x, -y, 5, 5)

cb_rows = [cb_display_sprite.get_row(y)

for y in range(cb_display_sprite.height)]

if clear_first:

self.set_bulk(0, bytes(cb_rows))

else:

for i, row in enumerate(cb_rows):

self.or_mask(i, bytes(row))

def scroll_sprite(self, sprite, interval=0.1, direction='L'):

"""Scrolls a sprite.

direction = direction.upper()[0] # only take the first char

if direction == 'L':

for i in range(sprite.width+5):

self.draw_sprite(5-i, 0, sprite)

time.sleep(interval)

elif direction == 'D':

for i in range(sprite.height+5):

self.draw_sprite(0, 5-i, sprite)

time.sleep(interval)

elif direction == 'R':

for i in reversed(range(sprite.width+5)):

self.draw_sprite(5-i, 0, sprite)

time.sleep(interval)

elif direction == 'U':

for i in reversed(range(sprite.height+5)):

self.draw_sprite(0, 5-i, sprite)

time.sleep(interval)

def config_extension_io(self):

self.set(CHANNEL_INDEX_EXT_CONF, EXTENSION_CONF_IO)

def config_extension_spi(self):

self.set(CHANNEL_INDEX_EXT_CONF, EXTENSION_CONF_SPI)

def config_extension_i2c(self):

self.set(CHANNEL_INDEX_EXT_CONF, EXTENSION_CONF_I2C)

def config_extension_uart(self):

self.set(CHANNEL_INDEX_EXT_CONF, EXTENSION_CONF_UART)

def spi_transaction(self,

data,

cs_idle_high=1,

input_sample_middle=1,

spi_mode=0):

"""Run an SPI transaction using the extensions pins. Be sure to

# control channel

spi_mode = (spi_mode & 0x03) << 3

input_sample_middle = (input_sample_middle & 1) << 2

cs_idle_high = (cs_idle_high & 1) << 1

go = 0x01

control = spi_mode | input_sample_middle | cs_idle_high | go

# put data into the buffer

self.set_buffer(0, bytes(list(data)))

# set the length and control channels in one go

self.set_bulk(CHANNEL_INDEX_SPI_LENGTH, bytes([len(data), control]))

# return data from buffer

return self.get_buffer(0, len(data))

def i2c_transaction(self,

*messages,

add_stop_last_message=True,

interval=0):

"""Run an I2C transaction using the extensions pins. Be sure to

# Can't use a tuple here because `+=` inside `send_msg` implicitly

# declares rx_buffer as a local variable (to send_msg).

rx_buffer = list()

def send_msg(msg):

"""Sends a single i2c message."""

# print("send_msg")

# print("address", hex(msg.address))

# print("msg.data", msg.data)

# print("length", msg.length)

# print("control", bin(msg.control))

# print()

self.set_buffer(0, bytes(msg.data))

# set the i2c address, length and control all in one go

self.set_bulk(CHANNEL_INDEX_I2C_ADDR,

bytes([msg.address, msg.length, msg.control]))

# if reading, add data to rx_buffer

if msg.control & I2C_CONTROL_READ_NOT_WRITE:

values = struct.unpack('B'*msg.length,

self.get_buffer(0, msg.length))

rx_buffer.extend(values)

time.sleep(interval)

if add_stop_last_message:

# send all messages except for the last one

for message in messages[:-1]:

send_msg(message)

# add stop control flag to the last message

messages[-1].control |= I2C_CONTROL_STOP

send_msg(messages[-1])

else:

# send all messages

for message in messages:

send_msg(message)

return tuple(rx_buffer)

def _get_uart_control_baud(self, baud):

"""Returns UART control value for given baud rate. Will raise

baud_control = {300: 0 << 2,

1200: 1 << 2,

2400: 2 << 2,

9600: 3 << 2,

10417: 4 << 2,

19200: 5 << 2,

57600: 6 << 2,

115200: 7 << 2}

if baud not in baud_control:

raise InvalidBaud('{} is not a valid baud rate (valid baud '

'rates: {}).'.format(baud, tuple(baud_control.keys())))

else:

return baud_control[baud]

def uart_set_baud(self, baud):

self.set(CHANNEL_INDEX_UART_CONTROL, self._get_uart_control_baud(baud))

def uart_tx(self, data_bytes, baud=UART_DEFAULT_BAUD):

"""Transmits data bytes over UART. Use this if you just want to

self.uart_tx_set_buffer(data_bytes)

self.uart_tx_start(len(data_bytes))

def uart_tx_start(self, length, offset=0, baud=UART_DEFAULT_BAUD):

"""Transmits 'length' data bytes from UART buffer starting at

control = self._get_uart_control_baud(baud) | UART_TX_GO_BUSY_MASK

self.set_bulk(CHANNEL_INDEX_UART_TX_OFFSET,

bytes((offset, length, control)))

def uart_tx_set_buffer(self, data_bytes, offset=0):

"""Add data_bytes to the UART buffer at offset."""

self.set_buffer(UART_TX_BUFFER_INDEX, data_bytes, offset)

def uart_rx_start(self, length, baud=UART_DEFAULT_BAUD, offset=0):

"""Begins receiving on the UART. RX will stop when length data is

self.set_bulk(CHANNEL_INDEX_UART_RX_OFFSET, bytes((offset, length)))

self.set(CHANNEL_INDEX_UART_CONTROL,

self._get_uart_control_baud(baud) | UART_RX_GO_BUSY_MASK)

def uart_rx_is_ready(self):

"""Returns True if the UART has finished receiving data."""

uart_control = self.get(CHANNEL_INDEX_UART_CONTROL)[0]

return uart_control & UART_RX_GO_BUSY_MASK == 0

def uart_rx_get_buffer(self, length, offset=0):

"""Returns data bytes from UART buffer."""

# Hardware can only do 16bit maths

def limit(v):

max_value = 0x7fff

min_value = -0x8000

return max(min_value, min(max_value, v))

x, from_low, from_high, to_low, to_high = map(

limit, (x, from_low, from_high, to_low, to_high))

# do the scale

from_delta = from_high - from_low

x_offset = x - from_low

to_delta = to_high - to_low

new_x = int((x_offset * to_delta) / from_delta)