GitHub/sdrtrunk
1
0
Fork 0
mirror of https://github.com/DSheirer/sdrtrunk.git synced 2026-11-13 09:07:27 -05:00
Code Issues Packages Projects Releases 2 Wiki Activity

Initial code check in continued

Browse Source
This commit is contained in:
dennis.sheirer
2014-04-26 19:48:24 +00:00
parent 960a6f9952
commit 3dfedcf8d1
474 changed files with 76613 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/crc/CRC.java Normal file
View File

@@ -0,0 +1,68 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
public enum CRC
{
PASSED ( "*", "Pass" ),
PASSED_INV ( "#", "Pass Invert" ),
FAILED_CRC ( "f", "Fail CRC" ),
FAILED_PARITY( "p", "Fail Parity" ),
CORRECTED ( "C", "Corrected" ),
UNKNOWN ( "-", "Unknown");
private String mAbbreviation;
private String mDisplayText;
CRC( String abbreviation, String displayText )
{
mAbbreviation = abbreviation;
mDisplayText = displayText;
}
public String getAbbreviation()
{
return mAbbreviation;
}
public String getDisplayText()
{
return mDisplayText;
}
public static String format( CRC[] checks )
{
StringBuilder sb = new StringBuilder();
for( int x = 0; x < checks.length; x++ )
{
CRC check = checks[ x ];
if( check != null )
{
sb.append( check.getAbbreviation() );
}
else
{
sb.append( CRC.UNKNOWN.getAbbreviation() );
}
}
return sb.toString();
}
}

207
src/crc/CRCFleetsync.java Normal file
View File

