bool SoftwareI2CPort::_read(uint8_t u8SlaveAddress, void* pData, uint16_t u16Size, bool holdLow)
{
uint8_t * transfer_data = reinterpret_cast<uint8_t *>(pData);
m_scl.setDirection(GpioPin::kInput);
m_sda.setDirection(GpioPin::kInput);
m_scl.clear();
m_sda.clear();
sendStart();
bool ret = sendByte((u8SlaveAddress << 1) | 0x01, true);
if (!ret)
{
sendStop();
return ret;
}
while (u16Size--)
{
// The last byte in the transfer must NAK the byte. This tells
// the slave device that the transfer is finished.
bool isLast = (u16Size == 0);
*transfer_data++ = readByte(!isLast, (isLast && holdLow));
}
sendStop();
return true;
}
void QSFcanvas::gamePadEvent(){
sf::Event Event;
if (this->GetEvent(Event))
{
if((Event.Type == sf::Event::JoyMoved) && ((Event.JoyMove.Axis == sf::Joy::AxisX)) ){
axisXPos = Event.JoyMove.Position/100;
// std::cout << this->GetInput().GetJoystickAxis(0,sf::Joy::AxisX) << std::endl;
}
if((Event.Type == sf::Event::JoyButtonPressed)){
if(Event.JoyButton.Button == 4) //L1
emit activBoost(true);
if(Event.JoyButton.Button == 0) //Triangle
emit sendStop(true);
}
if((Event.Type == sf::Event::JoyButtonReleased)){
if(Event.JoyButton.Button == 4) //L1
emit activBoost(false);
if(Event.JoyButton.Button == 0) //Triangle
emit sendStop(false);
}
}
emit sendPadPos(axisXPos);
}
int SoftwareI2CPort::send(uint8_t address, uint32_t subaddress, uint32_t subaddressLength, const void * data, uint32_t dataLength)
{
fillAddressBuffer(address, subaddress, subaddressLength);
m_scl.setDirection(GpioPin::kInput);
m_sda.setDirection(GpioPin::kInput);
m_scl.clear();
m_sda.clear();
sendStart();
bool ret = sendByte((address << 1), true);
if (!ret)
{
sendStop();
return I2C_ERROR_NO_SLAVE_ACK;
}
const uint8_t * subaddressData = (const uint8_t *)&m_addressBuffer[1];
while (subaddressLength--)
{
ret = sendByte(*subaddressData++, true);
if (!ret)
{
sendStop();
return I2C_ERROR_GOT_NAK;
}
}
const uint8_t * transfer_data = reinterpret_cast<const uint8_t *>(data);
uint32_t u16Size = dataLength;
while (u16Size--)
{
ret = sendByte(*transfer_data++, true);
if (!ret)
{
sendStop();
return I2C_ERROR_GOT_NAK;
}
}
sendStop();
return I2C_OK;
}
void Interpreter::handleSaveParams(bool reject)
{
bool running;
int32_t response;
// if we're running, stop so this doesn't take too long....
// (ie it would proceed with 1 property to returned frame, which could take 1 second or 2)
running = m_running;
if (running==1) // only if we're running and not in forced state (running==2)
sendStop();
// notify monmodules
sendMonModulesParamChange();
// save them in pixy
if (!reject)
handlePixySaveParams(false);
// reset the shadow parameters because we've saved all params
m_chirp->callSync(m_reset_shadows, END_OUT_ARGS, &response, END_IN_ARGS);
// if we're running, we've stopped, now resume
if (running==1)
{
sendRun();
m_fastPoll = false; // turn off fast polling...
}
}
void RiscComm::onConsoleInput(QString input)
{
m_sp->readAll(); // flush any residual crap out (from FPGA reset for example)
if (input.compare("s") == 0) {
sendStep();
doScan();
}
else if (input.compare("sc") == 0)
doScan();
else if (input.compare("q") == 0)
QCoreApplication::exit();
else if (input.compare("r") == 0)
sendRun();
else if (input.compare("rs") == 0)
sendReset();
else if (input.compare("st") == 0) {
sendStop();
doScan();
} else if (input.startsWith("wp")) {
QStringList args = input.split(" ");
if (args.length() == 2) { // upload a file
sendProgram(args.at(1));
}
} else if (input.compare("clrmem") == 0) {
QByteArray zeros;
zeros.fill(0, 256);
writeMem(zeros, 0, true);
} else if (input.compare("dm") == 0) {
dumpMem();
}
else
qDebug() << "Unknown command:" << input;
}
void Interpreter::handlePendingCommand()
{
QMutexLocker locker(&m_mutexQueue);
if (m_commandQueue.empty())
return;
const Command command = m_commandQueue.front();
m_commandQueue.pop();
locker.unlock();
switch (command.first)
{
case STOP:
sendStop();
break;
case RUN:
sendRun();
break;
case GET_ACTION:
sendGetAction(command.second.toInt());
break;
case LOAD_PARAMS:
handleLoadParams();
break;
case SAVE_PARAMS:
handleSaveParams();
break;
}
}
void DebuggerMagager::stop(const ast::Exp* pExp, int index)
{
//send stop information to all debuggers
setExp(pExp);
sendStop(index);
internal_stop();
clearExp();
}
bool SoftwareI2CPort::_write(uint8_t u8SlaveAddress, const void* pData, uint16_t u16Size, bool doSendStart, bool bStop, bool holdLow)
{
const uint8_t * transfer_data = reinterpret_cast<const uint8_t *>(pData);
if (doSendStart)
{
m_scl.setDirection(GpioPin::kInput);
}
m_sda.setDirection(GpioPin::kInput);
m_scl.clear();
m_sda.clear();
if (doSendStart)
{
sendStart();
}
bool ret = sendByte((u8SlaveAddress << 1), true);
if (!ret)
{
sendStop();
return ret;
}
while (u16Size--)
{
bool isLast = (u16Size == 0);
ret = sendByte(*transfer_data++, (isLast && holdLow));
if (!ret)
{
sendStop();
return ret;
}
}
if (bStop)
{
sendStop();
}
return true;
}
UniversalPana::UniversalPana(KInstance *inst,QObject *parent,QWidget *widgetParent, QString &desktopName, const char* name):
KonqSidebarPlugin(inst,parent,widgetParent,desktopName,name)
{
KGlobal::iconLoader()->addAppDir( "pana" );
widget = new panaWidget( widgetParent );
// widgetParent->resize(580,300);
KToolBar *topBar = new KToolBar( widget, "Topbar" );
topBar->setIconSize(16);
topBar->insertButton( "today", 0, SIGNAL( clicked() ), this, SLOT( currentTrack() ) );
topBar->insertButton( "document", 0, SIGNAL( clicked() ), this, SLOT( lyrics() ) );
topBar->insertButton( "personal", 0, SIGNAL( clicked() ), this, SLOT( wiki() ) );
browser = new KHTMLPart(widget, "widget-browser");
//browser=new KHTMLPart(widget);
kdDebug() << "parentPart() << " << browser->parentPart() << endl;
browser->setDNDEnabled( true );
browser->setEncoding( "utf8", true );
updateBrowser( HTML_FILE );
browser->view()->installEventFilter( widget );
panaDCOP = new DCOPClient();
panaDCOP->attach();
playerStub = new PanaPlayerInterface_stub( panaDCOP, "pana", "player");
playlistStub = new PanaPlaylistInterface_stub( panaDCOP, "pana", "playlist");
contextStub = new PanaContextBrowserInterface_stub (panaDCOP, "pana", "contextbrowser");
KToolBar* toolBar=new KToolBar(widget, "PlayerControls");
toolBar->setIconSize(16);
toolBar->insertButton( "player_start",0, SIGNAL( clicked() ), this, SLOT( sendPrev() ) );
toolBar->insertButton( "player_play", 0, SIGNAL( clicked() ), this, SLOT( sendPlay() ) );
toolBar->insertButton( "player_pause",0, SIGNAL( clicked() ), this, SLOT( sendPause() ) );
toolBar->insertButton( "player_stop", 0, SIGNAL( clicked() ), this, SLOT( sendStop() ) );
toolBar->insertButton( "player_end", 0, SIGNAL( clicked() ), this, SLOT( sendNext() ) );
toolBar->insertSeparator();
toolBar->insertButton( "arts", 0, SIGNAL( clicked() ), this, SLOT( sendMute() ) );
vol_slider = new QSlider(0,100,1,0,Qt::Horizontal, toolBar,"volume");
vol_slider->setLineStep(2);
connect(vol_slider, SIGNAL( valueChanged(int) ), this, SLOT(volChanged(int ) ) );
toolBar->insertWidget(1,2, vol_slider);
fileInfo = new QFileInfo(HTML_FILE);
QTimer *t = new QTimer( this );
connect( t, SIGNAL(timeout()), SLOT(updateStatus() ) );
t->start( 2000, false );
kdDebug() << "Connecting widget signal" << endl;
connect( widget, SIGNAL( emitURL( const KURL &)),
this, SLOT( openURLRequest( const KURL &) ) );
connect( browser->browserExtension(), SIGNAL( openURLRequest( const KURL &, const KParts::URLArgs & ) ),
this, SLOT( openURLRequest( const KURL & ) ) );
widget->show();
}
void Interpreter::handlePendingCommand()
{
QMutexLocker locker(&m_mutexQueue);
if (m_commandQueue.empty())
return;
const Command command = m_commandQueue.front();
m_commandQueue.pop_front();
locker.unlock();
switch (command.m_type)
{
case STOP:
sendStop();
break;
case RUN:
sendRun();
break;
case STOP_LOCAL:
m_localProgramRunning = false;
emit runState(false);
break;
case RUN_LOCAL:
if (m_program.size()>0)
{
m_localProgramRunning = true;
emit runState(true);
emit enableConsole(false);
m_pc = 0;
}
break;
case LOAD_PARAMS:
handleLoadParams();
break;
case SAVE_PARAMS:
handleSaveParams(command.m_arg0.toBool());
break;
case UPDATE_PARAM:
handleUpdateParam();
break;
case CLOSE:
emit runState(-1);
break;
}
}
tHandle cJuryTransmitter::CreateView()
{
QWidget* pWidget = (QWidget*)m_pViewport->VP_GetWindow();
m_pWidget = new DisplayWidget(pWidget);
connect(m_pWidget, SIGNAL(sendNotAus()), this, SLOT(OnNotAus()));
connect(m_pWidget, SIGNAL(sendStart(tInt16)), this, SLOT(OnStart(tInt16)));
connect(m_pWidget, SIGNAL(sendStop(tInt16)), this, SLOT(OnStop(tInt16)));
connect(m_pWidget, SIGNAL(sendReadyRequest(tInt16)), this, SLOT(OnRequestReady(tInt16)));
connect(this, SIGNAL(sendDriverState(int, int)), m_pWidget, SLOT(OnDriverState(int, int)));
connect(this, SIGNAL(sendMessage(QString)), m_pWidget, SLOT(OnAppendText(QString)));
return (tHandle)m_pWidget;
}
// note that you need to wait at least 5ms after power on to initialize
void HMC5843::init()
{
PORTC = 0b00110000; // Use the internal pull up resistors
// Choose 100KHz for the bus. Formula from 21.5.2 in ATmega168 datasheet.
TWSR &= ~((1<<TWPS1)&(1<<TWPS0));
TWBR = (unsigned char)(F_CPU/200000l-8);
// Put the HMC5843 into continuous mode
sendStart();
sendByte(0x3C);
sendByte(0x02);
sendByte(0x00);
sendStop();
// note that you need to wait 100ms after this before first calling recieve
}
void Interpreter::handlePendingCommand()
{
switch (m_pendingCommand)
{
case NONE:
break;
case STOP:
sendStop();
break;
case RUN:
sendRun();
break;
}
m_pendingCommand = NONE;
}
// This can be called at 100ms intervals to get new data
void HMC5843::getValues(int *x, int *y, int *z)
{
unsigned char xin, yin, zin;
// start the reading
sendStart();
sendByte(0x3D);
// read out the 3 values, 2 bytes each. lsb first, then msb.
xin = receiveByte();
*x = (xin<<8)|receiveByte();
yin = receiveByte();
*y = (yin<<8)|receiveByte();
zin = receiveByte();
*z = (zin<<8)|receiveByte();
// wrap back around for the next set of reads and close
sendByte(0x3D);
sendStop();
}
void Interpreter::handleLoadParams()
{
DBG("loading...");
uint i;
char *id, *desc;
uint32_t len;
uint32_t flags;
int response, res;
uint8_t *data, *argList;
int running;
// if we're running, stop so this doesn't take too long....
// (ie it would proceed with 1 property to returned frame, which could take 1 second or 2)
running = m_running;
if (running==1) // only if we're running and not in forced state (running==2)
sendStop();
for (i=0; true; i++)
{
QString category;
res = m_chirp->callSync(m_getAll_param, UINT16(i), END_OUT_ARGS, &response, &flags, &argList, &id, &desc, &len, &data, END_IN_ARGS);
if (res<0)
break;
if (response<0)
break;
QString sdesc(desc);
Parameter parameter(id, (PType)argList[0]);
parameter.setProperty(PP_FLAGS, flags);
handleProperties(argList, ¶meter, &sdesc);
parameter.setHelp(sdesc);
// deal with param category
if (strlen((char *)argList)>1)
{
QByteArray a((char *)data, len);
parameter.set(a);
}
else
{
if (argList[0]==CRP_INT8 || argList[0]==CRP_INT16 || argList[0]==CRP_INT32)
{
int32_t val = 0;
Chirp::deserialize(data, len, &val, END);
parameter.set(val);
}
else if (argList[0]==CRP_FLT32)
{
float val;
Chirp::deserialize(data, len, &val, END);
parameter.set(val);
}
else // not sure what to do with it, so we'll save it as binary
{
QByteArray a((char *)data, len);
parameter.set(a);
}
}
// it's changed! (ie, it's been loaded)
parameter.setDirty(true);
m_pixyParameters.add(parameter);
}
// if we're running, we've stopped, now resume
if (running==1)
{
sendRun();
m_fastPoll = false; // turn off fast polling...
}
DBG("loaded");
emit paramLoaded();
sendMonModulesParamChange();
m_pixyParameters.clean();
}
void Interpreter::handleSaveParams()
{
int i;
int res, response;
bool dirty, running;
// if we're running, stop so this doesn't take too long....
// (ie it would proceed with 1 property to returned frame, which could take 1 second or 2)
running = m_running;
if (running==1) // only if we're running and not in forced state (running==2)
sendStop();
Parameters ¶meters = m_pixyParameters.parameters();
for (i=0, dirty=false; i<parameters.size(); i++)
{
uint8_t buf[0x100];
if (parameters[i].dirty())
{
int len;
QByteArray str = parameters[i].id().toUtf8();
const char *id = str.constData();
PType type = parameters[i].type();
parameters[i].setDirty(false); // reset
dirty = true; // keep track for sending signal
qDebug() << id;
if (type==PT_INT8 || type==PT_INT16 || type==PT_INT32)
{
int val = parameters[i].value().toInt();
len = Chirp::serialize(NULL, buf, 0x100, type, val, END);
}
else if (type==PT_FLT32)
{
float val = parameters[i].value().toFloat();
len = Chirp::serialize(NULL, buf, 0x100, type, val, END);
}
else if (type==PT_INTS8)
{
QByteArray a = parameters[i].value().toByteArray();
len = a.size();
memcpy(buf, a.constData(), len);
}
else
continue; // don't know what to do!
res = m_chirp->callSync(m_set_param, STRING(id), UINTS8(len, buf), END_OUT_ARGS, &response, END_IN_ARGS);
if (res<0 || response<0)
{
emit error("There was a problem setting a parameter.");
break;
}
}
}
// if we're running, we've stopped, now resume
if (running==1)
{
sendRun();
m_fastPoll = false; // turn off fast polling...
}
if (dirty) // if we updated any parameters, output paramChange signal
emit paramChange();
}
void Interpreter::handleLoadParams()
{
qDebug("loading...");
uint i;
char *id, *desc;
uint32_t len;
uint32_t flags;
int response, res;
uint8_t *data, *argList;
int running;
// if we're running, stop so this doesn't take too long....
// (ie it would proceed with 1 property to returned frame, which could take 1 second or 2)
running = m_running;
if (running==1) // only if we're running and not in forced state (running==2)
sendStop();
for (i=0; true; i++)
{
QString category;
res = m_chirp->callSync(m_getAll_param, UINT16(i), END_OUT_ARGS, &response, &flags, &argList, &id, &desc, &len, &data, END_IN_ARGS);
if (res<0)
break;
if (response<0)
break;
QString sdesc(desc);
// deal with param category
QStringList words = QString(desc).split(QRegExp("\\s+"));
int i = words.indexOf("@c");
if (i>=0 && words.size()>i+1)
{
category = words[i+1];
sdesc = sdesc.remove("@c "); // remove form description
sdesc = sdesc.remove(category + " "); // remove from description
category = category.replace('_', ' '); // make it look prettier
}
else
category = CD_GENERAL;
Parameter parameter(id, (PType)argList[0], "("+printArgType(argList[0], flags)+") "+sdesc);
parameter.setProperty(PP_CATEGORY, category);
parameter.setProperty(PP_FLAGS, flags);
if (strlen((char *)argList)>1)
{
QByteArray a((char *)data, len);
parameter.set(a);
}
else
{
if (argList[0]==CRP_INT8 || argList[0]==CRP_INT16 || argList[0]==CRP_INT32)
{
int32_t val = 0;
Chirp::deserialize(data, len, &val, END);
parameter.set(val);
}
else if (argList[0]==CRP_FLT32)
{
float val;
Chirp::deserialize(data, len, &val, END);
parameter.set(val);
}
else // not sure what to do with it, so we'll save it as binary
{
QByteArray a((char *)data, len);
parameter.set(a);
}
}
m_pixyParameters.add(parameter);
}
// if we're running, we've stopped, now resume
if (running==1)
{
sendRun();
m_fastPoll = false; // turn off fast polling...
}
qDebug("loaded");
emit paramLoaded();
if (m_paramDirty) // emit first time to update any modules waiting to get paramter info
{
m_paramDirty = false;
emit paramChange();
}
}
void Interpreter::run()
{
int res;
QTime time;
// init
try
{
ChirpProc versionProc;
uint16_t *version;
uint32_t verLen, responseInt;
if (m_link.open()<0)
throw std::runtime_error("Unable to open USB device.");
m_chirp = new ChirpMon(this, &m_link);
// get version and compare
versionProc = m_chirp->getProc("version");
if (versionProc<0)
throw std::runtime_error("Can't get firmware version.");
res = m_chirp->callSync(versionProc, END_OUT_ARGS, &responseInt, &verLen, &version, END_IN_ARGS);
if (res<0)
throw std::runtime_error("Can't get firmware version.");
memcpy(m_version, version, 3*sizeof(uint16_t));
if (m_version[0]!=VER_MAJOR || m_version[1]>VER_MINOR)
{
char buf[0x100];
sprintf(buf, "This Pixy's firmware version (%d.%d.%d) is not compatible with this PixyMon version (%d.%d.%d).",
m_version[0], m_version[1], m_version[2], VER_MAJOR, VER_MINOR, VER_BUILD);
throw std::runtime_error(buf);
}
m_exec_run = m_chirp->getProc("run");
m_exec_running = m_chirp->getProc("running");
m_exec_stop = m_chirp->getProc("stop");
m_exec_get_action = m_chirp->getProc("getAction");
m_get_param = m_chirp->getProc("prm_get");
m_getAll_param = m_chirp->getProc("prm_getAll");
m_set_param = m_chirp->getProc("prm_set");
if (m_exec_run<0 || m_exec_running<0 || m_exec_stop<0 || m_exec_get_action<0 ||
m_get_param<0 || m_getAll_param<0 || m_set_param<0)
throw std::runtime_error("Communication error with Pixy.");
}
catch (std::runtime_error &exception)
{
emit error(QString(exception.what()));
return;
}
qDebug() << "*** init done";
time.start();
getRunning();
handleLoadParams(); // load params upon initialization
while(m_run)
{
if (!m_programming &&
((m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_FAST) ||
(!m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_SLOW)))
{
getRunning();
time.start();
}
else
{
m_chirp->service(false);
msleep(1); // give config thread time to run
}
handlePendingCommand();
if (!m_running)
{
if (m_localProgramRunning)
execute();
else
{
Sleeper::msleep(10);
if (m_mutexProg.tryLock())
{
if (m_argv.size())
{
if (m_externalCommand!="") // print command to make things explicit and all pretty
emit textOut(PROMPT " " + m_externalCommand);
if (m_argv[0]=="help")
handleHelp();
else
{
res = call(m_argv, true);
if (res<0)
{
if (m_programming)
{
endLocalProgram();
clearLocalProgram();
}
m_commandList.clear(); // abort our little scriptlet
}
}
m_argv.clear();
if (m_externalCommand=="")
prompt(); // print prompt only if we expect an actual human to be typing into the command window
else
m_externalCommand = "";
// check quickly to see if we're running after this command
if (!m_programming)
getRunning();
// is there another command in our little scriptlet?
if (m_commandList.size())
{
execute(m_commandList[0]);
m_commandList.removeFirst();
}
}
m_mutexProg.unlock();
}
}
}
}
sendStop();
msleep(200); // let things settle a bit
qDebug("worker thead exiting");
}
