int main(void) { SDL_Event e = {0}; bool running = false; struct vector *data[TRAINING_SIZE]; int i = 0; /* Start SDL window */ wind.title = "Simple machine learning of colours"; wind.width = 600; wind.height = 600; if (display_init(&wind) == EXIT_FAILURE) return EXIT_FAILURE; if (train(data) == EXIT_FAILURE) return EXIT_FAILURE; running = true; show_off(data, TRAINING_SIZE); while (running) { SDL_WaitEvent(&e); switch (e.type) { case SDL_QUIT: fprintf(stderr, "quit\n"); running = false; break; case SDL_KEYDOWN: fprintf(stderr, "key down\n"); switch (e.key.keysym.sym) { case SDLK_ESCAPE: case SDLK_q: running = false; break; } show_off(data, TRAINING_SIZE); break; default: break; } } display_stop(&wind); for (i = 0; i < TRAINING_SIZE; i++) vector_destroy(data[i]); return 0; }
/***************************************************************************** Prototype : display_delete Description : delete display module Input : DisplayHanlde hDisplay Output : None Return Value : Calls : Called By : History : 1.Date : 2012/8/28 Author : Sun Modification : Created function *****************************************************************************/ Int32 display_delete(DisplayHanlde hDisplay) { if(!hDisplay) return E_INVAL; if(hDisplay->isStreamOn) display_stop(hDisplay); close(hDisplay->fdDisplay); display_buf_free(hDisplay); free(hDisplay); return E_NO; }
int main(int argc, char *argv[]) { key_t shmkey; int shmid, shmsize; int i, j, k, t = 0, c = 0; int pause = PAUSE, again = 1; int setupIndex = -1; int minSampleIndex = -1, minMessageIndex = -1; int maxSampleIndex = -1, maxMessageIndex = -1; int minSampleValue = INT_MAX, minMessageValue = INT_MAX; int maxSampleValue = INT_MIN, maxMessageValue = INT_MIN; int maxCountCleared = 0, countCleared = 0, countLoop = 0; int countInvalid = 0, countData = 0, countSetup = 0, countCancel = 0, countUnknown = 0; for (i=0; i<MAXNUMTRIGCHAN; i++) lastValue[i] = 0; /* make the shared memory key * if ((shmkey = ftok(ACQ_MSGQ_SHMPATH, ACQ_MSGQ_SHMPROJID)) == -1) { * perror("ftok"); * exit(1); * } */ /* use the pre-defined shared memory key */ shmkey = ACQ_MSGQ_SHMKEY; /* determine the size of the shared memory buffer */ shmsize = sizeof(ACQ_MessagePacketType) * ACQ_MSGQ_SIZE; /* connect to (and possibly create) the segment */ if ((shmid = shmget(shmkey, shmsize, PERMISSION | IPC_CREAT )) == -1) { perror("shmget"); exit(1); } /* attach to the segment to get a pointer to it */ packet = shmat(shmid, (void *)0, 0); if ((char *)packet == (char *)(-1)) { perror("shmat"); exit(1); } display_start(); display_print("initializing\n"); // clear_all_except_setup(); // clear_all(); display_refresh(); while (again) { clear(); setupIndex = -1; minSampleIndex = -1, minMessageIndex = -1; maxSampleIndex = -1, maxMessageIndex = -1; minSampleValue = INT_MAX, minMessageValue = INT_MAX; maxSampleValue = INT_MIN, maxMessageValue = INT_MIN; countInvalid = 0, countData = 0, countSetup = 0, countCancel = 0, countUnknown = 0; /******************************************************************************* * collect information about all packets in the buffer *******************************************************************************/ for (i=0; i<ACQ_MSGQ_SIZE; i++) { if (i<SHOWPACKET) print_packet(i); switch (packet[i].message_type) { case ACQ_MSGQ_SETUP_COLLECTION: if (countSetup>0) { /* multiple packets with a setup are not allowed, only keep the first */ display_print("clearing superfluous setup packet at %d (setup @ %d)\n", i, setupIndex); clear_packet(i); countCleared++; break; } countSetup++; setupIndex = i; /* update the specifications that relate to trigger maintenance */ numRealChan = packet[i].data[DATASIZE-TRIGSIZE*3-MAXNUMTRIGCHAN-2]; /* update the value */ numTrigChan = packet[i].data[DATASIZE-TRIGSIZE*3-MAXNUMTRIGCHAN-1]; /* update the value */ trigChan = packet[i].data+DATASIZE-TRIGSIZE*3-MAXNUMTRIGCHAN; /* update the pointer */ trigPointer = packet[i].data+DATASIZE-TRIGSIZE*3; /* update the pointer */ if (numRealChan<0) numRealChan = 0; if (numTrigChan<0) numTrigChan = 0; if (numTrigChan>MAXNUMTRIGCHAN) { display_print("cannot maintain more than %d trigger channels in real time\n", MAXNUMTRIGCHAN); numTrigChan = MAXNUMTRIGCHAN; } break; case ACQ_MSGQ_DATA: countData++; if (packet[i].sampleNumber<minSampleValue) { minSampleIndex = i; minSampleValue = packet[i].sampleNumber; } if (packet[i].sampleNumber>maxSampleValue) { maxSampleIndex = i; maxSampleValue = packet[i].sampleNumber; } if (packet[i].messageId<minMessageValue) { minMessageIndex = i; minMessageValue = packet[i].messageId; } if (packet[i].messageId>maxMessageValue) { maxMessageIndex = i; maxMessageValue = packet[i].messageId; } if ((packet[i].sampleNumber/ packet[i].numSamples)>lastPacket) { /* detect the flanks in the trigger channels */ lastPacket = packet[i].sampleNumber/ packet[i].numSamples; for (j=0; j<numTrigChan; j++) { if (trigChan[j]>-1 && trigChan[j]<numRealChan) for (k=0; k<packet[i].numSamples; k++) { int sample = k*numRealChan + trigChan[j]; /* detect changes in the value of the trigger channel */ if (packet[i].data[sample]!=lastValue[j]) { lastValue[j] = packet[i].data[sample]; if (lastValue[j]) { display_print("trigger detected\n"); /* only store it if it is an upgoing flank */ trigPointer[numTrigger+0] = trigChan[j]; /* channel number */ trigPointer[numTrigger+1] = packet[i].sampleNumber+k; /* sample number */ trigPointer[numTrigger+2] = lastValue[j]; /* sample value */ numTrigger = wrapnumtrigger(numTrigger+3); } } } } } break; case ACQ_MSGQ_CLOSE_CONNECTION: countCancel++; break; case ACQ_MSGQ_INVALID: countInvalid++; break; default: countUnknown++; clear_packet(i); countCleared++; break; } /* end switch */ } /* end for */ /******************************************************************************* * print information about all packets in the buffer *******************************************************************************/ display_print("\n"); display_print("buffer size = %d\n", ACQ_MSGQ_SIZE); display_print("shm size = %d\n", shmsize); display_print("shm key = %#x\n", shmkey); display_print("pause = %d\n", pause); if (setupIndex>=0) display_print("dataset = %s @ %d\n", (char *)packet[setupIndex].data, setupIndex); else display_print("dataset = <unknown>\n"); display_print("\n"); display_print("countSetup = %d\n", countSetup); display_print("countData = %d\n", countData); display_print("countCancel = %d\n", countCancel); display_print("countInvalid = %d\n", countInvalid); display_print("countUnknown = %d\n", countUnknown); display_print("countCleared = %d\n", countCleared); display_print("\n"); /* this might look like a weird location to reinitialize */ maxCountCleared = (countCleared>maxCountCleared ? countCleared : maxCountCleared); countCleared = 0; display_print("min(sampleNumber) = %d @ %d\n", minSampleValue, minSampleIndex); display_print("max(sampleNumber) = %d @ %d\n", maxSampleValue, maxSampleIndex); // display_print("min(messageId) = %d @ %d\n", minMessageValue, minMessageIndex); // display_print("max(messageId) = %d @ %d\n", maxMessageValue, maxMessageIndex); display_print("max(countCleared) = %d\n", maxCountCleared); display_print("\n"); if (maxSampleIndex>=0) display_print("current trial = %d @ %d\n", maxSampleValue/packet[maxSampleIndex].numSamples, maxSampleIndex); else display_print("current trial = <unknown>\n"); display_print("\n"); display_print("numRealChan = %d\n", numRealChan); display_print("numTrigChan = %d\n", numTrigChan); display_print("numTrigger = %d\n", numTrigger/3); display_print("lastPacket = %d\n", lastPacket); display_print("trigChan = "); for (i=0; i<numTrigChan; i++) display_print("%d\t", trigChan[i]); display_print("\n"); display_print("lastValue = "); for (i=0; i<numTrigChan; i++) display_print("%d\t", lastValue[i]); display_print("\n"); display_print("\n"); display_refresh(); /******************************************************************************* * do the desired maintenance on the packet buffer (only if a key was pressed) *******************************************************************************/ k = getch(); switch (k) { case 's': write_setup(0); break; case 'p': pause = PAUSE; break; case 'f': while (countInvalid && packet[t].message_type!=ACQ_MSGQ_INVALID) t = wrapnumpacket(t+1); while (packet[t].message_type==ACQ_MSGQ_INVALID) { write_data(t, c); t = wrapnumpacket(t+1); c++; } break; case 'd': while (countInvalid && packet[t].message_type!=ACQ_MSGQ_INVALID) t = wrapnumpacket(t+1); write_data(t, c); t = wrapnumpacket(t+1); c++; break; case 'c': maxCountCleared = 0; clear_all_except_setup(); break; case 'h': showDisplay = (!showDisplay); break; case 'x': maxCountCleared = 0; clear_all(); break; case 'q': again = 0; break; } if (k!=ERR) { display_print("key pressed = %d\n", k); display_refresh(); continue; } /******************************************************************************* * do the regular maintenance on the packet buffer *******************************************************************************/ if (countCancel) { display_print("initializing all packets\n"); clear_all(); countInvalid = ACQ_MSGQ_SIZE; countData = 0; countSetup = 0; countCancel = 0; } // if ((MINFREE-countInvalid)>1 && pause) { // pause/=(MINFREE-countInvalid); // display_print("decreasing pause to %d\n", pause); // } while (countInvalid<MINFREE && countData) /* make more empty packets available */ if (setupIndex>-1) { /* moving the setup one packet at a time may look inefficient, but this only happens at the start of online acquisition */ display_print("moving setup from %d to %d\n", setupIndex, minSampleIndex); memcpy(&packet[minSampleIndex], &packet[setupIndex], sizeof(ACQ_MessagePacketType)); countCleared++; countInvalid++; countData--; // NOTE: don't clear the packet, since Matlab might be reading from it // display_print("clearing packet %d\n", setupIndex); // clear_packet(setupIndex); packet[setupIndex].message_type = ACQ_MSGQ_INVALID; setupIndex = minSampleIndex; minSampleIndex = wrapnumpacket(minSampleIndex+1); /* the next is probably now the oldest */ } else { display_print("clearing packet %d\n", minSampleIndex); clear_packet(minSampleIndex); countCleared++; countInvalid++; countData--; minSampleIndex = wrapnumpacket(minSampleIndex+1); /* the next is probably now the oldest */ } while (setupIndex>-1 && countData && packet[wrapnumpacket(setupIndex+1)].message_type==ACQ_MSGQ_INVALID) { /* move the setup to the next empty packet */ /* moving the setup one packet at a time may look inefficient, but this only happens at the start of online acquisition */ display_print("moving setup from %d to %d\n", setupIndex, wrapnumpacket(setupIndex+1)); memcpy(&packet[wrapnumpacket(setupIndex+1)], &packet[setupIndex], sizeof(ACQ_MessagePacketType)); // NOTE: don't clear the packet, since Matlab might be reading from it // clear_packet(setupIndex); packet[setupIndex].message_type = ACQ_MSGQ_INVALID; countCleared++; setupIndex = wrapnumpacket(setupIndex+1); } display_refresh(); usleep(pause); if (countInvalid>4) printf("ok %d\n", countLoop); else printf("error %d\n", countLoop); countLoop++; } /* detach from the shared memory segment */ if (shmdt(packet) == -1) { perror("shmdt"); exit(1); } /* end curses mode */ display_stop(); /* end of program */ return 0; }