@@ -0,0 +1,207 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
/**
* Fleetsync CRC checksum utility
*
* Fleetsync message blocks are 64 bits in length as follows:
* 0 - 47: message bits
* 48 - 62: CRC-15 check bits
* 63: even parity bit
*
* Fleetsync uses a CRC-15 (0x6815) with an initial fill of 0x0001, coupled with
* an even parity checkbit.
*
* CRC-15 Generating Polynomial: x15 + x14 + x13 + x11 + x4 + x2 + 1 (0x6815)
*/
public class CRCFleetsync
{
private static short[] sCHECKSUMS = new short[] {
0x740A, // 111010000001010 Bit 0
0x3A05, // 011101000000101 Bit 1
0x6908, // 110100100001000 Bit 2
0x3484, // 011010010000100 Bit 3
0x1A42, // 001101001000010 Bit 4
0x0D21, // 000110100100001 Bit 5
0x729A, // 111001010011010 Bit 6
0x394D, // 011100101001101 Bit 7
0x68AC, // 110100010101100 Bit 8
0x3456, // 011010001010110 Bit 9
0x1A2B, // 001101000101011 Bit 10
0x791F, // 111100100011111 Bit 11
0x4885, // 100100010000101 Bit 12
0x5048, // 101000001001000 Bit 13
0x2824, // 010100000100100 Bit 14
0x1412, // 001010000010010 Bit 15
0x0A09, // 000101000001001 Bit 16
0x710E, // 111000100001110 Bit 17
0x3887, // 011100010000111 Bit 18
0x6849, // 110100001001001 Bit 19
0x402E, // 100000000101110 Bit 20
0x2017, // 010000000010111 Bit 21
0x6401, // 110010000000001 Bit 22
0x460A, // 100011000001010 Bit 23
0x2305, // 010001100000101 Bit 24
0x6588, // 110010110001000 Bit 25
0x32C4, // 011001011000100 Bit 26
0x1962, // 001100101100010 Bit 27
0x0CB1, // 000110010110001 Bit 28
0x7252, // 111001001010010 Bit 29
0x3929, // 011100100101001 Bit 30
0x689E, // 110100010011110 Bit 31
0x344F, // 011010001001111 Bit 32
0x6E2D, // 110111000101101 Bit 33
0x431C, // 100001100011100 Bit 34
0x218E, // 010000110001110 Bit 35
0x10C7, // 001000011000111 Bit 36
0x7C69, // 111110001101001 Bit 37
0x4A3E, // 100101000111110 Bit 38
0x251F, // 010010100011111 Bit 39
0x6685, // 110011010000101 Bit 40
0x4748, // 100011101001000 Bit 41
0x23A4, // 010001110100100 Bit 42
0x11D2, // 001000111010010 Bit 43
0x08E9, // 000100011101001 Bit 44
0x707E, // 111000001111110 Bit 45
0x383F, // 011100000111111 Bit 46
0x6815, // 110100000010101 Bit 47
//Single bit errors in the CRC Checksum
0x4000, //Bit 48
0x2000, //Bit 49
0x1000, //Bit 50
0x0800, //Bit 51
0x0400, //Bit 52
0x0200, //Bit 53
0x0100, //Bit 54
0x0080, //Bit 55
0x0040, //Bit 56
0x0020, //Bit 57
0x0010, //Bit 58
0x0008, //Bit 59
0x0004, //Bit 60
0x0002, //Bit 61
0x0001 //Bit 62
};
/**
* Determines if message bits 0 - 47 pass the Fleetsync CRC checksum
* contained in bits 48 - 63, using a lookup table of CRC checksum values
* derived from the CRC-15 value, and verifies the message has even parity
*/
public static CRC check( BitSet msg )
{
CRC crc = CRC.UNKNOWN;
int calculated = 1; //Starting value
//Check even parity
if( msg.cardinality() % 2 == 0 )
{
//Iterate bits that are set and XOR running checksum with lookup value
for (int i = msg.nextSetBit( 0 ); i >= 0 && i < 48; i = msg.nextSetBit( i+1 ) )
{
calculated ^= sCHECKSUMS[ i ];
}
if( calculated == getChecksum( msg ) )
{
crc = CRC.PASSED;
}
else
{
crc = CRC.FAILED_CRC;
}
}
else
{
crc = CRC.FAILED_PARITY;
}
return crc;
}
/**
* Returns the integer value of the 15 bit crc checksum
*/
public static int getChecksum( BitSet msg )
{
int retVal = 0;
for( int x = 0; x < 15; x++ )
{
if( msg.get( x + 48 ) )
{
retVal += 1<<( 14 - x );
}
}
return retVal;
}
/**
* Determines the errant bit positions and returns them in an array of
* integer bit positions.
*
* Note: currently only detects single-bit errors
*
* @param msg to be checked for errors
* @return - array of integer positions of bits that need flipped
*/
public static int[] findBitErrors( BitSet msg )
{
int[] retVal = null;
int checksum = getChecksum( msg );
//Remove the initial fill value (1)
checksum ^= 1;
//Iterate set message bits, removing their respective checksum value
//from the transmitted checksum, to arrive at the remainder
for (int i = msg.nextSetBit( 0 ); i >= 0 && i < 48; i = msg.nextSetBit( i+1 ) )
{
checksum ^= sCHECKSUMS[ i ];
}
//If at this point the checksum is 0, then we have a parity bit error
if( checksum == 0 )
{
retVal = new int[ 1 ];
retVal[ 0 ] = 63;
}
//Otherwise, try to lookup the syndrome for a single bit error
else
{
for( int x = 0; x < 63; x++ )
{
if( checksum == sCHECKSUMS[ x ] )
{
//return this bit position
retVal = new int[ 1 ];
retVal[ 0 ] = x;
}
}
}
return retVal;
}
}

185
src/crc/CRCLTR.java Normal file
View File

