Controller

mux_test/mux_test.ino

@@ -0,0 +1,139 @@
+#define data 2
+
+#define eastEnable 3  //(low in non use)
+#define topEnable 4   //(low in non use)
+#define eastSelect 5  //(default = a)
+#define topSelect 6   //(default = a)
+
+#define westEnable 7  //(low in non use)
+#define botEnable 8   //(low in non use)
+
+char dataOut[4];
+
+void setup() {
+  // put yoursetup code here, to run once:
+  pinMode(data, INPUT);
+
+  pinMode(eastSelect, OUTPUT);
+  pinMode(eastEnable, OUTPUT);
+  pinMode(topSelect, OUTPUT);
+  pinMode(topEnable, OUTPUT);
+
+  pinMode(westEnable, OUTPUT);
+  pinMode(botEnable, OUTPUT);
+  Serial.begin(9600);
+}
+
+void readSpecTile(int in [3]){
+//input 4 bit number
+//output status of thatta tile.
+}
+
+void loop(){
+  //write to pins 2-5. target: 0000, then 0101
+  digitalWrite(2,0);
+  digitalWrite(3,0);
+  digitalWrite(4,0);
+  digitalWrite(5,0);
+  //read data on a5
+  Serial.println(!digitalRead(A5));
+
+}
+
+void old_loop() {
+
+  //EAST TOP
+  mux_setup(1, 1, 1, 1);           //CONTROLLS WHAT QUADRANT YOU'RE GETTING DATA FOR
+  dataOut[0] = digitalRead(data);  //tile 1
+
+  mux_setup(1, 1, 0, 0);
+  dataOut[1] = digitalRead(data);  //tile 2
+
+  mux_setup(1, 1, 1, 0);
+  dataOut[2] = digitalRead(data);  //tile 3
+
+  mux_setup(1, 1, 0, 1);
+  dataOut[3] = digitalRead(data);  //tile 4
+  printTile();
+
+
+
+  // //WEST TOP
+  // mux_setup(0, 1, 1, 1);           //CONTROLLS WHAT QUADRANT YOU'RE GETTING DATA FOR
+  // dataOut[0] = digitalRead(data);  //tile 1
+
+  // mux_setup(0, 1, 0, 0);
+  // dataOut[1] = digitalRead(data);  //tile 2
+
+  // mux_setup(0, 1, 1, 0);
+  // dataOut[2] = digitalRead(data);  //tile 3
+
+  // mux_setup(0, 1, 0, 1);
+  // dataOut[3] = digitalRead(data);  //tile 4
+  // printTile();
+
+
+
+
+  // //EAST BOTTOM
+  // mux_setup(1, 0, 1, 1);           //CONTROLLS WHAT QUADRANT YOU'RE GETTING DATA FOR
+  // dataOut[0] = digitalRead(data);  //tile 1
+
+  // mux_setup(1, 0, 0, 0);
+  // dataOut[1] = digitalRead(data);  //tile 2
+
+  // mux_setup(1, 0, 1, 0);
+  // dataOut[2] = digitalRead(data);  //tile 3
+
+  // mux_setup(1, 0, 0, 1);
+  // dataOut[3] = digitalRead(data);  //tile 4
+  // printTile();
+
+
+
+
+
+  // //WEST BOTTOM
+  // mux_setup(0, 0, 1, 1);           //CONTROLLS WHAT QUADRANT YOU'RE GETTING DATA FOR
+  // dataOut[0] = digitalRead(data);  //tile 1
+
+  // mux_setup(0, 0, 0, 0);
+  // dataOut[1] = digitalRead(data);  //tile 2
+
+  // mux_setup(0, 0, 1, 0);
+  // dataOut[2] = digitalRead(data);  //tile 3
+
+  // mux_setup(0, 0, 0, 1);
+  // dataOut[3] = digitalRead(data);  //tile 4
+  // printTile();
+
+  Serial.println("=====");
+
+  delay(250);
+}
+
+void printTile() {
+  //PRINT DATA: FOR DEBUG
+  char buf[40], *pos = buf;
+  for (int i = 0; i <= 3; i++) {
+    if (i) {
+      pos += sprintf(pos, ", ");
+    }
+    pos += sprintf(pos, "%d", dataOut[i]);
+  }
+  Serial.println(buf);
+}
+
+void mux_setup(bool eastEn, bool topEn, bool eastAB, bool topAB) {
+  //eastEnable
+  digitalWrite(eastEnable, !eastEn);
+  digitalWrite(westEnable, eastEn);
+  //eastSelect a or b
+  digitalWrite(eastSelect, !eastAB);
+
+  //topEnable
+  digitalWrite(topEnable, !topEn);
+  digitalWrite(botEnable, topEn);
+  //eastSelect a or b
+  digitalWrite(topSelect, !topAB);
+}

