boolean newBoardAvailable()
{
if((nBoards < MAX_N_BOARDS) && (nSenActs < MAX_N_SENACT)&&nFreeCH)
{
radio.stopListening();
radio.setChannel( APPLICATION_CH );
radio.startListening();
if(readPackage(newBoardPacked, 32))
{
if(writePackage(newBoardPacked, 32))return true;
else
{
Serial.println("\nError: writng back board");
return false;
}
}
else
{
//Serial.println("\nError: no New Board");
return false;
}
}
else
{
Serial.println("Error: no more buffer/channel space");
return false;
}
}
void XMLimport::readUnknownPackage()
{
while( ! atEnd() )
{
readNext();
qDebug()<<"[ERROR]: UNKNOWN readUnknownPackage() Package Element:"<<name().toString()<<"text:"<<text().toString();
if( isEndElement() )
{
break;
}
if( isStartElement() )
{
readPackage();
}
}
}
boolean readPackageAck(byte * package, unsigned char len, byte * ack, unsigned char lenAck)
{
if(readPackage(package,len))
{
for(int i = 0; i < lenAck; i++)
{
if(package[i] != ack[i])
{
Serial.println("\nACK failed: ");
//Serial.print(package[0]);
return false;
}
}
return true;
}
Serial.println("\nread failed");
return false;
}
UT_Error IE_Imp_EPUB::_loadFile(GsfInput* input)
{
m_epub = gsf_infile_zip_new(input, NULL);
if (m_epub == NULL)
{
UT_DEBUGMSG(("Can`t create gsf input zip object\n"));
return UT_ERROR;
}
UT_DEBUGMSG(("Reading metadata\n"));
if (readMetadata() != UT_OK)
{
UT_DEBUGMSG(("Failed to read metadata\n"));
return UT_ERROR;
}
UT_DEBUGMSG(("Reading package information\n"));
if (readPackage() != UT_OK)
{
UT_DEBUGMSG(("Failed to read package information\n"));
return UT_ERROR;
}
UT_DEBUGMSG(("Uncompressing OPS data\n"));
if (uncompress() != UT_OK)
{
UT_DEBUGMSG(("Failed to uncompress data\n"));
return UT_ERROR;
}
UT_DEBUGMSG(("Reading OPS data\n"));
if (readStructure() != UT_OK)
{
UT_DEBUGMSG(("Failed to read OPS data\n"));
return UT_ERROR;
}
return UT_OK;
}
void PeerObject::init(const QString &identifier)
{
// m_dbgLog.write("PeerObject::init()\n");
// m_dbgLog.flush();
// QLocalSocket throws SIGPIE
signal(SIGPIPE, SIG_IGN);
// Ignore closed terminal
signal(SIGHUP, SIG_IGN);
// Fill titles
s_actionTitles['d'] = "Data";
s_actionTitles['p'] = "Package";
s_actionTitles['s'] = "Socket descriptor";
m_peerSocket = new QLocalSocket();
connect(m_peerSocket, SIGNAL(readyRead()), SLOT(readStdin()), Qt::DirectConnection);
connect(m_peerSocket, SIGNAL(disconnected()), SLOT(closeDelayed()));
m_peerSocket->connectToServer("TestLocalSocket_Peer");
if(!m_peerSocket->waitForConnected()) {
qFatal("Peer: Cannot connect to QLocalServer!");
}
// qDebug("Peer: Control socket connected!");
m_socket = new LocalSocket(this);
connect(m_socket, SIGNAL(readyRead()), SLOT(readData()));
connect(m_socket, SIGNAL(readyReadPackage()), SLOT(readPackage()));
connect(m_socket, SIGNAL(readyReadSocketDescriptor()), SLOT(readSocketDescriptor()));
connect(m_socket, SIGNAL(disconnected()), SLOT(closeDelayed()));
if(!m_socket->connectToServer(identifier)) {
// m_dbgLog.write("Failed to open LocalSocket for reading!\n");
// m_dbgLog.flush();
qFatal("Peer: Failed to open LocalSocket for reading!");
}
// qDebug("Peer: LocalSocket connected!");
}
//*****************************************************************************
//
// This example application demonstrates the use of the timers to generate
// periodic interrupts.
//
//*****************************************************************************
int
main(void)
{
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
FPUEnable();
FPULazyStackingEnable();
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Initialize the UART and write status.
//
ConfigureUART();
ConfigureXBeeUART();
ConfigureUARTSensores();
ButtonsInit();
inicializa_motores();
//
// Enable the peripherals used by this example.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// Configure the two 32-bit periodic timers.
//
TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet()/200000);
//
// Setup the interrupts for the timer timeouts.
//
IntEnable(INT_TIMER1A);
TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable the timers.
//
TimerEnable(TIMER1_BASE, TIMER_A);
// Configure a wide timer for timing purposes
SysCtlPeripheralEnable(SYSCTL_PERIPH_WTIMER0);
TimerConfigure(WTIMER0_BASE, TIMER_CFG_PERIODIC_UP);
TimerLoadSet64(WTIMER0_BASE, (((long long)1) << 60));
TimerEnable(WTIMER0_BASE, TIMER_A);
int counter_verify_no_ar = 0;
while(1) {
SysCtlDelay(SysCtlClockGet() / 1000);
checkButtons();
readPackage();
counter_verify_no_ar++;
if (counter_verify_no_ar == 1000) {
counter_verify_no_ar = 0;
if (no_ar) {
enviaNoAr();
no_ar = false;
}
if (no_chao) {
enviaNoChao();
no_chao = false;
}
}
}
}
bool XMLimport::importPackage( QIODevice * device, QString packName, int moduleFlag)
{
mPackageName = packName;
setDevice( device );
gotTrigger = false;
gotTimer = false;
gotAlias = false;
gotKey = false;
gotAction = false;
gotScript = false;
module = moduleFlag;
/*if (moduleFlag)
module=1;*/
qDebug()<<"module flag:"<<module<<" importing: "<<mPackageName;
if( ! packName.isEmpty() )
{
mpKey = new TKey( 0, mpHost );
if (module){
mpKey->mModuleMasterFolder=true;
mpKey->mModuleMember=true;
}
mpKey->setPackageName( mPackageName );
mpKey->setIsActive( true );
mpKey->setName( mPackageName );
mpKey->setIsFolder( true );
mpTrigger = new TTrigger( 0, mpHost );
if (module){
mpTrigger->mModuleMasterFolder=true;
mpTrigger->mModuleMember=true;
}
mpTrigger->setPackageName( mPackageName );
mpTrigger->setIsActive( true );
mpTrigger->setName( mPackageName );
mpTrigger->setIsFolder( true );
mpTimer = new TTimer( 0, mpHost );
if (module){
mpTimer->mModuleMasterFolder=true;
mpTimer->mModuleMember=true;
}
mpTimer->setPackageName( mPackageName );
mpTimer->setIsActive( true );
mpTimer->setName( mPackageName );
mpTimer->setIsFolder( true );
mpAlias = new TAlias( 0, mpHost );
if (module){
mpAlias->mModuleMasterFolder=true;
mpAlias->mModuleMember=true;
}
mpAlias->setPackageName( mPackageName );
mpAlias->setIsActive( true );
mpAlias->setName( mPackageName );
mpAlias->setIsFolder( true );
mpAction = new TAction( 0, mpHost );
if (module){
mpAction->mModuleMasterFolder=true;
mpAction->mModuleMember=true;
}
mpAction->setPackageName( mPackageName );
mpAction->setIsActive( true );
mpAction->setName( mPackageName );
mpAction->setIsFolder( true );
mpScript = new TScript( 0, mpHost );
if (module){
mpScript->mModuleMasterFolder=true;
mpScript->mModuleMember=true;
}
mpScript->setPackageName( mPackageName );
mpScript->setIsActive( true );
mpScript->setName( mPackageName );
mpScript->setIsFolder( true );
mpHost->getTriggerUnit()->registerTrigger( mpTrigger );
mpHost->getTimerUnit()->registerTimer( mpTimer );
mpHost->getAliasUnit()->registerAlias( mpAlias );
mpHost->getActionUnit()->registerAction( mpAction );
mpHost->getKeyUnit()->registerKey( mpKey );
mpHost->getScriptUnit()->registerScript( mpScript );
}
while( ! atEnd() )
{
readNext();
if( isStartElement() )
{
if( name() == "MudletPackage" )// && attributes().value("version") == "1.0")
{
readPackage();
}
else if( name() == "map" )
{
maxAreas = 0;
maxRooms = 0;
areaMap.clear();
readMap();
mpHost->mpMap->init(mpHost);
}
else
{
qDebug()<<"ERROR:name="<<name().toString()<<"text:"<<text().toString();
}
}
}
if( ! packName.isEmpty())
{
if( ! gotTrigger )
mpHost->getTriggerUnit()->unregisterTrigger( mpTrigger );
if( ! gotTimer )
mpHost->getTimerUnit()->unregisterTimer( mpTimer );
if( ! gotAlias )
mpHost->getAliasUnit()->unregisterAlias( mpAlias );
if( ! gotAction )
mpHost->getActionUnit()->unregisterAction( mpAction );
if( ! gotKey )
mpHost->getKeyUnit()->unregisterKey( mpKey );
if( ! gotScript )
mpHost->getScriptUnit()->unregisterScript( mpScript );
}
return ! error();
}
boolean readSensorB(SenAct * theSenAct)
{
//Serial.print((char*)theSenAct->name);
//Serial.print(": ");
if(writePackage(&(theSenAct->nSA),1))
{
if(readPackage(theSenAct->lastReading, theSenAct->nData))
{
Serial.print("\n");
switch(theSenAct->type)
{
case BOOL:
//Serial.println(*((boolean*)theSenAct->lastReading));
Serial.print(theSenAct->name);
Serial.print('\t');
Serial.println(*((boolean*)theSenAct->lastReading));
break;
case U_CHAR:
//Serial.println(*((unsigned char*)theSenAct->lastReading));
break;
case S_CHAR:
//Serial.println(*((signed char*)theSenAct->lastReading));
break;
case U_INT16:
//Serial.println(*((unsigned int*)theSenAct->lastReading));
break;
case S_INT16:
//Serial.println(*((signed int*)theSenAct->lastReading));
break;
case UL_INT32:
//Serial.println(*((unsigned long int*)theSenAct->lastReading));
break;
case SL_INT32:
//Serial.println(*((signed long int*)theSenAct->lastReading));
break;
case FLOAT:
Serial.print(theSenAct->name);
Serial.print('\t');
Serial.println(*((float*)theSenAct->lastReading));
break;
case DOUBLE:
//Serial.println(*((double*)theSenAct->lastReading));
break;
case CHAR_ARRAY:
//Serial.println((char*)theSenAct->lastReading);
break;
}
return true;
}
else
{
Serial.println("Fail read sensor");
return false;
}
}
else
{
Serial.println("Fail write to read sensor");
return false;
}
}
boolean newBoardDefine()
{
byte k;
int index;
if(alreadyRegistared(&Boards[nBoards],&index))
return returnBoardToNetwork(&Boards[nBoards],index);
unsigned char tempNsenAct = nSenActs;
for(int i =0; i< Boards[nBoards].nSenAct; i++)
{
k=i;
if(writePackage(&k, 1))
{
unsigned char tempNsenAct = nSenActs;
if(readPackage(package,32))
{
unpackSenAct( &SenActs[nSenActs],package);
//Serial.println((char*)SenActs[nSenActs].name);
nSenActs++;
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in reading Senact pack");
return false;
}
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in write k");
return false;
}
}
//Send change channel command
k=0xf0;
if(writePackage(&k, 1))
{
k=1;
if(readPackageAck(package,1,&k,1))
{
if(writePackage(&freeCH[nextFreeCH],1))
{
if(readPackageAck(package,1,&k,1))
{
Boards[nBoards].channel = freeCH[nextFreeCH];
//Serial.println("\nfree Chanell: ");
//Serial.print(freeCH[nextFreeCH],DEC);
nFreeCH=nFreeCH-4;
nextFreeCH=nextFreeCH+4;
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in read ch ACK");
return false;
}
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in write ch");
return false;
}
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in read ch comm ACK");
return false;
}
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in write ch comm");
return false;
}
//Send connected command
k=0xff;
delay(10);
if(writePackage(&k, 1))
{
nBoards++;
return true;
}
else
{
nSenActs = tempNsenAct;
Serial.println("\nError in write conn");
return false;
}
}
Function* readBytecode(FILE *in) {
uint8_t version = fgetc(in);
if (version != kByteCodeVersion) {
error("The bytecode file (bcsv %d) is not compatible with this interpreter (bcsv %d).\n",
version, kByteCodeVersion);
}
DEBUG_LOG("Bytecode version %d", version);
const int classCount = readUInt16(in);
classTable = new Class*[classCount];
DEBUG_LOG("%d class(es) on the whole", classCount);
const int functionCount = readUInt16(in);
functionTable = new Function*[functionCount];
DEBUG_LOG("%d function(s) on the whole", functionCount);
for (int i = 0, l = fgetc(in); i < l; i++) {
DEBUG_LOG("📦 Reading package %d of %d", i + 1, l);
readPackage(in);
}
CL_STRING = classTable[0];
CL_LIST = classTable[1];
CL_DATA = classTable[2];
CL_DICTIONARY = classTable[3];
CL_CLOSURE = classTable[4];
DEBUG_LOG("✅ Read all packages");
uint16_t tableSize = readUInt16(in);
protocolDispatchTableTable = new ProtocolDispatchTable[tableSize];
protocolDTTOffset = readUInt16(in);
for (uint16_t count = readUInt16(in); count > 0; count--) {
DEBUG_LOG("➡️ Still %d value type protocol tables to load", count);
auto index = readUInt16(in);
readProtocolTable(protocolDispatchTableTable[index - protocolDTTOffset], functionTable, in);
}
size_t n = readInstruction(in);
boxObjectVariableRecordTable = new BoxObjectVariableRecords[n];
for (size_t i = 0; i < n; i++) {
boxObjectVariableRecordTable[i].count = readUInt16(in);
boxObjectVariableRecordTable[i].records = new ObjectVariableRecord[boxObjectVariableRecordTable[i].count];
for (size_t j = 0; j < boxObjectVariableRecordTable[i].count; j++) {
boxObjectVariableRecordTable[i].records[j].variableIndex = readUInt16(in);
boxObjectVariableRecordTable[i].records[j].condition = readUInt16(in);
boxObjectVariableRecordTable[i].records[j].type = static_cast<ObjectVariableType>(readUInt16(in));
}
}
stringPoolCount = readUInt16(in);
DEBUG_LOG("Reading string pool with %d strings", stringPoolCount);
stringPool = new Object*[stringPoolCount];
for (int i = 0; i < stringPoolCount; i++) {
Object *o = newObject(CL_STRING);
auto *string = o->val<String>();
string->length = readUInt16(in);
string->charactersObject = newArray(string->length * sizeof(EmojicodeChar));
for (int j = 0; j < string->length; j++) {
string->characters()[j] = readEmojicodeChar(in);
}
stringPool[i] = o;
}
DEBUG_LOG("✅ Program ready for execution");
return functionTable[0];
}
