int main(int argc, char *argv[]) { int flag; int error; char type[16]; int device_count = 0; int i; //////////////////////////////////////////////////////////////////////////// // parse & validate arguments //////////////////////////////////////////////////////////////////////////// parseArgs(argc, argv); if (dtg.year == 0) { printf("ERROR: invalid dtg provided\n"); usage(); } printf("sampleNum is: %i\n", sampleNum); if (sampleNum==0){ printf("Setting up the header file for the csv\n"); }else if (sampleNum >= 1){ printf("performing normal sampling\n"); }else { printf("ERROR: incorrect scanNum option provided\n"); usage(); } //////////////////////////////////////////////////////////////////////////// for(i = 0; i < SEABREEZE_MAX_DEVICES; i++) { printf("\nOpening spectrometer %d.\n", i); flag = seabreeze_open_spectrometer(i, &error); printf("...Result is (%d) [%s]\n", flag, get_error_string(error)); if(0 == flag) { device_count++; } else { break; } } for(i = 0; i < device_count; i++) { printf("\nGetting device %d name.\n", i); seabreeze_get_model(i, &error, type, sizeof(type)); printf("...Result is (%s) [%s]\n", type, get_error_string(error)); } printf("Number of devices found is: %d\n", device_count); for(i = 0; i < device_count; i++) { printf("\nSetting device %d integration time to 100ms.\n", i); seabreeze_set_integration_time_microsec(i, &error, 100000); //printf("...Result is [%s]\n", get_error_string(error)); } if (deviceIndex < device_count){ printf("\n\nBegin sampling using device: %d\n", deviceIndex); if (sampleNum == 0){ get_wavelengths(deviceIndex); }else if (sampleNum>=1){ get_spectrum(deviceIndex); } }else{ printf("deviceIndex provided in arguments is out of range of the number of devices found" ); usage(); } //get_raw_spectrum_test(i); //////////////////////////////////////////////////////////////////////////////// /////close the spectrometers /////////////////////////////////////////////////////////////////////////////// for(i = 0; i < device_count; i++) { printf("\nClosing spectrometer %d.\n", i); flag = seabreeze_close_spectrometer(i, &error); //printf("...Result is (%d) [%s]\n", flag, get_error_string(error)); } seabreeze_shutdown(); return 0; }
int main(int argc, char **argv) { int error = 0; parseArgs(argc, argv); if (gArgs.debug) seabreeze_set_verbose(1); sleep(1); //////////////////////////////////////////////////////////////////////////// // count connected devices //////////////////////////////////////////////////////////////////////////// for (int i = 0; i < SEABREEZE_MAX_DEVICES; i++) { if (!seabreeze_open_spectrometer(i, &error)) { connected_device_count++; } else { break; } } LOG_DEBUG(("%d devices found", connected_device_count)); if (!connected_device_count) { puts("ERROR: no spectrometers found"); exit(1); } //////////////////////////////////////////////////////////////////////////// // look for desired spectrometer //////////////////////////////////////////////////////////////////////////// int matching_device_count = 0; int matching_devices[MAX_DEVICES]; // iterate over connected devices, attempting to match on model & serial char thisType[MAX_LABEL_SIZE + 1]; char thisSerialNumber[MAX_LABEL_SIZE + 1]; memset(thisSerialNumber, 0, sizeof(thisSerialNumber)); // header if requested if (gArgs.list) { puts("## Type Serial Number"); puts("-- --------------- ---------------"); } for(int i = 0; i < connected_device_count; i++) { int potential_match = 1; // match on index if (gArgs.index >= 0) { if (i == gArgs.index) { LOG_DEBUG(("[%02d] matches desired index")); } else { LOG_DEBUG(("[%02d] does not match desired index")); potential_match = 0; } } // match on spectrometer type if (potential_match) { seabreeze_get_model(i, &error, thisType, sizeof(thisType)); if (!error) { if (gArgs.type) { if (!strcmp(thisType, gArgs.type)) { LOG_DEBUG(("[%02d] matches desired spectrometer type '%s'", i, thisType)); } else { LOG_DEBUG(("[%02d] does not match desired spectrometer type '%s' (%s)", i, gArgs.type, thisType)); potential_match = 0; } } else { LOG_DEBUG(("[%02d] has spectrometer type '%s' (no match criteria provided)", i, thisType)); } } else { printf("[%02d] Error getting type: %s\n", i, get_error_string(error)); potential_match = 0; } } // match on serial_number if (potential_match) { seabreeze_get_serial_number(i, &error, thisSerialNumber, sizeof(thisSerialNumber)); if (!error) { if (gArgs.serialNumber) { if (!strncmp(thisSerialNumber, gArgs.serialNumber, sizeof(thisSerialNumber))) { LOG_DEBUG(("[%02d] matches desired serial number '%s'", i, thisSerialNumber)); } else { LOG_DEBUG(("[%02d] does not match desired serial number '%s' (%s)", i, gArgs.serialNumber, thisSerialNumber)); potential_match = 0; } } else { LOG_DEBUG(("[%02d] has serial number '%s' (no match criteria provided)", i, thisSerialNumber)); } } else { printf("[%02d] Error getting serial number: %s\n", i, get_error_string(error)); potential_match = 0; } } // collect matching indices if (potential_match) { LOG_DEBUG(("[%02d] matched all search criteria", i)); matching_devices[matching_device_count++] = i; if (gArgs.list) { printf("%02d %-*s %-*s\n", i, MAX_LABEL_SIZE, thisType, MAX_LABEL_SIZE, thisSerialNumber); } } else { LOG_DEBUG(("[%02d] failed to match search criteria", i)); } } // give up if no matches if (!matching_device_count) { if (gArgs.list) puts("(no matching devices found)"); cleanUpAndClose(!gArgs.list); } // reject invalid unary command combinations if (matching_device_count != 1) { if (gArgs.serialNumberNew) { printf("Error: can only update serial number on exactly one spectrometer (%d matched)\n", matching_device_count); cleanUpAndClose(1); } } //////////////////////////////////////////////////////////////////////////// // Process matching devices //////////////////////////////////////////////////////////////////////////// // process each matching device for (int i = 0; i < matching_device_count; i++) { int index = matching_devices[i]; int error = 0; // get pixel count int pixels = seabreeze_get_formatted_spectrum_length(index, &error); LOG_DEBUG(("[%02d] has %d pixels", index, pixels)); // --list-eeprom if (gArgs.listEEPROMs) { printf("[%02d] EEPROM slots 0..%d:\n", index, gArgs.listEEPROMs - 1); for (int j = 0; j < gArgs.listEEPROMs; j++) { char* errorMessage = NULL; unsigned char buf[MAX_LABEL_SIZE + 1]; memset(buf, 0, sizeof(buf)); // read value (both raw and as double) seabreeze_read_eeprom_slot(index, &error, j, buf, sizeof(buf)); if (error) { errorMessage = (char*) get_error_string(error); } double d = atof((const char*) buf); // report printf("[%02d] %02d:", index, j); for (int k = 0; k < MAX_LABEL_SIZE; k++) printf(" %02x", buf[k]); printf(" %+le [", d); for (int k = 0; k < MAX_LABEL_SIZE; k++) printf("%c", buf[k] > 31 && buf[k] < 127 ? buf[k] : '.'); printf("]"); if (errorMessage) printf(" (returned error: %s)", errorMessage); printf("\n"); fflush(stdout); } } // --list-descriptors if (gArgs.listDescriptors) { printf("[%02d] USB Descriptors:\n", index); // Ocean Optics only uses descriptor strings 1 and 2, sometimes 3 for (int j = 1; j < 3; j++) { int bytesCopied = 0; char* errorMessage = NULL; unsigned char buf[80]; memset(buf, 0, sizeof(buf)); bytesCopied = seabreeze_get_usb_descriptor_string(index, &error, j, buf, sizeof(buf)); if (error) { errorMessage = (char*) get_error_string(error); } // report printf("[%02d] %02d:", index, j); if (errorMessage) { printf(" (returned error %s)", errorMessage); } else if (bytesCopied) { printf(" [%s]", (char*) buf); } printf("\n"); fflush(stdout); } } // --list-irrad if (gArgs.listIrrad) { float *irrad = (float*) malloc(pixels * sizeof(float)); int count = seabreeze_read_irrad_calibration(index, &error, irrad, pixels); fflush(stdout); if (!check_error(index, &error, "seabreeze_read_irrad_calibration")) { printf("[%02d] loaded %d irradiance calibration coefficients:\n", index, count); for (int j = 0; j < count; j++) { printf("[%02d] Coeff #%04d: %+le\n", index, j, irrad[j]); } } fflush(stdout); free(irrad); } // --list-edc-pixels if (gArgs.listEDCPixels) { #define MAX_INDICES 100 int indices[MAX_INDICES]; int count = seabreeze_get_electric_dark_pixel_indices(index, &error, indices, MAX_INDICES); fflush(stdout); if (!check_error(index, &error, "seabreeze_get_electric_dark_pixel_indices")) { printf("[%02d] found %d electrical dark pixel indices:\n", index, count); for (unsigned j = 0; j < count; j++) { printf("[%02d] EDC index #%04d: %d\n", index, j, indices[j]); } } } // --set-irrad if (gArgs.irradFilename) { FILE *infile = NULL; if ((infile = fopen(gArgs.irradFilename, "r")) != NULL) { float *irrad = (float*) malloc(pixels * sizeof(float)); int count = 0; while(count < pixels && !feof(infile)) { float f; int ok = fscanf(infile, "%f", &f); if (ok) { irrad[count++] = f; } } fclose(infile); printf("[%02d] read %d floats from %s\n", index, count, gArgs.irradFilename); if (count != pixels) printf("[%02d] WARNING: irradiance count %d != device pixel count %d\n", index, count, pixels); printf("[%02d] writing %d floats to spectrometer (may take awhile)\n", index, count); fflush(stdout); int ok = seabreeze_write_irrad_calibration(index, &error, irrad, count); if (ok && !check_error(index, &error, "seabreeze_read_irrad_calibration")) { printf("[%02d] wrote %d irradiance calibration coefficients to spectrometer\n", index, count); } free(irrad); } else { printf("Error: can't read %s\n", gArgs.irradFilename); } } // --set-serial-number if (gArgs.serialNumberNew) { printf("[%02d] updating serial_number => [%s]\n", index, gArgs.serialNumberNew); int len = strlen(gArgs.serialNumberNew); unsigned char *buffer = malloc(len + 1); strncpy((char*) buffer, gArgs.serialNumberNew, len + 1); seabreeze_write_eeprom_slot(index, &error, 0, buffer, len + 1); free(buffer); } // --set-eeprom-value if (gArgs.eepromValue) { unsigned char *buffer = (unsigned char*) malloc(MAX_LABEL_SIZE); printf("[%02d] setting eeprom slot %02d (0x%02x) ==> [%s] (bufferSize %d)\n", index, gArgs.eepromIndex, gArgs.eepromIndex, gArgs.eepromValue, MAX_LABEL_SIZE); renderHex(buffer, MAX_LABEL_SIZE, gArgs.eepromValue); for (int byteIndex = 0; byteIndex < MAX_LABEL_SIZE; byteIndex++) printf("[%02d] byte %02d: 0x%02x\n", index, byteIndex, buffer[byteIndex]); seabreeze_write_eeprom_slot(index, &error, gArgs.eepromIndex, buffer, MAX_LABEL_SIZE); free(buffer); } // other future commands here... } // cleanup cleanUpAndClose(0); }