Iztech Fork

Dependencies:   mbed

Fork of A2_Interface3_V_0_0 by Roger McArdell

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers BoardComms.h Source File

BoardComms.h

00001 /*
00002     Programmer: Roger McArdell
00003     Date: 02/08/2017
00004     Version 
00005     V0.1    First version
00006 */
00007 const string Revision = "0.0.1";
00008 
00009 static uint8_t EthAddWrite = '\xBE';
00010 static uint8_t EthAddRead = '\xBF';
00011 
00012 // Prototypes
00013 void CheckForData();
00014 void CheckaboxData();
00015 void WriteCEC(char Port, char data);
00016 void ReadCEC();
00017 void Processabox(string InString);
00018 void SetLEDs(uint8_t LEDNo, uint8_t LEDState);
00019 
00020 string RegBuff;
00021 string InString1 = "";
00022 
00023 void CheckForData()
00024 { 
00025     string bufchar;
00026     
00027     char c;
00028     while(pc.readable())
00029     {
00030         c = pc.getc();
00031         RegBuff += c;  
00032         bufchar = c;
00033         pc.printf("%s", bufchar.c_str()); // echo back to screen
00034          
00035         if (c == '\x0D') 
00036         {
00037             switch(RegBuff[0])
00038             {
00039                 case 'M': // Matrix
00040                     if (RegBuff[1] == 'R') //Read
00041                     {
00042                         pc.printf("Byte Received Read: %s\r\n", RegBuff.c_str());
00043                         switch(RegBuff[2])
00044                         {
00045                             case '0':
00046                                 switch(RegBuff[3])
00047                                 {
00048                                     case '0': ReadMatrix('\x00',1);  break;
00049                                     case '1': ReadMatrix('\x01',1);  break;
00050                                     case '2': ReadMatrix('\x02',1);  break;
00051                                     case '3': ReadMatrix('\x03',4);  break;   
00052                                     case '4': ReadMatrix('\x04',8);  break; 
00053                                     case '5': ReadMatrix('\x05',2);  break;
00054                                     case '6': ReadMatrix('\x06',2);  break;
00055                                     case '7': ReadMatrix('\x07',1);  break;
00056                                     case '8': ReadMatrix('\x08',1);  break;
00057                                     case '9': ReadMatrix('\x09',1);  break;
00058                                     case 'A': ReadMatrix('\x0A',1);  break;
00059                                     case 'B': ReadMatrix('\x0B',2);  break;
00060                                     case 'C': ReadMatrix('\x0C',1);  break;
00061                                     case 'E': ReadMatrix('\x0E',6);  break;
00062                                     case 'F': ReadMatrix('\x0F',6);  break;
00063                                 }
00064                             break;
00065                             case '1':
00066                                 switch(RegBuff[3])
00067                                 {
00068                                     case '0': ReadMatrix('\x10',5);  break;
00069                                     case '1': ReadMatrix('\x11',5);  break;
00070                                     case '2': ReadMatrix('\x12',5);  break;
00071                                     case '3': ReadMatrix('\x13',5);  break;   
00072                                     case '4': ReadMatrix('\x14',5);  break; 
00073                                     case '5': ReadMatrix('\x15',5);  break;
00074                                     case '6': ReadMatrix('\x16',5);  break;
00075                                     case '7': ReadMatrix('\x17',5);  break;
00076                                     case '8': ReadMatrix('\x18',5);  break;
00077                                 }
00078                             break;
00079                             case '2':
00080                                 switch(RegBuff[3])
00081                                 {
00082                                     case '0': ReadMatrix('\x20',5);  break;
00083                                     case '1': ReadMatrix('\x21',5);  break;
00084                                 }
00085                             break;   
00086                         } 
00087                     }
00088                     else if (RegBuff[1] == 'W') //Write
00089                     {
00090                         pc.printf("Byte Received Write: %s\r\n", RegBuff.c_str());
00091                         WriteMatrix(RegBuff);        
00092                     }
00093                     else if (RegBuff[1] == 'S') // Set matrix switcher
00094                     {
00095                        SwitchMatrix(RegBuff[2], RegBuff[3]); 
00096                     }
00097                 break;       
00098                 case 'S':
00099                     if (RegBuff[1] == 'R') //Read
00100                     {
00101                     }
00102                     else
00103                     if (RegBuff[1] == 'W') //Write
00104                     {
00105                         switch(RegBuff[2])
00106                         {
00107                             case '1':
00108                                 switch(RegBuff[3])
00109                                 {
00110                                     case '0': WriteCEC(Button1Address, Off); break;
00111                                     case '1': WriteCEC(Button1Address, Green); break;
00112                                     case '2': WriteCEC(Button1Address, Blue); break;
00113                                     case '3': WriteCEC(Button1Address, Red); break;
00114                                     case '4': WriteCEC(Button1Address, FlashRed); break;
00115                                     case '5': WriteCEC(Button1Address, FlashRedGreen); break;
00116                                     case '6': WriteCEC(Button1Address, FlashBlue); break;
00117                                 }
00118                             break;                            
00119                             case '2':
00120                                 switch(RegBuff[3])
00121                                 {
00122                                     case '0': WriteCEC(Button2Address, Off); break;
00123                                     case '1': WriteCEC(Button2Address, Green); break;
00124                                     case '2': WriteCEC(Button2Address, Blue); break;
00125                                     case '3': WriteCEC(Button2Address, Red); break;
00126                                     case '4': WriteCEC(Button2Address, FlashRed); break;
00127                                     case '5': WriteCEC(Button2Address, FlashRedGreen); break;
00128                                     case '6': WriteCEC(Button2Address, FlashBlue); break;
00129                                 }
00130                             break;
00131                             case '3':
00132                                 switch(RegBuff[3])
00133                                 {
00134                                     case '0': WriteCEC(Button3Address, Off); break;
00135                                     case '1': WriteCEC(Button3Address, Green); break;
00136                                     case '2': WriteCEC(Button3Address, Blue); break;
00137                                     case '3': WriteCEC(Button3Address, Red); break;
00138                                     case '4': WriteCEC(Button3Address, FlashRed); break;
00139                                     case '5': WriteCEC(Button3Address, FlashRedGreen); break;
00140                                     case '6': WriteCEC(Button3Address, FlashBlue); break;
00141                                 }
00142                             break;
00143                             case '4':
00144                                 switch(RegBuff[3])
00145                                 {
00146                                     case '0': WriteCEC(Button4Address, Off); break;
00147                                     case '1': WriteCEC(Button4Address, Green); break;
00148                                     case '2': WriteCEC(Button4Address, Blue); break;
00149                                     case '3': WriteCEC(Button4Address, Red); break;
00150                                     case '4': WriteCEC(Button4Address, FlashRed); break;
00151                                     case '5': WriteCEC(Button4Address, FlashRedGreen); break;
00152                                     case '6': WriteCEC(Button4Address, FlashBlue); break;
00153                                 }
00154                             break;
00155                         }
00156                     }
00157                 break;
00158                 case 'L':
00159                     Processabox(RegBuff);
00160                     // Format: LEXYZ/n 
00161                 break;
00162             }
00163             RegBuff = "";
00164         }      
00165     }
00166 }
00167 
00168 
00169 void WriteCEC(char Port, char data)
00170 {  
00171     char SendByte[2];
00172     SendByte[0] = '\x01';
00173     SendByte[1] = data;
00174     I2CBus.start(); // Not sure if this is required.
00175     I2CBus.write(Port, SendByte, 2);   
00176     I2CBus.stop(); 
00177 }
00178 char ReadCEC(char Port)
00179 {
00180     char TempRead[1]; 
00181     char RegAddress = '\x01';
00182     I2CBus.start(); // Not sure if this is required.
00183     I2CBus.write(Port, &RegAddress, 1); //
00184     I2CBus.read(Port, TempRead, 1);
00185     I2CBus.stop();
00186     
00187     printf("CEC value is %d: \r\n",TempRead);
00188       
00189     return TempRead[0];
00190 }
00191 void ReadEthernet(char Register)
00192 {
00193     char TempRead[10]; 
00194     I2CBus.start();
00195     I2CBus.write(EthAddWrite, &Register, 1); //
00196     I2CBus.read(EthAddRead, TempRead, 1);
00197     I2CBus.stop();
00198     
00199     printf("Ethernet Register %d: \r\n",Register);
00200     printf("Value is %d: \r\n",TempRead);
00201 }
00202 
00203 
00204 void CheckaboxData()
00205 { 
00206     string bufchar;
00207     string TempString;
00208     
00209     char inChar;
00210     while(aboxPort.readable()) 
00211     {
00212         inChar = aboxPort.getc(); // get the new byte
00213         InString1 += inChar; // add it to the inputString:
00214             
00215         if (inChar == '\n') 
00216         {
00217             TempString = InString1;
00218             InString1 = "";
00219             Processabox(TempString);
00220         }
00221     } 
00222 }
00223 void Processabox(string InString)
00224 {
00225     // Format: LEXXYYZZ/n where LE is the comand type, X is interface ID, Y is LED number and Z is the LED state. XYZ are hex 
00226     
00227     uint8_t BoxNo = ((InString[2] - 48)*10) + (InString[3] - 48); // convert from 2 char bytes to 1 byte number
00228     uint8_t LEDNo = ((InString[4] - 48)*10) + (InString[5] - 48); 
00229     uint8_t LEDState = ((InString[6] - 48)*10) + (InString[7] - 48); 
00230       
00231     switch (InString[0])
00232     {
00233         case'L': SetLEDs(LEDNo, LEDState); break;
00234         case'H':   
00235             if (InString[1] == 'B')
00236                 aboxPort.printf("HNTB\n");
00237                 //Send heartbeat
00238         break;
00239         case'M':
00240             if (InString[1] == 'A')
00241             {
00242                 
00243                            
00244             }
00245         case'U': // Update current status. 
00246             if (HDMI1Sync)
00247                 aboxPort.printf("DSY%d11\n", IDNumber);
00248             else
00249                 aboxPort.printf("DSY%d10\n", IDNumber);
00250             if (HDMI2Sync)
00251                 aboxPort.printf("DSY%d21\n", IDNumber);
00252             else
00253                 aboxPort.printf("DSY%d20\n", IDNumber);
00254             if (HDMI3Sync)
00255                 aboxPort.printf("DSY%d31\n", IDNumber);
00256             else
00257                 aboxPort.printf("DSY%d30\n", IDNumber);
00258             if (HDMI4Sync)
00259                 aboxPort.printf("DSY%d41\n", IDNumber);
00260             else
00261                 aboxPort.printf("DSY%d40\n", IDNumber);                 
00262         break;
00263         case'V': aboxPort.printf("REV%S\n", Revision.c_str()); break;
00264     }    
00265 }
00266 void SetLEDs(uint8_t LEDNo, uint8_t LEDState)
00267 {
00268     printf("Set LEDs: LEDNo: %d LEDState: %d \n\r", LEDNo, LEDState );
00269     switch(LEDNo)
00270     {
00271         case 1: WriteCEC(Button1Address, (LEDNo * 10) + LEDState); break;
00272         case 2: WriteCEC(Button1Address, (LEDNo * 10) + LEDState); break;
00273         case 3: WriteCEC(Button1Address, (LEDNo * 10) + LEDState); break; 
00274         case 4: WriteCEC(Button1Address, (LEDNo * 10) + LEDState); break;      
00275     }
00276 }
00277