@@ -0,0 +1,185 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
import message.MessageDirection;
/**
* LTR CRC checksum utility
*
* LTR message blocks are 41 bits in length as follows:
* 0 - 9: Sync
* 10 - 34: message bits
* 35 - 41: CRC-7 check bits
*
* LTR uses a CRC-7 (0xFD) with an initial fill of 0x00.
*
* CRC-7 Generating Polynomial: x7 + x6 + x5 + x4 + x3 + x2 + 1 (0xFD)
*/
public class CRCLTR
{
private static byte[] sCHECKSUMS = new byte[]
{
0x38, //Area
0x1C, //Channel 4
0x0E, //Channel 3
0x46, //Channel 2
0x23, //Channel 1
0x51, //Channel 0
0x68, //Home 4
0x75, //Home 3
0x7A, //Home 2
0x3D, //Home 1
0x1F, //Home 0
0x4F, //Group 7
0x26, //Group 6
0x52, //Group 5
0x29, //Group 4
0x15, //Group 3
0x0B, //Group 2
0x45, //Group 1
0x62, //Group 0
0x31, //Free 4
0x19, //Free 3
0x0D, //Free 2
0x07, //Free 1
0x43 //Free 0
};
/**
* Determines if message bits 10 - 34 pass the LTR CRC checksum
* contained in bits 35 - 41, using a lookup table of CRC checksum values
* derived from the CRC-7 value.
*/
public static CRC check( BitSet msg, MessageDirection direction )
{
CRC crc = CRC.UNKNOWN;
int calculated = getCalculatedChecksum( msg );
int transmitted = getTransmittedChecksum( msg );
/* Normal CRC only for Outbound Status Word */
if( direction == MessageDirection.OSW )
{
if( calculated == transmitted )
{
return CRC.PASSED;
}
}
/* Normal or Inverted CRC for Inbound Status Word */
else
{
if( ( calculated ^ 127 ) == transmitted )
{
return CRC.PASSED_INV;
}
else if( calculated == transmitted )
{
return CRC.PASSED;
}
}
return CRC.FAILED_CRC;
}
public static byte[] getChecks()
{
return sCHECKSUMS;
}
public static int getCalculatedChecksum( BitSet msg )
{
int calculated = 0;
//Iterate bits that are set and XOR running checksum with lookup value
for (int i = msg.nextSetBit( 9 ); i >= 9 && i < 33; i = msg.nextSetBit( i+1 ) )
{
calculated ^= sCHECKSUMS[ i - 9 ];
}
return calculated;
}
/**
* Returns the integer value of the 7 bit crc checksum
*/
public static int getTransmittedChecksum( BitSet msg )
{
int retVal = 0;
for( int x = 0; x < 7; x++ )
{
if( msg.get( x + 33 ) )
{
retVal += 1<<( 6 - x );
}
}
return retVal;
}
/**
* Determines the errant bit positions and returns them in an array of
* integer bit positions.
*
* Note: currently only detects single-bit errors
*
* @param msg to be checked for errors
* @return - array of integer positions of bits that need flipped
*/
public static int[] findBitErrors( BitSet msg )
{
int[] retVal = null;
int checksum = getTransmittedChecksum( msg );
//Remove the initial fill value (1)
checksum ^= 1;
//Iterate set message bits, removing their respective checksum value
//from the transmitted checksum, to arrive at the remainder
for (int i = msg.nextSetBit( 0 ); i >= 0 && i < 47; i = msg.nextSetBit( i+1 ) )
{
checksum ^= sCHECKSUMS[ i ];
}
//If at this point the checksum is 0, then the errant bit is the parity
//bit
if( checksum == 0 )
{
msg.flip( 62 );
}
//Otherwise, try to lookup the syndrome for a single bit error
else
{
for( int x = 0; x < 47; x++ )
{
if( checksum == sCHECKSUMS[ x ] )
{
//return this bit position
retVal = new int[ 1 ];
retVal[ 0 ] = x;
}
}
}
return retVal;
}
}

215
src/crc/CRCPassport.java Normal file
View File

