Request::Request(QString address /*= QString()*/)
{
setAddress(address);
}
void Device::poll() {
// Read the interrupts
class OTG::GINTSTS intsts(OTG.GINTSTS()->get());
/* SETUP or OUT transaction
* If the Rx FIFO is not empty, there is a SETUP or OUT transaction.
* The interrupt is done AFTER THE HANSDHAKE of the transaction. */
if (intsts.getRXFLVL()) {
class OTG::GRXSTSP grxstsp(OTG.GRXSTSP()->get());
// Store the packet status
OTG::GRXSTSP::PKTSTS pktsts = grxstsp.getPKTSTS();
// We only use endpoint 0
assert(grxstsp.getEPNUM() == 0);
if (pktsts == OTG::GRXSTSP::PKTSTS::OutTransferCompleted || pktsts == OTG::GRXSTSP::PKTSTS::SetupTransactionCompleted) {
// There is no data associated with this interrupt.
return;
}
assert(pktsts != OTG::GRXSTSP::PKTSTS::GlobalOutNAK);
/* We did not enable the GONAKEFFM (Global OUT NAK effective mask) bit in
* GINTSTS, so we should never get this interrupt. */
assert(pktsts == OTG::GRXSTSP::PKTSTS::OutReceived || pktsts == OTG::GRXSTSP::PKTSTS::SetupReceived);
TransactionType type = (pktsts == OTG::GRXSTSP::PKTSTS::OutReceived) ? TransactionType::Out : TransactionType::Setup;
if (type == TransactionType::Setup && OTG.DIEPTSIZ0()->getPKTCNT()) {
// SETUP received but there is a packet in the Tx FIFO. Flush it.
m_ep0.flushTxFifo();
}
// Save the received packet byte count
m_ep0.setReceivedPacketSize(grxstsp.getBCNT());
if (type == TransactionType::Setup) {
m_ep0.readAndDispatchSetupPacket();
} else {
assert(type == TransactionType::Out);
m_ep0.processOUTpacket();
}
m_ep0.discardUnreadData();
}
/* IN transactions.
* The interrupt is done AFTER THE HANSDHAKE of the transaction. */
if (OTG.DIEPINT(0)->getXFRC()) { // We only check endpoint 0.
m_ep0.processINpacket();
// Clear the Transfer Completed Interrupt
OTG.DIEPINT(0)->setXFRC(true);
}
// Handle USB RESET. ENUMDNE = **SPEED** Enumeration Done
if (intsts.getENUMDNE()) {
// Clear the ENUMDNE bit
OTG.GINTSTS()->setENUMDNE(true);
/* After a USB reset, the host talks to the device by sending messages to
* address 0; */
setAddress(0);
// Flush the FIFOs
m_ep0.reset();
m_ep0.setup();
/* In setup(), we should set the MPSIZ field in OTG_DIEPCTL0 to the maximum
* packet size depending on the enumeration speed (found in OTG_DSTS). We
* should always get FullSpeed, so we set the packet size accordingly. */
}
}
Host::Host(QString name, QString label, QObject *parent) : QObject(parent), _label(label), _address(name)
{
QHostInfo::lookupHost(name, this, SLOT(setAddress(QHostInfo)));
}
boolean Adafruit_VL53L0X::begin(uint8_t i2c_addr, boolean debug, TwoWire *i2c) {
int32_t status_int;
int32_t init_done = 0;
uint32_t refSpadCount;
uint8_t isApertureSpads;
uint8_t VhvSettings;
uint8_t PhaseCal;
// Initialize Comms
pMyDevice->I2cDevAddr = VL53L0X_I2C_ADDR; // default
pMyDevice->comms_type = 1;
pMyDevice->comms_speed_khz = 400;
pMyDevice->i2c = i2c;
pMyDevice->i2c->begin(); // VL53L0X_i2c_init();
// unclear if this is even needed:
if( VL53L0X_IMPLEMENTATION_VER_MAJOR != VERSION_REQUIRED_MAJOR ||
VL53L0X_IMPLEMENTATION_VER_MINOR != VERSION_REQUIRED_MINOR ||
VL53L0X_IMPLEMENTATION_VER_SUB != VERSION_REQUIRED_BUILD ) {
if( debug ) {
Serial.println( F( "Found " STR(VL53L0X_IMPLEMENTATION_VER_MAJOR) "." STR(VL53L0X_IMPLEMENTATION_VER_MINOR) "." STR(VL53L0X_IMPLEMENTATION_VER_SUB) " rev " STR(VL53L0X_IMPLEMENTATION_VER_REVISION) ) );
Serial.println( F( "Requires " STR(VERSION_REQUIRED_MAJOR) "." STR(VERSION_REQUIRED_MINOR) "." STR(VERSION_REQUIRED_BUILD) ) );
}
Status = VL53L0X_ERROR_NOT_SUPPORTED;
return false;
}
Status = VL53L0X_DataInit( &MyDevice ); // Data initialization
if (! setAddress(i2c_addr) ) {
return false;
}
Status = VL53L0X_GetDeviceInfo( &MyDevice, &DeviceInfo );
if( Status == VL53L0X_ERROR_NONE ) {
if( debug ) {
Serial.println( F( "VL53L0X Info:" ) );
Serial.print( F( "Device Name: ") ); Serial.print( DeviceInfo.Name );
Serial.print( F( ", Type: " ) ); Serial.print( DeviceInfo.Type );
Serial.print( F( ", ID: " ) ); Serial.println( DeviceInfo.ProductId );
Serial.print( F( "Rev Major: " ) ); Serial.print( DeviceInfo.ProductRevisionMajor );
Serial.print( F( ", Minor: " ) ); Serial.println( DeviceInfo.ProductRevisionMinor );
}
if( ( DeviceInfo.ProductRevisionMinor != 1 ) && ( DeviceInfo.ProductRevisionMinor != 1 ) ) {
if( debug ) {
Serial.print( F( "Error expected cut 1.1 but found " ) );
Serial.print( DeviceInfo.ProductRevisionMajor );
Serial.print( ',' );
Serial.println( DeviceInfo.ProductRevisionMinor );
}
Status = VL53L0X_ERROR_NOT_SUPPORTED;
}
}
if( Status == VL53L0X_ERROR_NONE ) {
if( debug ) {
Serial.println( F( "VL53L0X: StaticInit" ) );
}
Status = VL53L0X_StaticInit( pMyDevice ); // Device Initialization
}
if( Status == VL53L0X_ERROR_NONE ) {
if( debug ) {
Serial.println( F( "VL53L0X: PerformRefSpadManagement" ) );
}
Status = VL53L0X_PerformRefSpadManagement( pMyDevice, &refSpadCount, &isApertureSpads ); // Device Initialization
if( debug ) {
Serial.print( F( "refSpadCount = " ) );
Serial.print( refSpadCount );
Serial.print( F( ", isApertureSpads = " ) );
Serial.println( isApertureSpads );
}
}
if( Status == VL53L0X_ERROR_NONE ) {
if( debug ) {
Serial.println( F( "VL53L0X: PerformRefCalibration" ) );
}
Status = VL53L0X_PerformRefCalibration( pMyDevice, &VhvSettings, &PhaseCal ); // Device Initialization
}
if( Status == VL53L0X_ERROR_NONE ) {
// no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
if( debug ) {
Serial.println( F( "VL53L0X: SetDeviceMode" ) );
}
Status = VL53L0X_SetDeviceMode( pMyDevice, VL53L0X_DEVICEMODE_SINGLE_RANGING ); // Setup in single ranging mode
}
// Enable/Disable Sigma and Signal check
if( Status == VL53L0X_ERROR_NONE ) {
Status = VL53L0X_SetLimitCheckEnable( pMyDevice, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1 );
}
if( Status == VL53L0X_ERROR_NONE ) {
Status = VL53L0X_SetLimitCheckEnable( pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1 );
}
if( Status == VL53L0X_ERROR_NONE ) {
Status = VL53L0X_SetLimitCheckEnable( pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 1 );
}
if( Status == VL53L0X_ERROR_NONE ) {
Status = VL53L0X_SetLimitCheckValue( pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, (FixPoint1616_t)( 1.5 * 0.023 * 65536 ) );
}
if( Status == VL53L0X_ERROR_NONE ) {
return true;
} else {
if( debug ) {
Serial.print( F( "VL53L0X Error: " ) );
Serial.println( Status );
}
return false;
}
}
JmpCode(DWORD srcAddr, DWORD dstAddr)
: jmp(0xE9)
{
setAddress(srcAddr, dstAddr);
}
KInetSocketAddress::KInetSocketAddress(const QString &addr, unsigned short port, int family) : d(new KInetSocketAddressPrivate)
{
setAddress(addr, port, family);
}
KUnixSocketAddress::KUnixSocketAddress(QCString pathname) : d(new KUnixSocketAddressPrivate)
{
setAddress(pathname);
}
bool USBDeviceClass::handleStandardSetup(USBSetup &setup)
{
switch (setup.bRequest) {
case GET_STATUS:
if (setup.bmRequestType == 0) // device
{
// Send the device status
// TODO: Check current configuration for power mode (if device is configured)
// TODO: Check if remote wake-up is enabled
uint8_t buff[] = { 0, 0 };
armSend(0, buff, 2);
return true;
}
// if( setup.bmRequestType == 2 ) // Endpoint:
else
{
// Send the endpoint status
// Check if the endpoint if currently halted
uint8_t buff[] = { 0, 0 };
if (isEndpointHalt == 1)
buff[0] = 1;
armSend(0, buff, 2);
return true;
}
case CLEAR_FEATURE:
// Check which is the selected feature
if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
{
// Enable remote wake-up and send a ZLP
uint8_t buff[] = { 0, 0 };
if (isRemoteWakeUpEnabled == 1)
buff[0] = 1;
armSend(0, buff, 2);
return true;
}
else // if( setup.wValueL == 0) // ENDPOINTHALT
{
isEndpointHalt = 0;
sendZlp(0);
return true;
}
case SET_FEATURE:
// Check which is the selected feature
if (setup.wValueL == 1) // DEVICEREMOTEWAKEUP
{
// Enable remote wake-up and send a ZLP
isRemoteWakeUpEnabled = 1;
uint8_t buff[] = { 0 };
armSend(0, buff, 1);
return true;
}
if (setup.wValueL == 0) // ENDPOINTHALT
{
// Halt endpoint
isEndpointHalt = 1;
sendZlp(0);
return true;
}
case SET_ADDRESS:
setAddress(setup.wValueL);
return true;
case GET_DESCRIPTOR:
return sendDescriptor(setup);
case SET_DESCRIPTOR:
return false;
case GET_CONFIGURATION:
armSend(0, (void*)&_usbConfiguration, 1);
return true;
case SET_CONFIGURATION:
if (REQUEST_DEVICE == (setup.bmRequestType & REQUEST_RECIPIENT)) {
initEndpoints();
_usbConfiguration = setup.wValueL;
#if defined(CDC_ENABLED)
// Enable interrupt for CDC reception from host (OUT packet)
usbd.epBank1EnableTransferComplete(CDC_ENDPOINT_ACM);
usbd.epBank0EnableTransferComplete(CDC_ENDPOINT_OUT);
#endif
sendZlp(0);
return true;
} else {
return false;
}
case GET_INTERFACE:
armSend(0, (void*)&_usbSetInterface, 1);
return true;
case SET_INTERFACE:
_usbSetInterface = setup.wValueL;
sendZlp(0);
return true;
default:
return true;
}
}
Message::Message(Type type, const MessageAddress &address)
: _p(new qi::MessagePrivate())
{
setType(type);
setAddress(address);
}
// ScrollBar (18)
TBit *SP_v2_1::SetScrollBar()
{
TBit *ScrlB = new TBit[SPScrollBar_Nbr];
if (false == MainForm->addressFromFile) {
setAddress(&ScrlB[0], GLB_STR);
setAddress(&ScrlB[1], SPIKE_TH);
setAddress(&ScrlB[2], EDGE_TH);
setAddress(&ScrlB[3], FILTER_TH);
setAddress(&ScrlB[4], MAG_TH);
setAddress(&ScrlB[5], TAN_TH);
setAddress(&ScrlB[6], LUM_MEDIAN);
setAddress(&ScrlB[7], PIX_FILTER_DARK); //CONTRAST_STR->PIX_FILTER_DARK
setAddress(&ScrlB[8], PIX_FILTER_BRIGHT); //BRIGHT_MAX_ADJ->PIX_FILTER_BRIGHT
setAddress(&ScrlB[9], DARK_MAX_ADJ);
setAddress(&ScrlB[10], BRIGHT_MAX_ADJ); //STEP_GAIN->BRIGHT_MAX_ADJ
setAddress(&ScrlB[11], CE_STR); //VARIANT_THR->CE_STR
setAddress(&ScrlB[12], DARK_OFS);
setAddress(&ScrlB[13], BRIGHT_OFS);
setAddress(&ScrlB[14], DARK_DR);
setAddress(&ScrlB[15], BRIGHT_DR);
setAddress(&ScrlB[16], STEP_GAIN); //New Create
setAddress(&ScrlB[17], VARIANT_TH); //New Create
} else {
setAddressFromFile(&ScrlB[0], "GLB_STR "); //SP_GLB_STR->GLB_STR
setAddressFromFile(&ScrlB[1], "SPIKE_TH");
setAddressFromFile(&ScrlB[2], "EDGE_TH "); //SP_EDGE_THRESHOLD->EDGE_TH
setAddressFromFile(&ScrlB[3], "FILTER_TH");
setAddressFromFile(&ScrlB[4], "MAG_TH[5:0]");
setAddressFromFile(&ScrlB[5], "TAN_TH");
setAddressFromFile(&ScrlB[6], "LUM_MEDIAN");
setAddressFromFile(&ScrlB[7], "PIX_FILTER_DARK"); //CONTRAST_STR->PIX_FILTER_DARK
setAddressFromFile(&ScrlB[8], "PIX_FILTER_BRIGHT"); //BRIGHT_MAX_ADJ->PIX_FILTER_BRIGHT
setAddressFromFile(&ScrlB[9], "DARK_MAX_ADJ");
setAddressFromFile(&ScrlB[10], "BRIGHT_MAX_ADJ"); //STEP_GAIN->BRIGHT_MAX_ADJ
setAddressFromFile(&ScrlB[11], "CE_STR"); //VARIANT_THR->CE_STR
setAddressFromFile(&ScrlB[12], "DARK_OFS");
setAddressFromFile(&ScrlB[13], "BRIGHT_OFS");
setAddressFromFile(&ScrlB[14], "DARK_DR");
setAddressFromFile(&ScrlB[15], "BRIGHT_DR");
setAddressFromFile(&ScrlB[16], "STEP_GAIN"); //New Create
setAddressFromFile(&ScrlB[17], "VARIANT_TH"); //New Create
}
return ScrlB;
}
TBit *CE_11307::SetScrollBar()
{
TBit *ScrlB = new TBit[CEScrollBar_Nbr];
if (false == MainForm->addressFromFile) {
setAddress(&ScrlB[0], PATDET_FRM_NUM);
setAddress(&ScrlB[1], PATDET_LINE_NUM);
setAddress(&ScrlB[2], GRAD_GMA_STEP);
setAddress(&ScrlB[3], GRAD_FRM_STEP);
setAddress(&ScrlB[4], GRAD_PIXDIFF_THR);
setAddress(&ScrlB[5], EDG_DIFF_THR);
setAddress(&ScrlB[6], PIX_DIFF_THR);
setAddress(&ScrlB[7], STRENGTH_K);
setAddress(&ScrlB[8], MIN_EDGE);
setAddress(&ScrlB[9], MLC_THR);
setAddress(&ScrlB[10], JND_MAX);
setAddress(&ScrlB[11], JND_MIN);
setAddress(&ScrlB[12], ST_MAX);
setAddress(&ScrlB[13], ST_MIN);
} else {
setAddressFromFile(&ScrlB[0], "PATDET_FRM_NUM");
setAddressFromFile(&ScrlB[1], "PATDET_LINE_NUM");
setAddressFromFile(&ScrlB[2], "GRAD_GMA_STEP");
setAddressFromFile(&ScrlB[3], "GRAD_FRM_STEP");
setAddressFromFile(&ScrlB[4], "GRAD_PIXDIFF_THR");
setAddressFromFile(&ScrlB[5], "EDG_DIFF_THR");
setAddressFromFile(&ScrlB[6], "PIX_DIFF_THR");
setAddressFromFile(&ScrlB[7], "STRENGTH_K");
setAddressFromFile(&ScrlB[8], "MIN_EDGE");
setAddressFromFile(&ScrlB[9], "MLC_THR");
setAddressFromFile(&ScrlB[10], "JND_MAX");
setAddressFromFile(&ScrlB[11], "JND_MIN");
setAddressFromFile(&ScrlB[12], "ST_MAX");
setAddressFromFile(&ScrlB[13], "ST_MIN");
}
return ScrlB;
}
// ComboBox (7)
TBit *SP_v2_1::SetCboBx()
{
TBit *CboBox = new TBit[SPCboBox_Nbr];
if (false == MainForm->addressFromFile) {
setAddress(&CboBox[0], STR_TP1);
setAddress(&CboBox[1], STR_TP2);
setAddress(&CboBox[2], VMASK_SEL);
setAddress(&CboBox[3], HMASK_SEL);
setAddress(&CboBox[4], DARK_TP);
setAddress(&CboBox[5], BRIGHT_TP);
setAddress(&CboBox[6], MAG_TH_6); //New Create
} else {
setAddressFromFile(&CboBox[0], "STR_TP1");
setAddressFromFile(&CboBox[1], "STR_TP2");
setAddressFromFile(&CboBox[2], "VMASK_SEL");
setAddressFromFile(&CboBox[3], "HMASK_SEL");
setAddressFromFile(&CboBox[4], "DARK_TP");
setAddressFromFile(&CboBox[5], "BRIGHT_TP");
setAddressFromFile(&CboBox[6], "MAG_TH[6]"); //New Create
}
CboBox[0].choice_nbr = 4;
CboBox[0].choice = new String[4];
CboBox[0].choice[0] = " 0: 64";
CboBox[0].choice[1] = " 1: 128";
CboBox[0].choice[2] = " 2: 192";
CboBox[0].choice[3] = " 3: str_tp1 & str_tp2 = 2'b11 output keep 255";
CboBox[1].choice_nbr = 4;
CboBox[1].choice = new String[4];
CboBox[1].choice[0] = " 0: 255";
CboBox[1].choice[1] = " 1: 192";
CboBox[1].choice[2] = " 2: 128";
CboBox[1].choice[3] = " 3: str_tp1 & str_tp2 = 2'b11 output keep 255";
CboBox[2].choice_nbr = 4;
CboBox[2].choice = new String[4];
CboBox[2].choice[0] = " 0: no mask";
CboBox[2].choice[1] = " 1: mask 1/16 Vactive up/down";
CboBox[2].choice[2] = " 2: mask 1/8 Vactive up/dow";
CboBox[2].choice[3] = " 3: mask 1/4 Vactive up/down";
CboBox[3].choice_nbr = 4;
CboBox[3].choice = new String[4];
CboBox[3].choice[0] = " 0: no mask";
CboBox[3].choice[1] = " 1: mask 1/16 Hactive up/down";
CboBox[3].choice[2] = " 2: mask 1/8 Hactive up/dow";
CboBox[3].choice[3] = " 3: mask 1/4 Hactive up/down";
CboBox[4].choice_nbr = 2;
CboBox[4].choice = new String[2];
CboBox[4].choice[0] = " 0: turn point at Y32";
CboBox[4].choice[1] = " 1: turn point at Y64";
CboBox[5].choice_nbr = 2;
CboBox[5].choice = new String[2];
CboBox[5].choice[0] = " 0: turn point at Y224";
CboBox[5].choice[1] = " 1: turn point at Y192";
CboBox[6].choice_nbr = 2;
CboBox[6].choice = new String[2];
CboBox[6].choice[0] = " 0: Triangle Type";
CboBox[6].choice[1] = " 1: Rectangle Type";
return CboBox;
}
// CheckBox (12)
TBit *SP_v2_1::SetChkBx()
{
TBit *ChkBox = new TBit[SPChkBox_Nbr];
if (false == MainForm->addressFromFile) {
setAddress(&ChkBox[0], SP_EN);
setAddress(&ChkBox[1], SP_DEMO_EN);
setAddress(&ChkBox[2], SP_DEMO_LEFT);
setAddress(&ChkBox[3], FILTER_OFF);
setAddress(&ChkBox[4], TEXT_DET);
setAddress(&ChkBox[5], DEB_EN);
setAddress(&ChkBox[6], IMGEN_SP); //I3D_EDGE_EN->IMGEN_SP
setAddress(&ChkBox[7], CE_EN);
setAddress(&ChkBox[8], CE_DEMO_EN);
setAddress(&ChkBox[9], CE_DEMO_LEFT);
setAddress(&ChkBox[10], PIX_FILTER);
setAddress(&ChkBox[11], SMOOTH_EN);
} else {
setAddressFromFile(&ChkBox[0], "SP_EN");
setAddressFromFile(&ChkBox[1], "SP_DEMO");
setAddressFromFile(&ChkBox[2], "SP_DEMO_LEFT");
setAddressFromFile(&ChkBox[3], "FILTER_OFF");
setAddressFromFile(&ChkBox[4], "TEXT_DET");
setAddressFromFile(&ChkBox[5], "DEB_EN");
setAddressFromFile(&ChkBox[6], "IMGEN_SP"); //I3D_EDGE_EN->IMGEN_SP
setAddressFromFile(&ChkBox[7], "CE_EN");
setAddressFromFile(&ChkBox[8], "CE_DEMO");
setAddressFromFile(&ChkBox[9], "CE_DEMO_LEFT");
setAddressFromFile(&ChkBox[10], "PIX_FILTER");
setAddressFromFile(&ChkBox[11], "SMOOTH_EN");
}
return ChkBox;
}
TBit *SP_12307::SetScrollBar()
{
TBit *ScrlB = new TBit[SPScrollBar_Nbr];
if (false == MainForm->addressFromFile) {
setAddress(&ScrlB[0], GLB_STR);
setAddress(&ScrlB[1], SPIKE_TH);
setAddress(&ScrlB[2], EDGE_TH);
setAddress(&ScrlB[3], FILTER_TH);
setAddress(&ScrlB[4], MAG_TH);
setAddress(&ScrlB[5], TAN_TH);
setAddress(&ScrlB[6], LUM_MEDIAN);
setAddress(&ScrlB[7], CONTRAST_STR);
setAddress(&ScrlB[8], BRIGHT_MAX_ADJ);
setAddress(&ScrlB[9], DARK_MAX_ADJ);
setAddress(&ScrlB[10], STEP_GAIN);
setAddress(&ScrlB[11], VARIANT_THR);
setAddress(&ScrlB[12], DARK_OFS);
setAddress(&ScrlB[13], BRIGHT_OFS);
setAddress(&ScrlB[14], DARK_DR);
setAddress(&ScrlB[15], BRIGHT_DR);
} else {
setAddressFromFile(&ScrlB[0], "SP_GLB_STR");
setAddressFromFile(&ScrlB[1], "SPIKE_TH");
setAddressFromFile(&ScrlB[2], "SP_EDGE_THRESHOLD");
setAddressFromFile(&ScrlB[3], "FILTER_TH");
setAddressFromFile(&ScrlB[4], "MAG_TH");
setAddressFromFile(&ScrlB[5], "TAN_TH");
setAddressFromFile(&ScrlB[6], "LUM_MEDIAN");
setAddressFromFile(&ScrlB[7], "CONTRAST_STR");
setAddressFromFile(&ScrlB[8], "BRIGHT_MAX_ADJ");
setAddressFromFile(&ScrlB[9], "DARK_MAX_ADJ");
setAddressFromFile(&ScrlB[10], "STEP_GAIN");
setAddressFromFile(&ScrlB[11], "VARIANT_THR");
setAddressFromFile(&ScrlB[12], "DARK_OFS");
setAddressFromFile(&ScrlB[13], "BRIGHT_OFS");
setAddressFromFile(&ScrlB[14], "DARK_DR");
setAddressFromFile(&ScrlB[15], "BRIGHT_DR");
}
return ScrlB;
}
KInetSocketAddress::KInetSocketAddress(const sockaddr_in6 *sin6, ksocklen_t len) : d(new KInetSocketAddressPrivate)
{
setAddress(sin6, len);
}
/*
* Read system locales using org.freedesktop.locale1 dbus interface
*/
void
EnabledLocalesModel::updateSystemLocales()
{
QDBusInterface dbusInterface( "org.freedesktop.locale1",
"/org/freedesktop/locale1",
"org.freedesktop.locale1",
QDBusConnection::systemBus() );
QStringList localeEnviromentVariables = dbusInterface.property( "Locale" ).toStringList();
QModelIndex defaultIndex = QModelIndex();
for ( QString lev : localeEnviromentVariables )
{
if ( lev.startsWith( "LANG=" ) )
{
int defaultLocaleRow = findKey( lev.section( '=', 1 ) );
defaultIndex = index( defaultLocaleRow,0 );
}
}
setAddress( defaultIndex );
setCollate( defaultIndex );
setCtype( defaultIndex );
setIdentification( defaultIndex );
setLang( defaultIndex );
setLanguage( defaultIndex );
setMeasurement( defaultIndex );
setMonetary( defaultIndex );
setMessages( defaultIndex );
setName( defaultIndex );
setNumeric( defaultIndex );
setPaper( defaultIndex );
setTelephone( defaultIndex );
setTime( defaultIndex );
for ( QString lev : localeEnviromentVariables )
{
QString value = lev.section( '=', 1 );
if ( lev.startsWith( "LC_ADDRESS=" ) )
{
if ( value.isEmpty() )
setAddress( defaultIndex );
else
{
int row = findKey( value );
setAddress( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_COLLATE=" ) )
{
if ( value.isEmpty() )
setCollate( defaultIndex );
else
{
int row = findKey( value );
setCollate( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_CTYPE=" ) )
{
if ( value.isEmpty() )
setCtype( defaultIndex );
else
{
int row = findKey( value );
setCtype( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_IDENTIFICATION=" ) )
{
if ( value.isEmpty() )
setIdentification( defaultIndex );
else
{
int row = findKey( value );
setIdentification( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LANG=" ) )
{
if ( value.isEmpty() )
setLang( defaultIndex );
else
{
int row = findKey( value );
setLang( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LANGUAGE=" ) )
{
if ( value.isEmpty() )
setLanguage( defaultIndex );
else
{
int row = findKey( value );
setLanguage( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_MEASUREMENT=" ) )
{
if ( value.isEmpty() )
setMeasurement( defaultIndex );
else
{
int row = findKey( value );
setMeasurement( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_MESSAGES=" ) )
{
if ( value.isEmpty() )
setMessages( defaultIndex );
else
{
int row = findKey( value );
setMessages( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_MONETARY=" ) )
{
if ( value.isEmpty() )
setMonetary( defaultIndex );
else
{
int row = findKey( value );
setMonetary( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_NAME=" ) )
{
if ( value.isEmpty() )
setName( defaultIndex );
else
{
int row = findKey( value );
setName( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_NUMERIC=" ) )
{
if ( value.isEmpty() )
setNumeric( defaultIndex );
else
{
int row = findKey( value );
setNumeric( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_PAPER=" ) )
{
if ( value.isEmpty() )
setPaper( defaultIndex );
else
{
int row = findKey( value );
setPaper( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_TELEPHONE=" ) )
{
if ( value.isEmpty() )
setTelephone( defaultIndex );
else
{
int row = findKey( value );
setTelephone( index( row, 0 ) );
}
}
else if ( lev.startsWith( "LC_TIME=" ) )
{
if ( value.isEmpty() )
setTime( defaultIndex );
else
{
int row = findKey( value );
setTime( index( row, 0 ) );
}
}
}
}
KInetSocketAddress::KInetSocketAddress(const in6_addr &addr, unsigned short port) : d(new KInetSocketAddressPrivate)
{
setAddress(addr, port);
}
void RF24Mesh::setStaticAddress(uint8_t nodeID, uint16_t address){
setAddress(nodeID,address);
}
KUnixSocketAddress::KUnixSocketAddress(const sockaddr_un *_sun, ksocklen_t size) : d(new KUnixSocketAddressPrivate)
{
setAddress(_sun, size);
}
Address::Address(u8 a, u8 b, u8 c, u8 d, u16 port)
{
memset(&m_address, 0, sizeof(m_address));
setAddress(a, b, c, d);
setPort(port);
}
/** @~english
* @brief Set standards.
*
* Set standard i2c address 0x20, set ErrorFlag false
* @~german
* @brief Setze Standartwerte.
*
* Setze standard i2c Adresse 0x20 und setze das ErrorFlag auf false.
*/
gnublin_module_relay::gnublin_module_relay() {
error_flag=false;
setAddress(0x20);
}
Address::Address(const IPv6AddressBytes * ipv6_bytes, u16 port)
{
memset(&m_address, 0, sizeof(m_address));
setAddress(ipv6_bytes);
setPort(port);
}
void setPxl( uint8_t x, uint8_t y, uint16_t col )
{
setAddress(x, y, x, y);
sendDataSPI_16(col);
}
Address::Address(u32 address, u16 port)
{
memset(&m_address, 0, sizeof(m_address));
setAddress(address);
setPort(port);
}
IPRange::IPRange(const QString &a) {
setAddress(a);
}
DS2PStatus DS2Packet::packetFromRawPacket(const uint8_t* rawPacketData, uint16_t length, DS2PacketType type)
{
int16_t dataLength;
uint8_t checksum;
this->type = type;
if(type == DS2_8BIT)
{
// DEBUG("8 bit: size: 0x%x at 0x%x: ", length, rawPacketData);
if(length < 4)
{
// DEBUG("insufficient data for 8 bit packet\r\n");
return DS2_PSTATUS_INSUFFICIENT_DATA;
}
packetLength = rawPacketData[1];
dataLength = packetLength - 3;
}
else if(type == DS2_16BIT)
{
// DEBUG("16 bit: size: 0x%x at 0x%x: ", length, rawPacketData);
if(rawPacketData[1] != 0x00)
{
// DEBUG("high address byte is not 0x00: %x %x %x %x %x\r\n", rawPacketData[0], rawPacketData[1], rawPacketData[2], rawPacketData[3], rawPacketData[4]);
return DS2_PSTATUS_INVALID;
}
if(length < 5)
{
// DEBUG("insufficient data for 16 bit packet\r\n");
return DS2_PSTATUS_INSUFFICIENT_DATA;
}
packetLength = rawPacketData[2];
packetLength += rawPacketData[1] << 8;
dataLength = packetLength - 4;
}
else
{
throw;
}
if(packetLength == 0)
{
// DEBUG("bad packet: zero packet length: %x %x %x %x %x\r\n", rawPacketData[0], rawPacketData[1], rawPacketData[2], rawPacketData[3], rawPacketData[4]);
return DS2_PSTATUS_INVALID;
}
if(packetLength > MAX_PACKET_LENGTH)
{
// DEBUG("bad packet: packet length > 0x%x : %x %x %x %x %x\r\n", MAX_PACKET_LENGTH, rawPacketData[0], rawPacketData[1], rawPacketData[2], rawPacketData[3], rawPacketData[4]);
return DS2_PSTATUS_INVALID;
}
if(dataLength <= 0)
{
// DEBUG("bad packet: zero data length: %x %x %x %x %x\r\n", rawPacketData[0], rawPacketData[1], rawPacketData[2], rawPacketData[3], rawPacketData[4]);
return DS2_PSTATUS_INVALID;
}
if(length < packetLength)
{
// DEBUG("bad packet: insufficient data (want 0x%x)\r\n", packetLength);
return DS2_PSTATUS_INSUFFICIENT_DATA;
}
if(type == DS2_8BIT)
{
setData(rawPacketData+2, dataLength);
checksum = rawPacketData[dataLength + 2];
}
else if(type == DS2_16BIT)
{
setData(rawPacketData+3, dataLength);
checksum = rawPacketData[dataLength + 3];
}
else
{
throw;
}
setAddress(rawPacketData[0]);
//return true if packet has a valid checksum
generatePacket();
if(checksum == this->checksum)
return DS2_PSTATUS_OK;
else
return DS2_PSTATUS_CHECKSUM_ERROR;
}
bool Fixture::loadXML(const QDomElement& root,
const QLCFixtureDefCache* fixtureDefCache)
{
const QLCFixtureDef* fixtureDef = NULL;
const QLCFixtureMode* fixtureMode = NULL;
QString manufacturer;
QString model;
QString modeName;
QString name;
quint32 id = Fixture::invalidId();
quint32 universe = 0;
quint32 address = 0;
quint32 channels = 0;
if (root.tagName() != KXMLFixture)
{
qWarning() << Q_FUNC_INFO << "Fixture node not found";
return false;
}
QDomNode node = root.firstChild();
while (node.isNull() == false)
{
QDomElement tag = node.toElement();
if (tag.tagName() == KXMLQLCFixtureDefManufacturer)
{
manufacturer = tag.text();
}
else if (tag.tagName() == KXMLQLCFixtureDefModel)
{
model = tag.text();
}
else if (tag.tagName() == KXMLQLCFixtureMode)
{
modeName = tag.text();
}
else if (tag.tagName() == KXMLFixtureID)
{
id = tag.text().toUInt();
}
else if (tag.tagName() == KXMLFixtureName)
{
name = tag.text();
}
else if (tag.tagName() == KXMLFixtureUniverse)
{
universe = tag.text().toInt();
}
else if (tag.tagName() == KXMLFixtureAddress)
{
address = tag.text().toInt();
}
else if (tag.tagName() == KXMLFixtureChannels)
{
channels = tag.text().toInt();
}
else
{
qWarning() << Q_FUNC_INFO << "Unknown fixture tag:" << tag.tagName();
}
node = node.nextSibling();
}
/* Find the given fixture definition, unless its a generic dimmer */
if (manufacturer != KXMLFixtureGeneric && model != KXMLFixtureGeneric)
{
fixtureDef = fixtureDefCache->fixtureDef(manufacturer, model);
if (fixtureDef == NULL)
{
qWarning() << Q_FUNC_INFO << "No fixture definition for"
<< manufacturer << model;
}
else
{
/* Find the given fixture mode */
fixtureMode = fixtureDef->mode(modeName);
if (fixtureMode == NULL)
{
qWarning() << Q_FUNC_INFO << "Fixture mode" << modeName
<< "for" << manufacturer << model << "not found";
/* Set this also NULL so that a generic dimmer will be
created instead as a backup. */
fixtureDef = NULL;
}
}
}
/* Number of channels */
if (channels <= 0)
{
qWarning() << Q_FUNC_INFO << "Fixture" << name << "channels"
<< channels << "out of bounds";
channels = 1;
}
/* Make sure that address is something sensible */
if (address > 511 || address + (channels - 1) > 511)
{
qWarning() << Q_FUNC_INFO << "Fixture address range" << address << "-"
<< address + channels - 1 << "out of DMX bounds";
address = 0;
}
/* Check that the invalid ID is not used */
if (id == Fixture::invalidId())
{
qWarning() << Q_FUNC_INFO << "Fixture ID" << id << "is not allowed.";
return false;
}
if (fixtureDef != NULL && fixtureMode != NULL)
{
/* Assign fixtureDef & mode only if BOTH are not NULL */
setFixtureDefinition(fixtureDef, fixtureMode);
}
else
{
/* Otherwise set just the channel count */
setChannels(channels);
}
setAddress(address);
setUniverse(universe);
setName(name);
setID(id);
return true;
}
KInetSocketAddress::KInetSocketAddress(const KInetSocketAddress &other) : KSocketAddress(), d(new KInetSocketAddressPrivate)
{
setAddress(other);
}
AflClassProc::AflClassProc(LPVOID pClass,DWORD (*pFunction)(LPVOID,LPVOID))
{
setAddress(pClass,pFunction);
}
/** @~english
* @brief Set standard i2c address 0x20, set ErrorFlag false, sets the closemode to "1" (see i2c for details)
*
* @~german
* @brief Setze standard i2c Adresse 0x20, den closemode auf "1" (siehe i2c für Details) und setze das ErrorFlag auf false.
*
*/
gnublin_module_pca9555::gnublin_module_pca9555()
{
error_flag=false;
setAddress(0x20);
}
