#define ABS(x) (((x) > 0)?(x):(-(x))) #define MAX(x, y) (((x) > (y))?(x):(y)) #define MIN(x, y) (((x) < (y))?(x):(y)) #define CONVERT_BCD_TO_DEC(n) (((((n) >> 4) & 0x0F) * 10) + ((n) & 0x0F)) #define CONVERT_DEC_TO_BCD(n) (((n) > 99) ? 255 : (((((n) / 10) << 4) & 0xF0) | (((n) % 10) & 0x0F))) // set, delete and check bitpositions/-patterns #define SETBIT(AllBits, BITPOS) ((AllBits) |= (1 << (BITPOS))) #define CLEARBIT(AllBits, BITPOS) ((AllBits) &= ~(1 << (BITPOS))) #define CHECKBIT(AllBits, BITPOS) ((AllBits) & (1 << (BITPOS))) #define GETBIT(AllBits, BITPOS) (((AllBits) >> (BITPOS)) & 0x1) #define SETPAT(AllBits, BITPAT) ((AllBits) |= (BITPAT)) #define CLEARPAT(AllBits, BITPAT) ((AllBits) &= ~(BITPAT)) #define CHECKPAT(AllBits, BITPAT) ((AllBits) & (BITPAT)) #define COMPAREBIT(AllBits1, AllBits2, BITPOS) ((((AllBits1)^(AllBits2)) >> BITPOS) & 0x1) // 1 if bits are equal #define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
Acquiring images from the camera basically consists of the following steps:
This can be illustrated by a simple example which takes one image in single shot mode.
#include <iostream> #include <stdio.h> #include "OCamera.h" /* include the camera API header */ using namespace std; void SaveImageToFile(unsigned char *buf, int len, char * filename) { FILE *f = fopen(filename,"w+"); if (f) { fwrite(buf,1,len,f); fclose(f); } } int main(int argc, char *argv[]) { /* open the camera interface for the image sensor MT9V403 */ OCamera *pCamera = OCamera::CreateCameraInterface(OCamera::CAM_TYPE_MT9V403); if (pCamera) { /* * adjust camera settings: window, exposure time, trigger, gain */ pCamera->Open(640*480*4); /* specify frame buffer size = four images */ pCamera->SetCameraWindow(0,0,640,480); /* use full VGA window */ pCamera->SetShutterTime(2000); /* 2000us exposure time */ pCamera->SetIlluminationMode(OCamera::ILL_MODE_OFF); /* no illumination */ pCamera->SetTriggerSource(OCamera::TRIG_SRC_SOFTWARE); /* trigger by software */ pCamera->SetGain(5); /* set camera ADC gain */ pCamera->SetReadTimeout(2000000); /* do not wait longer than 2s for an image */ /* * start image acquisition in single shot mode */ pCamera->SetAcquisitionMode(OCamera::ACQ_MODE_SINGLE_SHOT); /* * get an image via the driver internal image buffer space */ OCameraImage img; /* image containter */ int ret = pCamera->GetImage(&img); /* trigger camera and read an image to container */ if (ret == 0) { /* do desired work with the image... here: save it to a file */ SaveImageToFile(img.pData,640*480,"img1.raw"); /* inform the driver that this buffer can be used again */ pCamera->ReleaseImage(&img); } else { cout << "GetImage returned error code: " << ret << endl; } pCamera->SetAcquisitionMode(OCamera::ACQ_MODE_STOP); pCamera->Close(); pCamera->Destroy(); } return 0; }
Simple example showing
file access to the FRAM.
ATTENTION: The WHOLE FRAM will be overwritten inside this example!!
#include <unistd.h> // usleep #include <stdio.h> // printf, fopen #include <stdlib.h> // EXIT_FAILURE // lowlevel file access #include <fcntl.h> // open, read write #include <sys/types.h> #include <sys/stat.h> int main(void) { // now camera is accessable printf("\nHello!\n\n"); // you can check the contents of the FRAM with "cat /dev/fram0" via telnet session int i; char cReadChar; long lPosition; int iNoBytes; char puffer[] = "opqrs"; char CharField[3000]; for(i = 0; i < 3000; i++) { if (i < 2000) { if (0 == i % 10) CharField[i] = '*'; else CharField[i] = '.'; } else { if (0 == i % 10) CharField[i] = '='; else CharField[i] = ':'; } } //--------------------------------------------------------------------------- // highlevel access //--------------------------------------------------------------------------- FILE *pFile; int iWrittenChar; // attaching FRAM to write to pFile = fopen("/dev/fram0", "w"); // a+, a, w+, r+ are also possible but // read/write position ALWAYS starts at FRAM[0] if (pFile == NULL) { printf("Error opening FRAM\n"); goto Error_Start; } // fill whole FRAM with characters // writing to indizes > 2047 BLOCKS application immedeately and for infinite!! for(i = 0; i < 2048; i++) { iWrittenChar = fputc(CharField[i], pFile); } fclose(pFile); pFile = fopen("/dev/fram0", "r+"); iNoBytes = fprintf(pFile, "1234567890"); // starts at FRAM[0] // another write operation starts one byte after the last write operation // but you CANNOT ask for the actual position of the write pointer (s.a. lseek down below) lPosition = fseek(pFile, 0L, SEEK_CUR); // actual position request returns ALWAYS 0!! => DON'T use it printf("Actual write position after 1. write operation: \n \ \tReturnvalues fseek() == %d <> fprintf() = %d\n", lPosition, iNoBytes); iNoBytes = fprintf(pFile, "abcdefghi"); // starts at FRAM[10] // begin writing at predefined index (offset from actual position) fseek(pFile, 5L, SEEK_CUR); iNoBytes = fwrite(puffer, 1, sizeof(puffer), pFile); // starts at FRAM[24] // begin writing at predefined index (offset starting at FRAM[0]) fseek(pFile, 3L, SEEK_END); iNoBytes = fprintf(pFile, "wwww"); // starts at FRAM[3]!!! fseek(pFile, 14L, SEEK_SET); for(i = 0; i < 4; i++) fputc('u', pFile); // starts at FRAM[14] // read 7 bytes starting at FRAM[13] fseek(pFile, 13L, SEEK_SET); for(i = 0; i < 7; i++) { cReadChar = fgetc(pFile); printf("%c = %d = %#lx\n", cReadChar, cReadChar, cReadChar); } fclose(pFile); fseek(pFile, 13L, SEEK_SET); fscanf(pFile,"%c",&cReadChar); printf("%c = %d = %#lx\n", cReadChar, cReadChar, cReadChar); printf("\nNow waiting for lowlevel FRAM access for 5 Seconds ... "); fflush(stdout); usleep(5000000); printf("Starting\n\n"); //--------------------------------------------------------------------------- // lowlevel access (PREFERABLE) //--------------------------------------------------------------------------- int iFileHandle; char Character; if (-1 == (iFileHandle = open("/dev/fram0", O_RDWR))) { printf("Error opening FRAM\n"); goto Error_Start; } // fill into FRAM predefined values iNoBytes = write(iFileHandle, &CharField[0], 60*sizeof(char)); printf("%d Bytes written starting at FRAM[0]\n", iNoBytes); // actual position of filepointer in FRAM lPosition = lseek(iFileHandle, 0L, SEEK_CUR); printf("Actual Position of rw-pointer is at %d\n",lPosition); Character = '>'; lPosition = lseek(iFileHandle, 29, SEEK_SET); // you can also use SEEK_END instead iNoBytes = write(iFileHandle, &Character, sizeof(Character)); // starts at FRAM[29] printf("%d Bytes written starting at FRAM[%d]\n", iNoBytes, lPosition); // read 4 bytes starting at FRAM[28] lPosition = lseek(iFileHandle, 28, SEEK_END); // you can also use SEEK_SET instead for(i = 0; i < 4; i++) { iNoBytes = read(iFileHandle, &cReadChar, sizeof(cReadChar)); printf("FRAM[%d]: %c = %d = %#lx\n", lPosition + i, cReadChar, cReadChar, cReadChar); } lPosition = lseek(iFileHandle, 0L, SEEK_CUR); printf("Actual Position of rw-pointer is at %d\n",lPosition); // at FRAM[32] close(iFileHandle); Error_Start: printf("\nGoodbye!\n\n"); return(EXIT_SUCCESS); }
Implemented are three different input wait strategies:
#include "OCamera.h" #include <sys/time.h> // struct timeval, gettimeofday() #include <unistd.h> // usleep #include <stdio.h> #include <stdlib.h> // EXIT_FAILURE OCameraInputs *pIn; int main(void) { pIn = OCameraInputs::poCreateInterface(); if(pIn < 0) { printf("Error creation Inputs interface\n"); goto Error_Input; } if(pIn->iOpen() < 0) { printf("Error opening Inputs\n"); goto Error_InOpen; } // now all interfaces are successfully attached and opened printf("\nHello!\n\n"); ////////////////////////////////////////////////////////////////////////////////////// // now enter code for personal use ////////////////////////////////////////////////////////////////////////////////////// int InValue; struct timeval StartTime, EndTime; InValue = pIn->iGetInputs(); printf("Actual Input-State %#x\n", InValue); printf("\tInputs 1 0 = %s %s\n", (InValue & OCameraInputs::INPUT_I1) ? "ON" : "OFF", \ (InValue & OCameraInputs::INPUT_I0) ? "ON" : "OFF"); int iRetVal; //--------------------------------------------------------------------------- // Wait infinite pIn->iSetTimeout(-1); do { printf("Waiting infinite until Input 0 changes from 0 -> 1\n"); gettimeofday(&StartTime,0); // clear sticky edge detection bits iRetVal = pIn->iClearEdges((OCameraInputs::INPUT_I0_RE | OCameraInputs::INPUT_I0_FE | OCameraInputs::INPUT_I1_RE | OCameraInputs::INPUT_I1_FE)); // stop program execution until input zero changes to 1 iRetVal = pIn->iWaitForInput(OCameraInputs::INPUT_I0_RE, 1); gettimeofday(&EndTime,0); InValue = pIn->iGetInputs(); printf("Returncode = %d\tTime elapsed: %dsec %dusec\n", iRetVal, \ (EndTime.tv_sec - StartTime.tv_sec), (EndTime.tv_usec - StartTime.tv_usec)); printf("Actual Input-State %#x\n", pIn->iGetInputs()); printf("\tInputs 1 0 == %s %s\n", (InValue & OCameraInputs::INPUT_I1) ? "ON" : "OFF", \ (InValue & OCameraInputs::INPUT_I0) ? "ON" : "OFF"); printf("Exit if Inputs 1 0 == ON ON\n"); } while ((InValue & OCameraInputs::INPUT_ALL) != OCameraInputs::INPUT_ALL); printf("\nRelease Inputs!!\n\n"); usleep(3000000); //--------------------------------------------------------------------------- // Wait with timeout pIn->iSetTimeout(3000); // no more infinite waiting!! do { printf("Wait until Input 0 and 1 equal each 1 OR 3000ms elapsed\n"); gettimeofday(&StartTime,0); // stop program execution until // - input zero changes to 1 OR // - input one changes to 1 OR // - 3000 milliseconds elapsed iRetVal = pIn->iWaitForInputs(OCameraInputs::INPUT_ALL, 3); gettimeofday(&EndTime,0); InValue = pIn->iGetInputs(); printf("Returncode == %d\tInValue == %d\n",iRetVal,InValue); if (iRetVal < 0) { // timeout or error occurred printf("\tTimeout: Time elapsed: %ldusec\n", (EndTime.tv_sec - StartTime.tv_sec)*1000 + (EndTime.tv_usec - StartTime.tv_usec)); } else { printf("\tInput: Time elapsed: %dlusec\n", (EndTime.tv_sec - StartTime.tv_sec)*1000 + (EndTime.tv_usec - StartTime.tv_usec)); printf("\t\tInputs 1 0 == %s %s\n", (pIn->iGetInput(OCameraInputs::INPUT_I1)) ? "ON" : "OFF", \ (pIn->iGetInput(OCameraInputs::INPUT_I0)) ? "ON" : "OFF"); } printf("Exit if Inputs 1 0 == ON ON [%#x]\n", InValue); } while ((InValue & OCameraInputs::INPUT_ALL) != OCameraInputs::INPUT_ALL); printf("\nRelease Inputs!!\n\n"); usleep(3000000); //--------------------------------------------------------------------------- // Wait infinite for input changes pIn->iSetTimeout(-1); // set timeout value to wait infinite do { printf("Wait until Input 0 OR 1 changes\n"); gettimeofday(&StartTime,0); // stop program execution until // - input zero changes OR // - input one changes iRetVal = pIn->iWaitForInputsChange(OCameraInputs::INPUT_I0 | OCameraInputs::INPUT_I1); gettimeofday(&EndTime,0); InValue = pIn->iGetInputs(); printf("Returncode = %d\tTime elapsed: %dsec %dusec\n", iRetVal, \ (EndTime.tv_sec - StartTime.tv_sec), (EndTime.tv_usec - StartTime.tv_usec)); printf("Actual Input-State %#x\n", pIn->iGetInputs()); printf("\tInputs 1 0 = %s %s\n", (InValue & OCameraInputs::INPUT_I1) ? "ON" : "OFF", \ (InValue & OCameraInputs::INPUT_I0) ? "ON" : "OFF"); printf("Exit if Inputs 1 0 == ON ON\n"); } while ((InValue & OCameraInputs::INPUT_ALL) != OCameraInputs::INPUT_ALL); ////////////////////////////////////////////////////////////////////////////////////// //--------------------------------------------------------------------------- // Cleanup //--------------------------------------------------------------------------- // defined cleanup of all interfaces pIn->iClose(); Error_InOpen: pIn->Destroy(); Error_Input: printf("\nGoodbye!\n\n"); return(EXIT_SUCCESS); }
This application opens the interface to the three digital outputs and manipulates their state.
#include "OCamera.h" #include <unistd.h> // usleep #include <stdio.h> #include <stdlib.h> // EXIT_FAILURE OCameraOutputs *pOut; int main(void) { pOut = OCameraOutputs::poCreateInterface(); if(!pOut) { printf("Error creation Outputs interface\n"); goto Error_Output; } if(pOut->iOpen() < 0) { printf("Error opening Outputs\n"); goto Error_OutOpen; } // now all interfaces are successfully attached and opened printf("\nHello!\n\n"); ////////////////////////////////////////////////////////////////////////////////////// // now enter code for personal use ////////////////////////////////////////////////////////////////////////////////////// int OutValue; OutValue = pOut->iGetOutputs(); printf("Actual Output-State %#x (2 1 0)\n", OutValue); printf("\tOutputs 2 1 0 = %s %s %s\n", (OutValue & OCameraOutputs::OUTPUT_O2) ? "ON" : "OFF", \ (OutValue & OCameraOutputs::OUTPUT_O1) ? "ON" : "OFF", \ (OutValue & OCameraOutputs::OUTPUT_O0) ? "ON" : "OFF"); pOut->iSetOutput(OCameraOutputs::OUTPUT_O0, 1); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_O1, 1); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_O2, 1); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_O0, 0); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_O1, 0); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_O2, 0); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_ALL, 1); usleep(300000); pOut->iSetOutput(OCameraOutputs::OUTPUT_ALL, 0); usleep(300000); // activate ONLY outputs zero and two even if a iState of 0x7 is chosen!! pOut->iSetOutputs(OCameraOutputs::OUTPUT_O0 | OCameraOutputs::OUTPUT_O2, 0x7); printf("Actual Output-State %#x\n", pOut->iGetOutputs()); printf("\tOutput 1 = %s\n", (pOut->iGetOutput(OCameraOutputs::OUTPUT_O1)) ? "ON" : "OFF"); usleep(1000000); // toggle some outputs pOut->iToggleOutputs(OCameraOutputs::OUTPUT_O1 | OCameraOutputs::OUTPUT_O2); printf("Actual Output-State %#x\n", pOut->iGetOutputs()); usleep(800000); pOut->iToggleOutput(OCameraOutputs::OUTPUT_O0); printf("Actual Output-State %#x\n", pOut->iGetOutputs()); usleep(800000); ////////////////////////////////////////////////////////////////////////////////////// //--------------------------------------------------------------------------- // Cleanup //--------------------------------------------------------------------------- // defined cleanup of all interfaces pOut->iClose(); Error_OutOpen: pOut->Destroy(); Error_Output: printf("\nGoodbye!\n\n"); return(EXIT_SUCCESS); }
This simple application opens the interface to the leds and toggles them.
#include "OCamera.h" void main(void) { OCameraLEDs LED; LED.iToggleLEDs(LED_ALL_GREEN); // toogle all green leds on the camera }
This demo-application opens the interface to the led-handler and demonstrates the usage of manipulating the led-states (color).
#include "OCamera.h" #include <unistd.h> // usleep #include <stdio.h> #include <stdlib.h> // EXIT_FAILURE OCameraLEDs *pLED; int main(void) { pLED = OCameraLEDs::poCreateInterface(); if(!pLED) { printf("Error creation LEDs interface\n"); goto Error_LED; } if(pLED->iOpen() < 0) { printf("Error opening LEDs\n"); goto Error_LEDOpen; } // now all interfaces are successfully attached and opened printf("\nHello!\n\n"); ////////////////////////////////////////////////////////////////////////////////////// // now enter code for personal use ////////////////////////////////////////////////////////////////////////////////////// int LEDValue; LEDValue = pLED->iGetLEDs(); printf("Actual LED-State %#x (D C B A)\n", LEDValue); printf("\tLED A green red = %s %s\n", (LEDValue & OCameraLEDs::LED_0_GREEN) ? "ON" : "OFF", \ (LEDValue & OCameraLEDs::LED_0_RED) ? "ON" : "OFF"); printf("\tLED B green red = %s %s\n", (LEDValue & OCameraLEDs::LED_1_GREEN) ? "ON" : "OFF", \ (LEDValue & OCameraLEDs::LED_1_RED) ? "ON" : "OFF"); printf("\tLED C yellow red = %s %s\n", (LEDValue & OCameraLEDs::LED_2_YELLOW) ? "ON" : "OFF", \ (LEDValue & OCameraLEDs::LED_2_RED) ? "ON" : "OFF"); printf("\tLED D yellow red = %s %s\n", (LEDValue & OCameraLEDs::LED_3_YELLOW) ? "ON" : "OFF", \ (LEDValue & OCameraLEDs::LED_3_RED) ? "ON" : "OFF"); pLED->iSetLED(OCameraLEDs::LED_ALL, 1); usleep(500000); pLED->iSetLED(OCameraLEDs::LED_ALL, 0); usleep(300000); pLED->iSetLED(OCameraLEDs::LED_0_GREEN, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_0_RED, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_1_GREEN, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_1_RED, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_2_YELLOW, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_2_RED, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_3_YELLOW, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_3_RED, 1); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_0_GREEN, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_0_RED, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_1_GREEN, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_1_RED, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_2_YELLOW, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_2_RED, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_3_YELLOW, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_3_RED, 0); usleep(200000); pLED->iSetLED(OCameraLEDs::LED_ALL_RED, 1); usleep(500000); pLED->iSetLED(OCameraLEDs::LED_ALL_RED, 0); usleep(300000); pLED->iSetLED(OCameraLEDs::LED_ALL_GREEN, 1); usleep(500000); pLED->iSetLED(OCameraLEDs::LED_ALL_GREEN, 0); usleep(300000); pLED->iSetLED(OCameraLEDs::LED_ALL_YELLOW, 1); usleep(500000); pLED->iSetLED(OCameraLEDs::LED_ALL_YELLOW, 0); usleep(300000); // activate ONLY LEDs C and D and two even if a iState of 0xFF is chosen!! pLED->iSetLEDs(OCameraLEDs::LED_2_YELLOW | OCameraLEDs::LED_2_RED | \ OCameraLEDs::LED_3_YELLOW | OCameraLEDs::LED_3_RED, 0xFF); printf("Actual LED-State %#x\n", pLED->iGetLEDs()); printf("\tLED C yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_2_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_2_RED)) ? "ON" : "OFF"); printf("\tLED D yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_3_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_3_RED)) ? "ON" : "OFF"); usleep(500000); // toggle some outputs pLED->iToggleLEDs(OCameraLEDs::LED_2_YELLOW | OCameraLEDs::LED_3_RED); printf("Actual LED-State %#x\n", pLED->iGetLEDs()); printf("\tLED C yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_2_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_2_RED)) ? "ON" : "OFF"); printf("\tLED D yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_3_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_3_RED)) ? "ON" : "OFF"); usleep(500000); pLED->iToggleLED(OCameraLEDs::LED_3_YELLOW); printf("Actual LED-State %#x\n", pLED->iGetLEDs()); printf("\tLED C yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_2_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_2_RED)) ? "ON" : "OFF"); printf("\tLED D yellow red = %s %s\n", (pLED->iGetLED(OCameraLEDs::LED_3_YELLOW)) ? "ON" : "OFF", \ (pLED->iGetLED(OCameraLEDs::LED_3_RED)) ? "ON" : "OFF"); usleep(500000); ////////////////////////////////////////////////////////////////////////////////////// //--------------------------------------------------------------------------- // Cleanup //--------------------------------------------------------------------------- // defined cleanup of all interfaces pLED->iClose(); Error_LEDOpen: pLED->Destroy(); Error_LED: printf("\nGoodbye!\n\n"); return(EXIT_SUCCESS); }
This program displays messages of the CAN bus.
-b <baudrate>
or input tracing with -i
)can_fd = open(device, O_RDWR);
CAN_LISTEN_MODE
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> /* exit */ #include <sys/ioctl.h> /* ioctl */ #include <signal.h> #include "can.h" /* from the camera's /include directory */ static int can_fd; static int in_fd; static int bInputsIsOn = 0; /* test for inputs */ void main_cleanup (int signal) { int ret; /* added for stability reasons * => change to the device's initial startup mode */ ret = ioctl(can_fd, CAN_IOC_MODE, CAN_CONFIG_MODE); if (ret < 0) perror("ioctl reset to normal mode"); ioctl(can_fd, CAN_IOC_RESET, 0); // added to avoid rx buffer full messages in dmesg close(can_fd); if(bInputsIsOn) { close(in_fd); } exit(0); } int read_inputs(void) { char buf[64]; int val = 0; if (in_fd > 0) { lseek(in_fd,0,SEEK_SET); int len = read(in_fd,buf,sizeof(buf)); if (len != 0) sscanf(buf,"0x%x",&val); } return (val & 0x3); } void print_msg(struct msg_t *msg) { int i; printf("%04ld:%06ld ", msg->rx_time/1000000, msg->rx_time%1000000); if(bInputsIsOn) { printf("I=%d ID 0x%03x ", read_inputs(),msg->ident); }else { printf("ID 0x%03x ", msg->ident); } if (msg->bits & 0x01) printf("EID 0x%05x ", msg->eident); if (msg->bits & 0x02) printf("RTR\n"); else { printf("["); for (i = 0; i < msg->data_length; i++) if (i == 0) printf("0x%02x",msg->data[i]); else printf(" 0x%02x",msg->data[i]); printf("]\n"); } } void print_usage(void) { printf("\ncanalyser for festo cameras\n\n"); printf("arguments: -b <baudrate>\n"); printf(" -i (for additional input tracing)\n\n"); } int main(int argc, char *argv[]) { char device[] = "/dev/can0"; struct msg_t msg; int i,ret; struct mcp2515_filter_t filter; int baudrate = 1000000; /* * check for -h or --help */ for (i=1; i<argc; i++) { if ((strcmp(argv[i],"-?") == 0) || (strcmp(argv[i],"-h") == 0) || (strcmp(argv[i],"--help") == 0)) { print_usage(); return 0; } } /* * check for baudrate argument */ for (i=1; i<argc; i++) { if (strcmp(argv[i],"-b") == 0) { if (i+1 < argc) { baudrate = atoi(argv[i+1]); } } } /* * check for input argument */ for (i=1; i<argc; i++) { if (strcmp(argv[i],"-i") == 0) { bInputsIsOn = 1; /* * open input driver */ in_fd = open("/proc/inputs", O_RDONLY); if (in_fd < 0) { perror("Can't open input device"); exit(-1); } } } /* * open the CAN driver */ can_fd = open(device, O_RDWR); if (can_fd < 0) { perror("Can't open device file "); exit(-2); } /* * set listen only mode */ ret = ioctl(can_fd, CAN_IOC_MODE, CAN_LISTEN_MODE); if (ret < 0) perror("ioctl set listen only mode"); /* * set baud rate */ ret = ioctl(can_fd, CAN_IOC_BAUDRATE, baudrate); if (ret < 0) perror("ioctl baudrate - "); /* * set receive filter to receive all messages */ filter.rollover = 0x0; filter.filter_mode[0] = 0x3; /* no filter, receive all */ filter.filter_mode[1] = 0x3; /* no filter, receive all */ filter.mask_sid[0] = 0x700; filter.mask_sid[1] = 0x700; filter.mask_eid[0] = 0x3FF00; filter.mask_eid[1] = 0x3FF00; for (i=0; i<6; i++) { filter.filter_frame[i] = 0x1; filter.filter_sid[i] = 0x600; filter.filter_eid[i] = 0x20100 | (i & 0xF); } ret = ioctl(can_fd, CAN_IOC_FILTER, &filter); if (ret < 0) perror("ioctl filter"); /* * signal handling for Ctrl-C */ (void) signal (SIGINT, main_cleanup); // Ctrl-C (void) signal (SIGTERM, main_cleanup); // terminate /* * receive CAN messages and send them back! */ printf("starting CAN message reception (%d), stop with Ctrl-C \n", baudrate); while(1) { ret = read(can_fd, &msg, sizeof(msg)); if (ret == sizeof(msg)) { print_msg(&msg); } } return 0; }
This is an example, that
#------------------------------------------------------------------------------ # system dependent part of the makefile (Linux with gcc-3.4) #------------------------------------------------------------------------------ # #------------------------------------------------------------------------------ # Copyright (c) 2007 MVTec Software GmbH, http://www.mvtec.com # # To adapt: # - The variable HALCONROOT_CROSS # - The variable CROSSROOT # # HALCONROOT_CROSS: includes and libraries to cross compile # HALCON applications for the Festo SBO series # CROSSROOT: cross environment for the Festo SBO series #------------------------------------------------------------------------------- .EXPORT_ALL_VARIABLES: ifneq ($(HALCONROOT_CROSS),) ifneq ($(HALCONROOT),) $(warning Information: Using HALCONROOT_CROSS instead of HALCONROOT) endif HALCONROOT = $(HALCONROOT_CROSS) endif ifeq ($(HALCONROOT),) $(error The environment variable HALCONROOT must be set!) endif CROSSROOT = /opt/sbo/gcc332 #------------------------------------------------------------------------------ # Machine dependent part of the makefile #------------------------------------------------------------------------------ # # CAMERAROOT = $(CROSSROOT)/arm-linux PATH := $(CROSSROOT)/bin:$(PATH) X11ROOT = $(CAMERAROOT)/lib # Compiler CC = arm-linux-gcc CCFLAGS = -DLINUX -DFAST \ -Wall -Wno-strict-aliasing \ -pipe -fPIC \ -Os -fomit-frame-pointer -msoft-float CPP = arm-linux-g++ CPPFLAGS = $(CCFLAGS) # Linker SHLIB_LINKER = arm-linux-gcc SHLIB_EXTENSION = so STD_LIBS = -lpthread -lm -lc H_INCLUDE = $(HALCONROOT)/include HCPP_INCLUDE = $(HALCONROOT)/include/cpp HDEV_INCLUDE = $(HALCONROOT)/include/hdevengine H_LIB = $(HALCONROOT)/lib/$(HALCONARCH) CAM_INCLUDE = $(CAMERAROOT)/usr/include CAM_LIBS = -L$(CAMERAROOT)/lib -lcamera X11_LIBS = -L$(X11ROOT) -lXext -lX11
#---------------------------------------------------------------------------- # USAGE: make [PROG=<filename>] # #---------------------------------------------------------------------------- # Copyright (c) 2007 MVTec Software GmbH, http://www.mvtec.com # #------------------------------------------------------------------------------- .EXPORT_ALL_VARIABLES: HALCONARCH = arm-festo-linux2.6 include ../../make.$(HALCONARCH) PROG = example3 all: $(PROG) $(PROG): $(PROG).o $(CPP) -o $(PROG) $(PROG).o $(STD_LIBS) \ -L$(H_LIB) -lhalcon -lhalconcpp $(X11_LIBS) $(PROG).o: $(PROG).cpp $(CPP) $(CPPFLAGS) -I$(H_INCLUDE) -I$(HCPP_INCLUDE) \ -c -o $(PROG).o $(PROG).cpp .PHONY: clean mostlyclean mostlyclean: -rm -f *.o Cache.log clean: mostlyclean -rm -f $(PROG)
/***************************************************************************** * example3.cpp ***************************************************************************** * * Project: HALCON/C++ for Festo SBO series * Description: Example program for HALCON/C++ for Festo SBO series * * (c) 2007 by MVTec Software GmbH * www.mvtec.com ***************************************************************************** * - open framegrabber * - grab images * - display live images * - program ends by mouse click ***************************************************************************** */ #include "HalconCpp.h" #include "HIOStream.h" #if !defined(USE_IOSTREAM_H) using namespace std; #endif int main(int argc, char *argv[]) { using namespace Halcon; int Button; HDPoint2D Point; cout << "--------------------------------------------------" << endl; cout << "Example program for HALCON/C++ for Festo SBO series:" << endl; cout << "--------------------------------------------------" << endl; cout << "- open framegrabber" << endl; cout << "- grab images" << endl; cout << "- display live images" << endl; cout << "- program ends by mouse click" << endl << endl; close_all_framegrabbers(); HFramegrabber Framegrabber("festo",1,1,640,480); /* open the framegrabber */ HImage Image = Framegrabber.GrabImageAsync(-1); /* grab first image */ HWindow Window; if (Image.Width() > 1000) /* open window for display*/ Window.SetWindowExtents(0,0,Image.Width()/2,Image.Height()/2); else Window.SetWindowExtents(0,0,Image.Width(),Image.Height()); Window.SetPart(0,0,Image.Height()-1,Image.Width()-1); Image.Display(Window); cout << "To quit program: Click with right button into graphics window ..." << endl; Button = 0; while (Button != 4) { Image = Framegrabber.GrabImageAsync(-1); Image.Display(Window); Point = Window.GetMposition(&Button); switch (Button) { case 1: printf("-> Left button pressed!\n"); break; case 2: printf("-> Middle button pressed!\n"); break; case 4: printf("-> Right button pressed!\n"); break; } } cout << "The End." << endl; return(0); }
This example shows how a laser profile is acquired from the camera. Basically this is done by the following steps:
/***************************************************************************** * laser_demo.cpp ***************************************************************************** * * Description: Program demonstrating FPGA-based laser-profile aquisition * ****************************************************************************/ #include <stdio.h> #include "OCamera.h" /*----------------------------------------------------------------------------- * main() *----------------------------------------------------------------------------- */ int main(int argc, char *argv[]) { OCamera *pCamera; OCameraImage img; /* image containter */ bool acquisitionError; unsigned short *pProf; /* pointer to laser profile */ float value; /* single profile value */ pCamera = OCamera::CreateCameraInterface(OCamera::CAM_TYPE_MT9V403); if (pCamera) { /* basic camera setup */ int width = 640; int height = 480; int x0 = 0; int y0 = 0; pCamera->Open(width*height*2); pCamera->SetCameraWindow(x0,y0,width,height); pCamera->SetFrequency(OCamera::FREQU_40MHz); pCamera->SetShutterTime(2000); pCamera->SetGain(5); pCamera->SetIlluminationMode(OCamera::ILL_MODE_OFF); pCamera->SetTriggerSource(OCamera::TRIG_SRC_SOFTWARE); pCamera->SetTriggerDelay(0); pCamera->SetReadTimeout(2000000); pCamera->SetAcquisitionMode(OCamera::ACQ_MODE_SINGLE_SHOT); /* take single shots */ /* laser profiling setup */ int tmin = 100; /* threshold min */ int tmax = 255; /* threshold max */ int amin = 500; /* area min */ int amax = 5000; /* area max */ OCamera::ePointPriority prio = OCamera::PRIO_FIRST_POINT; /* line priority */ OCamera::eProfileDirection dir = OCamera::DIRECTION_TOP_DOWN; /* profile direction */ pCamera->SetupLaserProfiling(true,x0,y0,width,height,prio,dir,tmin,tmax,amin,amax); /* trigger camera and transfer a laser profile */ int ret = pCamera->GetImage(&img); if (ret < 0) acquisitionError = true; else { acquisitionError = false; /* processing the profile data of the acquired image. */ pProf = (unsigned short *)img.pData; for (int i=0;i<width;i++) { /* the 16 bit output value has a fractional part of four bits, therefore we divide by 16 to get the resulting column-value */ value = (float)(pProf[i])/16; /* in this example we print all column-values to stdout */ fprintf(stdout,"value %d:\t %.4f\n",i,value); } pCamera->ReleaseImage(&img); } /* close camera interface */ pCamera->SetAcquisitionMode(OCamera::ACQ_MODE_STOP); pCamera->Close(); pCamera->Destroy(); } return 0; }