patchReader/patchReader.ino

@@ -0,0 +1,107 @@
+/*
+
+2 pins control enable the east and west side of the board, 
+and the following 4 pins enable one of 4 chips in each quadrant. 
+using E/W_SEL and SEL, you can control which of 8 lines you can 
+get data from. I can explain in more depth later, but this will be 
+how each tile is read.
+*/
+#define D6 6
+#define D7 7
+#define D13 13 //invert: low = on
+#define D12 12
+#define D11 11//invert
+#define D10 10//invert
+#define D9 9//invert
+
+int pins [8];
+void setup() {
+
+  pinMode(D6, INPUT);  //east
+  pinMode(D7, INPUT);  //west
+  pinMode(A2, INPUT);  //tile 1
+  pinMode(A3, INPUT);  //tile 2
+  pinMode(A4, INPUT);  //tile 3
+  pinMode(A1, INPUT);  //tile 4
+
+  //pins to control  for reading
+  pinMode(D13, OUTPUT);  //sel
+  pinMode(D11, OUTPUT);  //e/w_sel
+  pinMode(D10, OUTPUT);  //top sel
+  pinMode(D9, OUTPUT);   //bot sel
+
+  pinMode(D12, INPUT);  //read input data from this pin (a or b input)
+}
+void loop() {
+  tile_sel(1, 1);  //east, bottom right
+//  Serial.println(pins[0]);
+//  Serial.println(pins[1]);
+//  Serial.println(pins[2]);
+//  Serial.println(pins[3]);
+//  Serial.println(pins[4]);
+//  Serial.println(pins[5]);
+//  Serial.println(pins[6]);
+//  Serial.println(pins[7]);
+    Serial.println(digitalRead(A2));
+  Serial.println("===");
+  delay(1000);
+}
+
+void tile_sel(int is_east, int cardinal) {
+  if (is_east) {
+    pins[0] = 1;             //east?
+    pins[1] = 0;             //west?
+    digitalWrite(D7, LOW);   //set west to low
+    digitalWrite(D6, HIGH);  //set west to low
+  } else {
+    pins[0] = 0;             //east?
+    pins[1] = 1;             //west?
+    digitalWrite(D7, HIGH);  //set west to low
+    digitalWrite(D6, HIGH);  //set west to low
+  }
+
+  switch (cardinal) {
+    case 1:  //top left
+      pins[2] = 1;
+      pins[3] = 0;
+      pins[4] = 0;
+      pins[5] = 0;
+      digitalWrite(D10, HIGH);   //top and bottom sel
+      digitalWrite(D9, LOW);
+      break;
+
+    case 2:  //top right
+      pins[2] = 0;
+      pins[3] = 1;
+      pins[4] = 0;
+      pins[5] = 0;
+      digitalWrite(D10, !HIGH);   //top and bottom sel
+      digitalWrite(D9, !LOW);
+      break;
+
+    case 3:  //bottom left
+      pins[2] = 0;
+      pins[3] = 0;
+      pins[4] = 1;
+      pins[5] = 0;
+      digitalWrite(D10, !LOW);   //top and bottom sel
+      digitalWrite(D9, !HIGH);
+      break;
+
+    case 4:  //bottom right
+      pins[2] = 0;
+      pins[3] = 0;
+      pins[4] = 0;
+      pins[5] = 1;
+      digitalWrite(D10, !LOW);   //top and bottom sel
+      digitalWrite(D9, !HIGH);
+      break;
+    default: Serial.println("invalid input!");
+  }
+  digitalWrite(A2, pins[2]);
+  digitalWrite(A3, pins[3]);
+  digitalWrite(A4, pins[4]);
+  digitalWrite(A5, pins[5]);
+
+  digitalWrite(D13, (cardinal % 2 == 0));
+}