@@ -0,0 +1,215 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
import bits.BitSetBuffer;
/**
* Passport CRC checksum utility
*
* Passport message blocks are 68 bits in length as follows:
* 0 - 8: Sync
* 9 - 59: message bits
* 60 - 67: CRC-7 check bits plus 1 parity
*
* Passport uses a CRC-7 (0x44) with an initial fill of 0x44 plus parity set.
*
* CRC-7 Generating Polynomial: x6 + x2 + 1 (0x44)
*/
public class CRCPassport
{
private static final byte sFILL_00 = (byte)0x00;
private static byte[] sCHECKSUMS = new byte[]
{
(byte)0x6E, //DCC 1
(byte)0xBF, //DCC 0
(byte)0xD6, //LCN 10
(byte)0xE3, //LCN 9
(byte)0xF8, //LCN 8
(byte)0x7C, //LCN 7
(byte)0x3E, //LCN 6
(byte)0x97, //LCN 5
(byte)0xC2, //LCN 4
(byte)0xE9, //LCN 3
(byte)0x75, //LCN 2
(byte)0x3B, //LCN 1
(byte)0x94, //LCN 0
(byte)0x4A, //SITE 6
(byte)0xAD, //SITE 5
(byte)0x57, //SITE 4
(byte)0xA2, //SITE 3
(byte)0xD9, //SITE 2
(byte)0x6D, //SITE 1
(byte)0x37, //SITE 0
(byte)0x92, //GROUP 15
(byte)0xC1, //GROUP 14
(byte)0x61, //GROUP 13
(byte)0x31, //GROUP 12
(byte)0x19, //GROUP 11
(byte)0x0D, //GROUP 10
(byte)0x07, //GROUP 9
(byte)0x8A, //GROUP 8
(byte)0xCD, //GROUP 7
(byte)0x67, //GROUP 6
(byte)0xBA, //GROUP 5
(byte)0xD5, //GROUP 4
(byte)0x6B, //GROUP 3
(byte)0xBC, //GROUP 2
(byte)0x5E, //GROUP 1
(byte)0xA7, //GROUP 0
(byte)0xDA, //TYPE 3
(byte)0xE5, //TYPE 2
(byte)0x73, //TYPE 1
(byte)0xB0, //TYPE 0
(byte)0x58, //FREE 10
(byte)0x2C, //FREE 9
(byte)0x16, //FREE 8
(byte)0x83, //FREE 7
(byte)0xC8, //FREE 6
(byte)0x64, //FREE 5
(byte)0x32, //FREE 4
(byte)0x91, //FREE 3
(byte)0x49, //FREE 2
(byte)0x25, //FREE 1
(byte)0x13 //FREE 0
};
/**
* Determines if message bits 9 - 59 pass the CRC checksum
* contained in bits 60 - 68, using a lookup table of CRC checksum values
* derived from the CRC-7 value and the final parity bit
*/
public static CRC check( BitSet msg )
{
CRC crc = CRC.UNKNOWN;
byte calculated = 0x0; //Starting value for an OSW
//Iterate bits that are set and XOR running checksum with lookup value
for (int i = msg.nextSetBit( 9 ); i >= 9 && i <= 59; i = msg.nextSetBit( i+1 ) )
{
calculated ^= sCHECKSUMS[ i - 9 ];
}
//Apply the message checksum to derive the residual
calculated ^= getChecksum( msg );
switch( (byte)calculated )
{
case sFILL_00:
crc = CRC.PASSED;
break;
default:
crc = CRC.FAILED_CRC;
}
return crc;
}
public static byte getResidual( BitSet msg )
{
byte calculated = 0x0; //Initial fill of zero
//Iterate bits that are set and XOR running checksum with lookup value
for (int i = msg.nextSetBit( 9 ); i >= 9 && i <= 59; i = msg.nextSetBit( i+1 ) )
{
calculated ^= sCHECKSUMS[ i - 9 ];
}
calculated ^= getChecksum( msg );
return calculated;
}
public static byte[] getChecks()
{
return sCHECKSUMS;
}
/**
* Returns the integer value of the 7 bit crc checksum
*/
public static byte getChecksum( BitSet msg )
{
byte retVal = 0x0;
for( int x = 0; x < 8; x++ )
{
if( msg.get( x + 60 ) )
{
retVal ^= (byte)( 1<<( 7 - x ) );
}
}
return retVal;
}
/**
* Initial take on error correction. The majority of the errors detected
* are in the final 2 bits, owing to the forward looking soft bit detection
* used in the decoder. For right now, correct any messages where the
* residual indicates that the final 1 or 2 bits are bad.
*/
public static BitSetBuffer correct( BitSetBuffer msg )
{
int residual = (int)( 0xFF & getResidual( msg ) );
switch( residual )
{
case 1:
case 136:
msg.flip( 67 );
break;
case 3:
case 138:
msg.flip( 66 );
msg.flip( 67 );
break;
case 2:
case 139:
msg.flip( 66 );
break;
case 140:
msg.flip( 65 );
msg.flip( 67 );
break;
case 153:
msg.flip( 67 );
break;
case 142:
msg.flip( 65 );
msg.flip( 66 );
msg.flip( 67 );
break;
}
return msg;
}
/**
* Performs an even parity check on the bitset. If the number of bits that
* are set is an even number, then it passes the even parity check
*/
public static boolean isEvenParity( BitSetBuffer bits )
{
return ( bits.cardinality() % 2 == 0 );
}
}

58
src/crc/CRCUtil.java Normal file
View File

