View difference between Paste ID: XmjGYSnJ and zfLNcx9q

 #include "crc_table.h"
 
 #define CTRL_PIN 3
 #define CTRL_HIGH DDRD &= ~0x01
 #define CTRL_LOW DDRD |= 0x01
 #define CTRL_QUERY (PIND & 0x01)
 
 #define CNSL_PIN 5
 #define CNSL_HIGH DDRC &= ~0x40
 #define CNSL_LOW DDRC |= 0x40
 #define CNSL_QUERY (PINC & 0x40)
 
 //From console to controller
 char console_raw_dump[281];
 unsigned char console_command;
 
 //From controller to console
 unsigned char controller_buffer[33];
 
 struct state {
   char stick_x;
   char stick_y;
   // bits: 0, 0, 0, start, y, x, b, a
   unsigned char data1;
   // bits: 1, L, R, Z, Dup, Ddown, Dright, Dleft
   unsigned char data2;
 } N64_status;
 
 void setup()
 {
   Serial.begin(9600);
 
   // Communication with the N64-console on this pin
   digitalWrite(CNSL_PIN, LOW);
   pinMode(CNSL_PIN, INPUT);
 
   // Communication with the N64-controller on this pin
   digitalWrite(CTRL_PIN, LOW);
   pinMode(CTRL_PIN, INPUT);
 }
 
 void loop()
 {
   unsigned char data, addr;
   memset(controller_buffer, 0, sizeof(controller_buffer));
 
    noInterrupts();
   CTRL_get();
    interrupts();
   translate_raw_data();
   print_CTRL_status();
 
   noInterrupts();
 
   get_console_command();
   Serial.println(console_command, HEX);
   switch (console_command)
     {
         case 0x00:
         case 0xFF:
             // identify
             // mutilate the n64_buffer array with our status
             // we return 0x050001 to indicate we have a rumble pack
             // or 0x050002 to indicate the expansion slot is empty
             //
             // 0xFF I've seen sent from Mario 64 and Shadows of the Empire.
             // I don't know why it's different, but the controllers seem to
             // send a set of status bytes afterwards the same as 0x00, and
             // it won't work without it.
             controller_buffer[0] = 0x05;
             controller_buffer[1] = 0x00;
             controller_buffer[2] = 0x02;
 
             console_send(controller_buffer, 3, 0);
 
             //Serial.println("It was 0x00: an identify command");
             break;
         case 0x01:
             // Send to n64 the received data
 
             console_send(controller_buffer, 4, 0);
             //Serial.println("It was 0x01: the query command");
             break;
         case 0x02:
             // A read. If the address is 0x8000, return 32 bytes of 0x80 bytes,
             // and a CRC byte.  this tells the system our attached controller
             // pack is a rumble pack
 
             // Assume it's a read for 0x8000, which is the only thing it should
             // be requesting anyways
             memset(controller_buffer, 0x80, 32);
             controller_buffer[32] = 0xB8; // CRC
 
             console_send(controller_buffer, 33, 1);
 
             //Serial.println("It was 0x02: the read command");
             break;
         case 0x03:
             // A write. we at least need to respond with a single CRC byte.  If
             // the write was to address 0xC000 and the data was 0x01, turn on
             // rumble! All other write addresses are ignored. (but we still
             // need to return a CRC)
 
             // decode the first data byte (fourth overall byte), bits indexed
             // at 24 through 31
             data = 0;
             data |= (console_raw_dump[16] != 0) << 7;
             data |= (console_raw_dump[17] != 0) << 6;
             data |= (console_raw_dump[18] != 0) << 5;
             data |= (console_raw_dump[19] != 0) << 4;
             data |= (console_raw_dump[20] != 0) << 3;
             data |= (console_raw_dump[21] != 0) << 2;
             data |= (console_raw_dump[22] != 0) << 1;
             data |= (console_raw_dump[23] != 0);
 
             // get crc byte, invert it, as per the protocol for
             // having a memory card attached
             controller_buffer[0] = crc_repeating_table[data] ^ 0xFF;
 
             // send it
             console_send(controller_buffer, 1, 1);
 
             // end of time critical code
             // was the address the rumble latch at 0xC000?
             // decode the first half of the address, bits
             // 8 through 15
             addr = 0;
             addr |= (console_raw_dump[0] != 0) << 7;
             addr |= (console_raw_dump[1] != 0) << 6;
             addr |= (console_raw_dump[2] != 0) << 5;
             addr |= (console_raw_dump[3] != 0) << 4;
             addr |= (console_raw_dump[4] != 0) << 3;
             addr |= (console_raw_dump[5] != 0) << 2;
             addr |= (console_raw_dump[6] != 0) << 1;
             addr |= (console_raw_dump[7] != 0);
 
             if (addr == 0xC0) {
             //    rumble = (data != 0);
             }
 
            // Serial.println("It was 0x03: the write command");
             //Serial.print("Addr was 0x");
             //Serial.print(addr, HEX);
             //Serial.print(" and data was 0x");
             //Serial.println(data, HEX);
             break;
 
     }
 
 interrupts();
 }
 
 void translate_raw_data()
 {
   memset(&N64_status, 0, sizeof(N64_status));
   for (int i = 0; i < 8; i++) {
     N64_status.data1 |= controller_buffer[i] ? (0x80 >> i) : 0;
     N64_status.data2 |= controller_buffer[8 + i] ? (0x80 >> i) : 0;
     N64_status.stick_x |= controller_buffer[16 + i] ? (0x80 >> i) : 0;
     N64_status.stick_y |= controller_buffer[24 + i] ? (0x80 >> i) : 0;
   }
 }
 
 void print_CTRL_status()
   {
     char out[30];
     sprintf(out, "%i%i%i%i%i%i%i%i%i%i%i%i%i%i %i %i",
       N64_status.data1&16?1:0,
       N64_status.data1&32?1:0,
       N64_status.data1&64?1:0,
       N64_status.data1&128?1:0,
       N64_status.data2&32?1:0,
       N64_status.data2&16?1:0,
       N64_status.data2&0x08?1:0,
       N64_status.data2&0x04?1:0,
       N64_status.data2&0x01?1:0,
       N64_status.data2&0x02?1:0,
       N64_status.data1&0x08?1:0,
       N64_status.data1&0x04?1:0,
       N64_status.data1&0x01?1:0,
       N64_status.data1&0x02?1:0,
       N64_status.stick_x,
       N64_status.stick_y);
     Serial.println(out);
   }
 
 //Send to console
 // completly copied and pasted to not mess up timings
 void console_send(unsigned char *buffer, char length, bool wide_stop)
 {
     asm volatile (";Starting N64 Send Routine");
     // Send these bytes
     char bits;
 
     bool bit;
 
     // This routine is very carefully timed by examining the assembly output.
     // Do not change any statements, it could throw the timings off
     //
     // We get 16 cycles per microsecond, which should be plenty, but we need to
     // be conservative. Most assembly ops take 1 cycle, but a few take 2
     //
     // I use manually constructed for-loops out of gotos so I have more control
     // over the outputted assembly. I can insert nops where it was impossible
     // with a for loop
 
     asm volatile (";Starting outer for loop");
 outer_loop:
     {
         asm volatile (";Starting inner for loop");
         bits=8;
 inner_loop:
         {
             // Starting a bit, set the line low
             asm volatile (";Setting line to low");
             CNSL_LOW; // 1 op, 2 cycles
 
             asm volatile (";branching");
             if (*buffer >> 7) {
                 asm volatile (";Bit is a 1");
                 // 1 bit
                 // remain low for 1us, then go high for 3us
                 // nop block 1
                 asm volatile ("nop\nnop\nnop\nnop\nnop\n");
 
                 asm volatile (";Setting line to high");
                 CNSL_HIGH;
 
                 // nop block 2
                 // we'll wait only 2us to sync up with both conditions
                 // at the bottom of the if statement
                 asm volatile ("nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               );
 
             } else {
                 asm volatile (";Bit is a 0");
                 // 0 bit
                 // remain low for 3us, then go high for 1us
                 // nop block 3
                 asm volatile ("nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\nnop\n"
                               "nop\n");
 
                 asm volatile (";Setting line to high");
                 CNSL_HIGH;
 
                 // wait for 1us
                 asm volatile ("; end of conditional branch, need to wait 1us more before next bit");
 
             }
             // end of the if, the line is high and needs to remain
             // high for exactly 16 more cycles, regardless of the previous
             // branch path
 
             asm volatile (";finishing inner loop body");
             --bits;
             if (bits != 0) {
                 // nop block 4
                 // this block is why a for loop was impossible
                 asm volatile ("nop\nnop\nnop\nnop\nnop\n"
                               "nop\nnop\nnop\nnop\n");
                 // rotate bits
                 asm volatile (";rotating out bits");
                 *buffer <<= 1;
 
                 goto inner_loop;
             } // fall out of inner loop
         }
         asm volatile (";continuing outer loop");
         // In this case: the inner loop exits and the outer loop iterates,
         // there are /exactly/ 16 cycles taken up by the necessary operations.
         // So no nops are needed here (that was lucky!)
         --length;
         if (length != 0) {
             ++buffer;
             goto outer_loop;
         } // fall out of outer loop
     }
 
     // send a single stop (1) bit
     // nop block 5
     asm volatile ("nop\nnop\nnop\nnop\n");
     CNSL_LOW;
     // wait 1 us, 16 cycles, then raise the line
     // take another 3 off for the wide_stop check
     // 16-2-3=11
     // nop block 6
     asm volatile ("nop\nnop\nnop\nnop\nnop\n"
                   "nop\nnop\nnop\nnop\nnop\n"
                   "nop\n");
     if (wide_stop) {
         asm volatile (";another 1us for extra wide stop bit\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\n");
     }
 
     CNSL_HIGH;
 }
 
 void get_console_command()
 {
 
     int bitcount;
     char *bitbin = console_raw_dump;
     int idle_wait;
 
 func_top:
     console_command = 0;
 
     bitcount = 8;
 
     // wait to make sure the line is idle before
     // we begin listening
     for (idle_wait=32; idle_wait>0; --idle_wait) {
         if (!CNSL_QUERY) {
             idle_wait = 32;
         }
     }
 
 read_loop:
         // wait for the line to go low
         while (CNSL_QUERY){}
 
         // wait approx 2us and poll the line
         asm volatile (
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                 );
         if (CNSL_QUERY)
             console_command |= 0x01;
 
         --bitcount;
         if (bitcount == 0)
             goto read_more;
 
         console_command <<= 1;
 
         // wait for line to go high again
         // I don't want this to execute if the loop is exiting, so
         // I couldn't use a traditional for-loop
         while (!CNSL_QUERY) {}
         goto read_loop;
 
 read_more:
         switch (console_command)
         {
             case (0x03):
                 // write command
                 // we expect a 2 byte address and 32 bytes of data
                 bitcount = 272 + 1; // 34 bytes * 8 bits per byte
                 //Serial.println("command is 0x03, write");
                 break;
             case (0x02):
                 // read command 0x02
                 // we expect a 2 byte address
                 bitcount = 16 + 1;
                 //Serial.println("command is 0x02, read");
                 break;
             case (0x00):
             case (0x01):
             default:
                 // get the last (stop) bit
                 bitcount = 1;
                 break;
             //default:
             //    Serial.println(consele_command, HEX);
             //    goto func_top;
         }
 
         // make sure the line is high. Hopefully we didn't already
         // miss the high-to-low transition
         while (!CNSL_QUERY) {}
 read_loop2:
         // wait for the line to go low
         while (CNSL_QUERY){}
 
         // wait approx 2us and poll the line
         asm volatile (
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                       "nop\nnop\nnop\nnop\nnop\n"
                 );
         *bitbin = CNSL_QUERY;
         ++bitbin;
         --bitcount;
         if (bitcount == 0)
             return;
 
         // wait for line to go high again
         while (!CNSL_QUERY) {}
         goto read_loop2;
 }
 
 void CTRL_get()
 {
   // listen for the expected 8 bytes of data back from the controller and
   // blast it out to the N64_raw_dump array, one bit per byte for extra speed.
   // Afterwards, call translate_raw_data() to interpret the raw data and pack
   // it into the N64_status struct.
   asm volatile (";Starting to listen");
   unsigned char timeout;
   char bitcount = 32;
   char *bitbin = controller_buffer;
 
   // Again, using gotos here to make the assembly more predictable and
   // optimization easier (please don't kill me)
 read_loop:
   timeout = 0x3f;
   // wait for line to go low
   while (CTRL_QUERY) {
     if (!--timeout)
       return;
   }
   // wait approx 2us and poll the line
   asm volatile (
     "nop\nnop\nnop\nnop\nnop\n"
     "nop\nnop\nnop\nnop\nnop\n"
     "nop\nnop\nnop\nnop\nnop\n"
     "nop\nnop\nnop\nnop\nnop\n"
     "nop\nnop\nnop\nnop\nnop\n"
     "nop\nnop\nnop\nnop\nnop\n"
   );
   *bitbin = CTRL_QUERY;
   ++bitbin;
   --bitcount;
   if (bitcount == 0)
     return;
 
   // wait for line to go high again
   // it may already be high, so this should just drop through
   timeout = 0x3f;
   while (!CTRL_QUERY) {
     if (!--timeout)
       return;
   }
   goto read_loop;
 
 }