// reset for vs10xx
void VS10XX::reset()
{
putInReset();
delay(100);//it is a must
/* Send dummy SPI byte to initialize atmel SPI */
////SPIPutCharWithoutWaiting(0xFF);
deselectControlBus();
deselectDataBus();
releaseFromReset();
while (!readDREQ());
/* Set clock register, doubler etc. */
writeRegister(SPI_CLOCKF, 0xc0, 0x00);
Serial.print("\r\nClockF:");
Serial.println(readRegister(SPI_CLOCKF),HEX);
/* Wait for DREQ */
while (!readDREQ());
softReset();//comment this, as it will be executed everytime playing a music file.
writeRegister(SPI_WRAMADDR, 0xc0, 0x13);
/* Switch on the analog parts */
setVolume(40,40);
//setVolume(0xff,0xff);
//SPISetFastClock();
}
/**
* Write handler for PHY Control register.
*
* Handles reset.
*
* @param index Register index in register array.
* @param value The value to store (ignored).
*/
static void Phy::regWritePCTRL(PPHY pPhy, uint32_t index, uint16_t u16Value)
{
if (u16Value & PCTRL_RESET)
softReset(pPhy);
else
regWriteDefault(pPhy, index, u16Value);
}
int Caen785Module::singleShot()
{
softReset();
configure();
if(pollTrigger()) return acquireSingleEventMBLT();
return -1;
}
void Engine::setAccType(QString type) {
if (currentType != type || recoveredDStack) {
if (dStack.isEmpty()) {
currentType = type;
executeInstructionOnStack("Factory"); // No tr
state = sAppend;
} else {
if (recoveredDStack) {
//don't call dualReset() or recoveredDStack will be deleted
dStack.clear();
iStack.clear();
braceCount = 0;
softReset();
changeResetState(drNone);
putData(recoveredDStack);
}
wantedType = type;
if (currentType == "NONE") // workaround for bug #3356
currentType = dStack.top()->getType();
if (currentType != wantedType) {
if (!recoveredDStack)
executeInstructionOnStack("Convert"); // No tr
else // don't convert recoveredStack
recoveredDStack = 0;
}
}
// Doublecheck the type in case a factory or convert doesn't go as planned.
currentType = dStack.top()->getType();
emit(stackChanged());
}
changeResetState(drs);
}
bool X86AtaDevice::isAttached() const
{
softReset(); /* waits until master drive is ready again */
outb(_ioPort + kAtaRegisterDriveSelect, 0xA0 | _slaveBit << 4);
outb(_ioPort + kAtaRegisterLbaLow, 0x0);
outb(_ioPort + kAtaRegisterLbaMid, 0x0);
outb(_ioPort + kAtaRegisterLbaHigh, 0x0);
outb(_ioPort + kAtaRegisterCommand, 0xEC);
return waitForStatus(-1) != 0;
}
uint8_t myGRBL::begin() {
if (_connected) _conn.end();
_conn.begin(_speed);
_connected = true;
uint8_t retCode = softReset();
if (!_ready) {
_conn.end();
_connected = false;
}
return retCode;
}
bool SI7021::begin() {
Wire.begin();
Wire.beginTransmission(I2C_ADDR);
if (Wire.endTransmission() == 0) {
_si_exists = true;
softReset();
}
return _si_exists;
}
void DW1000Class::reset() {
if(_rst < 0) {
softReset();
} else {
digitalWrite(_rst, LOW);
delay(10);
digitalWrite(_rst, HIGH);
delay(10);
// force into idle mode (although it should be already after reset)
idle();
}
}
void DomainHandler::hardReset() {
softReset();
qCDebug(networking) << "Hard reset in NodeList DomainHandler.";
_iceDomainID = QUuid();
_iceServerSockAddr = HifiSockAddr();
_hostname = QString();
_sockAddr.clear();
// clear any pending path we may have wanted to ask the previous DS about
_pendingPath.clear();
}
Sensirion::Sensirion(uint8_t data, uint8_t clock)
{
// Pins for software SPI
_pinData = data;
_pinClock = clock;
// set DDR for software SPI pins
pinMode(_pinClock, OUTPUT);
pinMode(_pinData, OUTPUT);
softReset();
}
void PowerMonitor::begin(int voltage,int f) // initialisation of powermionitor, **** include the option to have this initialise for 110V systems or 220/230 etc
{
Serial.begin(38400); // 78M6613 only speaks at 38400 baud, this will hopefully change in later revisions
//set the defualt values for the shield, Vmax + alarms, frequency + alarms, IAmax, IBmax, IAcreep, IBcreep,
// VMAX = 356,892 according to the Vdivider on the board
// f = 50.00 Hz +- 1 Hz)
// Imax A = 65.4, IAcreep =default, IAmax
// Imax B = 0 IBcreep =default, IBmax
// note that all the factory defaults are for 120 Vrms, 60 Hz power systems, we will change these to correspond to 230V 50 Hz systems now
delay(2000);
Serial.println("I");
delay(100); // wait 1.5 second for pMon to send its welcome string
Serial.flush();
delay(20);
vMaxSet(374.80); // set the external RMS voltage corresponding to 250 mVpk input of the ADC (A0) // 332.222 on V0.2, 356.892 on V 1, V0.2 477.8021536
iMaxSet(1,65.470); // set the external RMS current corresponding to 250 mVpk input of the ADC (A2)(A4)
alarmCurrentMaxThreshold( 65.000); // threshold for max current alarm, factory default = 15.000(D9) // channel A only
if(voltage >=100 && voltage <=120)
{
alarmVoltageSAGthreshold(80.0); // threshold for voltage SAG detection factory defualt = 80.0( D4)
alarmVoltageMinThreshold(100.000); // threshold for min voltage alarm, factory default = 100.000 (D5)
alarmVoltageMaxThreshold(140.000); // threshold for max voltage alarm, factory default = 140.000 (D6)
}
if(voltage >=200 && voltage <=240)
{
alarmVoltageSAGthreshold(160.0); // threshold for voltage SAG detection factory defualt = 80.0( D4)
alarmVoltageMinThreshold(200.000); // threshold for min voltage alarm, factory default = 100.000 (D5)
alarmVoltageMaxThreshold(260.000); // threshold for max voltage alarm, factory default = 140.000 (D6)
alarmCurrentMaxThreshold( 65.000); // threshold for max current alarm, factory default = 15.000(D9) // channel A only
}
if(f >=49 &&f <=51)
{
alarmFreqMinThreshold(49.00); // minimum threshold for frequency alarm factory defualt = 59.00 Hz ( D2)
alarmFreqMaxThreshold(51.00); // maximum threshold for frequency alarm factory defualt = 61.00 Hz ( D3)
}
if(f >=59 &&f <=61)
{
alarmFreqMinThreshold(59.00); // minimum threshold for frequency alarm factory defualt = 59.00 Hz ( D2)
alarmFreqMaxThreshold(61.00); // maximum threshold for frequency alarm factory defualt = 61.00 Hz ( D3)
}
applyDefaultSettings(); // U, note, CE must be disabled before sending U, and reenabsed afterwards
softReset(); // reset device
delay(1000);
Serial.flush();
}
X86AtaDevice::Type X86AtaDevice::type() const
{
softReset(); /* waits until master drive is ready again */
outb(_ioPort + kAtaRegisterDriveSelect, 0xA0 | _slaveBit<<4);
ioWait(); /* wait 400ns for drive select to work */
uint8_t cl = inb(_ioPort + kAtaRegisterCylinderLow); /* get the "signature bytes" */
uint8_t ch = inb(_ioPort + kAtaRegisterCylinderHigh);
/* differentiate ATA, ATAPI, SATA and SATAPI */
if (cl==0x14 && ch==0xEB) return Type::PATAPI;
if (cl==0x69 && ch==0x96) return Type::SATAPI;
if (cl==0 && ch == 0) return Type::PATA;
if (cl==0x3c && ch==0xc3) return Type::SATA;
return Type::Unknown;
}
void Engine::hardReset() {
while (!dStack.isEmpty())
delete dStack.pop();
dStack.clear();
while (!iStack.isEmpty())
delete iStack.pop();
iStack.clear();
braceCount = 0;
if (recoveredDStack) {
delete recoveredDStack;
recoveredDStack = 0;
}
softReset();
changeResetState(drNone);
}
boolean ESP8266::begin(void)
{
connected = false;
pinMode(ESP8266_RST, OUTPUT);
clearAllRequests();
hardReset();
lastActivityTimestamp = 0;
DBGBEG();
_wifiSerial.begin(ESP8266_BAUD_RATE);
//_wifiSerial.flush();
//_wifiSerial.setTimeout(ESP8266_SERIAL_TIMEOUT);
state = STATE_IDLE;
attemptCounter = 0;
softReset();
}
void DomainHandler::hardReset() {
emit resetting();
softReset();
qCDebug(networking) << "Hard reset in NodeList DomainHandler.";
_iceDomainID = QUuid();
_iceServerSockAddr = HifiSockAddr();
_hostname = QString();
_sockAddr.clear();
_hasCheckedForAccessToken = false;
_domainConnectionRefusals.clear();
// clear any pending path we may have wanted to ask the previous DS about
_pendingPath.clear();
}
void Adafruit_VS1053::reset() {
// TODO: http://www.vlsi.fi/player_vs1011_1002_1003/modularplayer/vs10xx_8c.html#a3
// hardware reset
if (_reset >= 0) {
digitalWrite(_reset, LOW);
delay(100);
digitalWrite(_reset, HIGH);
}
digitalWrite(_cs, HIGH);
digitalWrite(_dcs, HIGH);
delay(100);
softReset();
delay(100);
sciWrite(VS1053_REG_CLOCKF, 0x6000);
setVolume(40, 40);
}
void DomainHandler::hardReset() {
emit resetting();
softReset();
_isInErrorState = false;
emit redirectErrorStateChanged(_isInErrorState);
qCDebug(networking) << "Hard reset in NodeList DomainHandler.";
_pendingDomainID = QUuid();
_iceServerSockAddr = HifiSockAddr();
_sockAddr.clear();
_domainURL = QUrl();
_domainConnectionRefusals.clear();
_hasCheckedForAccessToken = false;
// clear any pending path we may have wanted to ask the previous DS about
_pendingPath.clear();
}
boolean Adafruit_VS1053::prepareRecordOgg(char *plugname) {
sciWrite(VS1053_REG_CLOCKF, 0xC000); // set max clock
delay(1); while (! readyForData() );
sciWrite(VS1053_REG_BASS, 0); // clear Bass
softReset();
delay(1); while (! readyForData() );
sciWrite(VS1053_SCI_AIADDR, 0);
// disable all interrupts except SCI
sciWrite(VS1053_REG_WRAMADDR, VS1053_INT_ENABLE);
sciWrite(VS1053_REG_WRAM, 0x02);
int pluginStartAddr = loadPlugin(plugname);
if (pluginStartAddr == 0xFFFF) return false;
Serial.print("Plugin at $"); Serial.println(pluginStartAddr, HEX);
if (pluginStartAddr != 0x34) return false;
return true;
}
void loop(){
if (dataLesen()==1) {
//QFF-Berechnung
x = ((temp + konst1)/(qfe/100)*exp(((temp+konst1+konst2)*11.5526-26821)/(temp+konst1+konst2-1060)));
qff = (qfe/100)*exp(konst2*10.5152/(x+temp+konst1+konst2));
//Messwerten abschicken
if (client.connect(serverName, 80)) {
//Serial.println("Verbunden ... sende ... fertig!");
// URL anrufen:
client.print("GET /upload.php?TEMP=");
client.print(temp);
client.print("&TAU=");
client.print(taupunkt);
client.print("&QFE=");
client.print(qfe/100, 1);
client.print("&QFF=");
client.print(qff,1);
client.print("&FEUCHTE=");
client.print(feuchte);
client.println("&key=root HTTP/1.0\n");
client.println("Host: localhost");
client.println("User-Agent: Arduino");
client.println();
client.stop();
}
if (!client.connected()) {
/*Serial.println();
Serial.println("disconnecting.");*/
client.stop();
}
delay(899500);
softReset();
/* else {
// 2. Worst-Case-Szenario
Serial.println("connection failed");
}*/
}
}
void DW1000Class::begin(int irq, int rst) {
// generous initial init/wake-up-idle delay
delay(5);
// start SPI
SPI.begin();
SPI.usingInterrupt(irq);
// pin and basic member setup
_rst = rst;
_irq = irq;
_deviceMode = IDLE_MODE;
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
// reset chip (either soft or hard)
if(_rst <= 0) {
softReset();
} else {
reset();
}
// try locking clock at PLL speed (should be done already,
// but just to be sure)
enableClock(AUTO_CLOCK);
delay(5);
// default network and node id
writeValueToBytes(_networkAndAddress, 0xFF, LEN_PANADR);
writeNetworkIdAndDeviceAddress();
// default system configuration
memset(_syscfg, 0, LEN_SYS_CFG);
setDoubleBuffering(false);
setInterruptPolarity(true);
writeSystemConfigurationRegister();
// default interrupt mask, i.e. no interrupts
clearInterrupts();
writeSystemEventMaskRegister();
// attach interrupt
attachInterrupt(_irq, DW1000Class::handleInterrupt, RISING);
}
void CODECClass::configure() {
hardReset();
PAGE_SELECT(0x00);
softReset();
//Clock
write(0x0B, 0x81); //NDAC on, div = 1
write(0x0C, 0x82); //MDAC on, div = 2
write(0x0D, 0x00); //DAC OSR = 128
write(0x0E, 0x80); // ^
write(0x12, 0x81); //NADC on, div = 1
write(0x13, 0x82); //NADC on, div = 2
write(0x14, 0x80); //ADC OSR = 128
//Interface
write(0x1B, 0x00); //I2S, 16b, WCLK & BCLK inputs
//Processing Block
write(0x3C, 0x08); //DAC: PRB_P8
write(0x3D, 0x01); //ADC: PRB_R1
//Analog PS
PAGE_SELECT(0x01);
write(0x01, 0x08); //Disable AVDD/DVDD connection
write(0x02, 0x01); //Enable AVDD LDO
write(0x0A, 0x3B); //Output common mode is 1.65V, Full chip CM is 0.9V, HP powered from LDO (1.8-3.6V)
//Power up
write(0x47, 0x31); //Analog inputs power up in 3ms
write(0x7B, 0x01); //Reference powers up in 40ms
write(0x14, 0x65); //Headphone powers up in 50ms, charges for 5 time constants @ 6k ohms
//DAC routing
write(0x0C, 0x08); //Left DAC -> Left headphone
write(0x0D, 0x08); //Right DAC -> Right headphone
write(0x0E, 0x08); //Left DAC -> Left line out
write(0x0F, 0x08); //Right DAC -> Right line out
//ADC routing
write(0x34, 0xC0); //IN1L -> MICPGA L+, 40k
write(0x36, 0xC0); //CM -> MICPGA L-, 40k
write(0x37, 0xC0); //IN1R -> MICPGA R+, 40k
write(0x39, 0xC0); //CM -> MICPGA R-, 40k
//1Hz filter L
PAGE_SELECT(0x08);
write(0x18, 0x7F);
write(0x19, 0xFF);
write(0x1A, 0x00);
write(0x1C, 0x80);
write(0x1D, 0x01);
write(0x1E, 0x00);
write(0x20, 0x7F);
write(0x21, 0xFC);
write(0x22, 0x00);
//1Hz filter R
PAGE_SELECT(0x09);
write(0x20, 0x7F);
write(0x21, 0xFF);
write(0x22, 0x00);
write(0x24, 0x80);
write(0x25, 0x01);
write(0x26, 0x00);
write(0x28, 0x7F);
write(0x29, 0xFC);
write(0x2A, 0x00);
return;
}
int main(int argc, char **argv)
{
if (!bcm2835_init())
return 1;
bcm2835_spi_begin();
bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST); // The default
bcm2835_spi_setDataMode(BCM2835_SPI_MODE0); // The default
bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536); // The default
bcm2835_spi_chipSelect(BCM2835_SPI_CS0); // The default
bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW); // the default
softReset();
/*
printf("status: %d \n", readStatus());
printf("config: %d \n", readConfig());
printf("mode: %d \n", readMode());
printf("gain: %d \n", gainSetting);
*/
//changeInput(0);
//changeGain(AD7794_GAIN_8);
//delay(changeInputDelay); //Time to value is ready
long fullData;
int readAmount = 10;
int delayMilis=20;
while(1){
long input0 = readAvgValueFromInput(0, readAmount, delayMilis);
printf("Value at input %d: %d / %06X\n", currentInput, input0, input0);
long input1 = readAvgValueFromInput(1, readAmount, delayMilis);
printf("Value at input %d: %d / %06X\n", currentInput, input1, input1);
long input2 = readAvgValueFromInput(2, readAmount, delayMilis);
printf("Value at input %d: %d / %06X\n", currentInput, input2, input2);
long input3 = readAvgValueFromInput(3, readAmount, delayMilis);
printf("Value at input %d: %d / %06X\n", currentInput, input3, input3);
long avg = (input0 + input1 + input2 + input3) / 4;
printf("avg: %d / %06X\n", avg, avg);
}
int loopc=0;
while(1){
fullData = readSingleValue();
printf("Value at input %d: %d / %06X\n", currentInput, fullData, fullData);
printf("status: %d \n", readStatus());
++loopc;
if (loopc>=10){
if (currentInput<3){
changeInput(currentInput+1);
} else {
changeInput(0);
}
delay(changeInputDelay);
loopc=0;
} else {
delay(delayMilis);
}
}
bcm2835_spi_end();
return 0;
}
uint8_t BayGPRSInterface::init(uint8_t unlock_only){
uint8_t count=0;
init_start:
uint8_t i=0;
printP("AT"); //Wake up
delay(200);
println();
wait_forOK(1000);
printlnP("AT"); //Check communication
if(! wait_forOK(200)){
//communication ok!
printlnP("ATE0"); //Command echo off
wait_forOK(500);
printlnP("AT+CSCLK=2"); //Auto-Sleepmode
wait_forOK(500);
//Check PIN
printlnP("AT+CPIN?");
while(wait_forPGM(PSTR("+CPIN: "),5000,7,_base64buffer)){
printlnP("AT");
wait_forOK(200);
printlnP("AT+CFUN=0");
//Disable
wait_forOK(10000);
printlnP("AT+CFUN=1");
//delay(2000);
//Enable
wait_forOK(10000);
printlnP("AT");
wait_forOK(200);
printlnP("AT+CPIN?");
i++;
if(i>2) return 6;
}
if(_base64buffer[5]=='U') return 3; //SIM PUK
if(_base64buffer[5]=='I'){ //SIM PIN
printlnP("AT");
wait_forOK(200);
printP("AT+CPIN=\"");
print(_pin);
println("\"");
if(wait_forOK(30000)) {
return 2; //Wrong PIN
}
wait_for("SMS Ready",(unlock_only?5000:60000));
}
//Return here - Moden will try to connect and attach in the background!
if(unlock_only) return 0;
// Waiting for Modem to Connect
for(i=0;i<127;i++){
if(isRegistered()) break;
delay(500);
}
if(i==127) return 4;
for(i=0;i<127;i++){
if(isAttached()) break;
delay(500);
}
if(i==127) return 5;
return 0;
}
softReset();
softSwitch();
i_begin(_baud);
skipChars();
printP("AT"); //Will autoconfigure BAUD-Rate - Auto BAUD-Rate did not work with Sleep-Mode!
delay(100);
println();
printP("AT+IPR=");
println(_baud);
wait_forOK(200);
count++;
if(count>1) return 1;
goto init_start;
}
// TODO: Should probably return boolean
uint8_t Sensirion::reset(void)
{
return softReset();
}
void DomainHandler::hardReset() {
softReset();
_hostname = QString();
_sockAddr.setAddress(QHostAddress::Null);
}
// Reset
void Engine::dualReset() {
if (drs == drHard)
hardReset();
else
softReset();
}
Error SynopsisUSB::initialize()
{
Error r = USBController::initialize();
if (r != ESUCCESS)
return r;
// Map USB host controller registers
if (m_io.map(IO_BASE + Base, PAGESIZE*2,
Memory::User|Memory::Readable|Memory::Writable|Memory::Device) != IO::Success)
{
ERROR("failed to map I/O registers");
return EIO;
}
// Check device ID
if (m_io.read(VendorId) != DefaultVendorId)
{
ERROR("incompatible vendorId: " << m_io.read(VendorId) << " != " << DefaultVendorId);
return EIO;
}
DEBUG("UserId: " << m_io.read(UserId) << " VendorId: " << m_io.read(VendorId));
NOTICE("Synopsis Design Ware USB-on-the-go Host Controller found");
// Initialize power manager
if (m_power.initialize() != BroadcomPower::Success)
{
ERROR("failed to initialize power manager");
return EIO;
}
// Power on the USB subsystem
if (m_power.enable(BroadcomPower::USB) != BroadcomPower::Success)
{
ERROR("failed to power on the USB subsystem");
return EIO;
}
DEBUG("powered on");
// Soft-Reset
softReset();
DEBUG("software reset done");
// Setup DMA
m_io.write(RxFIFOSize, 1024);
m_io.write(TxFIFOSize, (1024 << 16) | 1024);
m_io.write(PeriodTxFIFOSize, (1024 << 16) | 2048);
m_io.set(AHBConfig, DMAEnable | AXIWait);
// Enable the USB controller interrupt on the ARM's interrupt controller
addIRQHandler(InterruptNumber, (IRQHandlerFunction) &SynopsisUSB::interruptHandler);
addIRQHandler(0, (IRQHandlerFunction) &SynopsisUSB::interruptHandler); // TODO: ARM does not have IRQ_REG() yet
ProcessCtl(SELF, WatchIRQ, InterruptNumber);
ProcessCtl(SELF, EnableIRQ, InterruptNumber);
DEBUG("interrupt handler installed");
// Clear all pending core interrupts
m_io.write(CoreIntMask, 0);
m_io.write(CoreInterrupt, 0xffffffff);
// Enable core host channel and port interrupts
m_io.write(CoreIntMask, CoreIntChannel | CoreIntPort);
// Enable interrupts globally on the USB host controller.
m_io.set(AHBConfig, InterruptEnable);
DEBUG("interrupts enabled");
// Power-on host port (virtual root hub)
u32 val = m_io.read(HostPortControl);
val &= ~(HostPortEnable | HostPortEnableChanged |
HostPortConnectChanged | HostPortCurrentChanged);
val |= HostPortPower;
m_io.write(HostPortControl, val);
DEBUG("poweron host port");
// Begin host port reset (raise the reset signal)
val = m_io.read(HostPortControl);
val &= ~(HostPortEnable | HostPortEnableChanged |
HostPortConnectChanged | HostPortCurrentChanged);
val |= HostPortReset;
m_io.write(HostPortControl, val);
#warning TODO: implement real sleep() now. We need it here.
sleep(60);
// Finish host port reset (lower the reset signal)
val = m_io.read(HostPortControl);
val &= ~(HostPortEnable | HostPortEnableChanged |
HostPortConnectChanged | HostPortCurrentChanged);
m_io.write(HostPortControl, val);
DEBUG("host port reset done");
// Clear host port interrupt flags
val = m_io.read(HostPortControl);
val |= HostPortEnableChanged | HostPortConnectChanged | HostPortCurrentChanged;
m_io.write(HostPortControl, val);
DEBUG("host port (root hub) enabled");
DEBUG("host port status=" << m_io.read(HostPortControl) << " connected=" <<
(m_io.read(HostPortControl) & HostPortConnect));
// Done.
return ESUCCESS;
}
uns8 ScriptCtrl_Add(struct led_cmd *pCmd)
{
/* We have to reject all commands until buffer was cleared completely */
if(gScriptBuf.isClearing) {
return SCRIPTBUFFER_FULL;
}
switch(pCmd->cmd)
{
case CLEAR_SCRIPT:
//Trace_String("Clearing script buffer;");
gScriptBuf.isClearing = TRUE;
return OK;
case LOOP_ON:
gScriptBuf.loopStart[gScriptBuf.loopDepth] = gScriptBuf.write;
gScriptBuf.loopDepth++;
return ScriptCtrl_Write(pCmd);
case LOOP_OFF:
{
gScriptBuf.loopDepth--;
uns8 loopStart = gScriptBuf.loopStart[gScriptBuf.loopDepth];
pCmd->data.loopEnd.startIndex = ScriptBufInc(loopStart);
pCmd->data.loopEnd.depth = gScriptBuf.loopDepth;
uns8 numLoops = pCmd->data.loopEnd.numLoops;
pCmd->data.loopEnd.counter = numLoops;
/*Trace_String("Add LOOP_OFF: ");
Trace_Hex(gScriptBuf.write);
Trace_Hex(pCmd->data.loopEnd.startIndex);
Trace_Hex(pCmd->data.loopEnd.depth);
Trace_Hex(pCmd->data.loopEnd.counter);
Trace_String(";");*/
return ScriptCtrl_Write(pCmd);
}
case WAIT:
{
return ScriptCtrl_Write(pCmd);
}
case START_BL:
{
CommandIO_CreateResponse(&g_ResponseBuf, START_BL, OK);
CommandIO_SendResponse(&g_ResponseBuf);
Platform_EnableBootloaderAutostart();
softReset();
/* never reach this */
return OK;
}
#ifdef __CC8E__
case GET_RTC:
{
return OK;
}
case SET_RTC:
{
g_RtcTime.tm_year = pCmd->data.set_rtc.tm_year;
g_RtcTime.tm_mon = pCmd->data.set_rtc.tm_mon;
g_RtcTime.tm_mday = pCmd->data.set_rtc.tm_mday;
g_RtcTime.tm_wday = pCmd->data.set_rtc.tm_wday;
g_RtcTime.tm_hour = pCmd->data.set_rtc.tm_hour;
g_RtcTime.tm_min = pCmd->data.set_rtc.tm_min;
g_RtcTime.tm_sec = pCmd->data.set_rtc.tm_sec;
Rtc_Ctl(RTC_SET_TIME, &g_RtcTime);
return OK;
}
#endif /* #ifdef __CC8E__ */
case SET_COLOR_DIRECT:
{
Ledstrip_SetColorDirect((uns8 *)&pCmd->data.set_color_direct.ptr_led_array);
return NO_RESPONSE;
}
#ifdef __CC8E__
case GET_CYCLETIME:
{
return OK;
}
case GET_TRACE:
{
return OK;
}
#endif /* #ifdef __CC8E__ */
case GET_FW_VERSION:
{
return OK;
}
case SET_FADE:
{
return ScriptCtrl_Write(pCmd);
}
case SET_GRADIENT:
{
return ScriptCtrl_Write(pCmd);
}
case GET_LED_TYP:
{
return OK;
}
default:
{
return BAD_COMMAND_CODE;
}
}
}