@@ -0,0 +1,58 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
public class CRCUtil
{
public static BitSet check( BitSet originalMessage,
int messageLength,
BitSet polynomial,
int polynomialLength )
{
//Make a copy of the message, since we're going to modify it
BitSet copy = originalMessage.get( 0, messageLength );
//Iterate through the message bits
for( int x = 0; x < messageLength; x++ )
{
//If we're aligned against a starting 1 in the message, divide it
if( copy.get( 0 ) )
{
copy.xor( polynomial );
}
//Left shift the message
copy = copy.get( 1, messageLength + polynomialLength - x );
}
return copy.get( 0, polynomialLength );
}
public static void log( String message )
{
System.out.println( message );
}
public enum Status
{
PASS, FAIL, BITINVERTED, WORDINVERTED;
}
}

52
src/crc/Checksum.java Normal file
View File

@@ -0,0 +1,52 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
/**
* Calculates a 7-bit checksum using an array of xor values from the
* ChecksumType class
*/
public class Checksum
{
public static boolean validate7BitChecksum( BitSet message,
byte messageChecksum,
ChecksumType checksumType )
{
return ( messageChecksum & get7BitChecksum( message, checksumType ) ) == 0;
}
public static byte get7BitChecksum( BitSet message,
ChecksumType checksumType )
{
byte checksum = 0x00;
short[] checkValues = checksumType.getValues();
for( int x = 0; x < checkValues.length; x++ )
{
if( message.get( x ) )
{
checksum ^= checkValues[ x ];
}
}
return checksum;
}
}

96
src/crc/ChecksumTest.java Normal file
View File

@@ -0,0 +1,96 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
import java.util.BitSet;
public class ChecksumTest
{
/**
* @param args
*/
public static void main( String[] args )
{
log( "START!" );
String msg = "111000001000010010001110";
log( msg + " check:" + String.format( "%02X", Checksum.get7BitChecksum( load( msg ), ChecksumType.LTR ) ) );
log( "DONE!" );
}
public static void log( String message )
{
System.out.println( message );
}
public static String getString( BitSet bitset, int length )
{
StringBuilder sb = new StringBuilder();
for( int x = 0; x < length; x++ )
{
if( bitset.get( x ) )
{
sb.append( "1" );
}
else
{
sb.append( "0" );
}
}
return sb.toString();
}
public static String getStringReverse( BitSet bitset, int length )
{
StringBuilder sb = new StringBuilder();
for( int x = length - 1; x > -1; x-- )
{
if( bitset.get( x ) )
{
sb.append( "1" );
}
else
{
sb.append( "0" );
}
}
return sb.toString();
}
public static BitSet load( String message )
{
BitSet retVal = new BitSet();
for( int x = 0; x < message.length(); x++ )
{
if( message.substring( x, x + 1 ).contentEquals( "1" ) )
{
retVal.set( x );
}
}
return retVal;
}
}

223
src/crc/ChecksumType.java Normal file
View File

