static void restore_link(const uint8_t *eeaddr)
{
enter_command_mode();
SEND_COMMAND("Q,2\r\n"); // quiet
//SEND_COMMAND("SX,1\r\n"); // bond
//SEND_COMMAND("SR,Z\r\n"); // remove remote address
SEND_STR("SR,"); // set remote address from EEPROM
for (int i = 0; i < 12; i++) {
uint8_t c = eeprom_read_byte(eeaddr+i);
rn42_putc(c);
dprintf("%c ", c);
}
SEND_COMMAND("\r\n");
SEND_STR("C,"); // set remote address from EEPROM
for (int i = 0; i < 12; i++) {
uint8_t c = eeprom_read_byte(eeaddr+i);
rn42_putc(c);
dprintf("%c ", c);
}
dprintf("\r\n");
SEND_COMMAND("\r\n");
wait_ms(5000);
SEND_COMMAND("R,1\r\n"); // reboot
exit_command_mode_2();
}
static void pairing(void)
{
enter_command_mode();
SEND_COMMAND("SR,Z\r\n"); // remove remote address
SEND_COMMAND("R,1\r\n"); // reboot
exit_command_mode();
}
LoginMediator::LoginMediator(LoginPanel* instance)
{
panel = instance;
registerAttentions(3,LOGIN_GAME,LOGIN_RESPONSE,LOGIN_CHECK_ACTIVE_RESPONSE);
ATTENTION_CALLBACK
{
if(eventName == LOGIN_GAME)
{
DEFINE_COMMAND_PARMA(LOGIN_GAME);
CREATE_COMMAND_PARMA(GAME_ACCOUNT,panel->nameTf->getStringValue());
CREATE_COMMAND_PARMA(GAME_PASSWORD,panel->passwordTf->getStringValue());
int modelKey = 10000 + CCRANDOM_0_1()* 10000000;
CREATE_COMMAND_PARMA(PHONE_MODEL,cocos2d::StringUtils::toString(modelKey));
//CREATE_COMMAND_PARMA(PHONE_MODEL,cocos2d::FileUtils::getInstance()->getIMEI(),param);
SEND_COMMAND(LOING_COMMAND);
}
else if(eventName == LOGIN_RESPONSE)
{
if(LoginModel::getInstance()->ret->state == 1)
{
DEFINE_COMMAND_PARMA(WEB_CHECK_ACTIVE);
CREATE_COMMAND_PARMA(HTTP_ACTION, WEB_CHECK_ACTIVE);
CREATE_COMMAND_PARMA(GAME_TOKEN,LoginModel::getInstance()->ret->token);
SEND_COMMAND(LOING_COMMAND);
}
else
{
loading::Alert::getInstance()->showNotice("该用户已经登录");
}
}
else if(eventName == LOGIN_CHECK_ACTIVE_RESPONSE)
{
loading::PreLoader::getInstance()->unLoadLoginPanel();
//loading::PreLoader::getInstance()->loadTraven();return;
if(LoginModel::getInstance()->is_actived == 0)
{
//REPLACE_SCENE(SelectCharacterPanel);
loading::PreLoader::getInstance()->loadCreateCharcater();
}
else
{
loading::PreLoader::getInstance()->loadMainCity();
}
}
};
panel->registerMeditor(this);
}
static void enter_command_mode_2(void)
{
prev_driver = host_get_driver();
clear_keyboard();
host_set_driver(&rn42_config_driver); // null driver; not to send a key to host
//while (rn42_linked()) ;
wait_ms(1100); // need 1 sec
SEND_COMMAND("$$$");
wait_ms(600); // need 1 sec
print_rn42();
const char *s = SEND_COMMAND("v\r\n");
if (strncmp("v", s, 1) != 0) SEND_COMMAND("+\r\n"); // local echo on
}
static int optical_init_sensor(struct iio_dev *indio_dev)
{
int err;
struct optical_data *sdata = iio_priv(indio_dev);
printk (KERN_ALERT "[%s]\n", __FUNCTION__);
mutex_init(&sdata->tb.buf_lock);
SEND_COMMAND(sdata,0x01);//reset
//asm volatile ("nop");
//asm volatile ("nop");
//asm volatile ("nop");
//asm volatile ("nop");
printk (KERN_ALERT "[%s 1]\n", __FUNCTION__);
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_HW_HEY, reg_defaults[REGS_HW_HEY]);
if (err < 0)
goto init_error;
printk (KERN_ALERT "[%s 2]\n", __FUNCTION__);
SEND_COMMAND_PARAM_SET(sdata,0x01,0x01);//enble ps only
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_INT_CFG, reg_defaults[REGS_INT_CFG]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_IRQ_ENABLE, reg_defaults[REGS_IRQ_ENABLE]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_IRQ_MODE1, reg_defaults[REGS_IRQ_MODE1]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_IRQ_MODE2, reg_defaults[REGS_IRQ_MODE2]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_MEAS_RATE, reg_defaults[REGS_MEAS_RATE]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_ALS_RATE, reg_defaults[REGS_ALS_RATE]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_PS_RATE, reg_defaults[REGS_PS_RATE]);
if (err < 0)
goto init_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_PS_LED21, reg_defaults[REGS_PS_LED21]);
if (err < 0)
goto init_error;
SEND_COMMAND(sdata,0x0D);//ps auto
init_error:
if(err>=0)
printk("vung optical_init_sensor -----------------ok");
return err;
}
static void quiet_mode(void)
{
enter_command_mode_2();
SEND_COMMAND("Q\r\n"); // quiet
//SEND_COMMAND("Z\r\n"); // quiet
exit_command_mode_2();
}
static void exit_command_mode_2(void)
{
print("Exiting config mode ...\n");
SEND_COMMAND("---\r\n"); // exit
clear_keyboard();
host_set_driver(prev_driver);
}
static gboolean
gst_hdv1394src_unlock (GstBaseSrc * bsrc)
{
GstHDV1394Src *src = GST_HDV1394SRC (bsrc);
SEND_COMMAND (src, CONTROL_STOP);
return TRUE;
}
static void init_rn42(void)
{
// RN-42 configure
if (!config_mode) enter_command_mode();
SEND_COMMAND("SF,1\r\n"); // factory defaults
SEND_COMMAND("S-,TmkBT\r\n");
SEND_COMMAND("SS,Keyboard/Mouse\r\n");
SEND_COMMAND("SM,4\r\n"); // auto connect(DTR)
SEND_COMMAND("SW,8000\r\n"); // Sniff disable
SEND_COMMAND("S~,6\r\n"); // HID profile
SEND_COMMAND("SH,003C\r\n"); // combo device, out-report, 4-reconnect
SEND_COMMAND("SY,FFF4\r\n"); // transmit power -12
SEND_COMMAND("R,1\r\n");
if (!config_mode) exit_command_mode();
}
static void init_rn42(void)
{
// RN-42 configure
// Should probably put in a baud rate setting..? Maybe?
// only remembering 4 pairings?
if (!config_mode) enter_command_mode();
SEND_COMMAND("SF,1\r\n"); // factory defaults
SEND_COMMAND("S-,TmkBT\r\n"); //sets the serialized "friendly name"
SEND_COMMAND("SS,Keyboard/Mouse\r\n"); // sets "service name"
SEND_COMMAND("SM,4\r\n"); // auto connect(DTR) - use gpio 6 to make and break connections
SEND_COMMAND("SW,8000\r\n"); // Sniff disable - deep sleep setting READ MORE
SEND_COMMAND("S~,6\r\n"); // HID profile
SEND_COMMAND("SH,003C\r\n"); // combo device, out-report, 4-reconnect. binary: 111100
SEND_COMMAND("SY,FFF4\r\n"); // transmit power -12
SEND_COMMAND("R,1\r\n"); // reboot module
if (!config_mode) exit_command_mode();
}
static wiced_result_t rfcomm_add_sdp_record( wiced_bt_rfcomm_socket_t* socket, const char* service_name, const wiced_bt_uuid_t* uuid )
{
bt_packet_t* packet = NULL;
mpaf_event_params_t* params = NULL;
uint8_t record_handle;
uint8_t channel;
mpaf_protocol_element_param_t protocol_descriptor_list[2];
mpaf_uuid_param_t uuid_sequence;
/* Create SDP record for Device ID Profile */
SEND_COMMAND( bt_mpaf_sdp_create_record() );
RECEIVE_EVENT( packet );
params = (mpaf_event_params_t*)packet->data_start;
if ( params->command_complete.return_params.sdp_create_record.status != MPAF_SUCCESS )
{
bt_packet_pool_free_packet( packet );
return WICED_BT_ERROR;
}
/* SDP record successfully created. Retrieve record handle */
socket->shared.lock( socket );
socket->shared.sdp_record_handle = params->command_complete.return_params.sdp_create_record.record_handle;
record_handle = socket->shared.sdp_record_handle;
channel = socket->shared.channel;
socket->shared.unlock( socket );
protocol_descriptor_list[0].protocol_uuid = 0x0100;
protocol_descriptor_list[0].number_of_params = 0;
protocol_descriptor_list[0].params[0] = 0;
protocol_descriptor_list[0].params[1] = 0;
protocol_descriptor_list[1].protocol_uuid = 0x0003;
protocol_descriptor_list[1].number_of_params = 1;
protocol_descriptor_list[1].params[0] = channel;
protocol_descriptor_list[1].params[1] = 0;
/* Add Protocol descriptor list */
SEND_COMMAND( bt_mpaf_sdp_add_protocol_descriptor_list( record_handle, protocol_descriptor_list, 2 ) );
RECEIVE_EVENT( packet );
params = (mpaf_event_params_t*)packet->data_start;
if ( params->command_complete.return_params.sdp_add_protocol_descriptor_list.status != MPAF_SUCCESS )
{
goto delete_record;
}
uuid_sequence.uuid_size = uuid->size;
memcpy( uuid_sequence.uuid, &uuid->value, sizeof( uuid_sequence.uuid ));
/* Add Service Class UUID */
SEND_COMMAND( bt_mpaf_sdp_add_uuid_sequence( record_handle, 0x0001, &uuid_sequence, 1 ) );
RECEIVE_EVENT( packet );
params = (mpaf_event_params_t*)packet->data_start;
if ( params->command_complete.return_params.sdp_add_uuid_sequence.status != MPAF_SUCCESS )
{
goto delete_record;
}
/* Add device name Attribute */
SEND_COMMAND( bt_mpaf_sdp_add_attributes( record_handle,
0x0100,
MPAF_SDP_ATTRIBUTE_STRING,
strnlen( service_name, 21 ),
(const void*)service_name ) );
RECEIVE_EVENT( packet );
params = (mpaf_event_params_t*)packet->data_start;
if ( params->command_complete.return_params.sdp_add_attributes.status != MPAF_SUCCESS )
{
goto delete_record;
}
uuid_sequence.uuid_size = UUID_SIZE_16BIT;
uuid_sequence.uuid[0] = 0x02;
uuid_sequence.uuid[1] = 0x10;
uuid_sequence.uuid[2] = 0x00;
/* Add Service Class UUID */
SEND_COMMAND( bt_mpaf_sdp_add_uuid_sequence( record_handle, 0x0005, &uuid_sequence, 1 ) );
RECEIVE_EVENT( packet );
params = (mpaf_event_params_t*)packet->data_start;
if ( params->command_complete.return_params.sdp_add_uuid_sequence.status != MPAF_SUCCESS )
{
goto delete_record;
}
return WICED_BT_SUCCESS;
delete_record:
SEND_COMMAND( bt_mpaf_sdp_delete_record( record_handle ) );
RECEIVE_EVENT( packet );
bt_packet_pool_free_packet( packet );
return WICED_BT_ERROR;
}
static int optical_set_enable(struct iio_dev *indio_dev,bool enable)
{
//u8 tmp_value;
int err = -EINVAL;
struct optical_data *sdata = iio_priv(indio_dev);
//struct optical_data *sdata= indio_dev->dev_data;
#if 0
printk (KERN_ALERT "[optical_set_enable %d %d %d %d]\n", enable,sdata->sensor->pw_prox.addr,sdata->sensor->pw_prox.mask,sdata->sensor->pw_prox.value_on);
if (enable)
{
tmp_value = sdata->sensor->pw_prox.value_on;
err = optical_write_data_with_mask(indio_dev,
sdata->sensor->pw_prox.addr,
sdata->sensor->pw_prox.mask, tmp_value);
if (err < 0)
goto set_enable_error;
tmp_value = sdata->sensor->pw_light.value_on;
err = optical_write_data_with_mask(indio_dev,
sdata->sensor->pw_light.addr,
sdata->sensor->pw_light.mask, tmp_value);
if (err < 0)
goto set_enable_error;
sdata->enabled = true;
}
else
{
err = optical_write_data_with_mask(indio_dev,
sdata->sensor->pw_prox.addr,
sdata->sensor->pw_prox.mask,
sdata->sensor->pw_prox.value_off);
if (err < 0)
goto set_enable_error;
err = optical_write_data_with_mask(indio_dev,
sdata->sensor->pw_light.addr,
sdata->sensor->pw_light.mask,
sdata->sensor->pw_light.value_off);
if (err < 0)
goto set_enable_error;
sdata->enabled = false;
}
#else
if(enable)
{
printk (KERN_ALERT "[optical_set_enable %d]\n", enable);
printk("vungGV---------------------------------optical_set_enable");
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_IRQ_STATUS, 0x27);//clear all int
if (err < 0)
goto set_enable_error;
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_INT_CFG, B_INT_STICKY|B_INT_OUTPUT_ENABLE);
if (err < 0)
goto set_enable_error;
SEND_COMMAND(sdata,0x0D);//ps auto
SEND_COMMAND_WITH_PARAM(sdata,0xA1,0x01);//enable ps1
sdata->enabled = true;
}
else
{
u8 rspReg=0;
/* tri-states INT pin to stop any LT_1PHXX interrupts */
err = sdata->tf->write_byte(&sdata->tb, sdata->dev, REGS_INT_CFG, B_INT_STICKY|B_INT_OUTPUT_DISABLE);
if (err < 0)
goto set_enable_error;
/* Need to make sure the machine is paused */
/* condier that error condition in response register is asynchronous */
while (1)
{
printk (KERN_ALERT "[optical_set_enable %d]\n", enable);
/* Keep sending nops until the response is zero */
while (1)
{
rspReg = 0x00;
sdata->tf->read_byte(&sdata->tb, sdata->dev,REGS_RESPONSE, &rspReg);
if(rspReg == 0x00)
break;
else
SEND_COMMAND(sdata,0x00);//nop
}
/* Pause the device */
SEND_COMMAND(sdata,0x0B);//ps als pause
/* Wait for response */
while(1)
{
rspReg = 0x00;
sdata->tf->read_byte(&sdata->tb, sdata->dev,REGS_RESPONSE, &rspReg);
if (rspReg != 0x00)
break;
}
/* When the PsAlsPause() response is good, we expect it to be a '1'. */
if (rspReg == 0x01)
{
sdata->enabled = false;
break;
}
else
{
//goto set_enable_error;
}
}
}
#endif
set_enable_error:
return err;
}
/*
* This flow is of commands is based on an USB capture of
* traffic between LM Flash Programmer and the Stellaris Launchpad
* when doing a firmware write
*/
static int write_firmware(libusb_device_handle *handle, FILE *f)
{
uint32_t val = 0;
uint32_t addr;
size_t rdbytes;
int retval = 0;
uint32_t size;
print_icdi_version(handle);
SEND_COMMAND("debug clock \0");
SEND_STRING("qSupported");
SEND_STRING("?");
MEM_WRITE(FP_CTRL, 0x3000000);
MEM_READ(DID0, &val);
MEM_READ(DID1, &val);
SEND_STRING("?");
MEM_READ(DHCSR, &val);
SEND_COMMAND("debug sreset");
MEM_READ(DHCSR, &val);
MEM_READ(ROMCTL, &val);
MEM_WRITE(ROMCTL, 0x0);
MEM_READ(DHCSR, &val);
MEM_READ(RCC, &val);
MEM_READ(DID0, &val);
MEM_READ(DID1, &val);
MEM_READ(DC0, &val);
MEM_READ(DID0, &val);
MEM_READ(NVMSTAT, &val);
MEM_WRITE(FMA, 0x0);
MEM_READ(DHCSR, &val);
if (erase_used) {
fseek(f, 0, SEEK_END);
size = ftell(f);
for (addr = start_addr; addr < (start_addr + size); addr += FLASH_ERASE_SIZE)
FLASH_ERASE(addr, FLASH_ERASE_SIZE);
fseek(f, 0, SEEK_SET);
} else {
FLASH_ERASE(0, 0);
}
SEND_COMMAND("debug creset");
MEM_READ(DHCSR, &val);
MEM_WRITE(DHCSR, 0x0);
MEM_READ(ROMCTL, &val);
MEM_WRITE(ROMCTL, 0x0);
MEM_READ(DHCSR, &val);
for (addr = start_addr; !feof(f); addr += sizeof(flash_block)) {
rdbytes = fread(flash_block, 1, sizeof(flash_block), f);
if (rdbytes < sizeof(flash_block) && !feof(f)) {
perror("fread");
return LIBUSB_ERROR_OTHER;
}
/*
* Avoid writing a buffer with zero-sized content which can
* happen when the input file has a size multiple of flash_block
*/
if (rdbytes)
FLASH_WRITE(addr, flash_block, rdbytes);
}
if (do_verify) {
fseek(f, 0, SEEK_SET);
for (addr = start_addr; !feof(f); addr += sizeof(flash_block)) {
rdbytes = fread(flash_block, 1, sizeof(flash_block), f);
if (rdbytes < sizeof(flash_block) && !feof(f)) {
perror("fread");
return LIBUSB_ERROR_OTHER;
}
/* On error don't return immediately... finish resetting the board */
retval = send_flash_verify(handle, addr, flash_block, rdbytes);
if (retval) {
printf("Error verifying flash\n");
break;
}
}
}
SEND_COMMAND("set vectorcatch 0");
SEND_COMMAND("debug disable");
/* reset board */
MEM_WRITE(FP_CTRL, 0x3000000);
SEND_COMMAND("debug hreset");
SEND_COMMAND("set vectorcatch 0");
SEND_COMMAND("debug disable");
return retval;
}
