00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00043 #define COMMSCORE_C
00044 #include "inc/freeEMS.h"
00045 #include "inc/flashWrite.h"
00046 #include "inc/interrupts.h"
00047 #include "inc/utils.h"
00048 #include "inc/tableLookup.h"
00049 #include "inc/blockDetailsLookup.h"
00050 #include "inc/commsCore.h"
00051 #include <string.h>
00052
00053
00063 void populateBasicDatalog(){
00064
00065 unsigned char* position = TXBufferCurrentPositionHandler;
00066
00067
00068 memcpy(TXBufferCurrentPositionHandler, CoreVars, sizeof(CoreVar));
00069 TXBufferCurrentPositionHandler += sizeof(CoreVar);
00070
00071 memcpy(TXBufferCurrentPositionHandler, DerivedVars, sizeof(DerivedVar));
00072 TXBufferCurrentPositionHandler += sizeof(DerivedVar);
00073
00074 memcpy(TXBufferCurrentPositionHandler, ADCArrays, sizeof(ADCArray));
00075 TXBufferCurrentPositionHandler += sizeof(ADCArray);
00076
00077
00078 TXBufferCurrentPositionHandler = position + configuredBasicDatalogLength;
00079 }
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00146 void checksumAndSend(){
00147
00148 unsigned short TXPacketLengthToSend = (unsigned short)TXBufferCurrentPositionHandler - (unsigned short)&TXBuffer;
00149
00150
00151 *TXBufferCurrentPositionHandler = checksum((unsigned char*)&TXBuffer, TXPacketLengthToSend);
00152 TXPacketLengthToSend++;
00153
00154
00155
00156
00157 if(TXBufferInUseFlags & COM_SET_SCI0_INTERFACE_ID){
00158
00159 TXPacketLengthToSendSCI0 = TXPacketLengthToSend;
00160 TXPacketLengthToSendCAN0 = TXPacketLengthToSend;
00161
00162
00163
00164
00165
00166
00167
00168 SCI0DRL = START_BYTE;
00169 while(!(SCI0SR1 & 0x80)){}
00170 SCI0DRL = START_BYTE;
00171
00172
00173
00174 SCI0CR2 |= SCICR2_TX_ISR_ENABLE;
00175 }
00176
00177 if(TXBufferInUseFlags & COM_SET_CAN0_INTERFACE_ID){
00178
00179 TXBufferInUseFlags &= COM_CLEAR_CAN0_INTERFACE_ID;
00180 }
00181
00182 if(TXBufferInUseFlags & COM_SET_SPARE2_INTERFACE_ID){
00183
00184 TXBufferInUseFlags &= COM_CLEAR_SPARE2_INTERFACE_ID;
00185 }
00186
00187 if(TXBufferInUseFlags & COM_SET_SPARE3_INTERFACE_ID){
00188
00189 TXBufferInUseFlags &= COM_CLEAR_SPARE3_INTERFACE_ID;
00190 }
00191
00192 if(TXBufferInUseFlags & COM_SET_SPARE4_INTERFACE_ID){
00193
00194 TXBufferInUseFlags &= COM_CLEAR_SPARE4_INTERFACE_ID;
00195 }
00196
00197 if(TXBufferInUseFlags & COM_SET_SPARE5_INTERFACE_ID){
00198
00199 TXBufferInUseFlags &= COM_CLEAR_SPARE5_INTERFACE_ID;
00200 }
00201
00202 if(TXBufferInUseFlags & COM_SET_SPARE6_INTERFACE_ID){
00203
00204 TXBufferInUseFlags &= COM_CLEAR_SPARE6_INTERFACE_ID;
00205 }
00206
00207 if(TXBufferInUseFlags & COM_SET_SPARE7_INTERFACE_ID){
00208
00209 TXBufferInUseFlags &= COM_CLEAR_SPARE7_INTERFACE_ID;
00210 }
00211 }
00212
00213
00222 void decodePacketAndRespond(){
00223
00224 RXBufferCurrentPosition = (unsigned char*)&RXBuffer;
00225 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer;
00226
00227
00228 TXBufferCurrentPositionSCI0 = (unsigned char*)&TXBuffer;
00229 TXBufferCurrentPositionCAN0 = (unsigned char*)&TXBuffer;
00230
00231
00232 RXCalculatedPayloadLength = RXPacketLengthReceived;
00233
00234
00235 RXHeaderFlags = *RXBufferCurrentPosition;
00236 RXBufferCurrentPosition++;
00237 RXCalculatedPayloadLength--;
00238
00239
00240 TXBufferInUseFlags |= COM_SET_SCI0_INTERFACE_ID;
00241
00242
00243
00244 unsigned char* TXHeaderFlags = TXBufferCurrentPositionHandler;
00245 *TXHeaderFlags = 0;
00246 TXBufferCurrentPositionHandler++;
00247
00248
00249 RXHeaderPayloadID = *((unsigned short*)RXBufferCurrentPosition);
00250 *((unsigned short*)TXBufferCurrentPositionHandler) = RXHeaderPayloadID + 1;
00251 RXBufferCurrentPosition += 2;
00252 TXBufferCurrentPositionHandler += 2;
00253 RXCalculatedPayloadLength -= 2;
00254
00255
00256 if(RXHeaderFlags & HEADER_HAS_ACK){
00257 *TXBufferCurrentPositionHandler = *RXBufferCurrentPosition;
00258 *TXHeaderFlags |= HEADER_HAS_ACK;
00259 RXBufferCurrentPosition++;
00260 TXBufferCurrentPositionHandler++;
00261 RXCalculatedPayloadLength--;
00262 }
00263
00264
00265 if(RXHeaderFlags & HEADER_HAS_ADDRS){
00266
00267 if(*RXBufferCurrentPosition != fixedConfigs1.serialSettings.networkAddress){
00268
00269 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
00270 TXBufferInUseFlags = 0;
00271 return;
00272 }
00273 RXBufferCurrentPosition++;
00274
00275
00276 RXHeaderSourceAddress = *RXBufferCurrentPosition;
00277 RXBufferCurrentPosition++;
00278 if(RXHeaderSourceAddress == 0){
00279 sendErrorInternal(sourceAddressIsBroadcast);
00280 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
00281 return;
00282 }
00283 if(RXHeaderSourceAddress == fixedConfigs1.serialSettings.networkAddress){
00284 sendErrorInternal(sourceAddressIsDuplicate);
00285 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
00286 return;
00287 }
00288
00289
00290 *TXHeaderFlags |= HEADER_HAS_ADDRS;
00291
00292 *TXBufferCurrentPositionHandler = RXHeaderSourceAddress;
00293 TXBufferCurrentPositionHandler++;
00294
00295 *TXBufferCurrentPositionHandler = fixedConfigs1.serialSettings.networkAddress;
00296 TXBufferCurrentPositionHandler++;
00297
00298 RXCalculatedPayloadLength -= 2;
00299 }
00300
00301
00302 RXCalculatedPayloadLength--;
00303
00304
00305 if(RXHeaderFlags & HEADER_HAS_LENGTH){
00306 RXHeaderPayloadLength = *((unsigned short*)RXBufferCurrentPosition);
00307 RXBufferCurrentPosition += 2;
00308 RXCalculatedPayloadLength -= 2;
00309
00310 if(RXHeaderPayloadLength != RXCalculatedPayloadLength){
00311 sendErrorInternal(payloadLengthHeaderMismatch);
00312 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
00313 return;
00314 }
00315 }
00316
00317
00318
00319
00320
00321
00322 if (RXHeaderFlags & HEADER_IS_PROTO){
00323
00324 *TXHeaderFlags |= HEADER_IS_PROTO;
00325
00326 switch (RXHeaderPayloadID){
00327 case requestInterfaceVersion:
00328 {
00329 if(RXCalculatedPayloadLength != 0){
00330 sendErrorInternal(payloadLengthTypeMismatch);
00331 break;
00332 }
00333
00334
00335 *((unsigned short*)TXBufferCurrentPositionHandler) = sizeof(interfaceVersionAndType);
00336 *TXHeaderFlags |= HEADER_HAS_LENGTH;
00337 TXBufferCurrentPositionHandler += 2;
00338
00339 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&interfaceVersionAndType, sizeof(interfaceVersionAndType));
00340 TXBufferCurrentPositionHandler += sizeof(interfaceVersionAndType);
00341 checksumAndSend();
00342 break;
00343 }
00344 case requestFirmwareVersion:
00345 {
00346 if(RXCalculatedPayloadLength != 0){
00347 sendErrorInternal(payloadLengthTypeMismatch);
00348 break;
00349 }
00350
00351 *((unsigned short*)TXBufferCurrentPositionHandler) = sizeof(firmwareVersion);
00352 *TXHeaderFlags |= HEADER_HAS_LENGTH;
00353 TXBufferCurrentPositionHandler += 2;
00354
00355 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&firmwareVersion, sizeof(firmwareVersion));
00356 TXBufferCurrentPositionHandler += sizeof(firmwareVersion);
00357 checksumAndSend();
00358 break;
00359 }
00360 case requestMaxPacketSize:
00361 {
00362 if(RXCalculatedPayloadLength != 0){
00363 sendErrorInternal(payloadLengthTypeMismatch);
00364 break;
00365 }
00366
00367 *((unsigned short*)TXBufferCurrentPositionHandler) = RX_BUFFER_SIZE;
00368 TXBufferCurrentPositionHandler += 2;
00369 checksumAndSend();
00370 break;
00371 }
00372 case requestEchoPacketReturn:
00373 {
00374
00375 *((unsigned short*)TXBufferCurrentPositionHandler) = RXPacketLengthReceived;
00376 *TXHeaderFlags |= HEADER_HAS_LENGTH;
00377 TXBufferCurrentPositionHandler += 2;
00378
00379 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&RXBuffer, RXPacketLengthReceived);
00380
00381
00382 TXBufferCurrentPositionHandler += RXPacketLengthReceived;
00383 checksumAndSend();
00384 break;
00385 }
00386 case requestSoftSystemReset:
00387 {
00388
00389 if(asyncDatalogType){
00390 asyncDatalogType = asyncDatalogOff;
00391 }else{
00392 asyncDatalogType = asyncDatalogBasic;
00393 }
00394 sendAckIfRequired();
00395 break;
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415 }
00416 case requestHardSystemReset:
00417 {
00418 if(RXCalculatedPayloadLength != 0){
00419 sendErrorInternal(payloadLengthTypeMismatch);
00420 break;
00421 }
00422
00423
00424 COPCTL = 0x01;
00425 ARMCOP = 0xFF;
00426
00427
00428 }
00429 default:
00430 {
00431 if((RXHeaderPayloadID % 2) == 1){
00432 sendErrorInternal(invalidProtocolPayloadID);
00433 }else{
00434 sendErrorInternal(unrecognisedProtocolPayloadID);
00435 }
00436 }
00437 }
00438 }else{
00439 switch (RXHeaderPayloadID) {
00440 case replaceBlockInRAM:
00441 {
00442
00443 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00444 RXBufferCurrentPosition += 2;
00445
00446
00447 blockDetails details;
00448 lookupBlockDetails(locationID, &details);
00449
00450
00451 if((RXCalculatedPayloadLength - 2) != details.size){
00452 sendErrorInternal(payloadLengthTypeMismatch);
00453 break;
00454 }
00455
00456 if((details.RAMPage == 0) || (details.RAMAddress == 0)){
00457 sendErrorInternal(invalidMemoryActionForID);
00458 break;
00459 }
00460
00461
00462 unsigned short errorID = 0;
00463 if(locationID < 16){
00464
00465 errorID = validateMainTable((mainTable*)RXBufferCurrentPosition);
00466 }else if((locationID > 399) && (locationID < 900)){
00467
00468 errorID = validateTwoDTable((twoDTableUS*)RXBufferCurrentPosition);
00469 }
00470
00471 if(errorID != 0){
00472 sendErrorInternal(errorID);
00473 break;
00474 }
00475
00476
00477 unsigned char oldRamPage = RPAGE;
00478
00479 RPAGE = details.RAMPage;
00480
00481 memcpy(details.RAMAddress, RXBufferCurrentPosition, details.size);
00482
00483 RPAGE = oldRamPage;
00484
00485 sendAckIfRequired();
00486 break;
00487 }
00488 case replaceBlockInFlash:
00489 {
00490
00491 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00492 RXBufferCurrentPosition += 2;
00493
00494
00495 blockDetails details;
00496 lookupBlockDetails(locationID, &details);
00497
00498
00499 if((RXCalculatedPayloadLength - 2) != details.size){
00500 sendErrorInternal(payloadLengthTypeMismatch);
00501 break;
00502 }
00503
00504 if((details.FlashPage == 0) || (details.FlashAddress == 0)){
00505 sendErrorInternal(invalidMemoryActionForID);
00506 break;
00507 }
00508
00509
00510 unsigned short errorID = 0;
00511 if(locationID < 16){
00512
00513 errorID = validateMainTable((mainTable*)RXBufferCurrentPosition);
00514 }else if((locationID > 399) && (locationID < 900)){
00515
00516 errorID = validateTwoDTable((twoDTableUS*)RXBufferCurrentPosition);
00517 }
00518
00519 if(errorID != 0){
00520 sendErrorInternal(errorID);
00521 break;
00522 }
00523
00524
00525 void* buffer = (void*)((unsigned short)&RXBuffer + RXPacketLengthReceived);
00526
00527
00528 unsigned char originalRAMPage = details.RAMPage;
00529 void* originalRAMAddress = details.RAMAddress;
00530 details.RAMPage = RPAGE;
00531 details.RAMAddress = RXBufferCurrentPosition;
00532
00533
00534 errorID = writeBlock(&details, buffer);
00535 if(errorID != 0){
00536 sendErrorInternal(errorID);
00537 break;
00538 }
00539
00540
00541 if((originalRAMPage != 0) && (originalRAMAddress != 0)){
00542
00543 unsigned char oldRamPage = RPAGE;
00544
00545 RPAGE = originalRAMPage;
00546
00547 memcpy(originalRAMAddress, RXBufferCurrentPosition, details.size);
00548
00549 RPAGE = oldRamPage;
00550 }
00551
00552 sendAckIfRequired();
00553
00554 break;
00555 }
00556 case retrieveBlockFromRAM:
00557 {
00558 if(RXCalculatedPayloadLength != 2){
00559 sendErrorInternal(payloadLengthTypeMismatch);
00560 break;
00561 }
00562
00563
00564 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00565
00566 *(unsigned short*)TXBufferCurrentPositionHandler = locationID;
00567 TXBufferCurrentPositionHandler += 2;
00568
00569
00570 if(locationID < 16){
00571
00572 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_RPM_LENGTH;
00573 TXBufferCurrentPositionHandler += 2;
00574
00575 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_LOAD_LENGTH;
00576 TXBufferCurrentPositionHandler += 2;
00577
00578 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_MAIN_LENGTH;
00579 TXBufferCurrentPositionHandler += 2;
00580 }
00581
00582
00583 blockDetails details;
00584 lookupBlockDetails(locationID, &details);
00585
00586 if((details.RAMPage == 0) || (details.RAMAddress == 0)){
00587 sendErrorInternal(invalidMemoryActionForID);
00588 break;
00589 }
00590
00591
00592 unsigned char oldRamPage = RPAGE;
00593 RPAGE = details.RAMPage;
00594
00595
00596 memcpy(TXBufferCurrentPositionHandler, details.RAMAddress, details.size);
00597 TXBufferCurrentPositionHandler += details.size;
00598
00599
00600 RPAGE = oldRamPage;
00601
00602 checksumAndSend();
00603 break;
00604 }
00605 case retrieveBlockFromFlash:
00606 {
00607 if(RXCalculatedPayloadLength != 2){
00608 sendErrorInternal(payloadLengthTypeMismatch);
00609 break;
00610 }
00611
00612
00613 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00614
00615 *(unsigned short*)TXBufferCurrentPositionHandler = locationID;
00616 TXBufferCurrentPositionHandler += 2;
00617
00618
00619 if(locationID < 16){
00620
00621 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_RPM_LENGTH;
00622 TXBufferCurrentPositionHandler += 2;
00623
00624 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_LOAD_LENGTH;
00625 TXBufferCurrentPositionHandler += 2;
00626
00627 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_MAIN_LENGTH;
00628 TXBufferCurrentPositionHandler += 2;
00629 }
00630
00631
00632 blockDetails details;
00633 lookupBlockDetails(locationID, &details);
00634
00635 if((details.FlashPage == 0) || (details.FlashAddress == 0)){
00636 sendErrorInternal(invalidMemoryActionForID);
00637 break;
00638 }
00639
00640
00641 unsigned char oldFlashPage = PPAGE;
00642 PPAGE = details.FlashPage;
00643
00644
00645 memcpy(TXBufferCurrentPositionHandler, details.FlashAddress, details.size);
00646 TXBufferCurrentPositionHandler += details.size;
00647
00648
00649 PPAGE = oldFlashPage;
00650
00651 checksumAndSend();
00652 break;
00653 }
00654 case burnBlockFromRamToFlash:
00655 {
00656 if(RXCalculatedPayloadLength != 2){
00657 sendErrorInternal(payloadLengthTypeMismatch);
00658 break;
00659 }
00660
00661
00662 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00663
00664
00665 blockDetails details;
00666 lookupBlockDetails(locationID, &details);
00667
00668
00669 if((details.RAMPage == 0) || (details.RAMAddress == 0) || (details.FlashPage == 0) || (details.FlashAddress == 0)){
00670 sendErrorInternal(invalidMemoryActionForID);
00671 break;
00672 }
00673
00674
00675 void* buffer = (void*)((unsigned short)&RXBuffer + RXPacketLengthReceived);
00676
00677
00678 unsigned short errorID = writeBlock(&details, buffer);
00679
00680 if(errorID != 0){
00681 sendErrorInternal(errorID);
00682 break;
00683 }
00684
00685 sendAckIfRequired();
00686 break;
00687 }
00688 case eraseAllBlocksFromFlash:
00689 {
00690 if(RXCalculatedPayloadLength != 0){
00691 sendErrorInternal(payloadLengthTypeMismatch);
00692 break;
00693 }
00694
00695
00696 unsigned char page = 0xE0;
00697 unsigned short start = 0x8000;
00698 unsigned short end = 0xC000;
00699 unsigned short inc = 0x0400;
00700 for(;page < 0xF8;page++){
00701 unsigned short addr;
00702 for(addr = start;addr < end; addr += inc){
00703
00704 eraseSector(page, (unsigned short*)addr);
00705 }
00706 }
00707 sendDebugInternal("Erased three 128k Flash blocks!");
00708 break;
00709 }
00710 case burnAllBlocksOfFlash:
00711 {
00712 if(RXCalculatedPayloadLength != 0){
00713 sendErrorInternal(payloadLengthTypeMismatch);
00714 break;
00715 }
00716
00717
00718 unsigned char page = 0xE0;
00719 unsigned short start = 0x8000;
00720 unsigned short end = 0xC000;
00721 unsigned short inc = 0x0400;
00722 for(;page < 0xF8;page++){
00723 unsigned short addr;
00724 for(addr = start;addr < end; addr += inc){
00725 writeSector(RPAGE, (unsigned short*)0xc000, page, (unsigned short*)addr);
00726 }
00727 }
00728 sendDebugInternal("Overwrote three 128k Flash blocks!");
00729 break;
00730 }
00731 case adjustMainTableCell:
00732 {
00733 if(RXCalculatedPayloadLength != 8){
00734 sendErrorInternal(payloadLengthTypeMismatch);
00735 break;
00736 }
00737
00738
00739 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00740 RXBufferCurrentPosition += 2;
00741
00742
00743 if(15 < locationID){
00744 sendErrorInternal(invalidIDForMainTableAction);
00745 break;
00746 }
00747
00748
00749 unsigned short RPMIndex = *((unsigned short*)RXBufferCurrentPosition);
00750 RXBufferCurrentPosition += 2;
00751 unsigned short LoadIndex = *((unsigned short*)RXBufferCurrentPosition);
00752 RXBufferCurrentPosition += 2;
00753 unsigned short cellValue = *((unsigned short*)RXBufferCurrentPosition);
00754
00755
00756 blockDetails details;
00757 lookupBlockDetails(locationID, &details);
00758
00759
00760 unsigned short errorID = setPagedMainTableCellValue(details.RAMPage, details.RAMAddress, RPMIndex, LoadIndex, cellValue);
00761 if(errorID != 0){
00762 sendErrorInternal(errorID);
00763 }else{
00764 sendAckIfRequired();
00765 }
00766 break;
00767 }
00768 case adjustMainTableRPMAxis:
00769 {
00770 if(RXCalculatedPayloadLength != 6){
00771 sendErrorInternal(payloadLengthTypeMismatch);
00772 break;
00773 }
00774
00775
00776 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00777 RXBufferCurrentPosition -= 2;
00778
00779
00780 if(15 < locationID){
00781 sendErrorInternal(invalidIDForMainTableAction);
00782 break;
00783 }
00784
00785
00786 unsigned short RPMIndex = *((unsigned short*)RXBufferCurrentPosition);
00787 RXBufferCurrentPosition -= 2;
00788 unsigned short RPMValue = *((unsigned short*)RXBufferCurrentPosition);
00789
00790
00791 blockDetails details;
00792 lookupBlockDetails(locationID, &details);
00793
00794
00795 unsigned short errorID = setPagedMainTableRPMValue(details.RAMPage, details.RAMAddress, RPMIndex, RPMValue);
00796 if(errorID != 0){
00797 sendErrorInternal(errorID);
00798 }else{
00799 sendAckIfRequired();
00800 }
00801 break;
00802 }
00803 case adjustMainTableLoadAxis:
00804 {
00805 if(RXCalculatedPayloadLength != 6){
00806 sendErrorInternal(payloadLengthTypeMismatch);
00807 break;
00808 }
00809
00810
00811 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00812 RXBufferCurrentPosition -= 2;
00813
00814
00815 if(15 < locationID){
00816 sendErrorInternal(invalidIDForMainTableAction);
00817 break;
00818 }
00819
00820
00821 unsigned short LoadIndex = *((unsigned short*)RXBufferCurrentPosition);
00822 RXBufferCurrentPosition -= 2;
00823 unsigned short LoadValue = *((unsigned short*)RXBufferCurrentPosition);
00824
00825
00826 blockDetails details;
00827 lookupBlockDetails(locationID, &details);
00828
00829
00830 unsigned short errorID = setPagedMainTableLoadValue(details.RAMPage, details.RAMAddress, LoadIndex, LoadValue);
00831 if(errorID != 0){
00832 sendErrorInternal(errorID);
00833 }else{
00834 sendAckIfRequired();
00835 }
00836 break;
00837 }
00838 case adjust2dTableAxis:
00839 {
00840 if(RXCalculatedPayloadLength != 6){
00841 sendErrorInternal(payloadLengthTypeMismatch);
00842 break;
00843 }
00844
00845
00846 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00847 RXBufferCurrentPosition -= 2;
00848
00849
00850 if((locationID > 899) || (locationID < 400)){
00851 sendErrorInternal(invalidIDForTwoDTableAction);
00852 break;
00853 }
00854
00855
00856 unsigned short axisIndex = *((unsigned short*)RXBufferCurrentPosition);
00857 RXBufferCurrentPosition -= 2;
00858 unsigned short axisValue = *((unsigned short*)RXBufferCurrentPosition);
00859
00860
00861 blockDetails details;
00862 lookupBlockDetails(locationID, &details);
00863
00864
00865 unsigned short errorID = setPagedTwoDTableAxisValue(details.RAMPage, details.RAMAddress, axisIndex, axisValue);
00866 if(errorID != 0){
00867 sendErrorInternal(errorID);
00868 }else{
00869 sendAckIfRequired();
00870 }
00871 break;
00872 }
00873 case adjust2dTableCell:
00874 {
00875 if(RXCalculatedPayloadLength != 6){
00876 sendErrorInternal(payloadLengthTypeMismatch);
00877 break;
00878 }
00879
00880
00881 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition);
00882 RXBufferCurrentPosition -= 2;
00883
00884
00885 if((locationID > 899) || (locationID < 400)){
00886 sendErrorInternal(invalidIDForTwoDTableAction);
00887 break;
00888 }
00889
00890
00891 unsigned short cellIndex = *((unsigned short*)RXBufferCurrentPosition);
00892 RXBufferCurrentPosition -= 2;
00893 unsigned short cellValue = *((unsigned short*)RXBufferCurrentPosition);
00894
00895
00896 blockDetails details;
00897 lookupBlockDetails(locationID, &details);
00898
00899
00900 unsigned short errorID = setPagedTwoDTableCellValue(details.RAMPage, details.RAMAddress, cellIndex, cellValue);
00901 if(errorID != 0){
00902 sendErrorInternal(errorID);
00903 }else{
00904 sendAckIfRequired();
00905 }
00906 break;
00907 }
00908 case requestBasicDatalog:
00909 {
00910 if((RXCalculatedPayloadLength > 2) || (RXCalculatedPayloadLength == 1)){
00911 sendErrorInternal(payloadLengthTypeMismatch);
00912 break;
00913 }else if(RXCalculatedPayloadLength == 2){
00914 unsigned short newConfiguredLength = *((unsigned short*)RXBufferCurrentPosition);
00915 if(newConfiguredLength > maxBasicDatalogLength){
00916 sendErrorInternal(datalogLengthExceedsMax);
00917 break;
00918 }else{
00919 configuredBasicDatalogLength = newConfiguredLength;
00920 }
00921 }
00922
00923
00924 *TXHeaderFlags |= HEADER_HAS_LENGTH;
00925 *(unsigned short*)TXBufferCurrentPositionHandler = configuredBasicDatalogLength;
00926
00927
00928 populateBasicDatalog();
00929 checksumAndSend();
00930 break;
00931 }
00932 case requestConfigurableDatalog:
00933 {
00934
00935 sendErrorInternal(unimplementedFunction);
00936 break;
00937 }
00938 case forwardPacketOverCAN:
00939 {
00940
00941 sendErrorInternal(unimplementedFunction);
00942 break;
00943 }
00944 case forwardPacketOverOtherUART:
00945 {
00946
00947 sendErrorInternal(unimplementedFunction);
00948 break;
00949 }
00950 case setAsyncDatalogType:
00951 {
00952 if(RXCalculatedPayloadLength != 1){
00953 sendErrorInternal(payloadLengthTypeMismatch);
00954 break;
00955 }
00956
00957 unsigned char newDatalogType = *((unsigned char*)RXBufferCurrentPosition);
00958 if(newDatalogType > 0x03){
00959 sendErrorInternal(noSuchAsyncDatalogType);
00960 break;
00961 }else{
00962 asyncDatalogType = newDatalogType;
00963 }
00964
00965 sendAckIfRequired();
00966 break;
00967 }
00968 default:
00969 if((RXHeaderPayloadID % 2) == 1){
00970 sendErrorInternal(invalidFirmwarePayloadID);
00971 }else{
00972 sendErrorInternal(unrecognisedFirmwarePayloadID);
00973 }
00974 }
00975 }
00976
00977 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
00978 PORTK |= BIT0;
00979 }
00980
00981
00994 void sendErrorIfClear(unsigned short errorID){
00995 if(!TXBufferInUseFlags){
00996 TXBufferInUseFlags = ONES;
00997 sendErrorInternal(errorID);
00998 }else{
00999 Counters.commsErrorMessagesNotSent++;
01000 }
01001 }
01002
01003
01018 void sendErrorBusyWait(unsigned short errorID){
01019 while(TXBufferInUseFlags){}
01020 TXBufferInUseFlags = ONES;
01021 sendErrorInternal(errorID);
01022 }
01023
01024
01043 void sendErrorInternal(unsigned short errorCode){
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer;
01065
01066
01067
01068 *TXBufferCurrentPositionHandler = 0x01;
01069 TXBufferCurrentPositionHandler++;
01070
01071 *((unsigned short*)TXBufferCurrentPositionHandler) = asyncErrorCodePacket;
01072 TXBufferCurrentPositionHandler += 2;
01073
01074 *((unsigned short*)TXBufferCurrentPositionHandler) = errorCode;
01075 TXBufferCurrentPositionHandler += 2;
01076 checksumAndSend();
01077
01078 }
01079
01080
01091 void sendDebugIfClear(unsigned char* message){
01092 if(!TXBufferInUseFlags){
01093 TXBufferInUseFlags = ONES;
01094 sendDebugInternal(message);
01095 }else{
01096 Counters.commsDebugMessagesNotSent++;
01097 }
01098 }
01099
01100
01112 void sendDebugBusyWait(unsigned char* message){
01113 while(TXBufferInUseFlags){}
01114 TXBufferInUseFlags = ONES;
01115 sendDebugInternal(message);
01116 }
01117
01118
01136 void sendDebugInternal(unsigned char* message){
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer;
01164
01165
01166 *TXBufferCurrentPositionHandler = 0x11;
01167 TXBufferCurrentPositionHandler++;
01168
01169
01170 *((unsigned short*)TXBufferCurrentPositionHandler) = asyncDebugInfoPacket;
01171 TXBufferCurrentPositionHandler += 2;
01172
01173
01174 unsigned short* TXLength = (unsigned short*)TXBufferCurrentPositionHandler;
01175 TXBufferCurrentPositionHandler += 2;
01176
01177
01178 unsigned short messageLength = stringCopy(TXBufferCurrentPositionHandler, message);
01179 *TXLength = messageLength;
01180 TXBufferCurrentPositionHandler += messageLength;
01181
01182 checksumAndSend();
01183
01184 }
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01256 void sendAckIfRequired(){
01257 TXBufferInUseFlags = 0;
01258
01259 }