Dependencies: PinDetect TextLCD mbed mRotaryEncoder
SDCard.cpp
- Committer:
- cicklaus
- Date:
- 2012-02-13
- Revision:
- 0:afb2650fb49a
File content as of revision 0:afb2650fb49a:
//mbed Microcontroller Library //SDCard Interface //Copyright 2010 //Thomas Hamilton #include "SDCard.h" SDCard::SDCard(PinName mosi, PinName miso, PinName sck, PinName cs, const char* DiskName) : FATFileSystem(DiskName), DataLines(mosi, miso, sck), ChipSelect(cs), t(0), Timeout(1024), CRCMode(1), Capacity(0), Version(0), Status(0x00) //card always starts uninitialized and in CRC mode; version 1 low-capacity //card protocols are backwards-compatible with all other card protocols { DataLines.frequency(100000); //set universal speed ChipSelect.write(1); //deselect the chip GenerateCRCTable(1, 137, CommandCRCTable); //generate the CRC7 lookup table; polynomial x^7 + x^3 + 1 converts to //decimal 137 GenerateCRCTable(2, 69665, DataCRCTable); //generate the crc16 lookup table; polynomial x^16 + x^12 + x^5 + 1 //converts to decimal 69665 Initialize(); //run setup operations } SDCard::~SDCard() //delete all tables and card data registers { delete[] CommandCRCTable; delete[] DataCRCTable; delete[] OCR; delete[] CSD; delete[] FSR; delete this; } unsigned char SDCard::disk_initialize() //give the FAT module access to the card setup routine { if (Status == 0x01) { return Initialize(); } else { return Status; } } unsigned char SDCard::disk_status() //return card initialization and availability status { return Status; } unsigned char SDCard::disk_read( unsigned char* buff, unsigned long sector, unsigned char count) //give the FAT module access to the multiple-sector reading function { return Read((unsigned int)sector, count, buff); } unsigned char SDCard::disk_write( const unsigned char* buff, unsigned long sector, unsigned char count) //give the FAT module access to the multiple-sector writing function { return Write((unsigned int)sector, count, (unsigned char*)buff); } unsigned char SDCard::disk_sync() //the disk is always synchronized, so return "disk ready" { return 0x00; } unsigned long SDCard::disk_sector_count() //calculate and return the number of sectors on the card from the CSD { switch (CSD[0] & 0xC0) { case 0x00: //calculate sector count as specified for version 1 cards return ((((CSD[6] & 0x03) << 10) | (CSD[7] << 2) | ((CSD[8] & 0xC0) >> 6)) + 1) * (1 << ((((CSD[9] & 0x03) << 1) | ((CSD[10] & 0x80) >> 7)) + 2)); case 0x40: //calculate sector count as specified for version 2 cards return ((((CSD[7] & 0x3F) << 16) | (CSD[8] << 8) | CSD[9]) + 1) * 1024; default: return 0; } } unsigned short SDCard::disk_sector_size() //fix the sector size to 512 bytes for all cards versions { return 512; } unsigned long SDCard::disk_block_size() //calculate and return the number of sectors in an erase block from the CSD { if (Version) //the erase sector size is the allocation unit for version 2 cards { return 1; } else //calculate the erase sector size for version 1 cards { return (CSD[10] << 1) | (CSD[11] >> 7) + 1; } } unsigned char SDCard::Format(unsigned int AllocationUnit) //call the FAT module formatting function { if (format(AllocationUnit)) { return 0x01; } else { return 0x00; } } unsigned char SDCard::Log(unsigned char Control, unsigned char Data) { static unsigned char Workspace; //work area for card commands and data transactions static unsigned short Index = 0; //store last written byte number of current memory block static unsigned char Mode = 0x00; //store previous operating mode to determine current behavior SelectCRCMode(0); //CRC's are not used in raw data mode switch (Control) { case 0x00: //control code 0x00 synchronizes the card if (Mode) //if the card is in read or write mode, synchronize the card { ChipSelect.write(0); for (; Index < 512; Index++) //get through the left over space, filling with 0xFF { DataLines.write(0xFF); } DataLines.write(0xFF); DataLines.write(0xFF); //get through the CRC ChipSelect.write(1); if (Mode == 0x01) //if the card is in write mode, finish the current sector //and finalize the writing operation { ChipSelect.write(0); t = 0; do { t++; } while (((DataLines.write(0xFF) & 0x11) != 0x01) && (t < Timeout)); //get through the data response token while (!DataLines.write(0xFF)); //get through the busy signal DataLines.write(0xFD); DataLines.write(0xFF); //send the stop transmission token while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); DataLines.write(0xFF); } else //if the card is in read mode, finish the current sector //and finalize the reading operation { Command(12, 0, &Workspace); //send the stop transmission command ChipSelect.write(0); while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); DataLines.write(0xFF); } Index = 0; Mode = 0x00; //reset the index to the start and switch the mode to //synchronized mode } return 0xFF; case 0x01: //control code 1 writes a byte if (Mode != 0x01) //if the previous call was not a write operation, synchronize //the card, start a new write block, and set the function to //write mode { Log(0, 0); Command(25, 0, &Workspace); Mode = 0x01; } if (Index == 0) //if the index is at the start, send the start block token //before the byte { ChipSelect.write(0); DataLines.write(0xFC); DataLines.write(Data); ChipSelect.write(1); Index++; } else if (Index < 511) //if the index is between the boundaries, write the byte { ChipSelect.write(0); DataLines.write(Data); ChipSelect.write(1); Index++; } else //if the index is at the last address, get through the CRC, //data response token, and busy signal and reset the index { ChipSelect.write(0); DataLines.write(Data); DataLines.write(0xFF); DataLines.write(0xFF); t = 0; do { t++; } while (((DataLines.write(0xFF) & 0x11) != 0x01) && (t < Timeout)); while (!DataLines.write(0xFF)); ChipSelect.write(1); Index = 0; } return 0xFF; case 0x02: //control code 2 reads a byte if (Mode != 0x02) //if the previous call was not a read operation, synchronise //the card, start a new read block, and set the function to //read mode { Log(0, 0); Command(18, 0, &Workspace); Mode = 0x02; } if (Index == 0) //if the index is at the start, get the start block token //and read the first byte { ChipSelect.write(0); t = 0; do { t++; } while ((DataLines.write(0xFF) != 0xFE) && (t < Timeout)); Workspace = DataLines.write(0xFF); ChipSelect.write(1); Index++; return Workspace; } else if (Index < 511) //if the index is between the boundaries, read the byte { ChipSelect.write(0); Workspace = DataLines.write(0xFF); ChipSelect.write(1); Index++; return Workspace; } else //if the index is at the last address, get through the CRC and //reset the index { ChipSelect.write(0); Workspace = DataLines.write(0xFF); DataLines.write(0xFF); DataLines.write(0xFF); ChipSelect.write(1); Index = 0; return Workspace; } default: //undefined control codes will only return stuff bits return 0xFF; } } unsigned char SDCard::Write(unsigned int Address, unsigned char* Data) { unsigned char Workspace[2]; //work area for card commands and data transactions if (Capacity) //send the single-block write command addressed for high-capacity cards { Command(24, Address, Workspace); } else //send the single-block write command addressed for low-capacity cards { Command(24, Address * 512, Workspace); } if (Workspace[0]) //if a command error occurs, return "parameter error" { return 0x04; } DataCRC(512, Data, Workspace); //calculate the CRC16 ChipSelect.write(0); DataLines.write(0xFE); //write start block token for (unsigned short i = 0; i < 512; i++) //write the data to the addressed card sector { DataLines.write(Data[i]); } DataLines.write(Workspace[0]); DataLines.write(Workspace[1]); //write the data CRC16 t = 0; do { Workspace[0] = DataLines.write(0xFF); t++; } while (((Workspace[0] & 0x11) != 0x01) && (t < Timeout)); //gather the data block response token while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); DataLines.write(0xFF); if (((Workspace[0] & 0x1F) != 0x05) || (t == Timeout)) //if the data response token indicates error, return write error { return 0x01; } else { return 0x00; } } unsigned char SDCard::Write( unsigned int Address, unsigned char SectorCount, unsigned char* Data) { unsigned char Workspace[5]; //work area for card commands and data transactions static unsigned char CurrentSectorCount = 1; //store the last write sector count if (SectorCount != CurrentSectorCount) //set the expected number of write blocks if its different from //previous multiple-block write operations { Command(55, 0, Workspace); Command(23, SectorCount, Workspace); if (Workspace[0]) { return 0x04; } CurrentSectorCount = SectorCount; } if (Capacity) //send the multiple-block write command addressed for high-capacity //cards { Command(25, Address, Workspace); } else //send the multiple-block write command addressed for low-capacity //cards { Command(25, Address * 512, Workspace); } if (Workspace[0]) //if a command error occurs, return "parameter error" { return 0x04; } Workspace[4] = 0x00; //initialize the error detection variable for (unsigned char i = 0; i < SectorCount; i++) //write each data sector { DataCRC(512, &Data[i * 512], Workspace); //calculate the CRC16 ChipSelect.write(0); DataLines.write(0xFC); //send multiple write block start token for (unsigned int j = i * 512; j < (i + 1) * 512; j++) //write each data block { DataLines.write(Data[j]); } DataLines.write(Workspace[0]); DataLines.write(Workspace[1]); //write the CRC16 t = 0; do { Workspace[0] = DataLines.write(0xFF); t++; } while (((Workspace[0] & 0x11) != 0x01) && (t < Timeout)); //gather the data block response token while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); Workspace[4] |= Workspace[0]; //record if any write errors that are detected in the data response //tokens if (t == Timeout) //if a block write operation times out, stop operations { break; } } ChipSelect.write(0); DataLines.write(0xFD); DataLines.write(0xFF); //send the stop transmission token while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); DataLines.write(0xFF); if (((Workspace[4] & 0x1F) != 0x05) || (t == Timeout)) //if a data response token indicated an error, return "write error" { return 0x01; } else { return 0x00; } } unsigned char SDCard::Read(unsigned int Address, unsigned char* Data) { unsigned char Workspace[4]; //work area for card commands and data transactions if (Capacity) //send the single-block read command addressed for high-capacity cards { Command(17, Address, Workspace); } else //send the single-block read command addressed for low-capacity cards { Command(17, Address * 512, Workspace); } if (Workspace[0]) //if a command error occurs, return "parameter error" { return 0x04; } ChipSelect.write(0); t = 0; do { t++; } while ((DataLines.write(0xFF) != 0xFE) && (t < Timeout)); //get to the start block token if (t == Timeout) { ChipSelect.write(1); DataLines.write(0xFF); return 0x01; } for (unsigned short i = 0; i < 512; i++) { Data[i] = DataLines.write(0xFF); } //read the data from the addressed card sector Workspace[2] = DataLines.write(0xFF); Workspace[3] = DataLines.write(0xFF); //read the CRC16 ChipSelect.write(1); DataLines.write(0xFF); DataCRC(512, Data, Workspace); //calculate the CRC16 if (CRCMode && ((Workspace[0] != Workspace[2]) || (Workspace[1] != Workspace[3]))) //if the CRC is invalid, return "read error" { return 0x01; } else { return 0x00; } } unsigned char SDCard::Read( unsigned int Address, unsigned char SectorCount, unsigned char* Data) { unsigned char Workspace[5]; //work area for card commands and data transactions if (Capacity) //send the multiple-block read command addressed for high-capacity //cards { Command(18, Address, Workspace); } else //send the multiple-block read command addressed for low-capacity //cards { Command(18, Address * 512, Workspace); } if (Workspace[0]) //if a command error occurs, return "parameter error" { return 0; } Workspace[4] = 0x00; //initialize error detection variable for (unsigned char i = 0; i < SectorCount; i++) //read each data sector { ChipSelect.write(0); t = 0; do { t++; } while ((DataLines.write(0xFF) != 0xFE) && (t < Timeout)); //get to the data block start token if (t == Timeout) { break; } //if a block read operation times out, stop operations for (unsigned int j = i * 512; j < (i + 1) * 512; j++) { Data[j] = DataLines.write(0xFF); } //read the data block Workspace[2] = DataLines.write(0xFF); Workspace[3] = DataLines.write(0xFF); //read the data CRC from the card ChipSelect.write(1); DataCRC(512, &Data[i * 512], Workspace); //calculate the CRC16 for each read data block Workspace[4] |= (CRCMode && ((Workspace[0] != Workspace[2]) || (Workspace[1] != Workspace[3]))); //record if any invalid CRCs are detected during the //transaction } Command(12, 0, Workspace); //send the stop transmission command ChipSelect.write(0); while (!DataLines.write(0xFF)); //get through the busy signal ChipSelect.write(1); DataLines.write(0xFF); if ((Workspace[4]) || (t == Timeout)) //if an invalid CRC was detected, return "read error" { return 0x01; } else { return 0x00; } } unsigned char SDCard::SelectCRCMode(bool Mode) { unsigned char Response; if (CRCMode != Mode) //only send command if CRCMode has been changed { t = 0; do { Command(59, Mode, &Response); //send the set CRC mode command t++; } while (Response && (t < Timeout)); CRCMode = Mode; } if (t == Timeout) //if the command times out, return "error" { return 0x01; } else { return 0x00; } } void SDCard::SetTimeout(unsigned int Retries) { Timeout = Retries; //Set the global number of times for operations to be retried } unsigned char SDCard::Initialize() { unsigned char Workspace[5]; //work area for card commands and data transactions for (unsigned char i = 0; i < 16; i++) //clock card at least 74 times to power up { DataLines.write(0xFF); } t = 0; do { Command(0, 0, Workspace); //send the reset command to put the card into SPI mode t++; } while ((Workspace[0] != 0x01) && (t < Timeout)); //check for command acceptance if (t == Timeout) { Status = 0x01; return Status; } t = 0; do { Command(59, 1, Workspace); //turn on CRCs t++; } while ((Workspace[0] != 0x01) && (Workspace[0] != 0x05) && (t < Timeout)); //the set CRC mode command is not valid for all cards in idle state if (t == Timeout) { Status = 0x01; return Status; } t = 0; do { Command(8, 426, Workspace); //the voltage bits are 0x01 for 2.7V - 3.6V, the check pattern is //0xAA, 0x000001AA converts to decimal 426 t++; } while (((Workspace[0] != 0x01) || ((Workspace[3] & 0x0F) != 0x01) || (Workspace[4] != 0xAA)) && (Workspace[0] != 0x05) && (t < Timeout)); //check the version, voltage acceptance, and check pattern if (t == Timeout) { Status = 0x01; return Status; } Version = Workspace[0] != 0x05; //store the card version if (!Version) { t = 0; do { Command(16, 512, Workspace); //set the data-block length to 512 bytes t++; } while (Workspace[0] && (t < Timeout)); if (t == Timeout) { Status = 0x01; return Status; } } t = 0; do { Command(58, 0, Workspace); //check the OCR t++; } while (((Workspace[0] != 0x01) || !((Workspace[2] & 0x20) || (Workspace[2] & 0x10))) && (t < Timeout)); //check for the correct operating voltage, 3.3V if (t == Timeout) { Status = 0x01; return Status; } t = 0; do { Command(55, 0, Workspace); //initialize card command is application-specific Command(41, 1073741824, Workspace); //specify host supports high capacity cards, 0x40000000 converts to //decimal 1073741824d t++; } while (Workspace[0] && (t < Timeout)); //check if the card is ready if (t == Timeout) { Status = 0x01; return Status; } if (SelectCRCMode(1)) //turn on CRCs for all cards { Status = 0x01; return Status; } t = 0; do { Command(58, 0, Workspace); //check the OCR again t++; } while ((Workspace[0] || !(Workspace[1] & 0x80)) && (t < Timeout)); //check the power up status if (t == Timeout) { Status = 0x01; return Status; } for (unsigned char i = 0; i < 4; i++) //record the OCR { OCR[i] = Workspace[i + 1]; } Capacity = (OCR[0] & 0x40) == 0x40; //record the capacity t = 0; do { do { Command(9, 0, Workspace); //read the CSD t++; } while (Workspace[0] && (t < Timeout)); if (t == Timeout) { Status = 0x01; return Status; } ChipSelect.write(0); do { t++; } while ((DataLines.write(0xFF) != 0xFE) && (t < Timeout)); //get to the start data block token if (t == Timeout) { ChipSelect.write(1); DataLines.write(0xFF); Status = 0x01; return Status; } for (unsigned char i = 0; i < 16; i++) //record the CSD { CSD[i] = DataLines.write(0xFF); } Workspace[2] = DataLines.write(0xFF); Workspace[3] = DataLines.write(0xFF); //save the CSD CRC16 ChipSelect.write(1); DataLines.write(0xFF); DataCRC(16, CSD, Workspace); //calculate the CSD CRC16 Workspace[4] = 0; for (unsigned char i = 0; i < 15; i++) { Workspace[4] = CommandCRCTable[Workspace[4]] ^ CSD[i]; } Workspace[4] = CommandCRCTable[Workspace[4]] | 0x01; //calculate the CSD CRC7 t++; } while (((Workspace[0] != Workspace[2]) || (Workspace[1] != Workspace[3]) || (Workspace[4] != CSD[15])) && (t < Timeout)); //perform all CSD CRCs if (t == Timeout) { Status = 0x01; return Status; } if (((CSD[3] & 0x07) > 0x02) || (((CSD[3] & 0x78) > 0x30) && ((CSD[3] & 0x07) > 0x01))) //read the CSD card speed bits and speed up card operations { DataLines.frequency(25000000); //maximum frequency is 25MHz } else { Workspace[0] = 1; for (unsigned char i = 0; i < (CSD[3] & 0x07); i++) { Workspace[0] *= 10; //the first three bits are a power of ten multiplier for speed } switch (CSD[3] & 0x78) { case 0x08: DataLines.frequency(Workspace[0] * 100000); break; case 0x10: DataLines.frequency(Workspace[0] * 120000); break; case 0x18: DataLines.frequency(Workspace[0] * 140000); break; case 0x20: DataLines.frequency(Workspace[0] * 150000); break; case 0x28: DataLines.frequency(Workspace[0] * 200000); break; case 0x30: DataLines.frequency(Workspace[0] * 250000); break; case 0x38: DataLines.frequency(Workspace[0] * 300000); break; case 0x40: DataLines.frequency(Workspace[0] * 350000); break; case 0x48: DataLines.frequency(Workspace[0] * 400000); break; case 0x50: DataLines.frequency(Workspace[0] * 450000); break; case 0x58: DataLines.frequency(Workspace[0] * 500000); break; case 0x60: DataLines.frequency(Workspace[0] * 550000); break; case 0x68: DataLines.frequency(Workspace[0] * 600000); break; case 0x70: DataLines.frequency(Workspace[0] * 700000); break; case 0x78: DataLines.frequency(Workspace[0] * 800000); break; default: break; } } if (CSD[4] & 0x40) //check for switch command class support { t = 0; do { Command(6, 2147483649, Workspace); //switch to high-speed mode (SDR25, 50MHz) t++; } while (Workspace[0] && (Workspace[0] != 0x04) && (t < Timeout)); //some cards that support switch class commands respond with //"illegal command" if (t == Timeout) { Status = 0x01; return Status; } if (!Workspace[0]) { do { ChipSelect.write(0); do { t++; } while ((DataLines.write(0xFF) != 0xFE) && (t < Timeout)); //get to the start data block token if (t == Timeout) { ChipSelect.write(1); DataLines.write(0xFF); Status = 0x01; return Status; } for (unsigned char i = 0; i < 64; i++) //gather the function status register { FSR[i] = DataLines.write(0xFF); } Workspace[2] = DataLines.write(0xFF); Workspace[3] = DataLines.write(0xFF); //record the CRC16 ChipSelect.write(1); DataLines.write(0xFF); DataCRC(64, FSR, Workspace); //calculate the CRC16 t++; } while (((Workspace[0] != Workspace[2]) || (Workspace[1] != Workspace[3])) && (t < Timeout)); //perform the CRC if (t == Timeout) { Status = 0x01; return Status; } if ((FSR[13] & 0x02) && ((FSR[16] & 0x0F) == 0x01)) { DataLines.frequency(50000000); //increase the speed if the function switch was successful } } } if (SelectCRCMode(0)) { Status = 0x01; return Status; } //turn off CRCs Status = 0x00; return Status; } void SDCard::Command( unsigned char Index, unsigned int Argument, unsigned char* Response) { CommandCRC(&Index, &Argument, Response); //calculate the CRC7 ChipSelect.write(0); //assert chip select low to synchronize the command DataLines.write(0x40 | Index); //the index is assumed valid, commands start with bits 01 DataLines.write(((char*)&Argument)[3]); DataLines.write(((char*)&Argument)[2]); DataLines.write(((char*)&Argument)[1]); DataLines.write(((char*)&Argument)[0]); //send the argument bytes in order from MSB to LSB DataLines.write(*Response); //send the CRC7 t = 0; do { Response[0] = DataLines.write(0xFF); //clock the card high to let it run operations, the first byte //will be busy (all high), the response will be sent later t++; } while ((Response[0] & 0x80) && (t < Timeout)); //check for a response by testing if the first bit is low if ((Index == 8) || (Index == 13) || (Index == 58)) //if the command returns a larger response, get the rest of it { for (unsigned char i = 1; i < 5; i++) { Response[i] = DataLines.write(0xFF); } } ChipSelect.write(1); //assert chip select high to synchronize command DataLines.write(0xFF); //clock the deselected card high to complete processing for some cards } void SDCard::CommandCRC( unsigned char* IndexPtr, unsigned int* ArgumentPtr, unsigned char* Result) { if (CRCMode) //only calculate if data-checks are desired { Result[0] = CommandCRCTable[ CommandCRCTable[ CommandCRCTable[ CommandCRCTable[ CommandCRCTable[ *IndexPtr | 0x40 ] ^ ((char*)ArgumentPtr)[3] ] ^ ((char*)ArgumentPtr)[2] ] ^ ((char*)ArgumentPtr)[1] ] ^ ((char*)ArgumentPtr)[0] ] | 0x01; //calculate the CRC7, SD protocol requires the last bit to be high } else //if no data-checking is desired, the return bits are not used { Result[0] = 0xFF; } } void SDCard::DataCRC( unsigned short Length, unsigned char* Data, unsigned char* Result) { if (CRCMode) //only calculate if data-checks are desired { unsigned char Reference; //store the current CRC16 lookup value Result[0] = 0x00; Result[1] = 0x00; //initialize the result carrier for (unsigned short i = 0; i < Length; i++) //step through each byte of the data to be checked { Reference = Result[0]; //record the current CRC16 lookup for both bytes Result[0] = DataCRCTable[2 * Reference] ^ Result[1]; //the first byte result is XORed with the old second byte Result[1] = DataCRCTable[(2 * Reference) + 1] ^ Data[i]; //the second byte result is XORed with the new data byte } for (unsigned char i = 0; i < 2; i++) //the final result must be XORed with two 0x00 bytes { Reference = Result[0]; Result[0] = DataCRCTable[2 * Reference] ^ Result[1]; Result[1] = DataCRCTable[(2 * Reference) + 1]; } } else //if no data-checking is desired, the return bits are not used { Result[0] = 0xFF; Result[1] = 0xFF; } } void SDCard::GenerateCRCTable(unsigned char Size, unsigned long long Generator, unsigned char* Table) { unsigned char Index[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; //this will hold information from the generator; the position indicates //the order of the encountered 1, the value indicates its position in //the generator, the 9th entry indicates the number of 1's encountered for (unsigned char i = 0; i < 64; i++) //shift generator left until the first bit is high { if (((char*)&Generator)[7] & 0x80) { break; } Generator = Generator << 1; } for (unsigned char i = 0; i < Size; i++) //initialize table { Table[i] = 0x00; } for (unsigned char i = 0; i < 8; i++) //increment through each generator bit { if ((0x80 >> i) & ((unsigned char*)&Generator)[7]) //if a 1 is encountered in the generator, record its order and //location and increment the counter { Index[Index[8]] = i; Index[8]++; } for (unsigned char j = 0; j < (0x01 << i); j++) //each bit doubles the number of XOR operations { for (unsigned char k = 0; k < Size; k++) //we need to precalculate each byte in the CRC table { Table[(Size * ((0x01 << i) + j)) + k] = Table[(Size * j) + k]; //each power of two is equal to all previous entries with //an added XOR with the generator on the leftmost bit and //on each succeeding 1 in the generator for (unsigned char l = 0; l < Index[8]; l++) //increment through the encountered generator 1s { Table[(Size * ((0x01 << i) + j)) + k] ^= (((unsigned char*)&Generator)[7-k] << (i + 1 - Index[l])); Table[(Size * ((0x01 << i) + j)) + k] ^= (((unsigned char*)&Generator)[6-k] >> (7 - i + Index[l])); //XOR the new bit and the new generator 1s } } } } }