main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 
00004 DigitalOut led1(P3_25);     //leds are inversed!
00005 DigitalOut led2(P3_26);     //leds are inversed!
00006 DigitalOut transmitter(P0_6);
00007 Timeout transmitterTimeOutControl;
00008 
00009 DigitalIn receiverIn(P0_5);
00010 int previousReceiverState = 0;
00011 Timer receiverTimer;
00012 
00013 #define RING_BUFFER_LENGTH 500
00014 
00015 #define PREAMBULA_MINIMUM_LENGTH 150
00016 #define PREAMBULA_MAXIMUM_LENGTH 200
00017 #define BIT_0_MINIMUM_LENGTH 27
00018 
00019 #define PACKET_LENGTH_IN_BITS 94
00020 
00021 unsigned short ringBuffer[RING_BUFFER_LENGTH];
00022 int ringBufferWriteIndex=0, ringBufferReadIndex=0;
00023 
00024 Serial pc(P0_2, P0_3);
00025 
00026 void parseAvcPacket(int fromRingIndex, int toRingIndex)
00027 {
00028     int bitIndex = 0, blockStartLengthIndex = 0;
00029     unsigned short blockBits = 0x0000;
00030     for (int ringIndex = fromRingIndex; ringIndex != toRingIndex; )
00031     {
00032         int us_count = ringBuffer[ringBufferReadIndex];             
00033         
00034         if (us_count >= PREAMBULA_MAXIMUM_LENGTH)
00035         {
00036             pc.printf("\r\nWRONG %d us");
00037             break;
00038         }
00039         else if (us_count >= PREAMBULA_MINIMUM_LENGTH)
00040             pc.printf("\r\n");
00041         else 
00042         {
00043             unsigned short bit = (us_count > BIT_0_MINIMUM_LENGTH) ? 0 : 1;
00044             blockBits |= (bit << blockStartLengthIndex);
00045                 
00046             int outInBlockLength = 8;//1, 4, 8, 12
00047             if ((bitIndex == 0) || (bitIndex == 13) || (bitIndex == 26) || (bitIndex == 27) || (bitIndex == 32) || (bitIndex == 33) || 
00048                 (bitIndex == 42) || (bitIndex == 43) || (bitIndex == 52) || (bitIndex == 53) || (bitIndex == 62) || (bitIndex == 63) || 
00049                 (bitIndex == 72) || (bitIndex == 73) || (bitIndex == 82) || (bitIndex == 83) || (bitIndex == 92) || (bitIndex == 93))
00050                  outInBlockLength = 1;
00051             else if (((bitIndex < 13) && (bitIndex >= 1)) || ((bitIndex < 26) && (bitIndex >= 14)))
00052                 outInBlockLength = 12;
00053             else if ((bitIndex < 32) && (bitIndex >= 28))
00054                 outInBlockLength = 4;
00055             
00056             if (blockStartLengthIndex >= outInBlockLength)
00057             {
00058                 if (outInBlockLength == 1)
00059                     pc.printf("%d ", blockBits);
00060                 else if (outInBlockLength == 4)
00061                     pc.printf("%X ", blockBits);
00062                 else if (outInBlockLength == 8)
00063                     pc.printf("%X ", blockBits);
00064                 else if (outInBlockLength == 12)
00065                     pc.printf("%X ", blockBits);
00066                     
00067                 blockStartLengthIndex = 0;
00068                 blockBits = 0x0000;
00069             }
00070 
00071             bitIndex ++;            
00072             blockStartLengthIndex ++;
00073         }
00074             
00075         ringIndex = (ringIndex+1) % RING_BUFFER_LENGTH;        
00076     }
00077 }
00078 
00079 void serialCommunicationThreadFunction(void const *args)
00080 {
00081     pc.baud(115200);
00082     pc.printf("\r\nAVC-Lan sniffer is ON\r\n\r\n");
00083     
00084     led1 = 1;
00085 
00086     while (true) 
00087     {
00088         led1 = (ringBufferWriteIndex == ringBufferReadIndex);
00089 
00090         int packetEndIndex = (ringBufferReadIndex+1) % RING_BUFFER_LENGTH;
00091         int packetBitLength = 0;
00092         for (; ringBufferWriteIndex != packetEndIndex; )
00093             if ((packetBitLength == PACKET_LENGTH_IN_BITS) || ((ringBuffer[packetEndIndex] >= PREAMBULA_MINIMUM_LENGTH) && (ringBuffer[packetEndIndex] < PREAMBULA_MAXIMUM_LENGTH)))
00094             {
00095                 parseAvcPacket(ringBufferReadIndex, (packetBitLength == PACKET_LENGTH_IN_BITS) ? packetEndIndex : (packetEndIndex-1));
00096                 break;
00097             }
00098             else
00099             {
00100                 packetEndIndex = (packetEndIndex+1) % RING_BUFFER_LENGTH;
00101                 packetBitLength ++;
00102             }
00103     }
00104 }
00105 
00106 int main()
00107 {
00108     Thread serialCommunicationThread(serialCommunicationThreadFunction);
00109 
00110     receiverIn.mode(PullUp);
00111 
00112     receiverTimer.reset();
00113     led2 = 1;
00114 
00115     while (true) 
00116     {
00117         if (receiverIn != previousReceiverState)
00118         {     
00119             led2 = 0;
00120             if (receiverIn)
00121             {
00122                 receiverTimer.reset();
00123                 receiverTimer.start();
00124             }
00125             else
00126             {
00127                 receiverTimer.stop();
00128                 int us_count = receiverTimer.read_us();                
00129                 ringBuffer[ringBufferWriteIndex] = us_count;
00130                 ringBufferWriteIndex = (ringBufferWriteIndex+1) % RING_BUFFER_LENGTH;
00131             }
00132                 
00133             previousReceiverState = receiverIn;
00134             led2 = 1;
00135         }
00136     }
00137 }