#include "inc/freeEMS.h"
#include "inc/flashWrite.h"
#include "inc/interrupts.h"
#include "inc/utils.h"
#include "inc/tableLookup.h"
#include "inc/commsCore.h"
#include <string.h>
Include dependency graph for commsCore.c:
Go to the source code of this file.
Defines | |
#define | COMMSCORE_C |
Functions | |
void | sendError (unsigned short) |
void | sendDebug (unsigned char *) |
void | checksumAndSend () |
void | decodePacketAndBuildResponse () |
void | lookupBlockDetails (unsigned short locationID, blockDetails *details) |
#define COMMSCORE_C |
Definition at line 24 of file commsCore.c.
void checksumAndSend | ( | ) |
Definition at line 38 of file commsCore.c.
References checksum(), COM_CLEAR_CAN0_INTERFACE_ID, COM_CLEAR_SPARE2_INTERFACE_ID, COM_CLEAR_SPARE3_INTERFACE_ID, COM_CLEAR_SPARE4_INTERFACE_ID, COM_CLEAR_SPARE5_INTERFACE_ID, COM_CLEAR_SPARE6_INTERFACE_ID, COM_CLEAR_SPARE7_INTERFACE_ID, COM_SET_CAN0_INTERFACE_ID, COM_SET_SCI0_INTERFACE_ID, COM_SET_SPARE2_INTERFACE_ID, COM_SET_SPARE3_INTERFACE_ID, COM_SET_SPARE4_INTERFACE_ID, COM_SET_SPARE5_INTERFACE_ID, COM_SET_SPARE6_INTERFACE_ID, COM_SET_SPARE7_INTERFACE_ID, SCI0CR2, SCI0DRL, SCICR2_TX_ISR_ENABLE, START_BYTE, TXBufferCurrentPositionHandler, TXBufferInUseFlags, TXPacketLengthToSendCAN0, and TXPacketLengthToSendSCI0.
Referenced by decodePacketAndBuildResponse(), sendDebug(), and sendError().
00038 { 00039 /* Get the length from the pointer */ 00040 unsigned short TXPacketLengthToSend = (unsigned short)TXBufferCurrentPositionHandler - (unsigned short)&TXBuffer; 00041 00042 /* Tag the checksum on the end */ 00043 *TXBufferCurrentPositionHandler = checksum((unsigned char*)&TXBuffer, TXPacketLengthToSend); 00044 TXPacketLengthToSend++; 00045 00046 /* Send it out on all the channels required. */ 00047 00048 /* SCI0 - Main serial interface */ 00049 if(TXBufferInUseFlags & COM_SET_SCI0_INTERFACE_ID){ 00050 /* Copy numbers to interface specific vars */ 00051 TXPacketLengthToSendSCI0 = TXPacketLengthToSend; 00052 TXPacketLengthToSendCAN0 = TXPacketLengthToSend; 00053 00054 /* Initiate transmission */ 00055 SCI0DRL = START_BYTE; 00056 /* Note : Order Is Important! */ 00057 /* TX empty flag is already set, so we must clear it by writing out before enabling the interrupt */ 00058 SCI0CR2 |= SCICR2_TX_ISR_ENABLE; 00059 } 00060 /* CAN0 - Main CAN interface */ 00061 if(TXBufferInUseFlags & COM_SET_CAN0_INTERFACE_ID){ 00062 // just clear up front for now 00063 TXBufferInUseFlags &= COM_CLEAR_CAN0_INTERFACE_ID; 00064 } 00065 /* spare2 */ 00066 if(TXBufferInUseFlags & COM_SET_SPARE2_INTERFACE_ID){ 00067 // just clear up front for now 00068 TXBufferInUseFlags &= COM_CLEAR_SPARE2_INTERFACE_ID; 00069 } 00070 /* spare3 */ 00071 if(TXBufferInUseFlags & COM_SET_SPARE3_INTERFACE_ID){ 00072 // just clear up front for now 00073 TXBufferInUseFlags &= COM_CLEAR_SPARE3_INTERFACE_ID; 00074 } 00075 /* spare4 */ 00076 if(TXBufferInUseFlags & COM_SET_SPARE4_INTERFACE_ID){ 00077 // just clear up front for now 00078 TXBufferInUseFlags &= COM_CLEAR_SPARE4_INTERFACE_ID; 00079 } 00080 /* spare5 */ 00081 if(TXBufferInUseFlags & COM_SET_SPARE5_INTERFACE_ID){ 00082 // just clear up front for now 00083 TXBufferInUseFlags &= COM_CLEAR_SPARE5_INTERFACE_ID; 00084 } 00085 /* spare6 */ 00086 if(TXBufferInUseFlags & COM_SET_SPARE6_INTERFACE_ID){ 00087 // just clear up front for now 00088 TXBufferInUseFlags &= COM_CLEAR_SPARE6_INTERFACE_ID; 00089 } 00090 /* spare7 */ 00091 if(TXBufferInUseFlags & COM_SET_SPARE7_INTERFACE_ID){ 00092 // just clear up front for now 00093 TXBufferInUseFlags &= COM_CLEAR_SPARE7_INTERFACE_ID; 00094 } 00095 }
Here is the call graph for this function:
void decodePacketAndBuildResponse | ( | void | ) |
Definition at line 98 of file commsCore.c.
References _start(), adjust2dTableAxis, adjust2dTableCell, adjustMainTableCell, adjustMainTableLoadAxis, adjustMainTableRPMAxis, BIT0, burnBlockFromRamToFlash, checksumAndSend(), CLEAR_ALL_SOURCE_ID_FLAGS, COM_SET_SCI0_INTERFACE_ID, currentFuelRPage, firmwareVersion, fixedConfigs, blockDetails::FlashAddress, blockDetails::FlashPage, forwardPacketOverCAN, forwardPacketOverUART, hardReset(), HEADER_HAS_ACK, HEADER_HAS_ADDRS, HEADER_HAS_LENGTH, HEADER_IS_PROTO, interfaceVersionAndType, invalidFirmwarePayloadID, invalidMemoryActionForID, invalidProtocolPayloadID, invalidSourceAddress, lookupBlockDetails(), MAINTABLE_MAX_LOAD_LENGTH, MAINTABLE_MAX_MAIN_LENGTH, MAINTABLE_MAX_RPM_LENGTH, fixedConfig::networkAddress, payloadLengthHeaderMismatch, payloadLengthTypeMismatch, PORTB, PORTK, PPAGE, blockDetails::RAMAddress, blockDetails::RAMPage, replace2dTableInRAM, replaceBlockInFlash, replaceBlockInRAM, requestAdjustableDatalog, requestBasicDatalog, requestEchoPacketReturn, requestFirmwareVersion, requestHardSystemReset, requestInterfaceVersion, requestMaxPacketSize, requestSoftSystemReset, resetReceiveState(), retrieveBlockFromFlash, retrieveBlockFromRAM, RPAGE, RX_BUFFER_SIZE, RXBufferCurrentPosition, RXCalculatedPayloadLength, RXHeaderFlags, RXHeaderPayloadID, RXHeaderPayloadLength, RXHeaderSourceAddress, RXPacketLengthReceived, sendDebug(), sendError(), setPagedMainTableCellValue(), setPagedMainTableLoadValue(), setPagedMainTableRPMValue(), blockDetails::size, TXBufferCurrentPositionCAN0, TXBufferCurrentPositionHandler, TXBufferCurrentPositionSCI0, TXBufferInUseFlags, unimplementedFunction, unrecognisedFirmwarePayloadID, unrecognisedProtocolPayloadID, validateMainTable(), validateTwoDTable(), and writeAlignedBlock().
Referenced by main().
00098 { 00099 /* Extract and build up the header fields */ 00100 RXBufferCurrentPosition = (unsigned char*)&RXBuffer; 00101 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer; 00102 00103 /* Initialised here such that override is possible */ 00104 TXBufferCurrentPositionSCI0 = (unsigned char*)&TXBuffer; 00105 TXBufferCurrentPositionCAN0 = (unsigned char*)&TXBuffer; 00106 00107 /* Start this off as full packet length and build down to the actual length */ 00108 RXCalculatedPayloadLength = RXPacketLengthReceived; 00109 00110 /* Grab the RX header flags out of the RX buffer */ 00111 RXHeaderFlags = *RXBufferCurrentPosition; 00112 RXBufferCurrentPosition++; 00113 RXCalculatedPayloadLength--; 00114 00115 /* Flag that we are transmitting! */ 00116 TXBufferInUseFlags |= COM_SET_SCI0_INTERFACE_ID; 00117 // SCI0 only for now... 00118 00119 /* Load a blank header into the TX buffer ready for masking */ 00120 unsigned char* TXHeaderFlags = TXBufferCurrentPositionHandler; 00121 *TXHeaderFlags = 0; 00122 TXBufferCurrentPositionHandler++; 00123 00124 /* Grab the payload ID for processing and load the return ID */ 00125 RXHeaderPayloadID = *((unsigned short*)RXBufferCurrentPosition); 00126 *((unsigned short*)TXBufferCurrentPositionHandler) = RXHeaderPayloadID + 1; 00127 RXBufferCurrentPosition += 2; 00128 TXBufferCurrentPositionHandler += 2; 00129 RXCalculatedPayloadLength -= 2; 00130 00131 /* If there is an ack, copy it to the return packet */ 00132 if(RXHeaderFlags & HEADER_HAS_ACK){ 00133 *TXBufferCurrentPositionHandler = *RXBufferCurrentPosition; 00134 *TXHeaderFlags |= HEADER_HAS_ACK; 00135 RXBufferCurrentPosition++; 00136 TXBufferCurrentPositionHandler++; 00137 RXCalculatedPayloadLength--; 00138 } 00139 00140 /* If the header has addresses, check them and if OK copy them */ 00141 if(RXHeaderFlags & HEADER_HAS_ADDRS){ 00142 /* Check the destination address against our address */ 00143 if(!(*RXBufferCurrentPosition == fixedConfigs.networkAddress)){ 00144 /* Addresses do not match, discard packet without error */ 00145 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS); 00146 TXBufferInUseFlags = 0; 00147 return; 00148 } 00149 RXBufferCurrentPosition++; 00150 00151 /* Save and check the source address */ 00152 RXHeaderSourceAddress = *RXBufferCurrentPosition; 00153 RXBufferCurrentPosition++; 00154 if(RXHeaderSourceAddress == 0){ 00155 sendError(invalidSourceAddress); 00156 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS); 00157 return; 00158 } 00159 00160 /* All is well, setup reply addresses */ 00161 *TXHeaderFlags |= HEADER_HAS_ADDRS; 00162 /* TX destination = RX source */ 00163 *TXBufferCurrentPositionHandler = RXHeaderSourceAddress; 00164 TXBufferCurrentPositionHandler++; 00165 /* TX source = our address */ 00166 *TXBufferCurrentPositionHandler = fixedConfigs.networkAddress; 00167 TXBufferCurrentPositionHandler++; 00168 /* Decrement for both at once to save a cycle */ 00169 RXCalculatedPayloadLength -= 2; 00170 } 00171 00172 /* Grab the length if available */ 00173 if(RXHeaderFlags & HEADER_HAS_LENGTH){ 00174 RXHeaderPayloadLength = *((unsigned short*)RXBufferCurrentPosition); 00175 RXBufferCurrentPosition += 2; 00176 RXCalculatedPayloadLength -= 2; 00177 /* Minus one for the checksum on the end ;-) */ 00178 if(RXHeaderPayloadLength != (RXCalculatedPayloadLength - 1)){ 00179 sendError(payloadLengthHeaderMismatch); 00180 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS); 00181 return; 00182 } 00183 } 00184 00185 /* Please Note : */ 00186 /* length (and it's flag) should be set by each return packet type handler if required or desired. */ 00187 /* If an ack has been requested, ensure the negative ack flag is set if the opration failed. */ 00188 00189 /* Perform the requested action based on payload ID */ 00190 if (RXHeaderFlags & HEADER_IS_PROTO){ /* Protocol payload types */ 00191 /* Set the return type to be protocol too */ 00192 *TXHeaderFlags |= HEADER_IS_PROTO; 00193 00194 switch (RXHeaderPayloadID){ 00195 case requestInterfaceVersion: 00196 /* Subtract one to exclude checksum */ 00197 if((RXCalculatedPayloadLength - 1) != 0){ 00198 sendError(payloadLengthTypeMismatch); 00199 break; 00200 } 00201 /* This type must have a length field, set that up */ 00202 *((unsigned short*)TXBufferCurrentPositionHandler) = sizeof(interfaceVersionAndType); 00203 *TXHeaderFlags |= HEADER_HAS_LENGTH; 00204 TXBufferCurrentPositionHandler += 2; 00205 /* Load the body into place */ 00206 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&interfaceVersionAndType, sizeof(interfaceVersionAndType)); 00207 TXBufferCurrentPositionHandler += sizeof(interfaceVersionAndType); 00208 checksumAndSend(); 00209 break; 00210 case requestFirmwareVersion: 00211 /* Subtract one to exclude checksum */ 00212 if((RXCalculatedPayloadLength - 1) != 0){ 00213 sendError(payloadLengthTypeMismatch); 00214 break; 00215 } 00216 /* This type must have a length field, set that up */ 00217 *((unsigned short*)TXBufferCurrentPositionHandler) = sizeof(firmwareVersion); 00218 *TXHeaderFlags |= HEADER_HAS_LENGTH; 00219 TXBufferCurrentPositionHandler += 2; 00220 /* Load the body into place */ 00221 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&firmwareVersion, sizeof(firmwareVersion)); 00222 TXBufferCurrentPositionHandler += sizeof(firmwareVersion); 00223 checksumAndSend(); 00224 break; 00225 case requestMaxPacketSize: 00226 /* Subtract one to exclude checksum */ 00227 if((RXCalculatedPayloadLength - 1) != 0){ 00228 sendError(payloadLengthTypeMismatch); 00229 break; 00230 } 00231 /* Load the size into place */ 00232 *((unsigned short*)TXBufferCurrentPositionHandler) = RX_BUFFER_SIZE; 00233 TXBufferCurrentPositionHandler += 2; 00234 checksumAndSend(); 00235 break; 00236 case requestEchoPacketReturn: 00237 /* This type must have a length field, set that up */ 00238 *((unsigned short*)TXBufferCurrentPositionHandler) = RXPacketLengthReceived; 00239 *TXHeaderFlags |= HEADER_HAS_LENGTH; 00240 TXBufferCurrentPositionHandler += 2; 00241 /* Load the body into place */ 00242 memcpy((void*)TXBufferCurrentPositionHandler, (void*)&RXBuffer, RXPacketLengthReceived); 00243 /* Note, there is no overflow check here because the TX buffer is slightly */ 00244 /* bigger than the RX buffer and there is overflow checking for receives anyway. */ 00245 TXBufferCurrentPositionHandler += RXPacketLengthReceived; 00246 checksumAndSend(); 00247 break; 00248 case requestSoftSystemReset: 00249 /* Subtract one to exclude checksum */ 00250 if((RXCalculatedPayloadLength - 1) != 0){ 00251 sendError(payloadLengthTypeMismatch); 00252 break; 00253 } 00254 /* Perform soft system reset */ 00255 _start(); 00256 case requestHardSystemReset: 00257 /* Subtract one to exclude checksum */ 00258 if((RXCalculatedPayloadLength - 1) != 0){ 00259 sendError(payloadLengthTypeMismatch); 00260 break; 00261 } 00262 /* Perform full hard system reset */ 00263 hardReset(); 00264 // Currently, corrupted memory instead of reset as of paged flash setup being introduced TODO FIXME this is broken... 00265 00266 /* 0xFFFE is the master reset vector. Using _start() */ 00267 /* only resets the app ignoring the monitor switch. */ 00268 /* It does not work properly because the location of */ 00269 /* _start is not the master reset vector location. */ 00270 default: 00271 if((RXHeaderPayloadID % 2) == 1){ 00272 sendError(invalidProtocolPayloadID); 00273 }else{ 00274 sendError(unrecognisedProtocolPayloadID); 00275 } 00276 } 00277 }else{ /* Otherwise firmware payload types */ 00278 switch (RXHeaderPayloadID) { 00279 case replaceBlockInRAM: 00280 { 00281 int id = PORTB; 00282 if(id < 16){ 00283 mainTable aTable; 00284 validateMainTable(&aTable); 00285 }else if(id > 27 && id < 50){ 00286 twoDTableUS aTable; 00287 validateTwoDTable(&aTable); 00288 } 00289 00290 00291 // /* Save page values for restore */ 00292 // unsigned char oldRamPage = RPAGE; 00293 // unsigned char oldFlashPage = PPAGE; 00294 // 00295 // 00296 // if((details->RAMPage == 0) || (details->RAMAddress == 0)){ 00297 // return bugInMemoryBlockCode; 00298 // } 00299 // /* Set the viewable ram page */ 00300 // RPAGE = details->RAMPage; 00301 // /* Copy from the RX buffer to the block of ram */ 00302 // memcpy(details->RAMAddress, RXBufferCurrentPosition, details->size); 00303 // 00304 // 00305 // /* Restore the original ram and flash pages */ 00306 // RPAGE = oldRamPage; 00307 // PPAGE = oldFlashPage; 00308 // 00309 00310 00311 // perform function TODO 00312 sendError(unimplementedFunction); 00313 break; 00314 } 00315 case replaceBlockInFlash: 00316 { 00317 // if 0 - 15 validate table 00318 mainTable aTable; 00319 validateMainTable(&aTable); 00320 // otherwise hope for the best 00321 00322 // check size > 0 and % 1024 != 0 same for ram to flash TODO 00323 00324 // /* Save page values for restore */ 00325 // unsigned char oldRamPage = RPAGE; 00326 // unsigned char oldFlashPage = PPAGE; 00327 // 00328 // 00329 // if((details->FlashPage == 0) || (details->FlashAddress == 0)){ 00330 // return bugInMemoryBlockCode; 00331 // } 00332 // /* Set the viewable flash page */ 00333 // PPAGE = details->FlashPage; 00334 // /* Copy from the RX buffer to the block of flash */ 00335 // error = writeAlignedBlock((unsigned short*)details->FlashAddress, (unsigned short*)RXBufferCurrentPosition); 00336 // /* If present in ram, update that too */ 00337 // if((details->RAMPage != 0) && (details->RAMAddress != 0)){ 00338 // /* Set the viewable ram page */ 00339 // RPAGE = details->RAMPage; 00340 // /* Copy from the RX buffer to the block of ram */ 00341 // memcpy(details->RAMAddress, RXBufferCurrentPosition, details->size); 00342 // } 00343 // 00344 // 00345 // /* Restore the original ram and flash pages */ 00346 // RPAGE = oldRamPage; 00347 // PPAGE = oldFlashPage; 00348 // 00349 00350 00351 // perform function TODO 00352 sendError(unimplementedFunction); 00353 break; 00354 } 00355 case retrieveBlockFromRAM: 00356 { 00357 /* Subtract one to exclude checksum */ 00358 if((RXCalculatedPayloadLength - 1) != 2){ 00359 sendError(payloadLengthTypeMismatch); 00360 break; 00361 } 00362 /* Extract the ram location ID from the received data */ 00363 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition); 00364 /* Store it back into the output data */ 00365 *(unsigned short*)TXBufferCurrentPositionHandler = locationID; 00366 TXBufferCurrentPositionHandler += 2; 00367 00368 /* If it's a main table we are returning, specify the limits explicitly */ 00369 if(locationID < 16){ 00370 /* Store it back into the output data */ 00371 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_RPM_LENGTH; 00372 TXBufferCurrentPositionHandler += 2; 00373 /* Store it back into the output data */ 00374 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_LOAD_LENGTH; 00375 TXBufferCurrentPositionHandler += 2; 00376 /* Store it back into the output data */ 00377 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_MAIN_LENGTH; 00378 TXBufferCurrentPositionHandler += 2; 00379 } 00380 00381 /* Look up the memory location details */ 00382 blockDetails details; 00383 lookupBlockDetails(locationID, &details); 00384 00385 if((details.RAMPage == 0) || (details.RAMAddress == 0)){ 00386 sendError(invalidMemoryActionForID); 00387 break; 00388 } 00389 00390 /* Save page value for restore and set the visible page */ 00391 unsigned char oldRamPage = RPAGE; 00392 RPAGE = details.RAMPage; 00393 00394 /* Copy the block of ram to the TX buffer */ 00395 memcpy(TXBufferCurrentPositionHandler, details.RAMAddress, details.size); 00396 TXBufferCurrentPositionHandler += details.size; 00397 00398 /* Restore the original ram and flash pages */ 00399 RPAGE = oldRamPage; 00400 00401 checksumAndSend(); 00402 break; 00403 } 00404 case retrieveBlockFromFlash: 00405 { 00406 /* Subtract one to exclude checksum */ 00407 if((RXCalculatedPayloadLength - 1) != 2){ 00408 sendError(payloadLengthTypeMismatch); 00409 break; 00410 } 00411 00412 /* Extract the flash location ID from the received data */ 00413 unsigned short locationID = *((unsigned short*)RXBufferCurrentPosition); 00414 /* Store it back into the output data */ 00415 *(unsigned short*)TXBufferCurrentPositionHandler = locationID; 00416 TXBufferCurrentPositionHandler += 2; 00417 00418 /* If it's a main table we are returning, specify the limits explicitly */ 00419 if(locationID < 16){ 00420 /* Store it back into the output data */ 00421 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_RPM_LENGTH; 00422 TXBufferCurrentPositionHandler += 2; 00423 /* Store it back into the output data */ 00424 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_LOAD_LENGTH; 00425 TXBufferCurrentPositionHandler += 2; 00426 /* Store it back into the output data */ 00427 *(unsigned short*)TXBufferCurrentPositionHandler = MAINTABLE_MAX_MAIN_LENGTH; 00428 TXBufferCurrentPositionHandler += 2; 00429 } 00430 00431 /* Look up the memory location details */ 00432 blockDetails details; 00433 lookupBlockDetails(locationID, &details); 00434 00435 if((details.FlashPage == 0) || (details.FlashAddress == 0)){ 00436 sendError(invalidMemoryActionForID); 00437 break; 00438 } 00439 00440 /* Save page value for restore and set the visible page */ 00441 unsigned char oldFlashPage = PPAGE; 00442 PPAGE = details.FlashPage; 00443 00444 /* Copy the block of flash to the TX buffer */ 00445 memcpy(TXBufferCurrentPositionHandler, details.FlashAddress, details.size); 00446 TXBufferCurrentPositionHandler += details.size; 00447 00448 /* Restore the original ram and flash pages */ 00449 PPAGE = oldFlashPage; 00450 00451 checksumAndSend(); 00452 break; 00453 } 00454 case burnBlockFromRamToFlash: 00455 { 00456 // perform function TODO 00457 writeAlignedBlock((unsigned short*)0x7c00, (unsigned short*)0xc000); 00458 00459 // unsigned char old = PPAGE; 00460 // PPAGE = BIGTABLES_PPAGE; 00461 // writeAlignedBlock((unsigned short*)&VETableMainFlash, (unsigned short*)0xC000); 00462 // PPAGE = old; 00463 //sendError(unimplementedFunction); 00464 // PORTB = ONES; 00465 00466 // check size > 0 and % 1024 != 0 same for ram to flash TODO 00467 00468 // /* Save page values for restore */ 00469 // unsigned char oldRamPage = RPAGE; 00470 // unsigned char oldFlashPage = PPAGE; 00471 // 00472 // 00473 // if((details->RAMPage == 0) || (details->RAMAddress == 0) || (details->FlashPage == 0) || (details->FlashAddress == 0)){ 00474 // return bugInMemoryBlockCode; 00475 // } 00476 // /* Set the viewable ram and flash pages */ 00477 // RPAGE = details->RAMPage; 00478 // PPAGE = details->FlashPage; 00479 // error = writeAlignedBlock((unsigned short*)details->FlashAddress, (unsigned short*)details->RAMAddress); 00480 // 00481 // 00482 // /* Restore the original ram and flash pages */ 00483 // RPAGE = oldRamPage; 00484 // PPAGE = oldFlashPage; 00485 00486 00487 00488 sendDebug("Burn Ran!"); 00489 break; 00490 } 00491 case adjustMainTableCell: 00492 { 00493 // extract id 00494 // extract value 00495 // extract indices x 2 00496 // lookup addresses 00497 mainTable aTable; 00498 validateMainTable(&aTable); 00499 /* Test */ 00500 setPagedMainTableCellValue(&TablesA.VETableMain, 0, 0, 32768, currentFuelRPage); 00501 // perform function TODO 00502 sendError(unimplementedFunction); 00503 break; 00504 } 00505 case adjustMainTableRPMAxis: 00506 { 00507 // extract id 00508 // extract value 00509 // extract index 00510 // lookup addresses 00511 mainTable aTable; 00512 validateMainTable(&aTable); 00513 /* Test */ 00514 setPagedMainTableRPMValue(&TablesA.VETableMain, 0, 0, currentFuelRPage); 00515 // perform function TODO 00516 sendError(unimplementedFunction); 00517 break; 00518 } 00519 case adjustMainTableLoadAxis: 00520 { 00521 // extract id 00522 // extract value 00523 // extract index 00524 // lookup addresses 00525 mainTable aTable; 00526 validateMainTable(&aTable); 00527 /* Test */ 00528 setPagedMainTableLoadValue(&TablesA.VETableMain, 0, 0, currentFuelRPage); 00529 // perform function TODO 00530 sendError(unimplementedFunction); 00531 break; 00532 } 00533 case adjust2dTableAxis: 00534 // extract id 00535 // extract value 00536 // extract index 00537 // lookup addresses 00538 00539 // perform function TODO 00540 sendError(unimplementedFunction); 00541 break; 00542 case adjust2dTableCell: 00543 // extract id 00544 // extract value 00545 // extract index 00546 // lookup addresses 00547 00548 // perform function TODO 00549 sendError(unimplementedFunction); 00550 break; 00551 case replace2dTableInRAM: 00552 { 00553 // extract id 00554 // lookup addresses 00555 twoDTableUS aTable; 00556 validateTwoDTable(&aTable); 00557 // perform function TODO 00558 sendError(unimplementedFunction); 00559 break; 00560 } 00561 case requestBasicDatalog: 00562 // perform function TODO 00563 sendError(unimplementedFunction); 00564 break; 00565 case requestAdjustableDatalog: 00566 // perform function TODO 00567 sendError(unimplementedFunction); 00568 break; 00569 case forwardPacketOverCAN: 00570 // perform function TODO 00571 sendError(unimplementedFunction); 00572 break; 00573 case forwardPacketOverUART: 00574 // perform function TODO 00575 sendError(unimplementedFunction); 00576 break; 00577 default: 00578 if((RXHeaderPayloadID % 2) == 1){ 00579 sendError(invalidFirmwarePayloadID); 00580 }else{ 00581 sendError(unrecognisedFirmwarePayloadID); 00582 } 00583 } 00584 } 00585 /* Switch reception back on now that we are done with the received data */ 00586 resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS); 00587 PORTK |= BIT0; 00588 }
Here is the call graph for this function:
void lookupBlockDetails | ( | unsigned short | locationID, | |
blockDetails * | details | |||
) |
Definition at line 594 of file commsCore.c.
References BIGTABLES_PPAGE, CHTTransferTable, CHTTransferTableLocationID, FixedConfig2LocationID, FixedConfigLocationID, fixedConfigs, fixedConfigs2, blockDetails::FlashAddress, blockDetails::FlashPage, IATTransferTable, IATTransferTableLocationID, IgnitionAdvanceTableMainFlash, IgnitionAdvanceTableMainFlash2, IgnitionAdvanceTableMainFlash2LocationID, IgnitionAdvanceTableMainFlashLocationID, IgnitionAdvanceTableSecondaryFlash, IgnitionAdvanceTableSecondaryFlash2, IgnitionAdvanceTableSecondaryFlash2LocationID, IgnitionAdvanceTableSecondaryFlashLocationID, InjectionAdvanceTableMainFlash, InjectionAdvanceTableMainFlash2, InjectionAdvanceTableMainFlash2LocationID, InjectionAdvanceTableMainFlashLocationID, InjectionAdvanceTableSecondaryFlash, InjectionAdvanceTableSecondaryFlash2, InjectionAdvanceTableSecondaryFlash2LocationID, InjectionAdvanceTableSecondaryFlashLocationID, LambdaTableFlash, LambdaTableFlash2, LambdaTableFlash2LocationID, LambdaTableFlashLocationID, MAFTransferTable, MAFTransferTableLocationID, MAINTABLE_SIZE, PPAGE, blockDetails::RAMAddress, blockDetails::RAMPage, RPAGE_FUEL_ONE, RPAGE_FUEL_TWO, RPAGE_TIME_ONE, RPAGE_TIME_TWO, RPAGE_TUNE_ONE, RPAGE_TUNE_TWO, blockDetails::size, SmallTablesAFlash, SmallTablesAFlash2, SmallTablesAFlash2LocationID, SmallTablesAFlashLocationID, SmallTablesBFlash, SmallTablesBFlash2, SmallTablesBFlash2LocationID, SmallTablesBFlashLocationID, SmallTablesCFlash, SmallTablesCFlash2, SmallTablesCFlash2LocationID, SmallTablesCFlashLocationID, SmallTablesDFlash, SmallTablesDFlash2, SmallTablesDFlash2LocationID, SmallTablesDFlashLocationID, TransferTableSize, VETableMainFlash, VETableMainFlash2, VETableMainFlash2LocationID, VETableMainFlashLocationID, VETableSecondaryFlash, VETableSecondaryFlash2, VETableSecondaryFlash2LocationID, VETableSecondaryFlashLocationID, VETableTertiaryFlash, VETableTertiaryFlash2, VETableTertiaryFlash2LocationID, and VETableTertiaryFlashLocationID.
Referenced by decodePacketAndBuildResponse().
00594 { 00595 /* Initialise the four values needed for operations on memory at 0 for error checking */ 00596 details->RAMPage = 0; 00597 details->FlashPage = 0; 00598 details->RAMAddress = 0; 00599 details->FlashAddress = 0; 00600 00601 /* Initialise the block size to 1024 to save code space and increase readability */ 00602 details->size = MAINTABLE_SIZE; 00603 00604 /* Look up the locations and set non default sizes */ 00605 switch (locationID) { 00606 case FixedConfigLocationID: 00607 details->FlashPage = PPAGE; 00608 details->FlashAddress = (void*)&fixedConfigs; 00609 break; 00610 case FixedConfig2LocationID: 00611 details->FlashPage = PPAGE; 00612 details->FlashAddress = (void*)&fixedConfigs2; 00613 break; 00614 case IATTransferTableLocationID: 00615 details->size = TransferTableSize; 00616 details->FlashPage = PPAGE; 00617 details->FlashAddress = (void*)&IATTransferTable; 00618 break; 00619 case CHTTransferTableLocationID: 00620 details->size = TransferTableSize; 00621 details->FlashPage = PPAGE; 00622 details->FlashAddress = (void*)&CHTTransferTable; 00623 break; 00624 case MAFTransferTableLocationID: 00625 details->size = TransferTableSize; 00626 details->FlashPage = PPAGE; 00627 details->FlashAddress = (void*)&MAFTransferTable; 00628 break; 00629 case VETableMainFlashLocationID: 00630 details->RAMPage = RPAGE_FUEL_ONE; 00631 details->FlashPage = BIGTABLES_PPAGE; 00632 details->RAMAddress = (void*)&TablesA; 00633 details->FlashAddress = (void*)&VETableMainFlash; 00634 break; 00635 case VETableMainFlash2LocationID: 00636 details->RAMPage = RPAGE_FUEL_TWO; 00637 details->FlashPage = BIGTABLES_PPAGE; 00638 details->RAMAddress = (void*)&TablesA; 00639 details->FlashAddress = (void*)&VETableMainFlash2; 00640 break; 00641 case VETableSecondaryFlashLocationID: 00642 details->RAMPage = RPAGE_FUEL_ONE; 00643 details->FlashPage = BIGTABLES_PPAGE; 00644 details->RAMAddress = (void*)&TablesB; 00645 details->FlashAddress = (void*)&VETableSecondaryFlash; 00646 break; 00647 case VETableSecondaryFlash2LocationID: 00648 details->RAMPage = RPAGE_FUEL_TWO; 00649 details->FlashPage = BIGTABLES_PPAGE; 00650 details->RAMAddress = (void*)&TablesB; 00651 details->FlashAddress = (void*)&VETableSecondaryFlash2; 00652 break; 00653 case VETableTertiaryFlashLocationID: 00654 details->RAMPage = RPAGE_FUEL_ONE; 00655 details->FlashPage = BIGTABLES_PPAGE; 00656 details->RAMAddress = (void*)&TablesC; 00657 details->FlashAddress = (void*)&VETableTertiaryFlash; 00658 break; 00659 case VETableTertiaryFlash2LocationID: 00660 details->RAMPage = RPAGE_FUEL_TWO; 00661 details->FlashPage = BIGTABLES_PPAGE; 00662 details->RAMAddress = (void*)&TablesC; 00663 details->FlashAddress = (void*)&VETableTertiaryFlash2; 00664 break; 00665 case LambdaTableFlashLocationID: 00666 details->RAMPage = RPAGE_FUEL_ONE; 00667 details->FlashPage = BIGTABLES_PPAGE; 00668 details->RAMAddress = (void*)&TablesD; 00669 details->FlashAddress = (void*)&LambdaTableFlash; 00670 break; 00671 case LambdaTableFlash2LocationID: 00672 details->RAMPage = RPAGE_FUEL_TWO; 00673 details->FlashPage = BIGTABLES_PPAGE; 00674 details->RAMAddress = (void*)&TablesD; 00675 details->FlashAddress = (void*)&LambdaTableFlash2; 00676 break; 00677 case IgnitionAdvanceTableMainFlashLocationID: 00678 details->RAMPage = RPAGE_TIME_ONE; 00679 details->FlashPage = BIGTABLES_PPAGE; 00680 details->RAMAddress = (void*)&TablesA; 00681 details->FlashAddress = (void*)&IgnitionAdvanceTableMainFlash; 00682 break; 00683 case IgnitionAdvanceTableMainFlash2LocationID: 00684 details->RAMPage = RPAGE_TIME_TWO; 00685 details->FlashPage = BIGTABLES_PPAGE; 00686 details->RAMAddress = (void*)&TablesA; 00687 details->FlashAddress = (void*)&IgnitionAdvanceTableMainFlash2; 00688 break; 00689 case IgnitionAdvanceTableSecondaryFlashLocationID: 00690 details->RAMPage = RPAGE_TIME_ONE; 00691 details->FlashPage = BIGTABLES_PPAGE; 00692 details->RAMAddress = (void*)&TablesB; 00693 details->FlashAddress = (void*)&IgnitionAdvanceTableSecondaryFlash; 00694 break; 00695 case IgnitionAdvanceTableSecondaryFlash2LocationID: 00696 details->RAMPage = RPAGE_TIME_TWO; 00697 details->FlashPage = BIGTABLES_PPAGE; 00698 details->RAMAddress = (void*)&TablesB; 00699 details->FlashAddress = (void*)&IgnitionAdvanceTableSecondaryFlash2; 00700 break; 00701 case InjectionAdvanceTableMainFlashLocationID: 00702 details->RAMPage = RPAGE_TIME_ONE; 00703 details->FlashPage = BIGTABLES_PPAGE; 00704 details->RAMAddress = (void*)&TablesC; 00705 details->FlashAddress = (void*)&InjectionAdvanceTableMainFlash; 00706 break; 00707 case InjectionAdvanceTableMainFlash2LocationID: 00708 details->RAMPage = RPAGE_TIME_TWO; 00709 details->FlashPage = BIGTABLES_PPAGE; 00710 details->RAMAddress = (void*)&TablesC; 00711 details->FlashAddress = (void*)&InjectionAdvanceTableMainFlash2; 00712 break; 00713 case InjectionAdvanceTableSecondaryFlashLocationID: 00714 details->RAMPage = RPAGE_TIME_ONE; 00715 details->FlashPage = BIGTABLES_PPAGE; 00716 details->RAMAddress = (void*)&TablesD; 00717 details->FlashAddress = (void*)&InjectionAdvanceTableSecondaryFlash; 00718 break; 00719 case InjectionAdvanceTableSecondaryFlash2LocationID: 00720 details->RAMPage = RPAGE_TIME_TWO; 00721 details->FlashPage = BIGTABLES_PPAGE; 00722 details->RAMAddress = (void*)&TablesD; 00723 details->FlashAddress = (void*)&InjectionAdvanceTableSecondaryFlash2; 00724 break; 00725 case SmallTablesAFlashLocationID: 00726 details->RAMPage = RPAGE_TUNE_ONE; 00727 details->FlashPage = PPAGE; 00728 details->RAMAddress = (void*)&TablesA; 00729 details->FlashAddress = (void*)&SmallTablesAFlash; 00730 break; 00731 case SmallTablesAFlash2LocationID: 00732 details->RAMPage = RPAGE_TUNE_TWO; 00733 details->FlashPage = PPAGE; 00734 details->RAMAddress = (void*)&TablesA; 00735 details->FlashAddress = (void*)&SmallTablesAFlash2; 00736 break; 00737 case SmallTablesBFlashLocationID: 00738 details->RAMPage = RPAGE_TUNE_ONE; 00739 details->FlashPage = PPAGE; 00740 details->RAMAddress = (void*)&TablesB; 00741 details->FlashAddress = (void*)&SmallTablesBFlash; 00742 break; 00743 case SmallTablesBFlash2LocationID: 00744 details->RAMPage = RPAGE_TUNE_TWO; 00745 details->FlashPage = PPAGE; 00746 details->RAMAddress = (void*)&TablesB; 00747 details->FlashAddress = (void*)&SmallTablesBFlash2; 00748 break; 00749 case SmallTablesCFlashLocationID: 00750 details->RAMPage = RPAGE_TUNE_ONE; 00751 details->FlashPage = PPAGE; 00752 details->RAMAddress = (void*)&TablesC; 00753 details->FlashAddress = (void*)&SmallTablesCFlash; 00754 break; 00755 case SmallTablesCFlash2LocationID: 00756 details->RAMPage = RPAGE_TUNE_TWO; 00757 details->FlashPage = PPAGE; 00758 details->RAMAddress = (void*)&TablesC; 00759 details->FlashAddress = (void*)&SmallTablesCFlash2; 00760 break; 00761 case SmallTablesDFlashLocationID: 00762 details->RAMPage = RPAGE_TUNE_ONE; 00763 details->FlashPage = PPAGE; 00764 details->RAMAddress = (void*)&TablesD; 00765 details->FlashAddress = (void*)&SmallTablesDFlash; 00766 break; 00767 case SmallTablesDFlash2LocationID: 00768 details->RAMPage = RPAGE_TUNE_TWO; 00769 details->FlashPage = PPAGE; 00770 details->RAMAddress = (void*)&TablesD; 00771 details->FlashAddress = (void*)&SmallTablesDFlash2; 00772 break; 00773 } 00774 }
void sendDebug | ( | unsigned char * | ) |
Definition at line 814 of file commsCore.c.
References asyncDebugInfoPacket, checksumAndSend(), stringCopy(), and TXBufferCurrentPositionHandler.
Referenced by decodePacketAndBuildResponse().
00814 { 00815 // if(TRUE){ 00816 // Counters.serialDebugUnsentCounter++; 00817 // return; 00818 // } 00819 // wrong : 00820 /* No need for atomic block here as one of two conditions will always be */ 00821 /* true when calling this. Either we have been flagged to receive and */ 00822 /* decode a packet, or we are in an ISR. In either case it is safe to */ 00823 /* check the flags and initiate the sequence if they are clear. */ 00824 //if(RXTXSerialStateFlags & TX_IN_PROGRESS){ 00825 // wrong : 00826 /* It's OK to return without resetting as it will be done by */ 00827 /* either of those processes if they are underway. The other */ 00828 /* processes are not overridden because they have priority. */ 00829 //TXBufferInUseFlags = 0; 00830 //return; 00831 // }else{ /* Turn off reception */ 00832 /* It's OK to turn this off if nothing was currently being received */ 00833 // SCI0CR2 &= SCICR2_RX_ISR_DISABLE; 00834 // SCI0CR2 &= SCICR2_RX_DISABLE; 00835 00836 /* Build up the packet */ 00837 /* Set the pointer to the start and init the length */ 00838 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer; 00839 00840 /* Load a protocol with length header into the TX buffer ready for masking */ 00841 *TXBufferCurrentPositionHandler = 0x11; 00842 TXBufferCurrentPositionHandler++; 00843 00844 /* Set the payload ID */ 00845 *((unsigned short*)TXBufferCurrentPositionHandler) = asyncDebugInfoPacket; 00846 TXBufferCurrentPositionHandler += 2; 00847 00848 /* Store the length location */ 00849 unsigned short* TXLength = (unsigned short*)TXBufferCurrentPositionHandler; 00850 TXBufferCurrentPositionHandler += 2; 00851 00852 /* Copy the string into place and record the length copied */ 00853 unsigned short messageLength = stringCopy(TXBufferCurrentPositionHandler, message); 00854 *TXLength = messageLength; 00855 TXBufferCurrentPositionHandler += messageLength; 00856 00857 checksumAndSend(); 00858 //} 00859 }
Here is the call graph for this function:
void sendError | ( | unsigned | short | ) |
Definition at line 778 of file commsCore.c.
References asyncErrorCodePacket, checksumAndSend(), and TXBufferCurrentPositionHandler.
Referenced by decodePacketAndBuildResponse().
00778 { 00779 // TXBufferInUseFlags = 0; 00780 /* No need for atomic block here as one of two conditions will always be */ 00781 /* true when calling this. Either we have been flagged to receive and */ 00782 /* decode a packet, or we are in an ISR. In either case it is safe to */ 00783 /* check the flags and initiate the sequence if they are clear. */ 00784 // if(RXTXSerialStateFlags & TX_IN_PROGRESS){ 00785 /* It's OK to return without resetting as it will be done by */ 00786 /* either of those processes if they are underway. The other */ 00787 /* processes are not overridden because they have priority. */ 00788 // return; 00789 // }else{ /* Turn off reception */ 00790 /* It's OK to turn this off if nothing was currently being received */ 00791 // SCI0CR2 &= SCICR2_RX_ISR_DISABLE; 00792 // SCI0CR2 &= SCICR2_RX_DISABLE; 00793 00794 /* Build up the packet */ 00795 /* Set the pointer to the start */ 00796 TXBufferCurrentPositionHandler = (unsigned char*)&TXBuffer; 00797 /* Set the length */ 00798 // TXPacketLengthToSend = 5; /* Flags + Payload ID + Error Code */ 00799 /* Flags = protocol with no extra fields */ 00800 *TXBufferCurrentPositionHandler = 0x01; 00801 TXBufferCurrentPositionHandler++; 00802 /* Set the payload ID */ 00803 *((unsigned short*)TXBufferCurrentPositionHandler) = asyncErrorCodePacket; 00804 TXBufferCurrentPositionHandler += 2; 00805 /* Set the error code */ 00806 *((unsigned short*)TXBufferCurrentPositionHandler) = errorCode; 00807 TXBufferCurrentPositionHandler += 2; 00808 checksumAndSend(); 00809 // } 00810 }
Here is the call graph for this function: