void
Stopwatch::startWithoutReset()
{
assert( !isRunning_ );
isRunning_ = true;
getTimeNow( startTime_ );
}
// Setup application data
void TeknoBlinkenlichtApp::setup() {
// Load graphics
this->tBackground = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("background.png")));
this->tSpede = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("spede.png")));
this->tKnob = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("potikka.png")));
this->mapLEDs["blue"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-blue.png")));
this->mapLEDs["green"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-green.png")));
this->mapLEDs["lilac"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-lilac.png")));
this->mapLEDs["orange"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-orange.png")));
this->mapLEDs["red"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-red.png")));
this->mapLEDs["yellow"] = ci::gl::Texture(ci::loadImage(ci::app::loadAsset("midi-yellow.png")));
// Try to initialize Arduino
this->devArduino = ci::Serial::findDeviceByName(ARDUINO_PORT);
if (this->devArduino.getName().compare(ARDUINO_PORT) != 0) {
std::cerr << "Le game needs an Arduino. Check port: " << ARDUINO_PORT << std::endl;
// exit(EXIT_FAILURE);
this->serArduino = NULL;
} else {
#if defined(DEBUG_OUTPUT)
std::cout << "Arduino found on port: " << ARDUINO_PORT << std::endl;
#endif
// Open serial connection to Arduino
this->serArduino = new ci::Serial(this->devArduino, ARDUINO_BAUD_RATE);
}
// Initialize MIDI I/O
this->controller = new MidiController(MIDI_CONTROLLER_IN, MIDI_CONTROLLER_OUT, this);
this->bGameOver = false;
this->mStartTime = getTimeNow();
}
// Get a new color
void TeknoBlinkenlichtApp::changeColor() {
if (this->setupDone == 0) { return; }
if (this->bGameOver) { return; }
// Randomize a new LED color
uint8_t newColor;
do {
newColor = (random() % 6) + 1;
} while (newColor == this->clrActive);
this->clrActive = newColor;
#if defined(DEBUG_OUTPUT)
switch (this->clrActive) {
case COLOR_RED:
std::cout << "New color RED, press GREEN" << std::endl;
break;
case COLOR_GREEN:
std::cout << "New color GREEN, press RED" << std::endl;
break;
case COLOR_BLUE:
std::cout << "New color BLUE, press ORANGE" << std::endl;
break;
case COLOR_YELLOW:
std::cout << "New color YELLOW, press LILAC" << std::endl;
break;
case COLOR_LILAC:
std::cout << "New color LILAC, press YELLOW" << std::endl;
break;
case COLOR_ORANGE:
std::cout << "New color ORANGE, press BLUE" << std::endl;
break;
}
#endif
// Send color message to Arduino
if (this->serArduino) {
this->serArduino->writeByte(this->clrActive);
}
// Start timing color
this->mColorTime = getTimeNow();
if (this->fTimeLimit > MIN_COLOR_TIME) {
this->fTimeLimit -= TIME_DECREMENT;
}
// Prevent double changes when player lifts finger.
// Occurs if a timed change happens while a button is being pressed.
this->bReadyToChange = false;
}
void
Stopwatch::addTimeThisRun( timeval &accumulator ) const
{
assert( isRunning_ );
timeval now;
getTimeNow( now );
timeval diff;
// diff = now.startTime_
TIMESUB( &now, &startTime_, &diff );
// elapsed += diff
TIMEADD( &accumulator, &diff, &accumulator );
}
int labelit(struct dos_name_t *dosname,
char *longname,
void *arg0,
direntry_t *entry)
{
time_t now;
/* find out current time */
getTimeNow(&now);
mk_entry(dosname, 0x8, 0, 0, now, &entry->dir);
return 0;
}
void ConsoleAppender::log(
std::string loggerName,
LogLevel level,
const char *fmt,
va_list ap,
const char *file,
int line,
const char *function)
{
char buffer[LOG_BUFFER_SIZE];
// time, levle and logger name
snprintf(buffer, LOG_BUFFER_SIZE, "%s %s %s %s - ",
getTimeNow().c_str(),
getLogLevelString(level).c_str(),
getPIDAndTID().c_str(),
loggerName.c_str());
// debug - location
int len = strlen(buffer);
if ((LOG_TRACE == level || LOG_DEBUG == level)
&& file != NULL && line != 0 && function != NULL) {
snprintf(buffer + len, LOG_BUFFER_SIZE - len,
"file: %s, line: %d, function: %s, ",
file, line, function);
}
// log data
len = strlen(buffer);
vsnprintf(buffer + len, LOG_BUFFER_SIZE - len, fmt, ap);
// 添加换行
len = strlen(buffer);
buffer[len++] = '\n';
buffer[len] = '\0';
len = strlen(buffer);
// 去掉多余的空行
while (buffer[len - 2] == '\n') {
--len;
}
buffer[len] = '\0';
// 输出到stderr
fprintf(stderr, "%s", buffer);
}
static int createDirCallback(direntry_t *entry, MainParam_t *mp)
{
Stream_t *ret;
time_t now;
ret = createDir(mp->File, mp->targetName, &((Arg_t *)(mp->arg))->ch,
ATTR_DIR, getTimeNow(&now));
if(ret == NULL)
return ERROR_ONE;
else {
FREE(&ret);
return GOT_ONE;
}
}
static int dos_copydir(direntry_t *entry, MainParam_t *mp)
/* copyes a directory to Dos */
{
Arg_t * arg = (Arg_t *) (mp->arg);
Arg_t newArg;
time_t now;
time_t date;
int ret;
const char *targetName = mpPickTargetName(mp);
if (!arg->recursive && mp->basenameHasWildcard)
return 0;
if(entry && isSubdirOf(mp->targetDir, mp->File)) {
fprintf(stderr, "Cannot recursively copy directory ");
fprintPwd(stderr, entry,0);
fprintf(stderr, " into one of its own subdirectories ");
fprintPwd(stderr, getDirentry(mp->targetDir),0);
fprintf(stderr, "\n");
return ERROR_ONE;
}
if (arg->mp.File->Class->get_data(arg->mp.File,
& date, 0, 0, 0) < 0 ){
fprintf(stderr, "Can't stat source file\n");
return ERROR_ONE;
}
if(!arg->type && arg->verbose)
fprintf(stderr,"Copying %s\n", mpGetBasename(mp));
if(entry && arg->preserveAttributes)
arg->attr = entry->dir.attr;
else
arg->attr = 0;
if (entry && (mp->targetDir == entry->Dir)){
arg->ch.ignore_entry = -1;
arg->ch.source = entry->entry;
} else {
arg->ch.ignore_entry = -1;
arg->ch.source = -2;
}
/* preserve mod time? */
if (arg->preserveTime)
now = date;
else
getTimeNow(&now);
newArg = *arg;
newArg.mp.arg = &newArg;
newArg.mp.targetName = 0;
newArg.mp.basenameHasWildcard = 1;
if(*targetName) {
/* maybe the directory already exist. Use it */
newArg.mp.targetDir = subDir(mp->targetDir, targetName);
if(!newArg.mp.targetDir)
newArg.mp.targetDir = createDir(mp->targetDir,
targetName,
&arg->ch, arg->attr,
now);
} else
newArg.mp.targetDir = mp->targetDir;
if(!newArg.mp.targetDir)
return ERROR_ONE;
ret = mp->loop(mp->File, &newArg.mp, "*");
if(*targetName)
FREE(&newArg.mp.targetDir);
return ret | GOT_ONE;
}
/*
* Open the named file for read, create the cluster chain, return the
* directory structure or NULL on error.
*/
static int writeit(char *dosname,
char *longname,
void *arg0,
direntry_t *entry)
{
Stream_t *Target;
time_t now;
int type, fat, ret;
time_t date;
mt_size_t filesize, newsize;
Arg_t *arg = (Arg_t *) arg0;
if (arg->mp.File->Class->get_data(arg->mp.File,
& date, &filesize, &type, 0) < 0 ){
fprintf(stderr, "Can't stat source file\n");
return -1;
}
if (type){
if (arg->verbose)
fprintf(stderr, "\"%s\" is a directory\n", longname);
return -1;
}
/*if (!arg->single || arg->recursive)*/
if(arg->verbose)
fprintf(stderr,"Copying %s\n", longname);
if(got_signal)
return -1;
/* will it fit? */
if (!getfreeMinBytes(arg->mp.targetDir, filesize))
return -1;
/* preserve mod time? */
if (arg->preserveTime)
now = date;
else
getTimeNow(&now);
mk_entry(dosname, arg->attr, 1, 0, now, &entry->dir);
Target = OpenFileByDirentry(entry);
if(!Target){
fprintf(stderr,"Could not open Target\n");
exit(1);
}
if (arg->needfilter & arg->textmode)
Target = open_filter(Target);
ret = copyfile(arg->mp.File, Target);
GET_DATA(Target, 0, &newsize, 0, &fat);
FREE(&Target);
if (arg->needfilter & arg->textmode)
newsize++; /* ugly hack: we gathered the size before the Ctrl-Z
* was written. Increment it manually */
if(ret < 0 ){
fat_free(arg->mp.targetDir, fat);
return -1;
} else {
mk_entry(dosname, arg->attr, fat, truncBytes32(newsize),
now, &entry->dir);
return 0;
}
}