tileRotation/tileRotation.ino

@@ -0,0 +1,116 @@
+#include <stdint.h>
+
+uint8_t tile_orientation [2];
+
+int tile_sel_left;
+int tile_sel_right;
+int tile_sel_hor;
+int tile_sel_vir;
+
+int tile_out_pin;
+
+int grid_ne_pin;
+int grid_nw_pin;
+int grid_se_pin;
+int grid_sw_pin;
+
+const unsigned long event_1 = 1000;
+
+bool determine_orientation = false;
+
+void setup()
+{
+  //=== ATTACH INTERRUPT TO CHECK TILE ORIENTATION EVERY SO OFTEN
+  // generate a 'TIMER0_COMPA' interrupt whenever the counter value passes 0xAF
+  OCR0A = 0xAF;
+  TIMSK0 |= _BV(OCIE0A);
+}
+
+// Interrupt is called once a millisecond,
+SIGNAL(TIMER0_COMPA_vect)
+{
+  determine_orientation = true;
+}
+
+int tile_read(int left, int right) {
+  int i = 0;
+  int out;
+
+  //read tile pin
+  digitalWrite(tile_sel_left, left); //a
+  digitalWrite(tile_sel_right, right); //b
+  out = digitalRead(tile_out_pin); //z
+  i++;
+  return out;
+}
+
+int grid_space_read(int quarter) {
+  //returns teh status of
+  int i = 0;
+  int out;
+  int grid_pin;
+  int hor;
+  int vir;
+
+  switch (quarter) {
+    case 1://NE
+      grid_pin = grid_ne_pin;
+      hor = 0;
+      vir = 0;
+      break;
+    case 2://NW
+      grid_pin = grid_nw_pin;
+      hor = 1;
+      vir = 0;
+      break;
+    case 3://SE
+      grid_pin = grid_se_pin;
+      hor = 0;
+      vir = 1;
+      break;
+    case 4://SW
+      grid_pin = grid_sw_pin;
+      hor = 1;
+      vir = 1;
+      break;
+  }
+
+  //read grid pin
+  digitalWrite(tile_sel_hor, hor); //a
+  digitalWrite(tile_sel_vir, vir); //b
+  out = digitalRead(grid_pin); //z
+  i++;
+  return out;
+}
+
+void status(int quadrant, int tile_orientation) {
+  char buffer[64];
+  snprintf(buffer, sizeof(buffer), "quadrant: %d, tile orientation: %d", quadrant, tile_orientation);
+  Serial.println(buffer);
+}
+
+void loop()
+{
+  delay(1000);
+  for (int quadrant = 0; quadrant < 4; quadrant++) {
+    int tile_orientation;
+    bool unfinished = true;
+    for (int tile = 0; tile < 4; tile++) {
+      if ( millis() > event_1  && unfinished) {
+        grid_space_read(quadrant);
+        tile_orientation = tile_read(0, 0);
+        status( quadrant,  tile_orientation);
+        tile_orientation = tile_read(0, 1);
+        status( quadrant,  tile_orientation);
+        tile_orientation = tile_read(1, 0);
+        status( quadrant,  tile_orientation);
+        tile_orientation = tile_read(1, 1);
+        status( quadrant,  tile_orientation);
+        Serial.println("===");
+        unfinished = false;
+      }
+    }
+    quadrant ++;
+  }
+determine_orientation = false;
+}