55 >> (7 - (column & 7))) & 1);
59 int row,
int column,
int value)
61 int bitIndex;
int byteIndex;
70 bitIndex = (7 - (column & 7));
73 pointer->
pixels[byteIndex] =
74 (((~(1<<bitIndex))&(pointer->
pixels[byteIndex]))|((value?1:0)<<bitIndex));
85 if((destination == NULL) || (source0 == NULL) || (source1 == NULL))
92 destination->
pixels[index] =
105 if((destination == NULL) || (source0 == NULL) || (source1 == NULL))
112 destination->
pixels[index] =
125 if((destination == NULL) || (source0 == NULL) || (source1 == NULL))
132 destination->
pixels[index] =
143 if(destination == NULL)
150 destination->
pixels[index] =
151 (~destination->
pixels[index]);
167 return (attributes->
readOnly ==
'R');
180 return (attributes->
hidden ==
'H');
193 return (attributes->
system ==
'S');
206 return (attributes->
volumeID ==
'V');
232 return (attributes->
archive ==
'A');
241 int errorValue;
int retVal0;
int retVal1;
static int resetTries;
243 resetTries = CMUCAM4_RESET_TRIES;
244 errorValue = setjmp(_env);
246 if(resetTries-- <= 0)
254 _state = DEACTIVATED;
255 _setReadTimeout(CMUCAM4_RESET_TIMEOUT);
258 _com.
begin(CMUCOM4_FAST_BAUD_RATE);
259 _com.
write((uint8_t)
'\0');
260 _com.
write((uint8_t)
'\0');
261 _com.
write((uint8_t)
'\0');
262 _com.
write(
"\rRS\r");
265 _com.
begin(CMUCOM4_MEDIUM_BAUD_RATE);
266 _com.
write((uint8_t)
'\0');
267 _com.
write((uint8_t)
'\0');
268 _com.
write((uint8_t)
'\0');
269 _com.
write(
"\rRS\r");
272 _com.
begin(CMUCOM4_SLOW_BAUD_RATE);
273 _com.
write((uint8_t)
'\0');
274 _com.
write((uint8_t)
'\0');
275 _com.
write((uint8_t)
'\0');
276 _com.
write(
"\rRS\r");
280 _waitForString(
"\rCMUcam4 v");
283 if(sscanf(_resBuffer,
"%1d.%2d ", &retVal0, &retVal1) != 2)
288 _version = ((_CMUcam4_version) ((retVal0 * 100) + retVal1));
292 case VERSION_100:
break;
293 case VERSION_101:
break;
294 case VERSION_102:
break;
295 case VERSION_103:
break;
304 _setReadTimeout(CMUCAM4_NON_FS_TIMEOUT);
310 case VERSION_101: _com.
write(CMUCOM4_MEDIUM_BR_STRING);
break;
312 case VERSION_103: _com.
write(CMUCOM4_FAST_BR_STRING);
break;
315 _com.
write((uint8_t)
'\r');
322 case VERSION_101: _com.
begin(CMUCOM4_MEDIUM_BAUD_RATE);
break;
324 case VERSION_103: _com.
begin(CMUCOM4_FAST_BAUD_RATE);
break;
327 _com.
write((uint8_t)
'\r');
333 _setReadTimeout(CMUCAM4_NON_FS_TIMEOUT);
339 case VERSION_101: _com.
write(CMUCOM4_MEDIUM_SB_STRING);
break;
341 case VERSION_103: _com.
write(CMUCOM4_FAST_SB_STRING);
break;
344 _com.
write((uint8_t)
'\r');
354 if(_state == DEACTIVATED)
359 _state = DEACTIVATED;
379 return _commandWrapper(
"SD\r", CMUCAM4_NON_FS_TIMEOUT);
384 return _commandWrapper(
"SL\r", CMUCAM4_NON_FS_TIMEOUT);
393 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
394 "CB %d\r", brightness) < CMUCAM4_CMD_BUFFER_SIZE)
395 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
401 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
402 "CC %d\r", contrast) < CMUCAM4_CMD_BUFFER_SIZE)
403 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
409 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
410 "CR %d\r", reg) < CMUCAM4_CMD_BUFFER_SIZE)
411 ? _intCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
417 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
418 "CW %d %d %d\r", reg, value, mask) < CMUCAM4_CMD_BUFFER_SIZE)
419 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
429 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
430 "AG %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
431 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
437 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
438 "AW %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
439 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
449 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
450 "HM %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
451 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
457 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
458 "VF %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
459 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
469 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
470 "BW %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
471 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
477 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
478 "NG %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
479 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
489 return _intCommandWrapper(
"GB\r", CMUCAM4_NON_FS_TIMEOUT);
494 int errorValue;
int resultValue;
long returnValue;
496 if(errorValue = _commandWrapper(
"GD\r", CMUCAM4_NON_FS_TIMEOUT))
501 if(errorValue = setjmp(_env))
507 resultValue = (sscanf(_resBuffer,
"%ld ", &returnValue) == 1);
515 return _intCommandWrapper(
"GP\r", CMUCAM4_NON_FS_TIMEOUT);
520 return _intCommandWrapper(
"GR\r", CMUCAM4_NON_FS_TIMEOUT);
525 return _intCommandWrapper(
"PI\r", CMUCAM4_NON_FS_TIMEOUT);
530 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
531 "PO %d %d\r", direction, output) < CMUCAM4_CMD_BUFFER_SIZE)
532 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
538 return _intCommandWrapper(
"TI\r", CMUCAM4_NON_FS_TIMEOUT);
543 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
544 "TO %d %d\r", direction, output) < CMUCAM4_CMD_BUFFER_SIZE)
545 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
551 return _intCommandWrapper(
"GI\r", CMUCAM4_NON_FS_TIMEOUT);
556 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
557 "SO %d %d\r", directions, outputs) < CMUCAM4_CMD_BUFFER_SIZE)
558 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
564 return _voidCommandWrapper(
"L0\r", CMUCAM4_NON_FS_TIMEOUT);
569 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
570 "L1 %ld\r", frequency) < CMUCAM4_CMD_BUFFER_SIZE)
571 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
581 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
582 "GS %d\r", servo) < CMUCAM4_CMD_BUFFER_SIZE)
583 ? _intCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
589 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
590 "SS %d %d %d\r", servo, active, pulseLength) < CMUCAM4_CMD_BUFFER_SIZE)
591 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
597 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
598 "AP %d %d\r", active, reverse) < CMUCAM4_CMD_BUFFER_SIZE)
599 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
605 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
606 "AT %d %d\r", active, reverse) < CMUCAM4_CMD_BUFFER_SIZE)
607 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
613 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
614 "PP %d %d\r", proportionalGain, derivativeGain) < CMUCAM4_CMD_BUFFER_SIZE)
615 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
621 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
622 "TP %d %d\r", proportionalGain, derivativeGain) < CMUCAM4_CMD_BUFFER_SIZE)
623 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
633 return _voidCommandWrapper(
"M0\r", CMUCAM4_NON_FS_TIMEOUT);
638 return _voidCommandWrapper(
"M1\r", CMUCAM4_NON_FS_TIMEOUT);
643 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
644 "MF %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
645 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
651 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
652 "MS %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
653 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
663 int errorValue;
int resultValue;
670 if(errorValue = _commandWrapper(
"GT\r", CMUCAM4_NON_FS_TIMEOUT))
675 if(errorValue = setjmp(_env))
681 resultValue = (sscanf(_resBuffer,
"%d %d %d %d %d %d ",
695 int errorValue;
int resultValue;
702 if(errorValue = _commandWrapper(
"GW\r", CMUCAM4_NON_FS_TIMEOUT))
707 if(errorValue = setjmp(_env))
713 resultValue = (sscanf(_resBuffer,
"%d %d %d %d ",
725 return _voidCommandWrapper(
"ST\r", CMUCAM4_NON_FS_TIMEOUT);
729 int greenMin,
int greenMax,
730 int blueMin,
int blueMax)
732 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
733 "ST %d %d %d %d %d %d\r",
734 redMin, redMax, greenMin, greenMax, blueMin, blueMax)
735 < CMUCAM4_CMD_BUFFER_SIZE)
736 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
742 return _voidCommandWrapper(
"SW\r", CMUCAM4_NON_FS_TIMEOUT);
746 int bottomRightX,
int bottomRightY)
748 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
750 topLeftX, topLeftY, bottomRightX, bottomRightY)
751 < CMUCAM4_CMD_BUFFER_SIZE)
752 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
758 int errorValue;
static int resetTries;
char cmdBuffer[CMUCAM4_IC_LENGTH];
760 if(_state == DEACTIVATED)
765 if(snprintf(cmdBuffer, CMUCAM4_IC_LENGTH,
766 CMUCAM4_IC_STRING, (_version / 100), (_version % 100))
767 >= CMUCAM4_IC_LENGTH)
772 resetTries = CMUCAM4_IDLE_TRIES;
773 errorValue = setjmp(_env);
775 if(resetTries-- <= 0)
780 _setReadTimeout(CMUCAM4_IDLE_TIMEOUT);
781 _com.
write((uint8_t)
'\0');
782 _com.
write((uint8_t)
'\0');
783 _com.
write((uint8_t)
'\0');
784 _com.
write(
"\rGV\r");
785 _waitForString(cmdBuffer);
792 return _commandWrapper(
"TC\r", CMUCAM4_NON_FS_TIMEOUT);
796 int greenMin,
int greenMax,
797 int blueMin,
int blueMax)
799 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
800 "TC %d %d %d %d %d %d\r",
801 redMin, redMax, greenMin, greenMax, blueMin, blueMax)
802 < CMUCAM4_CMD_BUFFER_SIZE)
803 ? _commandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
809 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
810 "TW %d %d %d\r", redRange, greenRange, blueRange)
811 < CMUCAM4_CMD_BUFFER_SIZE)
812 ? _commandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
818 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
819 "GH %d %d\r", channel, bins)
820 < CMUCAM4_CMD_BUFFER_SIZE)
821 ? _commandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
827 return _commandWrapper(
"GM\r", CMUCAM4_NON_FS_TIMEOUT);
839 if(errorValue = _responceWrapper(
'F'))
844 if(strcmp(_resBuffer,
"F ") != 0)
849 if(errorValue = setjmp(_env))
856 return (_readWithTimeout() ==
'\r')
862 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
869 if(errorValue = _responceWrapper(
'H'))
876 if((*buffer) ==
'\0')
881 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
884 if((*buffer) !=
'\0')
894 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
901 if(errorValue = _responceWrapper(
'H'))
908 if((*buffer) ==
'\0')
913 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
916 if((*buffer) !=
'\0')
926 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
933 if(errorValue = _responceWrapper(
'H'))
940 if((*buffer) ==
'\0')
945 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
948 if((*buffer) !=
'\0')
958 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
965 if(errorValue = _responceWrapper(
'H'))
972 if((*buffer) ==
'\0')
977 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
980 if((*buffer) !=
'\0')
990 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
997 if(errorValue = _responceWrapper(
'H'))
1004 if((*buffer) ==
'\0')
1009 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
1012 if((*buffer) !=
'\0')
1022 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
1029 if(errorValue = _responceWrapper(
'H'))
1036 if((*buffer) ==
'\0')
1041 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
1044 if((*buffer) !=
'\0')
1054 int errorValue;
char * buffer = (_resBuffer +
sizeof(
'H'));
size_t counter;
1061 if(errorValue = _responceWrapper(
'H'))
1068 if((*buffer) ==
'\0')
1073 pointer->
bins[counter] = ((uint8_t) strtol(buffer, &buffer, 10));
1076 if((*buffer) !=
'\0')
1093 if(errorValue = _responceWrapper(
'S'))
1098 return (sscanf(_resBuffer,
1099 "S %d %d %d %d %d %d %d %d %d %d %d %d ",
1111 &(pointer->
BStDev)) == 12)
1124 if(errorValue = _responceWrapper(
'T'))
1129 return (sscanf(_resBuffer,
1130 "T %d %d %d %d %d %d %d %d ",
1144 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1145 "PM %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1146 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1152 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1153 "LM %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1154 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1160 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1161 "SM %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1162 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1168 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1169 "TM %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1170 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1176 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1177 "CT %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1178 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1184 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1185 "HT %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1186 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1192 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1193 "IF %d\r", active) < CMUCAM4_CMD_BUFFER_SIZE)
1194 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1200 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1201 "NF %d\r", threshold) < CMUCAM4_CMD_BUFFER_SIZE)
1202 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT)
1211 const char * attributes)
1213 if((fileOrDirectoryPathName == NULL) || (attributes == NULL))
1218 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1219 "CA \"%s\" \"%s\"\r", fileOrDirectoryPathName, attributes)
1220 < CMUCAM4_CMD_BUFFER_SIZE)
1221 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1227 if(directoryPathAndName == NULL)
1232 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1233 "CD \"%s\"\r", directoryPathAndName)
1234 < CMUCAM4_CMD_BUFFER_SIZE)
1235 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1241 int errorValue;
int resultValue;
1248 if(errorValue = _commandWrapper(
"DI\r", CMUCAM4_FS_TIMEOUT))
1253 if(errorValue = setjmp(_env))
1262 resultValue = (sscanf(_resBuffer,
1263 "\"%" CMUCAM4_VL_LENGTH_STR
"c\" "
1264 "\"%" CMUCAM4_FST_LENGTH_STR
"c\" "
1265 "%lxh %lxh %lu %lu %lu %lu ",
1281 int errorValue;
int resultValue;
1288 if(errorValue = _commandWrapper(
"DS\r", CMUCAM4_FS_TIMEOUT))
1293 if(errorValue = setjmp(_env))
1300 resultValue = (sscanf(_resBuffer,
1311 return _voidCommandWrapper(
"FM\r", CMUCAM4_FS_TIMEOUT);
1315 size_t size,
unsigned long offset)
1317 int errorValue;
unsigned long directorySize;
1319 if(errorValue = _commandWrapper(
"LS\r", CMUCAM4_FS_TIMEOUT))
1324 if(errorValue = setjmp(_env))
1329 for(directorySize = 0; 1; directorySize++)
1333 if((*_resBuffer) ==
':')
1338 if((pointer != NULL) && (offset <= directorySize) &&
1339 ((directorySize - offset) < ((
unsigned long) size)))
1341 memset(pointer[directorySize - offset].name,
1343 memset(pointer[directorySize - offset].attributes,
1346 if(sscanf(_resBuffer,
1347 " \"%" CMUCAM4_NAME_LENGTH_STR
"c\" "
1348 "%" CMUCAM4_ATTR_LENGTH_STR
"c ",
1349 pointer[directorySize - offset].name,
1350 pointer[directorySize - offset].attributes) != 2)
1355 pointer[directorySize - offset].
size = 0;
1357 if(strchr(pointer[directorySize - offset].attributes,
'D') == NULL)
1359 if(sscanf(_resBuffer,
1360 " \"%*" CMUCAM4_NAME_LENGTH_STR
"c\" "
1361 "%*" CMUCAM4_ATTR_LENGTH_STR
"c "
1363 &(pointer[directorySize - offset].size)) != 1)
1371 return (
long) directorySize;
1376 if(directoryPathAndName == NULL)
1381 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1382 "MK \"%s\"\r", directoryPathAndName)
1383 < CMUCAM4_CMD_BUFFER_SIZE)
1384 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1389 const char * newEntryPathAndName)
1391 if((oldEntryPathAndName == NULL) || (newEntryPathAndName == NULL))
1396 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1397 "MV \"%s\" \"%s\"\r", oldEntryPathAndName, newEntryPathAndName)
1398 < CMUCAM4_CMD_BUFFER_SIZE)
1399 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1405 if((filePathAndName == NULL) || (textToAppend == NULL))
1410 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1411 "PL \"%s\" \"%s\"\r", filePathAndName, textToAppend)
1412 < CMUCAM4_CMD_BUFFER_SIZE)
1413 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1418 size_t size,
unsigned long offset)
1420 int errorValue;
unsigned long fileSize;
1422 if(filePathAndName == NULL)
1427 if(snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1428 "PR \"%s\"\r", filePathAndName) >= CMUCAM4_CMD_BUFFER_SIZE)
1433 if(errorValue = _commandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT))
1438 if(errorValue = setjmp(_env))
1445 if(sscanf(_resBuffer,
"%lu ", &fileSize) != 1)
1450 _readBinary(buffer, size, fileSize, offset);
1453 return (
long) fileSize;
1458 if(fileOrDirectoryPathAndName == NULL)
1463 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1464 "RM \"%s\"\r", fileOrDirectoryPathAndName)
1465 < CMUCAM4_CMD_BUFFER_SIZE)
1466 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1472 return _voidCommandWrapper(
"UM\r", CMUCAM4_FS_TIMEOUT);
1481 return _voidCommandWrapper(
"DB\r", CMUCAM4_FS_TIMEOUT);
1486 return (snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1487 "DF %d %d\r", horizontalResolution, verticalResolution)
1488 < CMUCAM4_CMD_BUFFER_SIZE)
1489 ? _voidCommandWrapper(_cmdBuffer, CMUCAM4_FS_TIMEOUT)
1502 if(errorValue = _commandWrapper(
"SB\r", CMUCAM4_NON_FS_TIMEOUT))
1507 if(errorValue = setjmp(_env))
1514 if(_readWithTimeout() !=
'\r')
1525 size_t horizonalSize,
size_t horizontalOffset,
1526 size_t verticalSize,
size_t verticalOffset)
1528 int errorValue;
int serialBuffer0;
int serialBuffer1;
1529 size_t indexX;
size_t indexY;
size_t resolutionX;
size_t resolutionY;
1531 resolutionX = (CMUCAM4_FRAME_H_RES >> horizontalResolution);
1532 resolutionY = (CMUCAM4_FRAME_V_RES >> verticalResolution);
1534 if(snprintf(_cmdBuffer, CMUCAM4_CMD_BUFFER_SIZE,
1535 "SF %d %d\r", horizontalResolution, verticalResolution)
1536 >= CMUCAM4_CMD_BUFFER_SIZE)
1541 if(errorValue = _commandWrapper(_cmdBuffer, CMUCAM4_NON_FS_TIMEOUT))
1546 if(errorValue = setjmp(_env))
1551 for(indexX = 0; indexX < resolutionX; indexX++)
1553 _setReadTimeout(CMUCAM4_NON_FS_TIMEOUT);
1557 if((*_resBuffer) ==
':')
1567 if(strcmp(_resBuffer,
"DAT:") != 0)
1577 if(strcmp(_resBuffer,
"DAT: ") != 0)
1585 for(indexY = 0; indexY < resolutionY; indexY++)
1587 serialBuffer0 = _readWithTimeout();
1588 serialBuffer1 = _readWithTimeout();
1590 if((buffer != NULL) && (horizontalOffset <= indexX) &&
1591 ((indexX - horizontalOffset) < horizonalSize) &&
1592 (verticalOffset <= indexY) &&
1593 ((indexY - verticalOffset) < verticalSize))
1595 buffer[((indexY - verticalOffset) * horizonalSize)
1596 + (indexX - horizontalOffset)]
1597 = ((uint16_t) (serialBuffer0 | (serialBuffer1 << 8)));
1601 if(_readWithTimeout() !=
'\r')
1615 int CMUcam4::_voidCommandWrapper(
const char * command,
unsigned long timeout)
1619 if(errorValue = _commandWrapper(command, timeout))
1624 if(errorValue = setjmp(_env))
1633 int CMUcam4::_intCommandWrapper(
const char * command,
unsigned long timeout)
1635 int errorValue;
int resultValue;
int returnValue;
1637 if(errorValue = _commandWrapper(command, timeout))
1642 if(errorValue = setjmp(_env))
1648 resultValue = (sscanf(_resBuffer,
"%d ", &returnValue) == 1);
1654 int CMUcam4::_commandWrapper(
const char * command,
unsigned long timeout)
1663 if(errorValue = setjmp(_env))
1668 _setReadTimeout(timeout);
1669 _com.
write(command);
1675 int CMUcam4::_responceWrapper(
char responce)
1679 if(_state == DEACTIVATED)
1684 if(errorValue = setjmp(_env))
1689 _setReadTimeout(CMUCAM4_NON_FS_TIMEOUT);
1695 if((*_resBuffer) == responce)
1700 if((*_resBuffer) ==
':')
1705 if(strcmp(_resBuffer,
"F ") == 0)
1709 if(_readWithTimeout() !=
'\r')
1719 void CMUcam4::_waitForIdle()
1725 if(_startsWithString(
"MSG"))
1732 if((*_resBuffer) !=
':')
1741 void CMUcam4::_waitForResponce()
1745 if(strcmp(_resBuffer,
"NCK") == 0)
1749 if((*_resBuffer) ==
':')
1757 if(strcmp(_resBuffer,
"ACK") != 0)
1763 void CMUcam4::_receiveData()
1769 if(_startsWithString(
"MSG"))
1780 void CMUcam4::_handleError()
1782 int errorValue;
int sum;
size_t index;
size_t length;
1784 if(_startsWithString(
"ERR"))
1786 sum = 0; length = strlen(_resBuffer);
1788 for(index = 0; index < length; index++)
1790 sum += _resBuffer[index];
1795 case CMUCAM4_CAMERA_TIMEOUT_ERROR_SUM:
1798 case CMUCAM4_CAMERA_CONNECTION_ERROR_SUM:
1801 case CMUCAM4_DISK_IO_ERROR_SUM:
1804 case CMUCAM4_FILE_SYSTEM_CORRUPTED_SUM:
1807 case CMUCAM4_FILE_SYSTEM_UNSUPPORTED_SUM:
1810 case CMUCAM4_CARD_NOT_DETECTED_SUM:
1813 case CMUCAM4_DISK_MAY_BE_FULL_SUM:
1816 case CMUCAM4_DIRECTORY_FULL_SUM:
1819 case CMUCAM4_EXPECTED_AN_ENTRY_SUM:
1822 case CMUCAM4_EXPECTED_A_DIRECTORY_SUM:
1825 case CMUCAM4_ENTRY_NOT_ACCESSIBLE_SUM:
1828 case CMUCAM4_ENTRY_NOT_MODIFIABLE_SUM:
1831 case CMUCAM4_ENTRY_NOT_FOUND_SUM:
1835 case CMUCAM4_ENTRY_ALREADY_EXISTS_SUM:
1839 case (CMUCAM4_ENTRY_ALREADY_EXISTS_SUM -
's'):
1842 case CMUCAM4_DIRECTORY_LINK_MISSING_SUM:
1845 case CMUCAM4_DIRECTORY_NOT_EMPTY_SUM:
1848 case CMUCAM4_NOT_A_DIRECTORY_SUM:
1851 case CMUCAM4_NOT_A_FILE_SUM:
1860 if((*_resBuffer) ==
':')
1862 longjmp(_env, errorValue);
1869 void CMUcam4::_waitForString(
const char *
string)
1871 size_t index;
size_t length = strlen(
string);
1872 memset(_resBuffer,
'\0', CMUCAM4_RES_BUFFER_SIZE);
1876 for(index = 1; index < length; index++)
1878 _resBuffer[index - 1] = _resBuffer[index];
1881 _resBuffer[length - 1] = _readWithTimeout();
1883 while(strcmp(_resBuffer,
string) != 0);
1886 int CMUcam4::_startsWithString(
const char *
string)
1888 return (strncmp(_resBuffer,
string, strlen(
string)) == 0);
1891 void CMUcam4::_readBinary(uint8_t * buffer,
size_t size,
1892 unsigned long packetSize,
1893 unsigned long packetOffset)
1895 int serialBuffer;
unsigned long serialCounter;
1897 for(serialCounter = 0; serialCounter < packetSize; serialCounter++)
1899 serialBuffer = _readWithTimeout();
1901 if((buffer != NULL) && (packetOffset <= serialCounter) &&
1902 ((serialCounter - packetOffset) < ((
unsigned long) size)))
1904 buffer[serialCounter - packetOffset] = ((uint8_t) serialBuffer);
1909 void CMUcam4::_readText()
1911 int serialBuffer;
size_t serialCounter = 0;
1912 memset(_resBuffer,
'\0', CMUCAM4_RES_BUFFER_SIZE);
1916 serialBuffer = _readWithTimeout();
1918 if(serialBuffer ==
'\r')
1923 _resBuffer[serialCounter++] = serialBuffer;
1925 if(serialCounter >= CMUCAM4_RES_BUFFER_SIZE)
1930 switch(serialCounter)
1934 if((*_resBuffer) ==
':')
1941 case (
sizeof(
"F ") - 1):
1943 if(strcmp(_resBuffer,
"F ") == 0)
1950 case (
sizeof(
"DAT:") - 1):
1952 if(_state == ACTIVATED)
1959 if(strcmp(_resBuffer,
"DAT:") == 0)
1975 case (
sizeof(
"DAT: ") - 1):
1977 if(_state == ACTIVATED)
1989 if(strcmp(_resBuffer,
"DAT: ") == 0)
2005 void CMUcam4::_setReadTimeout(
unsigned long timeout)
2011 int CMUcam4::_readWithTimeout()