void LocalPC::makeMaster()
{
bool online = false;
DEBUG_OUTPUT("[LocalPC]try make MASTER\n");
DEBUG_OUTPUT("[LocalPC]I'm %s\n", LOCAL_MASTER==getState()?"MASTER":"SLAVE");
enter();
online = floatIPOnline();
leave();
if(online)
{
DEBUG_OUTPUT("[LocalPC]ip(%s) online\n", mFloatIP);
return;
}
bool master = !isSlave();
if(master)
{
makeSlave();
return;
}
enter();
DEBUG_OUTPUT("[LocalPC]add ip(%s) to ethernet(%s) ... \n", mFloatIP, mEthernet);
Ipconfig ipconfig;
ipconfig.addIP(mEthernet, mFloatIP, mFloatNetmask, mFloatGateway);
online = floatIPOnline();
leave();
if(online)
{
DEBUG_OUTPUT("[LocalPC]add ip ok\n");
setState(LOCAL_MASTER);
}
}
MyMoneyMoney ReportAccount::deepCurrencyPrice(const QDate& date, bool exactDate) const
{
DEBUG_ENTER(Q_FUNC_INFO);
MyMoneyMoney result(1, 1);
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneySecurity undersecurity = file->security(currencyId());
if (! undersecurity.isCurrency()) {
const MyMoneyPrice &price = file->price(undersecurity.id(), undersecurity.tradingCurrency(), date, exactDate);
if (price.isValid()) {
result = price.rate(undersecurity.tradingCurrency());
DEBUG_OUTPUT(QString("Converting under %1 to deep %2, price on %3 is %4")
.arg(undersecurity.name())
.arg(file->security(undersecurity.tradingCurrency()).name())
.arg(date.toString())
.arg(result.toDouble()));
} else {
DEBUG_OUTPUT(QString("No price to convert under %1 to deep %2 on %3")
.arg(undersecurity.name())
.arg(file->security(undersecurity.tradingCurrency()).name())
.arg(date.toString()));
result = MyMoneyMoney();
}
}
return result;
}
uint8_t nrf24l01p_transmit( uint8_t *data, uint8_t len ){
uint8_t status;
uint8_t ret;
/* Check fifo full */
status = nrf24l01p_singleReadReg( FIFO_STATUS );
if( fifo_tx_full( status ) ){
DEBUG_OUTPUT( "transmit error: fifo full\n" );
return 0;
}
nrf24l01p_doCommand( W_TX_PAYLOAD, data, 0, len );
if( nrf24l01p_conf.config & (1<<MASK_TX_DS) ){ // Interrupt disabled
while( 1 ){
status = nrf24l01p_singleReadReg( STATUS );
if( status & (1<<TX_DS) ){
ret = 1;
break;
}
else if( status & (1<<MAX_RT) ){
DEBUG_OUTPUT( "transmit error: timeout\r\n" );
ret = 0;
break;
}
}
}
//nrf24l01p_singleWriteReg( STATUS, 0xff );
return ret;
}
/// Constructs a SimpleBlockFile based on sample data and writes
/// it to disk.
///
/// @param baseFileName The filename to use, but without an extension.
/// This constructor will add the appropriate
/// extension (.au in this case).
/// @param sampleData The sample data to be written to this block.
/// @param sampleLen The number of samples to be written to this block.
/// @param format The format of the given samples.
/// @param allowDeferredWrite Allow deferred write-caching
SimpleBlockFile::SimpleBlockFile(wxFileName baseFileName,
samplePtr sampleData, sampleCount sampleLen,
sampleFormat format,
bool allowDeferredWrite /* = false */):
BlockFile(wxFileName(baseFileName.GetFullPath() + wxT(".au")), sampleLen)
{
mCache.active = false;
DEBUG_OUTPUT("SimpleBlockFile created based on sample data");
bool useCache = GetCache();
if (!(allowDeferredWrite && useCache))
WriteSimpleBlockFile(sampleData, sampleLen, format, NULL);
if (useCache) {
DEBUG_OUTPUT("Caching block file data");
mCache.active = true;
mCache.needWrite = true;
mCache.format = format;
mCache.sampleData = new char[sampleLen * SAMPLE_SIZE(format)];
memcpy(mCache.sampleData,
sampleData, sampleLen * SAMPLE_SIZE(format));
void* summaryData = BlockFile::CalcSummary(sampleData, sampleLen,
format);
mCache.summaryData = new char[mSummaryInfo.totalSummaryBytes];
memcpy(mCache.summaryData, summaryData,
(size_t)mSummaryInfo.totalSummaryBytes);
}
}
static void *thread_task_entry(void *arg)
{
// attention! here no lock
easy_tp_man *manager = ((thread_task_arg *)(arg))->man;
thread_info *ti = ((thread_task_arg *)(arg))->ti;
int id = ((thread_task_arg *)(arg))->id;
//
for (;;)
{
task_node *task;
int ret = 0;
struct timespec ts;
pthread_mutex_lock(ti->active_mutex);
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += THREAD_TIMED_OUT;
while (ti->task == NULL && ret == 0)
ret = pthread_cond_timedwait(ti->active_cond, ti->active_mutex, &ts);
task = ti->task;
ti->task = NULL;
if (ret == ETIMEDOUT && ti->task == NULL)
{
DEBUG_OUTPUT("thread %d time out\n", id);
ti->timedout = 1;
}
pthread_mutex_unlock(ti->active_mutex);
if (!task)
{
DEBUG_OUTPUT("thread %d happend a NULL task\n", id);
break;
}
if (task->func != exit_task_entry)
{
// ASSERT(ti->task);
task->desc->ret = task->func(task->desc->arg);
if (task->desc->fire_task_over)
task->desc->fire_task_over(task->desc);
free(task);
// become idle
pthread_mutex_lock(manager->idle_threads.mutex);
manager->idle_threads.idxs[manager->idle_threads.size++] = id;
pthread_mutex_unlock(manager->idle_threads.mutex);
pthread_cond_signal(manager->idle_threads.cond);
}
else
{
free(task);
break;
}
}
exit_task_entry(&id);
free(arg);
return 0;
}
void gps_satellite_telemetry() {
DEBUG_OUTPUT("Time: %02d:%02d:%02d\r\n", NMEA::getHour(), NMEA::getMinute(), NMEA::getSecond());
DEBUG_OUTPUT("Satellites: %d\r\n", NMEA::getSatellites());
DEBUG_OUTPUT("Latitude: %0.5f\r\n", NMEA::getLatitude());
DEBUG_OUTPUT("Longitude: %0.5f\r\n", NMEA::getLongitude());
DEBUG_OUTPUT("Altitude: %0.2fm\r\n", NMEA::getAltitude());
DEBUG_OUTPUT("Speed: %0.2fkm/h\r\n", NMEA::getSpeed());
DEBUG_OUTPUT("GPS Bearing (Track made good): %0.2f degrees\r\n", NMEA::getBearing());
DEBUG_OUTPUT("Compass Bearing: %03.0f\r\n", bearing);
DEBUG_OUTPUT("Heading Delta to Waypoint: %03.0f\r\n", heading_delta(180.0, bearing));
DEBUG_OUTPUT("Distance to Next Nav %06.2fm\r\n",
distance_to_current_nav(degToRad((double)NMEA::getLatitude()), degToRad((double)NMEA::getLongitude()))
);
#ifdef SEND_TELEMETRY
shedBoat_Telemetry telemetryMessage = shedBoat_Telemetry_init_zero;
if(autopilotEngaged) {
telemetryMessage.status = shedBoat_Telemetry_Status_UNDERWAY_AUTOPILOT;
}
else {
telemetryMessage.status = shedBoat_Telemetry_Status_UNDERWAY_MANUAL;
}
telemetryMessage.has_location = true;
telemetryMessage.location.has_latitude = true;
telemetryMessage.location.latitude = NMEA::getLatitude();
telemetryMessage.location.has_longitude = true;
telemetryMessage.location.longitude = NMEA::getLongitude();
telemetryMessage.location.has_number_of_satellites_visible = true;
telemetryMessage.location.number_of_satellites_visible = NMEA::getSatellites();
telemetryMessage.location.has_true_heading = true;
telemetryMessage.location.true_heading = heading * 1000;
telemetryMessage.location.has_true_bearing = true;
telemetryMessage.location.true_bearing = bearing * 1000;
telemetryMessage.location.has_speed_over_ground = true;
telemetryMessage.location.speed_over_ground = NMEA::getSpeed() * 1000;
telemetryMessage.location.has_utc_seconds = true;
telemetryMessage.location.utc_seconds = NMEA::getSecond();
telemetryMessage.location.fix_quality = (_shedBoat_Location_Quality)NMEA::getFixQuality();
telemetryMessage.location.has_distance_to_waypoint = true;
telemetryMessage.location.distance_to_waypoint = (int32_t)distance_to_current_nav(degToRad((double)NMEA::getLatitude()), degToRad((double)NMEA::getLongitude()));
telemetryMessage.location.has_waypoint_number = true;
telemetryMessage.location.waypoint_number = get_nav_num();
uint8_t buffer[100];
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
bool success = pb_encode(&stream, shedBoat_Telemetry_fields, &telemetryMessage);
if(success) {
send_xbee_packet(buffer, stream.bytes_written);
} else {
error("Failed to encode Proto Buffer");
}
#endif
}
JNIEXPORT void JNICALL
Java_xxl_core_io_raw_NativeRawAccess_read (JNIEnv *env, jobject obj, jbyteArray jblock, jlong sector) {
FILE *jfilep = (FILE*) getfilep(env, obj); // Get the device int
jlong fpos; // The position to read on the device
jint sectorSize = getsectorSize(env, obj);
jlong len = (*env)->GetArrayLength(env, jblock);
jbyte *block = (*env)->GetByteArrayElements(env, jblock, 0);
#ifdef SEQ_OPT
jlong lastSector = getlastSector(env, obj);
#endif
DEBUG_OUTPUT("read: sector==%d", (long) sector);
if (jfilep==0) {
reportError(env,obj,"file not open");
return;
}
// Is it exactly one block
if (len!=sectorSize) {
reportError(env,obj,"byte array does not have sector size");
return;
}
#ifdef SEQ_OPT
if (sector != lastSector+1) {
// non sequential access!
#endif
fpos = (jlong) sector * sectorSize;
if (fseek(jfilep,fpos,SEEK_SET)==-1) {
reportError(env,obj,"filepointer could not be set");
return;
}
#ifdef SEQ_OPT
}
#endif
DEBUG_OUTPUT("read the block",0);
// Read the block
if (fread(block, 1, sectorSize, jfilep)!=sectorSize) {
reportError(env,obj,"read failed");
return;
}
// Convert the c block array to a java byte array
(*env)->SetByteArrayRegion(env, jblock, 0, sectorSize, block);
#ifdef SEQ_OPT
setlastSector(env, obj, sector);
#endif
(*env)->ReleaseByteArrayElements(env, jblock, block, 0);
}
void LocalPC::makeSlave()
{
bool found = false;
enter();
DEBUG_OUTPUT("[LocalPC]delete ip(%s) from ethernet(%s) ... \n", mFloatIP, mEthernet);
Ipconfig ipconfig;
ipconfig.delIP(mEthernet, mFloatIP);
found = (!ipconfig.hasIP(mFloatIP));
leave();
if(found)
{
DEBUG_OUTPUT("[LocalPC]delete ip ok\n");
setState(LOCAL_SLAVE);
}
}
void LocalPC::setEthernet(char *ethernet)
{
enter();
mEthernet = ethernet;
DEBUG_OUTPUT("[LocalPC]ethernet:%s\n", mEthernet);
leave();
}
void LocalPC::setFloatNetmask(char *netmask)
{
enter();
mFloatNetmask = netmask;
DEBUG_OUTPUT("[LocalPC]float netmask:%s\n", mFloatNetmask);
leave();
}
void LocalPC::tcpServerReceiveData(void *tcp, char *buffer, int size)
{
DEBUG_OUTPUT("[LocalPC]receive:\n%s\n", buffer_format(buffer, size));
HeartbeatProtocol protocol;
Heartbeat *hb = protocol.find(buffer, size);
if(hb!=NULL)
{
delete hb;
char *p = NULL;
int size = 0;
bool slave = isSlave();
double timePoint = getSetupTime();
Heartbeat *t = protocol.makeHeartbeat(slave, timePoint);
if(NULL!=t)
{
if(t->makeBuffer(&p, size))
{
TcpClient *client = (TcpClient *)tcp;
client->send(p, size);
delete p;
}
}
}
}
void LocalPC::setFloatIP(char *floatIP)
{
enter();
mFloatIP = floatIP;
DEBUG_OUTPUT("[LocalPC]float ip:%s\n", mFloatIP);
leave();
}
//*****************************************************************************
//
// Start the process of enumerating a new device by issuing a reset to the
// appropriate downstream port.
//
//*****************************************************************************
static void
HubDriverDeviceReset(uint8_t ui8Port)
{
DEBUG_OUTPUT("Starting enumeration for port %d\n", ui8Port);
//
// Record the fact that we are in the process of enumerating a device.
//
g_sRootHub.bEnumerationBusy = true;
//
// Save the port that is being enumerated.
//
g_sRootHub.ui8EnumIdx = ui8Port;
//
// Mark the port as being reset.
//
g_sRootHub.psPorts[ui8Port].iState = ePortResetActive;
//
// Initiate a reset on the relevant port to start the enumeration process.
//
HubSetPortFeature(&g_sRootHub, ui8Port, HUB_FEATURE_PORT_RESET);
}
ReportAccount::ReportAccount(const QString& accountid):
MyMoneyAccount(MyMoneyFile::instance()->account(accountid))
{
DEBUG_ENTER(Q_FUNC_INFO);
DEBUG_OUTPUT(QString("Account %1").arg(accountid));
calculateAccountHierarchy();
}
void send_debug_telemetry()
{
#ifdef SEND_TELEMETRY
shedBoat_Telemetry telemetryMessage = shedBoat_Telemetry_init_zero;
telemetryMessage.status = shedBoat_Telemetry_Status_STATIONARY;
telemetryMessage.has_debug = true;
telemetryMessage.debug.has_bearing_compensation = true;
telemetryMessage.debug.bearing_compensation = bearingCompensation * 1000;
telemetryMessage.debug.has_speed_over_ground_compensation = true;
telemetryMessage.debug.speed_over_ground_compensation = speedOverGroundCompensation * 1000;
telemetryMessage.debug.has_motor_1_throttle_compensation = true;
telemetryMessage.debug.motor_1_throttle_compensation = leftThrottle * 1000;
telemetryMessage.debug.has_motor_2_throttle_compensation = true;
telemetryMessage.debug.motor_2_throttle_compensation = rightThrottle * 1000;
uint8_t buffer[100];
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
bool success = pb_encode(&stream, shedBoat_Telemetry_fields, &telemetryMessage);
if(success) {
send_xbee_packet(buffer, stream.bytes_written);
} else {
error("Failed to encode Proto Buffer");
DEBUG_OUTPUT("Failed to encode Proto Buffer /r/n");
}
#endif
}
void printString(const String* inStr)
{
if(inStr->length == 0)
return;
DEBUG_OUTPUT(("%.*s", inStr->length, inStr->str));
}
ReportAccount::ReportAccount(const MyMoneyAccount& account):
MyMoneyAccount(account)
{
DEBUG_ENTER(Q_FUNC_INFO);
DEBUG_OUTPUT(QString("Account %1").arg(account.id()));
calculateAccountHierarchy();
}
void LocalPC::setFloatGateway(char *gateway)
{
enter();
mFloatGateway = gateway;
DEBUG_OUTPUT("[LocalPC]float gateway:%s\n", mFloatGateway);
leave();
}
//*****************************************************************************
//
// This function is used to retrieve the current status of a port on the
// hub.
//
// \param psHubInstance is the hub device instance.
// \param ui8Port is the port number for this request.
// \param pui16PortStatus is a pointer to the memory to store the current
// status of the port.
// \param pui16PortChange is a pointer to the memory to store the current
// change status of the ports.
//
// This function is used to retrieve the current overall status and change
// status for the port given in the \e ui8Port parameter. The \e ui8Port value
// indicates which port number to send this request to and can range from 0 to
// the number of valid ports on the given hub. A \e ui8Port value of 0 is an
// access to the hub itself and not one of the hub ports.
//
// \return None.
//
//*****************************************************************************
static bool
HubGetPortStatus(tHubInstance *psHubInstance, uint8_t ui8Port,
uint16_t *pui16PortStatus, uint16_t *pui16PortChange)
{
uint32_t ui32Data, ui32Read;
tUSBRequest sSetupPacket;
tUSBHostDevice *psDevice;
//
// Retrieve the device pointer.
//
psDevice = psHubInstance->psDevice;
//
// This is a standard OUT request.
//
sSetupPacket.bmRequestType = USB_RTYPE_DIR_IN | USB_RTYPE_CLASS |
USB_RTYPE_OTHER;
//
// Set the fields to get the hub status.
//
sSetupPacket.bRequest = USBREQ_GET_STATUS;
sSetupPacket.wValue = 0;
sSetupPacket.wIndex = (uint16_t)ui8Port;
sSetupPacket.wLength = 4;
//
// Send the request.
//
ui32Read = USBHCDControlTransfer(0, &sSetupPacket, psDevice,
(uint8_t *)&ui32Data, 4,
psDevice->sDeviceDescriptor.bMaxPacketSize0);
//
// Check that we received the correct number of bytes.
//
if(ui32Read != 4)
{
return(false);
}
else
{
//
// We got 4 bytes from the device. Now translate these into the 2
// 16-bit values we pass back to the caller.
//
*pui16PortStatus = (uint16_t)(ui32Data & 0xFFFF);
*pui16PortChange = (uint16_t)(ui32Data >> 16);
DEBUG_OUTPUT("Port %d, status 0x%04x, change 0x%04x\n", ui8Port,
*pui16PortStatus, *pui16PortChange);
}
//
// All is well.
//
return(true);
}
//*****************************************************************************
//
//! This function is used to release a hub device instance.
//!
//! \param psHubInstance is the hub device instance that is to be released.
//!
//! This function is called when an instance of the hub device must be
//! released. This function is typically made in preparation for shutdown or a
//! switch to function as a USB device when in OTG mode. Following this call,
//! the hub device is no longer available, but it can be opened again using a
//! call to USBHHubOpen(). After calling USBHHubClose(), the host hub driver
//! no longer provides any callbacks or accepts calls to other hub driver APIs.
//!
//! \return None.
//
//*****************************************************************************
void
USBHHubClose(tHubInstance *psHubInstance)
{
//
// Forget the instance pointer and callback.
//
psHubInstance->psDevice = 0;
psHubInstance->pfnCallback = 0;
DEBUG_OUTPUT("USBHHubClose completed.\n");
}
/// Read the summary section of the disk file.
///
/// @param *data The buffer to write the data to. It must be at least
/// mSummaryinfo.totalSummaryBytes long.
bool SimpleBlockFile::ReadSummary(void *data)
{
if (mCache.active)
{
DEBUG_OUTPUT("ReadSummary: Summary is already in cache");
memcpy(data, mCache.summaryData, (size_t)mSummaryInfo.totalSummaryBytes);
return true;
} else
{
DEBUG_OUTPUT("ReadSummary: Reading summary from disk");
wxFFile file(mFileName.GetFullPath(), wxT("rb"));
wxLogNull *silence=0;
if(mSilentLog)silence= new wxLogNull();
if(!file.IsOpened() ){
memset(data,0,(size_t)mSummaryInfo.totalSummaryBytes);
if(silence) delete silence;
mSilentLog=TRUE;
return true;
}
if(silence) delete silence;
mSilentLog=FALSE;
// The offset is just past the au header
if( !file.Seek(sizeof(auHeader)) )
return false;
int read = (int)file.Read(data, (size_t)mSummaryInfo.totalSummaryBytes);
FixSummary(data);
return (read == mSummaryInfo.totalSummaryBytes);
}
}
uint8_t nrf24l01p_dataPending( ){
uint8_t status;
uint8_t fifo_status;
uint8_t pipeno = NRF24L01P_PIPE_NONE;
status = nrf24l01p_singleReadReg( STATUS );
fifo_status = nrf24l01p_singleReadReg( FIFO_STATUS );
if( status & (1<<RX_DR) ){
nrf24l01p_singleWriteReg( STATUS, 0xff );
pipeno = (status&0x0e)>>1;
DEBUG_OUTPUT( "jjjj" );
}
/// Construct a SimpleBlockFile memory structure that will point to an
/// existing block file. This file must exist and be a valid block file.
///
/// @param existingFile The disk file this SimpleBlockFile should use.
SimpleBlockFile::SimpleBlockFile(wxFileName existingFile, sampleCount len,
float min, float max, float rms):
BlockFile(existingFile, len)
{
DEBUG_OUTPUT("SimpleBlockFile based on existing file created");
mMin = min;
mMax = max;
mRMS = rms;
mCache.active = false;
}
//*****************************************************************************
//
// A new device has been connected to the hub. Allocate resources to manage
// it and pass details back to the main USB host enumeration code to have the
// device enumerated.
//
//*****************************************************************************
static void
HubDriverDeviceConnect(uint8_t ui8Port)
{
DEBUG_OUTPUT("HubDriverDeviceConnect\n");
//
// We've allocated a port table entry so fill it in then initiate a reset
// on the device.
//
g_sRootHub.psPorts[ui8Port].bChanged = false;
//
// Mark the port as having a device present but not enumerated.
//
DEBUG_OUTPUT("Deferring enumeration for port %d\n", ui8Port);
g_sRootHub.psPorts[ui8Port].iState = ePortConnected;
//
// Wait 100ms to reset the device.
//
g_sRootHub.psPorts[ui8Port].ui32Count = 100;
}
//*****************************************************************************
//
//! This function is used to enable the host hub class driver before any
//! devices are present.
//!
//! \param pfnCallback is the driver call back for host hub events.
//!
//! This function is called to open an instance of a host hub device and
//! provides a valid callback function for host hub events in the
//! \e pfnCallback parameter. This function must be called before the USB
//! host code can successfully enumerate a hub device or any devices attached
//! to the hub. The \e pui8HubPool is memory provided to the hub class to
//! manage the devices that are connected to the hub. The \e ui32PoolSize is
//! the number of bytes and should be at least 32 bytes per device including
//! the hub device itself. A simple formula for providing memory to the hub
//! class is \b MAX_USB_DEVICES * 32 bytes of data to allow for proper
//! enumeration of connected devices. The value for \b MAX_USB_DEVICES is
//! defined in the usblib.h file and controls the number of devices
//! supported by the USB library. The \e ui32NumHubs parameter
//! defaults to one and only one buffer of size tHubInstance is required to
//! be passed in the \e psHubInstance parameter.
//!
//! \note Changing the value of \b MAX_USB_DEVICES requires a rebuild of the
//! USB library to have an effect on the library.
//!
//! \return This function returns the driver instance to use for the other
//! host hub functions. If there is no instance available at the time of
//! this call, this function returns zero.
//
//*****************************************************************************
tHubInstance *
USBHHubOpen(tUSBHHubCallback pfnCallback)
{
//
// Only one hub is supported.
//
if(g_sRootHub.pfnCallback)
{
DEBUG_OUTPUT("USBHHubOpen failed - already connected.\n");
return(0);
}
//
// Save the instance data for this device.
//
g_sRootHub.pfnCallback = pfnCallback;
DEBUG_OUTPUT("USBHHubOpen completed.\n");
//
// Return the device instance pointer.
//
return(&g_sRootHub);
}
MyMoneyMoney ReportAccount::foreignCurrencyPrice(const QString foreignCurrency, const QDate& date, bool exactDate) const
{
DEBUG_ENTER(Q_FUNC_INFO);
MyMoneyMoney result(1, 1);
MyMoneyFile* file = MyMoneyFile::instance();
MyMoneySecurity security = file->security(foreignCurrency);
//check whether it is a currency or a commodity. In the latter case case, get the trading currency
QString tradingCurrency;
if (security.isCurrency()) {
tradingCurrency = foreignCurrency;
} else {
tradingCurrency = security.tradingCurrency();
}
//It makes no sense to get the price if both currencies are the same
if (currency().id() != tradingCurrency) {
const MyMoneyPrice &price = file->price(currency().id(), tradingCurrency, date, exactDate);
if (price.isValid()) {
result = price.rate(tradingCurrency);
DEBUG_OUTPUT(QString("Converting deep %1 to currency %2, price on %3 is %4")
.arg(file->currency(currency().id()).name())
.arg(file->currency(foreignCurrency).name())
.arg(date.toString())
.arg(result.toDouble()));
} else {
DEBUG_OUTPUT(QString("No price to convert deep %1 to currency %2 on %3")
.arg(file->currency(currency().id()).name())
.arg(file->currency(foreignCurrency).name())
.arg(date.toString()));
}
}
return result;
}
void nrf24l01p_enterRxMode( void ){
uint8_t config;
nrf24l01p_chipEnable( 0 );
nrf24l01p_doCommand( FLUSH_TX, 0, 0, 0 );
nrf24l01p_doCommand( FLUSH_RX, 0, 0, 0 );
nrf24l01p_singleWriteReg( STATUS, 0xff );
//nrf24l01p_singleWriteReg( CONFIG, 0x07 );
DEBUG_OUTPUT( "enter RxMode, config=0x%x\n",
nrf24l01p_conf.config|(1<<PRIM_RX)|(1<<PWR_UP));
nrf24l01p_singleWriteReg( CONFIG,
nrf24l01p_conf.config|(1<<PRIM_RX)|(1<<PWR_UP) );
nrf24l01p_chipEnable( 1 );
}
void LocalPC::emitOnSlave()
{
DEBUG_OUTPUT("[LocalPC]emit OnSlave\n");
bool hasHandler = false;
enter();
hasHandler = (NULL!=mHandler);
leave();
if(!hasHandler)
{
return;
}
enter();
mHandler->onLocalIsSlave();
leave();
}
/*
* === FUNCTION ======================================================================
* Name: NVNewRoot
* Description:
* =====================================================================================
*/
int NVNewRoot(NVRDescr * addr, void *p, char * name, size_t size) {
// check valid addr of p
long newRootOffset = addr2offset(addr,p);
void * brk = offset2addr(addr,addr->dataRegionOffset);
// DEBUG_OUTPUT("test");
if ( newRootOffset>=addr->rootMapOffset || newRootOffset<=sizeof(NVRDescr)) {
errno = EINVAL;
e("NVNewRoot fail");
}
NVRootmapItem_t * nvrmPtrCurr= offset2addr(addr, addr->rootMapOffset);
// NVRootmapItem_t * nvrmPtrIdx=nvrmPtrCurr ;
// DEBUG_OUTPUT("test");
if (NVFetchRoot(addr,name)!=NULL) {
errno=EEXIST;
e("NVNewRoot fail"); // return -1
} else {
// DEBUG_OUTPUT("test");
// // segment fault
// #ifdef DEBUG
// printf("%p\n",nvrmPtrCurr);
// printf("%p\n",brk);
// #endif
if ((void *)(--nvrmPtrCurr)> brk){
if (p==NULL){
DEBUG_OUTPUT("Error in input address");
return -2;
} else {
// DEBUG_OUTPUT("test");
nvrmPtrCurr->location = p;
nvrmPtrCurr->type = size;
strcpy(nvrmPtrCurr->name,name);
// update meta data
addr->rootMapOffset=addr2offset(membase,nvrmPtrCurr);
addr->nvRootCnt++;
// update dataregion mem
return 0;
}
} else {
errno =ENOMEM;
e("NVNewRoot fail"); // return -1
}
// DEBUG_OUTPUT("test");
}
}
//*****************************************************************************
//
//! Informs the hub class driver that a downstream device failed to enumerate.
//!
//! \param ui8Hub is the address of the hub to which the downstream device
//! is attached.
//! \param ui8Port is the port on the hub to which the downstream device is
//! attached.
//!
//! This function is called by the host controller driver to inform the hub
//! class driver that an attempt to enumerate a downstream device has failed.
//! The hub driver then cleans up and continues enumeration of any other newly
//! connected devices.
//!
//! \return None.
//
//*****************************************************************************
void
USBHHubEnumerationError(uint8_t ui8Hub, uint8_t ui8Port)
{
DEBUG_OUTPUT("Enumeration error for hub %d, port %d\n", ui8Hub, ui8Port);
//
// Record the fact that the device is not working correctly.
//
g_sRootHub.psPorts[ui8Port].iState = ePortError;
//
// Clear the flag we use to defer further enumerations. This will cause
// the next connected device (if any) to start enumeration on the next
// call to USBHHubMain().
//
g_sRootHub.bEnumerationBusy = false;
}
