void HardwareController::loadConfiguration(string filename)
{
FILE* f = fopen(filename.c_str(), "r");
if (!f)
{
LOG(INFO) << filename << " not found. Not controlling external hardware.";
return;
}
std::unordered_map<string, string> settings;
string section = "";
char buffer[512];
while(fgets(buffer, sizeof(buffer), f))
{
string line = string(buffer).strip();
if(line.find("#") > -1)
line = line.substr(0, line.find("#")).strip();
if (line.startswith("[") && line.endswith("]"))
{
if (section != "")
{
handleConfig(section, settings);
settings.clear();
}
section = line;
}else if (line.find("=") > -1)
{
string key = line.substr(0, line.find("=")).strip();
string value = line.substr(line.find("=") + 1).strip();
settings[key] = value;
}
}
if (section != "")
handleConfig(section, settings);
fclose(f);
channels.resize(0);
for(HardwareOutputDevice* device : devices)
{
channels.resize(channels.size() + device->getChannelCount(), 0.0f);
}
LOG(INFO) << "Hardware subsystem initialized with: " << channels.size() << " channels";
if (devices.size() < 1)
{
LOG(INFO) << "List of available serial ports:";
for(string port : SerialPort::getAvailablePorts())
{
LOG(INFO) << port << " - " << SerialPort::getPseudoDriverName(port);
}
}
}
int OnSpawn( edict_t* pEntity )
{
if( !Initialized && EngineConfigReady )
{
handleConfig();
Initialized = true;
}
RETURN_META_VALUE( MRES_IGNORED, FALSE );
}
bool parseI2CMessage(int size, const byte *msg, CONTEXT *context)
{
switch (msg[0] )
{
case I2C_CMD_CONFIG:
return handleConfig(size, msg, context);
break;
case I2C_CMD_READ:
return handleRead(size, msg, context);
break;
case I2C_CMD_WRITE:
return handleWrite(size, msg, context);
break;
}
return false;
}
/* filePreset
*
* Load a file containing presetting information (a configuration file).
*/
static void
filePreset(
tOptions* pOpts,
char const* pzFileName,
int direction )
{
tmap_info_t cfgfile;
tOptState st = OPTSTATE_INITIALIZER(PRESET);
char* pzFileText =
text_mmap( pzFileName, PROT_READ|PROT_WRITE, MAP_PRIVATE, &cfgfile );
if (TEXT_MMAP_FAILED_ADDR(pzFileText))
return;
if (direction == DIRECTION_CALLED) {
st.flags = OPTST_DEFINED;
direction = DIRECTION_PROCESS;
}
/*
* IF this is called via "optionProcess", then we are presetting.
* This is the default and the PRESETTING bit will be set.
* If this is called via "optionFileLoad", then the bit is not set
* and we consider stuff set herein to be "set" by the client program.
*/
if ((pOpts->fOptSet & OPTPROC_PRESETTING) == 0)
st.flags = OPTST_SET;
do {
while (isspace( (int)*pzFileText )) pzFileText++;
if (isalpha( (int)*pzFileText )) {
pzFileText = handleConfig( pOpts, &st, pzFileText, direction );
} else switch (*pzFileText) {
case '<':
if (isalpha( (int)pzFileText[1] ))
pzFileText = handleStructure(pOpts, &st, pzFileText, direction);
else switch (pzFileText[1]) {
case '?':
pzFileText = handleDirective( pOpts, pzFileText );
break;
case '!':
pzFileText = handleComment( pzFileText );
break;
case '/':
pzFileText = strchr( pzFileText+2, '>' );
if (pzFileText++ != NULL)
break;
default:
goto all_done;
}
break;
case '[':
pzFileText = handleProgramSection( pOpts, pzFileText );
break;
case '#':
pzFileText = strchr( pzFileText+1, '\n' );
break;
default:
goto all_done; /* invalid format */
}
} while (pzFileText != NULL);
all_done:
text_munmap( &cfgfile );
}
int main(void) {
TCCR0B |= (1 << CS01); // Enable timer with 1/8th prescale
TIMSK0 |= 1 << OCIE0A; // Configure Timer0 for Compare Match
OCR0A = 255; // Match at 200
sei(); // Enable global interrupts
initialize();
DDRA |= (1 << PINA1); // Pin 12 - Red LED
DDRA |= (1 << PINA2); // Pin 11 - Green LED
DDRA |= (1 << PINA7); // Pin 6 - Solenoid
DDRB &= ~(1 << PINB1); // Pin 3 - Push button
DDRB &= ~(1 << PINB2); // Pin 5 - Trigger Pin 1
DDRA &= ~(1 << PINA6); // Pin 7 - Trigger Pin 2
// Other unknown pins
//DDRA |= (1 << PINA0); // Pin 13
//PORTA |= (1 << PINA0); // 13 - HIGH
#ifdef X7CLASSIC
DDRA |= (1 << PINA3); // Pin 10 - Power pin
PORTA |= (1 << PINA3); // 10 - HIGH
#endif
//PORTA &= ~(1 << PINA4); // 9 - LOW
//PORTA &= ~(1 << PINA5); // 8 - LOW
// Set Triggers HIGH
PORTB |= (1 << PINB2);
PORTA |= (1 << PINA6);
// Set Pushbutton HIGH
PORTB |= (1 << PINB1);
#ifdef X7CLASSIC
// Selector switch on pin 2
DDRB &= ~(1 << PINB0); // Pin 2
PORTB |= (1 << PINB0); // Pin 2 set HIGH
#endif
// If the trigger is held, don't do anything until it's release
while (macHold()) {
// Show the Red LED as solid
redOn();
}
// If the button is held during startup, enter config mode.
uint16_t buttonHeldTime = 0;
bool configMode = false;
while ((PINB & (1 << PINB1)) <= 0) {
delay_ms(1);
// Prevent overflow
buttonHeldTime++;
if (buttonHeldTime > 20000) {
buttonHeldTime = 20000;
}
}
if (buttonHeldTime >= 1000) {
configMode = true;
}
#ifdef DWELL_DEBOUNCE
bool advancedMenu = 0;
if (buttonHeldTime >= 10000) {
advancedMenu = 1;
}
#endif
if (configMode) {
// Initialize interrupts for the menu system
PCMSK1 |= (1 << PCINT10); //Enable interrupts on PCINT10 (trigger)
PCMSK1 |= (1 << PCINT9); // Enable interrupts for the push button
GIMSK = (1 << PCIE1); //Enable interrupts period for PCI0 (PCINT11:8
#ifdef DWELL_DEBOUNCE
if (advancedMenu) {
advancedConfig();
} else {
handleConfig();
}
#else
handleConfig();
#endif
} else { // Normal run mode
for (;;) {
// This prevents time from changing within an iteration
trigger_run(&millis);
pushbutton_run(&millis);
}
}
}
void HPJReader::parseFile()
{
HCStartFile( _scanner.name() );
int length = _scanner.getLine(); // Get the first line.
char section[15];
int i;
while( length != 0 ){
// The first line had better be the beginning of a section.
if( _scanner[0] != '[' ){
HCWarning( HPJ_NOTSECTION, _scanner.lineNum(), _scanner.name() );
length = skipSection();
continue;
}
// Read in the name of the section.
for( i=1; i < length ; i++ ){
if( _scanner[i] == ']' ) break;
section[i-1] = (char) toupper( _scanner[i] );
}
// If the section name wasn't terminated properly, skip the section.
if( i == length ){
HCWarning( HPJ_BADSECTION, _scanner.lineNum(), _scanner.name() );
length = skipSection();
continue;
}
section[i-1] = '\0';
// Pass control to the appropriate "section handler".
if( strcmp( section, SBaggage ) == 0 ){
length = handleBaggage();
} else if( strcmp( section, SOptions ) == 0 ){
length = handleOptions();
} else if( strcmp( section, SConfig ) == 0 ){
length = handleConfig();
} else if( strcmp( section, SFiles ) == 0 ){
length = handleFiles();
} else if( strcmp( section, SMap ) == 0 ){
length = handleMap();
} else if( strcmp( section, SBitmaps ) == 0 ){
length = handleBitmaps();
} else if( strcmp( section, SWindows ) == 0 ){
length = handleWindows();
} else {
HCWarning( HPJ_BADSECTION, _scanner.lineNum(), _scanner.name() );
length = skipSection();
}
}
if( _rtfFiles == NULL ){
HCError( HPJ_NOFILES );
}
// Now parse individual RTF files.
StrNode *curfile = _rtfFiles;
StrNode *curdir;
InFile source;
// First, implement phrase replacement if desired.
if( _theFiles->_sysFile->isCompressed() ){
_topFile = _rtfFiles;
_firstDir = _root;
_startDir = _homeDir;
_theFiles->_phrFile = new HFPhrases( _dir, &firstFile, &nextFile );
char full_path[_MAX_PATH];
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
_fullpath( full_path, _scanner.name(), _MAX_PATH );
_splitpath( full_path, drive, dir, fname, ext );
_makepath( full_path, drive, dir, fname, PhExt );
if( !_oldPhrases || !_theFiles->_phrFile->oldTable(full_path) ){
_theFiles->_phrFile->readPhrases();
_theFiles->_phrFile->createQueue( full_path );
}
}
_theFiles->_topFile = new HFTopic( _dir, _theFiles->_phrFile );
// For each file, search the ROOT path, and create a RTFparser
// to deal with it.
curfile = _rtfFiles;
while( curfile != NULL ){
curdir = _root;
if( curdir == NULL ){
source.open( curfile->_name );
} else while( curdir != NULL ){
chdir( curdir->_name );
source.open( curfile->_name );
chdir( _homeDir );
if( !source.bad() ) break;
curdir = curdir->_next;
}
if( source.bad() ){
HCWarning( FILE_ERR, curfile->_name );
} else {
RTFparser rtfhandler( _theFiles, &source );
rtfhandler.Go();
source.close();
}
curfile = curfile->_next;
}
}
/*** MAIN ***/
int main(int argc, char **argv)
{
RsslErrorInfo error;
RsslError rsslErr;
RsslCreateReactorOptions reactorOpts;
RsslReactorDispatchOptions dispatchOpts;
RsslInt32 j;
RsslReactorOMMNIProviderRole role;
RsslDataDictionary dictionary = RSSL_INIT_DATA_DICTIONARY;
char err[128];
RsslBuffer errBuf = {128, &err[0]};
int selRet;
time_t currentTime = 0;
RsslRet ret;
RsslInitializeExOpts initOpts = RSSL_INIT_INITIALIZE_EX_OPTS;
rsslInitNIChannelCommand(&chnlCommand);
handleConfig(argc, argv, &chnlCommand);
initializeCache(cacheCommandlineOption);
initOpts.jitOpts.libcryptoName = libcryptoName;
initOpts.jitOpts.libsslName = libsslName;
initOpts.jitOpts.libcurlName = libcurlName;
initOpts.rsslLocking = RSSL_LOCK_GLOBAL_AND_CHANNEL;
/* Initialize run-time */
initRuntime();
rsslInitializeEx(&initOpts, &rsslErr);
/* Setup role */
rsslClearOMMNIProviderRole((RsslReactorOMMNIProviderRole*)&role);
role.pLoginRequest = (RsslRDMLoginRequest*)&chnlCommand.loginRequest;
role.loginMsgCallback = processLoginResponse;
role.pDirectoryRefresh = &chnlCommand.directoryRefresh;
role.base.channelEventCallback = channelEventCallback;
role.base.defaultMsgCallback = processResponse;
printf("Connections:\n");
chnlCommand.pRole = (RsslReactorChannelRole*)&role;
chnlCommand.cOpts.rsslConnectOptions.guaranteedOutputBuffers = 500;
chnlCommand.cOpts.rsslConnectOptions.majorVersion = RSSL_RWF_MAJOR_VERSION;
chnlCommand.cOpts.rsslConnectOptions.minorVersion = RSSL_RWF_MINOR_VERSION;
chnlCommand.cOpts.rsslConnectOptions.userSpecPtr = (void*)&chnlCommand;
// printf(" %s:%s:%s\n", chnlCommand.hostName, chnlCommand.port, chnlCommand.serviceName);
printf(" MarketPriceItems:");
for(j = 0; j < CHAN_CMD_MAX_ITEMS; ++j)
{
RsslNIItemInfo *pItem = &chnlCommand.marketPriceItemInfo[j];
if (pItem->isActive)
printf(" %.*s", (int)sizeof(pItem->Itemname), pItem->Itemname);
}
printf(" MarketByOrderItems:");
for(j = 0; j < CHAN_CMD_MAX_ITEMS; ++j)
{
RsslNIItemInfo *pItem = &chnlCommand.marketByOrderItemInfo[j];
if (pItem->isActive)
printf(" %.*s", (int)sizeof(pItem->Itemname), pItem->Itemname);
}
printf("\n");
printf("\n");
/* Load local dictionary */
if(rsslLoadFieldDictionary("RDMFieldDictionary", &dictionary, &errBuf) < RSSL_RET_SUCCESS)
{
printf("Dictionary error: %s\n", errBuf.data);
exit(-1);
}
chnlCommand.dictionary = &dictionary;
initializeCacheDictionary(&dictionary);
rsslClearCreateReactorOptions(&reactorOpts);
reactorOpts.dispatchDecodeMemoryBufferSize = 1024;
setupLoginRequest(&chnlCommand, 1);
setupDirectoryResponseMsg(&chnlCommand, -1);
if (!(pReactor = rsslCreateReactor(&reactorOpts, &error)))
{
printf("Error: %s", error.rsslError.text);
exit(-1);
}
FD_ZERO(&readFds);
FD_ZERO(&writeFds);
FD_ZERO(&exceptFds);
FD_SET(pReactor->eventFd, &readFds);
if (rsslReactorConnect(pReactor, &chnlCommand.cOpts, chnlCommand.pRole, &error) != RSSL_RET_SUCCESS)
printf("Error rsslReactorConnect(): %s\n", error.rsslError.text);
rsslClearReactorDispatchOptions(&dispatchOpts);
//dispatchOpts.pReactorChannel = &chnlCommand.reactorChannel;
printf("Connection started!\n");
while ( RSSL_TRUE )
{
struct timeval selectTime;
int dispatchCount = 0;
fd_set useReadFds = readFds, useWriteFds = writeFds, useExceptFds = exceptFds;
selectTime.tv_sec = 1; selectTime.tv_usec = 0;
handleRuntime();
selRet = select(FD_SETSIZE, &useReadFds, &useWriteFds, &useExceptFds, &selectTime);
if (selRet == 0 ) /* no messages received, send updates and continue */
{
// Update items
updateItemInfo(&chnlCommand);
/* Send market price updates for each connected channel */
if (chnlCommand.startWrite == RSSL_TRUE)
{
if ((chnlCommand.reactorChannel != NULL) && (chnlCommand.reactorChannel->socketId != -1))
{
if (sendItemUpdates(pReactor,chnlCommand.reactorChannel) != RSSL_RET_SUCCESS)
recoverConnection(pReactor, chnlCommand.reactorChannel, &chnlCommand);
}
}
else
{
if (cacheInfo.useCache)
cacheItemData(&chnlCommand);
}
}
else if (selRet > 0)
{
RsslRet ret;
while ((ret = rsslReactorDispatch(pReactor, &dispatchOpts, &error)) > 0);
if(ret < 0)
{
printf("dispatch error! %i\n %s\n %s\n", ret, error.rsslError.text, error.errorLocation);
/* Reactor has shutdown. Clean up and exit. */
cleanUpAndExit();
}
}
/* get current time */
if ((currentTime = time(NULL)) < 0)
{
printf("time() failed.\n");
}
// send login reissue if login reissue time has passed
if (chnlCommand.canSendLoginReissue == RSSL_TRUE &&
currentTime >= (RsslInt)chnlCommand.loginReissueTime)
{
RsslReactorSubmitMsgOptions submitMsgOpts;
RsslErrorInfo rsslErrorInfo;
rsslClearReactorSubmitMsgOptions(&submitMsgOpts);
submitMsgOpts.pRDMMsg = (RsslRDMMsg*)chnlCommand.pRole->ommNIProviderRole.pLoginRequest;
if ((ret = rsslReactorSubmitMsg(pReactor,chnlCommand.reactorChannel,&submitMsgOpts,&rsslErrorInfo)) != RSSL_RET_SUCCESS)
{
printf("Login reissue failed: %d(%s)\n", ret, rsslErrorInfo.rsslError.text);
}
else
{
printf("Login reissue sent\n");
}
chnlCommand.canSendLoginReissue = RSSL_FALSE;
}
}
}
