| /PIC Stuff/Cerebot_32MX7_LED_Cube/CubeMain.py |
|---|
| File deleted |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/CubeInterface.py |
|---|
| File deleted |
| \ No newline at end of file |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/CubeRawCommands.py |
|---|
| File deleted |
| \ No newline at end of file |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/Ethernet API/animations.py |
|---|
| 0,0 → 1,59 |
| from cube import * |
| from time import sleep |
| def solid_colors(delay): |
| fb_set_all(0xFF, 0x00, 0x00) |
| cube_update() |
| sleep(delay) |
| fb_set_all(0x00, 0xFF, 0x00) |
| cube_update() |
| sleep(delay) |
| fb_set_all(0x00, 0x00, 0xFF) |
| cube_update() |
| sleep(delay) |
| def row_column_sweep(delay): |
| # Sweep across three colors (R,G,B) |
| for color in range(3): |
| # Sweep across each row |
| for row in range(8): |
| fb_set_clear() |
| for column in range(8): |
| for layer in range(8): |
| if color % 3 == 0: |
| fb_set_pixel(row, column, layer, 0xFF, 0x00, 0x00) |
| elif color % 3 == 1: |
| fb_set_pixel(row, column, layer, 0x00, 0xFF, 0x00) |
| else: |
| fb_set_pixel(row, column, layer, 0x00, 0x00, 0xFF) |
| cube_update() |
| sleep(delay) |
| # Sweep across each column |
| for column in range(8): |
| fb_set_clear() |
| for row in range(8): |
| for layer in range(8): |
| if color % 3 == 0: |
| fb_set_pixel(row, column, layer, 0xFF, 0x00, 0x00) |
| elif color % 3 == 1: |
| fb_set_pixel(row, column, layer, 0x00, 0xFF, 0x00) |
| else: |
| fb_set_pixel(row, column, layer, 0x00, 0x00, 0xFF) |
| cube_update() |
| sleep(delay) |
| # Sweep across each layer |
| for layer in range(7, -1, -1): |
| fb_set_clear() |
| for layer_2 in range(8): |
| if color % 3 == 0: |
| if layer_2 == layer: |
| set_layer(layer_2, 0xFF, 0x00, 0x00) |
| elif color % 3 == 1: |
| if layer_2 == layer: |
| set_layer(layer_2, 0x00, 0xFF, 0x00) |
| else: |
| if layer_2 == layer: |
| set_layer(layer_2, 0x00, 0x00, 0xFF) |
| cube_update() |
| sleep(delay) |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/Ethernet API/cube.py |
|---|
| 0,0 → 1,136 |
| import socket, struct, time |
| # Set the address of the Cerebot board |
| dst_addr = '00183E00D7EB'.decode('hex') |
| # Open a socket on the eth0 |
| sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW) |
| sock.bind(("eth0", 0x1)) |
| # Acquire MAC address of local machine |
| if_name, if_proto, pkt_type, hw_type, hw_addr = sock.getsockname() |
| # Create and initialize the frame buffer |
| frame_buffer_size = 1536 |
| frame_buffer = [0] * frame_buffer_size |
| def cube_init(): |
| '''Sets the cube into ethernet mode.''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 1) |
| txOpcode = "01".decode('hex') |
| sock.send(txFrame + txOpcode) |
| # Wait a few seconds for the cube to reset itself |
| time.sleep(6) |
| def cube_reset(): |
| '''Resets the cube into idle mode.''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 1) |
| txOpcode = "02".decode('hex') |
| sock.send(txFrame + txOpcode) |
| def cube_clear(): |
| '''Clear the cube's internal buffer.''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 1) |
| txOpcode = "0A".decode('hex') |
| sock.send(txFrame + txOpcode) |
| def cube_brightness(value): |
| '''Sets the global brightness value from 0 to 255.''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 2) |
| txOpcode = "0B".decode('hex') |
| txData = format(value, '02x').decode('hex') |
| sock.send(txFrame + txOpcode + txData) |
| def cube_rotate(direction): |
| '''Rotate the entire cube (0 = clockwise, 1 = counterclockwise).''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 2) |
| txOpcode = "0C".decode('hex') |
| txData = format(direction, '02x').decode('hex') |
| sock.send(txFrame + txOpcode + txData) |
| def cube_rotate_shell(direction, shell): |
| '''Rotate a specific layer (0 = clockwise, 0 = outermost layer).''' |
| # Generate and send the frame |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 3) |
| txOpcode = "0D".decode('hex') |
| txData = ''.join("%02x%02x" % (direction, shell)) |
| sock.send(txFrame + txOpcode + txData.decode('hex')) |
| # def cube_update(): |
| # '''Update the cube with the current frame buffer. |
| # Note: this requires jumbo frames (1536 bytes).''' |
| # # Generate the header, opcode, and format the frame buffer |
| # txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 0x0601) |
| # txOpcode = "10".decode('hex') |
| # txData = ''.join("%02x" % (x) for x in frame_buffer) |
| # sock.send(txFrame + txOpcode + txData.decode('hex')) |
| def cube_update_pixel(x, y, z, r, g, b): |
| '''Set a specific pixel on the cube.''' |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 7) |
| txOpcode = "11".decode('hex') |
| frame = [x, y, z, r, g, b] |
| txData = ''.join("%02x" % (x) for x in frame) |
| sock.send(txFrame + txOpcode + txData.decode('hex')) |
| def cube_update(): |
| '''Updates the cube with the current frame buffer. |
| The buffer is sent in three frames, one for each color channel.''' |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 514) |
| txOpcode = "12".decode('hex') |
| for c in range(3): |
| txColorCh = "%02x" % c |
| txData = ''.join( ["%02x" % (x) for x in frame_buffer[c::3]]) |
| payload = txFrame + txOpcode + txColorCh.decode('hex') + txData.decode('hex') |
| sock.send(payload) |
| def cube_update_text(string, r, g, b, update_rate): |
| '''Sets the scrolling text on the cube.''' |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, len(string) + 6) |
| txOpcode = "20".decode('hex') |
| txData = ''.join("%02x%02x%02x%02x%02x" % (len(string), r, g, b, update_rate)) |
| txString = string.encode('hex') |
| sock.send(txFrame + txOpcode + txData.decode('hex') + txString.decode('hex')) |
| def cube_update_waterfall(c0, c1, c2, c3, c4, c5, c6, c7): |
| '''Fills in one row and shifts rows by one.''' |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 9) |
| txOpcode = "30".decode('hex') |
| txData = ''.join("%02x%02x%02x%02x%02x%02x%02x%02x" % (c0, c1, c2, c3, c4, c5, c6, c7)) |
| sock.send(txFrame + txOpcode + txData.decode('hex')) |
| def cube_update_sphere(layer, r, g, b): |
| '''Sets the sphere layer to the specified color.''' |
| txFrame = struct.pack("!6s6sH", dst_addr, hw_addr, 5) |
| txOpcode = "31".decode('hex') |
| txData = ''.join("%02x%02x%02x%02x" % (layer, r, g, b)) |
| sock.send(txFrame + txOpcode + txData.decode('hex')) |
| def fb_clear(): |
| '''Clears the frame buffer/''' |
| for row in range(8): |
| for column in range(8): |
| for layer in range(8): |
| fb_set_pixel(row, column, layer, 0x00, 0x00, 0x00) |
| def fb_set_pixel(row, column, layer, R, G, B): |
| '''Sets a pixel to the given color in the frame buffer/''' |
| frame_buffer[layer * 192 + column * 24 + row * 3 + 0] = R |
| frame_buffer[layer * 192 + column * 24 + row * 3 + 1] = G |
| frame_buffer[layer * 192 + column * 24 + row * 3 + 2] = B |
| def fb_set_layer(layer, R, G, B): |
| '''Sets an entire layer to the given color in the frame buffer''' |
| for row in range(8): |
| for column in range(8): |
| fb_set_pixel(row, column, layer, R, G, B) |
| def fb_set_all(R, G, B): |
| '''Sets all the pixels in the frame buffer to the given color''' |
| for row in range(8): |
| for column in range(8): |
| for layer in range(8): |
| fb_set_pixel(row, column, layer, R, G, B) |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/Ethernet API/main.py |
|---|
| 0,0 → 1,44 |
| from cube import * |
| import animations |
| from time import sleep |
| if __name__ == '__main__': |
| # Put the cube into ethernet mode |
| print "Initializing cube. Wait 6 seconds...\n" |
| # cube_init() |
| # ----- Begin animations ----- |
| cube_clear() |
| cube_update_text("CCM LAB ", 0xFF, 0xFF, 0xFF, 100) |
| print "Looping animations...\n" |
| while(1): |
| # for i in range(9): |
| # cube_clear() |
| # cube_update_sphere(i, 0xFF, 0x00, 0x00) |
| # sleep(0.1) |
| cube_update_waterfall(1, 2, 3, 4, 5, 6, 7, 8) |
| sleep(0.1) |
| # #cube_update_pixel(x, y, z, r, g, b) |
| # for x in range(8): |
| # for y in range(8): |
| # for z in range(8): |
| # cube_update_pixel(x, y, z, 255, 255, 255) |
| # time.sleep(0.11) |
| # cube_update_pixel(x, y, z, 0, 0, 0) |
| # time.sleep(0.1) |
| # #time.sleep(0.1) |
| # ----- End Animations ----- |
| # Reset the cube into idle mode (optional) |
| print "Animations done. Returning board to idle mode..." |
| cube_reset() |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/UART API/CubeInterface.py |
|---|
| 0,0 → 1,257 |
| import serial |
| from CubeRawCommands import * |
| # Constants |
| CUBE_LAYER_COUNT = 8 |
| CUBE_ROW_COUNT = 8 |
| CUBE_COLUMN_COUNT = 8 |
| CUBE_ROTATIONS = 7 |
| GCS_REG_SIZE = 36 |
| GCS_LAYER_SIZE = GCS_REG_SIZE * CUBE_ROW_COUNT |
| # 3 bytes per LED, 1536 total for the cube |
| cube_buffer = bytearray(CUBE_LAYER_COUNT*GCS_LAYER_SIZE) |
| rotation_counter = 0 |
| # Specify the serial port to connect to |
| serial_port = serial.Serial() |
| '''Opens the serial port for sending commands through.''' |
| def Cube_Init(port, baudrate): |
| serial_port.port = port |
| serial_port.baudrate = baudrate |
| serial_port.open() |
| '''Clears the local buffer for LED values.''' |
| def Cube_Clear(): |
| for i in range(len(cube_buffer)): |
| cube_buffer[i] = 0 |
| '''Sets a specific pixel in the local buffer.''' |
| def Cube_Set_Pixel(layer, row, column, R, G, B): |
| # Set the specified pixel to the given color |
| R &= 0x0FFF |
| G &= 0x0FFF |
| B &= 0x0FFF |
| var = row * GCS_REG_SIZE + (column // 2 * 9) |
| offset = (layer * GCS_LAYER_SIZE) + var |
| if column % 2 == 0: |
| cube_buffer[offset+0] = R & 0xFF |
| cube_buffer[offset+1] = ((G << 4) | (R >> 8)) & 0xFF |
| cube_buffer[offset+2] = G >> 4 |
| cube_buffer[offset+3] = B & 0xFF |
| cube_buffer[offset+4] = ((cube_buffer[offset+4] & 0xF0) | (B >> 8)) & 0xFF |
| elif column % 2 == 1: |
| cube_buffer[offset+4] = ((cube_buffer[offset+4] & 0x0F) | (R << 4)) & 0xFF |
| cube_buffer[offset+5] = R >> 4 |
| cube_buffer[offset+6] = G & 0xFF |
| cube_buffer[offset+7] = ((B << 4) | (G >> 8)) & 0xFF |
| cube_buffer[offset+8] = B >> 4 |
| '''Retreives a specific pixel in the local buffer.''' |
| def Cube_Get_Pixel(layer, row, column): |
| # Get and return the color for the specified pixel |
| R = G = B = 0 |
| var = row * GCS_REG_SIZE + (column // 2 * 9) |
| offset = (layer * GCS_LAYER_SIZE) + var |
| if column % 2 == 0: |
| R = cube_buffer[offset+0] | ((cube_buffer[offset+1] & 0x0F) << 8); |
| G = (cube_buffer[offset+1] >> 4) | (cube_buffer[offset+2] << 4); |
| B = cube_buffer[offset+3] | ((cube_buffer[offset+4] & 0x0F) << 8); |
| elif column % 2 == 1: |
| R = (cube_buffer[offset+4] >> 4) | (cube_buffer[offset+5] << 4); |
| G = cube_buffer[offset+6] | ((cube_buffer[offset+7] & 0x0F) << 8); |
| B = (cube_buffer[offset+7] >> 4) | (cube_buffer[offset+8] << 4); |
| return [R,G,B] |
| '''Moves a value from one pixel to another in the local buffer.''' |
| def Cube_Move_Pixel(layer_1, row_1, column_1, layer_2, row_2, column_2): |
| old = Cube_Get_Pixel(layer1, row_1, column_1) |
| Cube_Set_Pixel(layer_2, row_2, column_2, old[0], old[1], old[2]) |
| '''Rotates the specified shell in the local buffer.''' |
| def Cube_Rotate_Shell(shell, direction): |
| for layer in range(CUBE_LAYER_COUNT): |
| if direction == 1: |
| if shell == 0: |
| # Rotate outermost layer |
| old = Cube_Get_Pixel(layer, 0, 0); |
| Cube_Move_Pixel(layer, 0, 1, layer, 0, 0); |
| Cube_Move_Pixel(layer, 0, 2, layer, 0, 1); |
| Cube_Move_Pixel(layer, 0, 3, layer, 0, 2); |
| Cube_Move_Pixel(layer, 0, 4, layer, 0, 3); |
| Cube_Move_Pixel(layer, 0, 5, layer, 0, 4); |
| Cube_Move_Pixel(layer, 0, 6, layer, 0, 5); |
| Cube_Move_Pixel(layer, 0, 7, layer, 0, 6); |
| Cube_Move_Pixel(layer, 1, 7, layer, 0, 7); |
| Cube_Move_Pixel(layer, 2, 7, layer, 1, 7); |
| Cube_Move_Pixel(layer, 3, 7, layer, 2, 7); |
| Cube_Move_Pixel(layer, 4, 7, layer, 3, 7); |
| Cube_Move_Pixel(layer, 5, 7, layer, 4, 7); |
| Cube_Move_Pixel(layer, 6, 7, layer, 5, 7); |
| Cube_Move_Pixel(layer, 7, 7, layer, 6, 7); |
| Cube_Move_Pixel(layer, 7, 6, layer, 7, 7); |
| Cube_Move_Pixel(layer, 7, 5, layer, 7, 6); |
| Cube_Move_Pixel(layer, 7, 4, layer, 7, 5); |
| Cube_Move_Pixel(layer, 7, 3, layer, 7, 4); |
| Cube_Move_Pixel(layer, 7, 2, layer, 7, 3); |
| Cube_Move_Pixel(layer, 7, 1, layer, 7, 2); |
| Cube_Move_Pixel(layer, 7, 0, layer, 7, 1); |
| Cube_Move_Pixel(layer, 6, 0, layer, 7, 0); |
| Cube_Move_Pixel(layer, 5, 0, layer, 6, 0); |
| Cube_Move_Pixel(layer, 4, 0, layer, 5, 0); |
| Cube_Move_Pixel(layer, 3, 0, layer, 4, 0); |
| Cube_Move_Pixel(layer, 2, 0, layer, 3, 0); |
| Cube_Move_Pixel(layer, 1, 0, layer, 2, 0); |
| Cube_Set_Pixel(layer, 1, 0, old[0], old[1], old[2]); |
| elif shell == 1: |
| # Rotate second to outermost layer |
| old = Cube_Get_Pixel(layer, 1, 1); |
| Cube_Move_Pixel(layer, 1, 2, layer, 1, 1); |
| Cube_Move_Pixel(layer, 1, 3, layer, 1, 2); |
| Cube_Move_Pixel(layer, 1, 4, layer, 1, 3); |
| Cube_Move_Pixel(layer, 1, 5, layer, 1, 4); |
| Cube_Move_Pixel(layer, 1, 6, layer, 1, 5); |
| Cube_Move_Pixel(layer, 2, 6, layer, 1, 6); |
| Cube_Move_Pixel(layer, 3, 6, layer, 2, 6); |
| Cube_Move_Pixel(layer, 4, 6, layer, 3, 6); |
| Cube_Move_Pixel(layer, 5, 6, layer, 4, 6); |
| Cube_Move_Pixel(layer, 6, 6, layer, 5, 6); |
| Cube_Move_Pixel(layer, 6, 5, layer, 6, 6); |
| Cube_Move_Pixel(layer, 6, 4, layer, 6, 5); |
| Cube_Move_Pixel(layer, 6, 3, layer, 6, 4); |
| Cube_Move_Pixel(layer, 6, 2, layer, 6, 3); |
| Cube_Move_Pixel(layer, 6, 1, layer, 6, 2); |
| Cube_Move_Pixel(layer, 5, 1, layer, 6, 1); |
| Cube_Move_Pixel(layer, 4, 1, layer, 5, 1); |
| Cube_Move_Pixel(layer, 3, 1, layer, 4, 1); |
| Cube_Move_Pixel(layer, 2, 1, layer, 3, 1); |
| Cube_Set_Pixel(layer, 2, 1, old[0], old[1], old[2]); |
| elif shell == 2: |
| # Rotate second to innermost layer |
| old = Cube_Get_Pixel(layer, 2, 2); |
| Cube_Move_Pixel(layer, 2, 3, layer, 2, 2); |
| Cube_Move_Pixel(layer, 2, 4, layer, 2, 3); |
| Cube_Move_Pixel(layer, 2, 5, layer, 2, 4); |
| Cube_Move_Pixel(layer, 3, 5, layer, 2, 5); |
| Cube_Move_Pixel(layer, 4, 5, layer, 3, 5); |
| Cube_Move_Pixel(layer, 5, 5, layer, 4, 5); |
| Cube_Move_Pixel(layer, 5, 4, layer, 5, 5); |
| Cube_Move_Pixel(layer, 5, 3, layer, 5, 4); |
| Cube_Move_Pixel(layer, 5, 2, layer, 5, 3); |
| Cube_Move_Pixel(layer, 4, 2, layer, 5, 2); |
| Cube_Move_Pixel(layer, 3, 2, layer, 4, 2); |
| Cube_Set_Pixel(layer, 3, 2, old[0], old[1], old[2]); |
| elif shell == 3: |
| # Rotate innermost layer |
| old = Cube_Get_Pixel(layer, 3, 3); |
| Cube_Move_Pixel(layer, 3, 4, layer, 3, 3); |
| Cube_Move_Pixel(layer, 4, 4, layer, 3, 4); |
| Cube_Move_Pixel(layer, 4, 3, layer, 4, 4); |
| Cube_Set_Pixel(layer, 4, 3, old[0], old[1], old[2]); |
| else: |
| if shell == 0: |
| # Rotate outermost layer |
| old = Cube_Get_Pixel(layer, 0, 0); |
| Cube_Move_Pixel(layer, 1, 0, layer, 0, 0); |
| Cube_Move_Pixel(layer, 2, 0, layer, 1, 0); |
| Cube_Move_Pixel(layer, 3, 0, layer, 2, 0); |
| Cube_Move_Pixel(layer, 4, 0, layer, 3, 0); |
| Cube_Move_Pixel(layer, 5, 0, layer, 4, 0); |
| Cube_Move_Pixel(layer, 6, 0, layer, 5, 0); |
| Cube_Move_Pixel(layer, 7, 0, layer, 6, 0); |
| Cube_Move_Pixel(layer, 7, 1, layer, 7, 0); |
| Cube_Move_Pixel(layer, 7, 2, layer, 7, 1); |
| Cube_Move_Pixel(layer, 7, 3, layer, 7, 2); |
| Cube_Move_Pixel(layer, 7, 4, layer, 7, 3); |
| Cube_Move_Pixel(layer, 7, 5, layer, 7, 4); |
| Cube_Move_Pixel(layer, 7, 6, layer, 7, 5); |
| Cube_Move_Pixel(layer, 7, 7, layer, 7, 6); |
| Cube_Move_Pixel(layer, 6, 7, layer, 7, 7); |
| Cube_Move_Pixel(layer, 5, 7, layer, 6, 7); |
| Cube_Move_Pixel(layer, 4, 7, layer, 5, 7); |
| Cube_Move_Pixel(layer, 3, 7, layer, 4, 7); |
| Cube_Move_Pixel(layer, 2, 7, layer, 3, 7); |
| Cube_Move_Pixel(layer, 1, 7, layer, 2, 7); |
| Cube_Move_Pixel(layer, 0, 7, layer, 1, 7); |
| Cube_Move_Pixel(layer, 0, 6, layer, 0, 7); |
| Cube_Move_Pixel(layer, 0, 5, layer, 0, 6); |
| Cube_Move_Pixel(layer, 0, 4, layer, 0, 5); |
| Cube_Move_Pixel(layer, 0, 3, layer, 0, 4); |
| Cube_Move_Pixel(layer, 0, 2, layer, 0, 3); |
| Cube_Move_Pixel(layer, 0, 1, layer, 0, 2); |
| Cube_Set_Pixel(layer, 0, 1, old[0], old[1], old[2]); |
| if shell == 1: |
| # Rotate second to outermost layer |
| old = Cube_Get_Pixel(layer, 1, 1); |
| Cube_Move_Pixel(layer, 2, 1, layer, 1, 1); |
| Cube_Move_Pixel(layer, 3, 1, layer, 2, 1); |
| Cube_Move_Pixel(layer, 4, 1, layer, 3, 1); |
| Cube_Move_Pixel(layer, 5, 1, layer, 4, 1); |
| Cube_Move_Pixel(layer, 6, 1, layer, 5, 1); |
| Cube_Move_Pixel(layer, 6, 2, layer, 6, 1); |
| Cube_Move_Pixel(layer, 6, 3, layer, 6, 2); |
| Cube_Move_Pixel(layer, 6, 4, layer, 6, 3); |
| Cube_Move_Pixel(layer, 6, 5, layer, 6, 4); |
| Cube_Move_Pixel(layer, 6, 6, layer, 6, 5); |
| Cube_Move_Pixel(layer, 5, 6, layer, 6, 6); |
| Cube_Move_Pixel(layer, 4, 6, layer, 5, 6); |
| Cube_Move_Pixel(layer, 3, 6, layer, 4, 6); |
| Cube_Move_Pixel(layer, 2, 6, layer, 3, 6); |
| Cube_Move_Pixel(layer, 1, 6, layer, 2, 6); |
| Cube_Move_Pixel(layer, 1, 5, layer, 1, 6); |
| Cube_Move_Pixel(layer, 1, 4, layer, 1, 5); |
| Cube_Move_Pixel(layer, 1, 3, layer, 1, 4); |
| Cube_Move_Pixel(layer, 1, 2, layer, 1, 3); |
| Cube_Set_Pixel(layer, 1, 2, old[0], old[1], old[2]); |
| if shell == 2: |
| # Rotate second to innermost layer |
| old = Cube_Get_Pixel(layer, 2, 2); |
| Cube_Move_Pixel(layer, 3, 2, layer, 2, 2); |
| Cube_Move_Pixel(layer, 4, 2, layer, 3, 2); |
| Cube_Move_Pixel(layer, 5, 2, layer, 4, 2); |
| Cube_Move_Pixel(layer, 5, 3, layer, 5, 2); |
| Cube_Move_Pixel(layer, 5, 4, layer, 5, 3); |
| Cube_Move_Pixel(layer, 5, 5, layer, 5, 4); |
| Cube_Move_Pixel(layer, 4, 5, layer, 5, 5); |
| Cube_Move_Pixel(layer, 3, 5, layer, 4, 5); |
| Cube_Move_Pixel(layer, 2, 5, layer, 3, 5); |
| Cube_Move_Pixel(layer, 2, 4, layer, 2, 5); |
| Cube_Move_Pixel(layer, 2, 3, layer, 2, 4); |
| Cube_Set_Pixel(layer, 2, 3, old[0], old[1], old[2]); |
| if shell == 3: |
| # Rotate innermost layer |
| old = Cube_Get_Pixel(layer, 3, 3); |
| Cube_Move_Pixel(layer, 4, 3, layer, 3, 3); |
| Cube_Move_Pixel(layer, 4, 4, layer, 4, 3); |
| Cube_Move_Pixel(layer, 3, 4, layer, 4, 4); |
| Cube_Set_Pixel(layer, 3, 4, old[0], old[1], old[2]); |
| '''Rotates the entire cube in the local buffer.''' |
| def Cube_Rotate(direction): |
| # Rotate outermost layer |
| Cube_Rotate_Shell(0, direction); |
| # Rotate second to outermost layer |
| if ((rotation_counter != 1) and (rotation_counter != 5)): |
| Cube_Rotate_Shell(1, direction); |
| # Rotate second to innermost layer |
| if ((rotation_counter != 0) and (rotation_counter != 2) and (rotation_counter != 4) and (rotation_counter != 6)): |
| Cube_Rotate_Shell(2, direction); |
| # Rotate innermost layer |
| if ((rotation_counter == 3) or (rotation_counter == 7)): |
| Cube_Rotate_Shell(3, direction); |
| if (direction == 0): |
| if rotation_counter == CUBE_ROTATIONS - 1: |
| rotation_counter = 0 |
| else: |
| rotation_counter = rotation_counter + 1 |
| else: |
| if rotation_counter == 0: |
| rotation_counter = CUBE_ROTATIONS - 1 |
| else: |
| rotation_counter = rotation_counter - 1 |
| '''Write the local buffer to the cube.''' |
| def Cube_Update(): |
| serial_port.write(CMD_Set_All(cube_buffer)) |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/UART API/CubeMain.py |
|---|
| 0,0 → 1,62 |
| import serial,time |
| from CubeRawCommands import * |
| from CubeInterface import * |
| def Animation_Row_Column_Sweep(iterations, delay): |
| for z in range(iterations): |
| for i in range(3): |
| for j in range(CUBE_ROW_COUNT): |
| Cube_Clear(); |
| for k in range(CUBE_COLUMN_COUNT): |
| if (i % 3 == 0): |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,j,k,0xFF,0x00,0x00) |
| elif (i % 3 == 1): |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,j,k,0x00,0xFF,0x00) |
| else: |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,j,k,0x00,0x00,0xFF) |
| Cube_Update() |
| time.sleep(delay) |
| for j in range(CUBE_ROW_COUNT): |
| Cube_Clear(); |
| for k in range(CUBE_COLUMN_COUNT): |
| if (i % 3 == 0): |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,k,j,0xFF,0x00,0x00) |
| elif (i % 3 == 1): |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,k,j,0x00,0xFF,0x00) |
| else: |
| for a in range(CUBE_LAYER_COUNT): |
| Cube_Set_Pixel(a,k,j,0x00,0x00,0xFF) |
| Cube_Update() |
| time.sleep(delay) |
| for j in range(CUBE_LAYER_COUNT-1, -1, -1): |
| Cube_Clear(); |
| if (i % 3 == 0): |
| for k in range(CUBE_LAYER_COUNT): |
| if (k == j): |
| for x in range(CUBE_ROW_COUNT): |
| for y in range(CUBE_COLUMN_COUNT): |
| Cube_Set_Pixel(k,x,y,0xFF,0x00,0x00) |
| elif (i % 3 == 1): |
| for k in range(CUBE_LAYER_COUNT): |
| if (k == j): |
| for x in range(CUBE_ROW_COUNT): |
| for y in range(CUBE_COLUMN_COUNT): |
| Cube_Set_Pixel(k,x,y,0x00,0xFF,0x00) |
| else: |
| for k in range(CUBE_LAYER_COUNT): |
| if (k == j): |
| for x in range(CUBE_ROW_COUNT): |
| for y in range(CUBE_COLUMN_COUNT): |
| Cube_Set_Pixel(k,x,y,0x00,0x00,0xFF) |
| Cube_Update() |
| time.sleep(delay) |
| if __name__ == '__main__': |
| Cube_Init('COM11', 256000) |
| Animation_Row_Column_Sweep(3,0) |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/UART API/CubeRawCommands.py |
|---|
| 0,0 → 1,43 |
| '''Generates the byte array for setting the global brightness.''' |
| def CMD_Set_BC(brightness): |
| barray = bytearray.fromhex('7E 00 02 0A') |
| barray.extend([brightness]) |
| barray.extend([Calculate_Checksum(barray)]) |
| return barray |
| '''Generates the byte array for clearing all pixels.''' |
| def CMD_Clear(): |
| return bytearray.fromhex('7E 00 01 0B F4') |
| '''Generates the command for setting a specific pixel.''' |
| def CMD_Set_Pixel(layer, row, column, r, g, b): |
| barray = bytearray.fromhex('7E 00 07 10') |
| barray.extend([layer,row,column,r,g,b,]) |
| barray.extend([Calculate_Checksum(barray)]) |
| return barray |
| '''Generates the command for setting the entire cube.''' |
| def CMD_Set_All(leds): |
| barray = bytearray.fromhex('7E 09 01 11') |
| barray.extend(leds) |
| barray.extend([Calculate_Checksum(barray)]) |
| return barray |
| '''Generates the command for setting the rotating overlay text.''' |
| def CMD_Start_Text(r, g, b, string): |
| length = len(string) + 4 |
| barray = bytearray.fromhex('7E 00') |
| barray.extend([length, 0x20, r, g, b]) |
| barray.extend(string.encode()) |
| barray.extend([Calculate_Checksum(barray)]) |
| return barray |
| '''Generates the command for stopping the rotating overlay text.''' |
| def CMD_Stop_Text(): |
| return bytes.fromhex('7E 00 01 21 DE') |
| def Calculate_Checksum(barray): |
| s = 0 |
| for entry in range(3,len(barray)): |
| s += barray[entry] |
| return 255 - (s & 0xFF) |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/defines.h |
|---|
| 8,8 → 8,8 |
| #include <stdint.h> |
| // Uncomment ONE of the following: |
| //#define CEREBOT_32MX7 |
| #define CEREBOT_MX7CK |
| #define CEREBOT_32MX7 |
| // #define CEREBOT_MX7CK |
| // Power supply must be 5V for proper operation of the board! |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/Makefile-genesis.properties |
|---|
| 1,5 → 1,5 |
| # |
| #Fri Feb 07 16:03:16 EST 2014 |
| #Fri Feb 07 17:53:36 EST 2014 |
| default.com-microchip-mplab-nbide-toolchainXC32-XC32LanguageToolchain.md5=83f4565fa27ad9b8015f63d69ef74f66 |
| default.languagetoolchain.dir=C\:\\Program Files (x86)\\Microchip\\xc32\\v1.31\\bin |
| com-microchip-mplab-nbide-embedded-makeproject-MakeProject.md5=1f98a0eed69cb2a45c12981fa9470927 |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/configurations.xml |
|---|
| 185,6 → 185,7 |
| <property key="ToolFirmwareFilePath" |
| value="Press to browse for a specific firmware version"/> |
| <property key="ToolFirmwareOption.UseLatestFirmware" value="true"/> |
| <property key="firmware.download.all" value="false"/> |
| <property key="memories.bootflash" value="false"/> |
| <property key="memories.configurationmemory" value="false"/> |
| <property key="memories.eeprom" value="false"/> |
| /PIC Stuff/Cerebot_32MX7_LED_Cube/nbproject/private/configurations.xml |
|---|
| 4,7 → 4,7 |
| <defaultConf>0</defaultConf> |
| <confs> |
| <conf name="default" type="2"> |
| <platformToolSN>:=MPLABComm-USB-Microchip:=<vid>04D8:=<pid>8108:=<rev>0002:=<man>Digilent:=<prod>CerebotMX7CK:=<sn>D459520:=<drv>x:=<xpt>h:=end</platformToolSN> |
| <platformToolSN>:=MPLABComm-USB-Microchip:=<vid>04D8:=<pid>8108:=<rev>0002:=<man>Digilent:=<prod>Cerebot 32MX7:=<sn>D370400:=<drv>x:=<xpt>h:=end</platformToolSN> |
| <languageToolchainDir>C:\Program Files (x86)\Microchip\xc32\v1.31\bin</languageToolchainDir> |
| <mdbdebugger version="1"> |
| <placeholder1>place holder 1</placeholder1> |