@@ -0,0 +1,223 @@
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2014 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
******************************************************************************/
package crc;
public enum ChecksumType
{
FLEETSYNC_ANI( new short[]
{
0x0000, //Unknown Always One
0x0000, //Status Msg Flag
0x14C3, //Status Message 6 001010011000011
0x6908, //Status Message 5 110100100001000
0x3484, //Status Message 4 011010010000100
0x1A42, //Status Message 3 001101001000010
0x0D21, //Status Message 2 000110100100001
0x729A, //Status Message 1 111001010011010
0x394D, //Status Message 0 011100101001101
0x0000, //Type 7
0x0000, //Type 6
0x0000, //Type 5
0x0000, //Type 4
0x0000, //Type 3
0x0000, //Type 2
0x0000, //Type 1
0x0000, //Type 0
0x0000, //Fleet From 7
0x0000, //Fleet From 6
0x0000, //Fleet From 5
0x0000, //Fleet From 4
0x402E, //Fleet From 3 100000000101110
0x2017, //Fleet From 2 010000000010111
0x6401, //Fleet From 1 110010000000001
0x460A, //Fleet From 0 100011000001010
0x0000, //Ident From 11
0x0000, //Ident From 10
0x0000, //Ident From 9
0x0000, //Ident From 8
0x0CB1, //Ident From 7 000110010110001
0x7252, //Ident From 6 111001001010010
0x3929, //Ident From 5 011100100101001
0x689E, //Ident From 4 110100010011110
0x344F, //Ident From 3 011010001001111
0x6E2D, //Ident From 2 110111000101101
0x431C, //Ident From 1 100001100011100
0x218E, //Ident From 0 010000110001110
0x0000, //Ident To 11
0x0000, //Ident To 10
0x0000, //Ident To 9
0x0000, //Ident To 8
0x6685, //Ident To 7 110011010000101
0x4748, //Ident To 6 100011101001000
0x23A4, //Ident To 5 010001110100100
0x11D2, //Ident To 4 001000111010010
0x08E9, //Ident To 3 000100011101001
0x707E, //Ident To 2 111000001111110
0x383F, //Ident To 1 011100000111111
0x6815, //Ident To 0 110100000010101
}),
LTR( new short[]
{ 0x0038, //Area
0x001C, //Channel 4
0x000E, //Channel 3
0x0046, //Channel 2
0x0023, //Channel 1
0x0051, //Channel 0
0x0068, //Home 4
0x0075, //Home 3
0x007A, //Home 2
0x003D, //Home 1
0x001F, //Home 0
0x004F, //Group 7
0x0026, //Group 6
0x0052, //Group 5
0x0029, //Group 4
0x0015, //Group 3
0x000B, //Group 2
0x0045, //Group 1
0x0062, //Group 0
0x0031, //Free 4
0x0019, //Free 3
0x000D, //Free 2
0x0007, //Free 1
0x0043 //Free 0
} ),
PASSPORT( new short[]
{
// 0x6e,
// 0xbf,
// 0xd6,
// 0xe3,
// 0xf8,
// 0x7c,
// 0x3e,
// 0x97,
// 0xc2,
// 0xe9,
// 0x75,
// 0x3b,
// 0x94,
// 0x4a,
// 0xad,
// 0x57,
// 0xa2,
// 0xd9,
// 0x6d,
// 0x37,
// 0x92,
// 0xc1,
// 0x61,
// 0x31,
// 0x19,
// 0x0d,
// 0x07,
// 0x8a,
// 0xcd,
// 0x67,
// 0xba,
// 0xd5,
// 0x6b, // 0111110
// 0xbc, // 1111100
// 0x5e, // 1101001
// 0xa7, // 1000011
// 0xda, // 0010111
// 0xe5, // 0101110
// 0x73, // 1011100
// 0xb0, // 0101001
// 0x58, // 1010010
// 0x2c, // 0110101 Bit 43
// 0x16, // 1101010
// 0x83, // 1000101 Bit 45
// 0xc8, // 0011011 Bit 46
// 0x64, // 0110110
// 0x32, // 1101100
// 0x91, // 1001001
// 0x49,
// 0x25,
// 0x13,
} ),
MULTINET( new short[]
{
// 0x96, // 0010110
// 0xAC, // 0101100
// 0xd8, // 1011000
// 0x21, // 0100001
// 0x42, // 1000010
// 0x95, // 0010101
// 0xaa, // 0101010
// 0xd4, // 1010100
// 0x39, // 0111001
// 0x72, // 1110010
// 0xf5, // 1110101 Bit 10
// 0x7b, // 1111011
// 0xe7, // 1100111
// 0x5f, // 1011111
// 0xaf, // 0101111
// 0xde, // 1011110
// 0x2d, // 0101101
// 0x5a, // 1011010
// 0xa5, // 0100101
// 0xca, // 1001010
// 0x05, // 0000101
// 0x0a, // 0001010
// 0x14, // 0010100
// 0x28, // 0101000
// 0x50, // 1010000
// 0xb1, // 0110001
// 0xe2, // 1100010
// 0x55, // 1010101
// 0xbb, // 0111011
// 0xf6, // 1110110
// 0x7d, // 1111101
// 0xeb, // 1101011
// 0x47, // 1000111
// 0x9f, // 0011111 Bit 33
// 0xbe, // 0111110
// 0xfc, // 1111100
// 0x69, // 1101001
// 0xc3, // 1000011
// 0x17, // 0010111
// 0x2e, // 0101110
// 0x5c, // 1011100
// 0xA9, // 0101001
// 0xD2, // 1010010
// 0x35, // 0110101 Bit 43
// 0x6A, // 1101010
// 0xC5, // 1000101 Bit 45
// 0x1B, // 0011011 Bit 46
// 0x36, // 0110110
// 0x6C, // 1101100
// 0xC9 // 1001001
});
private short[] mValues;
ChecksumType( short[] values )
{
mValues = values;
}
public short[] getValues()
{
return mValues;
}
}