static VM_DRV_TP_BOOL ctp_goodix_gt9xx_set_device_mode(
VM_DRV_TP_DEVICE_MODE mode) {
VMUINT8 suspend_command = 0x05;
VM_DCL_HANDLE eint_handle;
ctp_info_t ctp_info;
VMUINT8 ctp_buffer[2] = { 0 };
if (mode == VM_DRV_TP_ACTIVE_MODE) {
eint_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_eint_pin);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT,
NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_WRITE_HIGH, NULL);
delay_ms(15);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_MODE_2, NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
vm_dcl_close(eint_handle);
} else if ((mode == VM_DRV_TP_SLEEP_MODE)) {
eint_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_eint_pin);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT,
NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_WRITE_LOW, NULL);
delay_ms(5);
CTP_I2C_send(CTP_POWER_MODE_REG, &suspend_command, 1);
CTP_I2C_read(CTP_POWER_MODE_REG, ctp_buffer, 1);
vm_dcl_close(eint_handle);
} else if (mode == VM_DRV_TP_FIRMWARE_UPDATE) {
// need wdt
}
return VM_DRV_TP_FALSE;
}
/* AT command callback, which will be invoked when you send AT command from monitor tool */
static void at_callback(vm_cmd_command_t *param, void *user_data)
{
vm_dcl_pmu_ld0_buck_enable_t val;
if(strcmp("Test01",(char*)param->command_buffer) == 0)
{
/* enable vibrator LDO when receive AT command: AT+[1000]Test01 */
/* vibrator will on */
g_pmu_handle = vm_dcl_open(VM_DCL_PMU, 0);
val.enable = TRUE;
val.module = VM_DCL_PMU_VIBR;
vm_dcl_control(g_pmu_handle, VM_DCL_PMU_CONTROL_LDO_BUCK_SET_ENABLE, (void *)&val);
vm_dcl_close(g_pmu_handle);
}
else if(strcmp("Test02",(char*)param->command_buffer) == 0)
{
/* disable vibrator LDO when receive AT command: AT+[1000]Test02 */
/* vibrator will off */
g_pmu_handle = vm_dcl_open(VM_DCL_PMU, 0);
val.enable = FALSE;
val.module = VM_DCL_PMU_VIBR;
vm_dcl_control(g_pmu_handle, VM_DCL_PMU_CONTROL_LDO_BUCK_SET_ENABLE, (void *)&val);
vm_dcl_close(g_pmu_handle);
}
}
void lcd_st7789s_init(void)
{
lcd_reset_handle = vm_dcl_open(VM_DCL_GPIO, LCD_GPIO_RESET);
lcd_cs_handle = vm_dcl_open(VM_DCL_GPIO, LCD_GPIO_CS);
// Settings set in WFD_lcd_initialize
//LCD_SET_LCD_ROI_CTRL_OUTPUT_FORMAT(LCD_16BIT_16_BPP_RGB565_1);
*VSIM1_CON2 = *VSIM1_CON2 | 0x0002;
*VSIM1_CON0 = *VSIM1_CON0 | 0x0001;
//Serial Clock:
vm_drv_lcd_set_serial_clock(0, LCD_SERIAL_CLOCK_132MHZ);
vm_drv_lcd_operation(VM_DRV_LCD_DISABLE_SERIAL0_SINGLE_A0);
vm_drv_lcd_operation(VM_DRV_LCD_DISABLE_SERIAL0_CS_STAY_LOW);
vm_drv_lcd_operation(VM_DRV_LCD_ENABLE_SERIAL0_3WIRE);
//LCD_DISABLE_SERIAL0_SDI;
//vm_drv_lcd_operation(VM_DRV_LCD_DISABLE_SERIAL0_SINGLE_A0);
vm_drv_lcd_operation(VM_DRV_LCD_ENABLE_HW_CS);
vm_drv_lcd_operation2(VM_DRV_LCD_SET_SERIAL0_IF_SIZE,LCD_SCNF_IF_WIDTH_8);
//Timing need tuning
vm_drv_lcd_init_timing(0, 0, 0, 0, 0, 7, 7);
//Set Driving current
//set_lcd_driving_current_centralize(LCD_DRIVING_12MA);
vm_drv_lcd_set_serial0_1v8_driving(LCD_DRIVING_12MA);
vm_drv_lcd_setup_driver(&lcd_func_ST7789S);
}
ADC_HANDLE open_hx711(int scl_pin, int sda_pin)
{
ADC_HANDLE handle = 0;
handle_details* details;
hx711_task* task;
while (open_handles[handle] != NULL)
{
handle++;
if (handle > MAX_HANDLE)
{
return ADC_HANDLE_INVALID;
}
}
details = vm_calloc(sizeof(handle_details));
if (details == NULL)
{
return ADC_HANDLE_INVALID;
}
task = &details->task;
task->scl_handle = vm_dcl_open(VM_DCL_GPIO, scl_pin);
if (task->scl_handle == VM_DCL_HANDLE_INVALID)
{
vm_free(details);
return ADC_HANDLE_INVALID;
}
vm_dcl_control(task->scl_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(task->scl_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT, NULL);
vm_dcl_control(task->scl_handle, VM_DCL_GPIO_COMMAND_WRITE_HIGH, NULL);
task->sda_handle = vm_dcl_open(VM_DCL_GPIO, sda_pin);
if (task->sda_handle == VM_DCL_HANDLE_INVALID)
{
vm_dcl_close(task->scl_handle);
vm_free(details);
return ADC_HANDLE_INVALID;
}
vm_dcl_control(task->sda_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(task->sda_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
vm_mutex_init(&details->mutex);
task->op = WAIT;
task->delay = 100;
task->callback = dummy_callback;
task->callback_env = NULL;
open_handles[handle] = details;
write_console("open\n");
vm_thread_create(measurement, (void*) details, (VM_THREAD_PRIORITY) 0);
return handle;
}
VM_DCL_STATUS vm_dcl_config_pin_mode(VMUINT pin, VM_DCL_PIN_MODE mode)
{
VM_DCL_HANDLE gpio_handle;
VMINT i, j;
VM_DCL_STATUS status = VM_DCL_STATUS_FAIL;
for(i = 0; i<VM_DCL_PIN_TABLE_SIZE; i++)
{
if(pinTable[i].gpio == pin)
{
break;
}
}
if(i >=VM_DCL_PIN_TABLE_SIZE)
return status;
gpio_handle = vm_dcl_open(VM_DCL_GPIO,pin);
for(j = 0; j<VM_DCL_PIN_MODE_MAX; j++)
{
if(pinTable[i].mux[j] == mode)
{
vm_dcl_control(gpio_handle,4+j,NULL);
status = VM_DCL_STATUS_OK;
break;
}
}
vm_dcl_close(gpio_handle);
return status;
}
extern void digitalWrite( uint32_t ulPin, uint32_t ulVal )
{
//vm_log_info("digitalWrite(): pin = %d , value = %d", ulPin, ulVal);
if (ulPin > PIO_MAX_NUM )
{
return;
}
if(g_APinDescription[ulPin].ulHandle == VM_DCL_HANDLE_INVALID)
{
g_APinDescription[ulPin].ulHandle = vm_dcl_open(VM_DCL_GPIO, g_APinDescription[ulPin].ulGpioId);
}
// write PIN
switch (ulVal)
{
case HIGH:
vm_dcl_control(g_APinDescription[ulPin].ulHandle,VM_GPIO_CMD_WRITE_HIGH, NULL);
break;
case LOW:
vm_dcl_control(g_APinDescription[ulPin].ulHandle,VM_GPIO_CMD_WRITE_LOW, NULL);
break;
default:
break;
}
}
extern void pinMode( uint32_t ulPin, uint32_t ulMode )
{
VM_DCL_HANDLE gpio_handle;
vm_gpio_ctrl_set_pupd_r0_r1_t pupd;
//vm_log_info("pinMode(): pin = %d , pin_internal = %d, mode = %d", ulPin, g_APinDescription[ulPin].ulGpioId, ulMode);
if(!changePinType(ulPin, PIO_DIGITAL, &gpio_handle))
return;
if(gpio_handle == VM_DCL_HANDLE_INVALID)
gpio_handle = vm_dcl_open(VM_DCL_GPIO, g_APinDescription[ulPin].ulGpioId);
// set PIN direction
switch ( ulMode )
{
case INPUT:
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_DIR_IN, NULL);
if( g_APinDescription[ulPin].ulPupd)
{
pupd.fgSetPupd = 0;
pupd.fgSetR0 = 1;
pupd.fgSetR1 = 0;
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_PUPD_R0_R1, &pupd);
}
else
{
vm_dcl_control(gpio_handle,VM_GPIO_CMD_ENABLE_PULL, NULL);
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_PULL_LOW, NULL);
}
break ;
case INPUT_PULLUP:
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_DIR_IN, NULL);
if( g_APinDescription[ulPin].ulPupd)
{
pupd.fgSetPupd = 1;
pupd.fgSetR0 = 1;
pupd.fgSetR1 = 0;
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_PUPD_R0_R1, &pupd);
}
else
{
vm_dcl_control(gpio_handle,VM_GPIO_CMD_ENABLE_PULL, NULL);
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_PULL_HIGH, NULL);
}
break ;
case OUTPUT:
vm_dcl_control(gpio_handle,VM_GPIO_CMD_SET_DIR_OUT, NULL);
break ;
default:
break ;
}
g_APinDescription[ulPin].ulHandle = gpio_handle;
}
extern int digitalRead( uint32_t ulPin )
{
vm_gpio_ctrl_read_t data;
//vm_log_info("digitalRead(): pin = %d", ulPin);
if (ulPin > PIO_MAX_NUM )
{
//vm_log_info("digitalRead(): pin mapping failed, return LOW as default.");
return LOW;
}
if(g_APinDescription[ulPin].ulHandle == VM_DCL_HANDLE_INVALID)
{
g_APinDescription[ulPin].ulHandle = vm_dcl_open(VM_DCL_GPIO, g_APinDescription[ulPin].ulGpioId);
}
vm_dcl_control(g_APinDescription[ulPin].ulHandle, VM_GPIO_CMD_READ,(void *)&data);
if ( data.u1IOData == VM_GPIO_IO_LOW )
{
//vm_log_info("digitalRead(): result = LOW");
return LOW ;
}
else if ( data.u1IOData == VM_GPIO_IO_HIGH )
{
//vm_log_info("digitalRead(): result = HIGH");
return HIGH ;
}
else
{
//vm_log_info("digitalRead(): read failed, return LOW as default.");
return LOW ;
}
}
void UARTClass::begin( const uint32_t dwBaudRate )
{
vm_sio_ctrl_dcb_t data;
if(_usbNum == 2)
{
if(!changePinType(0, PIO_UART, &uart_handle))
return;
if(uart_handle == VM_DCL_HANDLE_INVALID)
uart_handle = vm_dcl_open(vm_uart_port1,vm_dcl_get_ownerid());
}
else
{
uart_handle = vm_dcl_open(vm_usb_port1,vm_dcl_get_ownerid());
}
if(VM_DCL_HANDLE_INVALID==uart_handle)
{
vm_log_info((char*)"UARTClass failed");
return;
}
data.u4OwenrId = vm_dcl_get_ownerid();
data.rUARTConfig.u4Baud = dwBaudRate;
data.rUARTConfig.u1DataBits = 8;
data.rUARTConfig.u1StopBits = 1;
data.rUARTConfig.u1Parity = 0;
data.rUARTConfig.u1FlowControl = 1;
data.rUARTConfig.ucXonChar = 0x11;
data.rUARTConfig.ucXoffChar = 0x13;
data.rUARTConfig.fgDSRCheck = 0;
vm_dcl_control(uart_handle,VM_SIO_CMD_SET_DCB_CONFIG,(void *)&data);
vm_dcl_registercallback(uart_handle,VM_UART_READY_TO_READ,(VM_DCL_CALLBACK)UartIrqHandler,(void*)NULL);
if(_usbNum == 2)
{
setPinHandle(0, uart_handle);
}
else
{
usb_device_handle = uart_handle;
}
}
void UARTClass::begin( const uint32_t dwBaudRate )
{
vm_dcl_sio_control_dcb_t data;
if(_usbNum == 2)
{
if(!changePinType(0, PIO_UART, &uart_handle))
return;
if(uart_handle == VM_DCL_HANDLE_INVALID)
uart_handle = vm_dcl_open(VM_DCL_SIO_UART_PORT1,vm_dcl_get_owner_id());
}
else
{
uart_handle = vm_dcl_open(VM_DCL_SIO_USB_PORT1,vm_dcl_get_owner_id());
}
if(VM_DCL_HANDLE_INVALID==uart_handle)
{
vm_log_info((char*)"UARTClass failed");
return;
}
data.owner_id = vm_dcl_get_owner_id();
data.config.baud_rate = (VM_DCL_SIO_UART_BAUDRATE)dwBaudRate;
data.config.data_bits_per_char_length = 8;
data.config.stop_bits = 1;
data.config.parity = 0;
data.config.flow_control = 1;
data.config.sw_xon_char = 0x11;
data.config.sw_xoff_char = 0x13;
data.config.dsr_check = 0;
vm_dcl_control(uart_handle,VM_DCL_SIO_COMMAND_SET_DCB_CONFIG,(void *)&data);
vm_dcl_register_callback(uart_handle,VM_DCL_SIO_UART_READY_TO_READ,(vm_dcl_callback)UartIrqHandler,(void*)NULL);
if(_usbNum == 2)
{
setPinHandle(0, uart_handle);
}
else
{
usb_device_handle = uart_handle;
}
}
void tp_gt9xx_init(void) {
gpio_ctp_eint_handle = vm_dcl_open(VM_DCL_EINT, 11);
if (VM_DCL_HANDLE_INVALID == gpio_ctp_eint_handle) {
vm_log_info("open EINT error");
return;
}
vm_drv_tp_setup_driver(&ctp_custom_func);
}
VMINT32 analogRead(VMUINT8 ulPin)
{
vm_dcl_adc_control_create_object_t obj_data;
VMINT status = 0 , i;
vm_dcl_adc_control_send_start_t start_data;
if(ulPin > 3)// for ADC0 ADC1 ADC2 ADC3
{
vm_log_info("ADC pin number is error");
return -1;
}
vm_dcl_close(g_adc_handle);
g_adc_handle = vm_dcl_open(VM_DCL_GPIO, ulPin);
vm_dcl_control(g_adc_handle,VM_DCL_GPIO_COMMAND_SET_MODE_2,NULL);
vm_dcl_close(g_adc_handle);
// Open ADC device
g_adc_handle = vm_dcl_open(VM_DCL_ADC,0);
// register ADC result callback
status = vm_dcl_register_callback(g_adc_handle, VM_DCL_ADC_GET_RESULT ,(vm_dcl_callback)adc_callback, (void *)NULL);
// Indicate to the ADC module driver to notify the result.
obj_data.owner_id = vm_dcl_get_owner_id();
// Set physical ADC channel which should be measured.
obj_data.channel = PIN2CHANNEL(ulPin);
// Set measurement period, the unit is in ticks.
obj_data.period = 1;
// Measurement count.
obj_data.evaluate_count = 1;
// Whether to send message to owner module or not.
obj_data.send_message_primitive = 1;
// setup ADC object
status = vm_dcl_control(g_adc_handle,VM_DCL_ADC_COMMAND_CREATE_OBJECT,(void *)&obj_data);
// start ADC
start_data.owner_id = vm_dcl_get_owner_id();
status = vm_dcl_control(g_adc_handle,VM_DCL_ADC_COMMAND_SEND_START,(void *)&start_data);
return g_adc_result;
}
void key_init(void){
VM_DCL_HANDLE kbd_handle;
vm_dcl_kbd_control_pin_t kbdmap;
kbd_handle = vm_dcl_open(VM_DCL_KBD,0);
kbdmap.col_map = 0x09;
kbdmap.row_map =0x05;
vm_dcl_control(kbd_handle,VM_DCL_KBD_COMMAND_CONFIG_PIN, (void *)(&kbdmap));
vm_dcl_close(kbd_handle);
}
void retarget_setup(void)
{
VM_DCL_HANDLE uart_handle;
vm_dcl_sio_control_dcb_t settings;
g_owner_id = vm_dcl_get_owner_id();
if (retarget_device_handle != -1)
{
return;
}
#if 1
vm_dcl_config_pin_mode(10, VM_DCL_PIN_MODE_UART);
vm_dcl_config_pin_mode(11, VM_DCL_PIN_MODE_UART);
uart_handle = vm_dcl_open(VM_DCL_SIO_UART_PORT1, g_owner_id);
#else
uart_handle = vm_dcl_open(VM_DCL_SIO_USB_PORT1, g_owner_id);
#endif
settings.owner_id = g_owner_id;
settings.config.dsr_check = 0;
settings.config.data_bits_per_char_length = VM_DCL_SIO_UART_BITS_PER_CHAR_LENGTH_8;
settings.config.flow_control = VM_DCL_SIO_UART_FLOW_CONTROL_NONE;
settings.config.parity = VM_DCL_SIO_UART_PARITY_NONE;
settings.config.stop_bits = VM_DCL_SIO_UART_STOP_BITS_1;
settings.config.baud_rate = VM_DCL_SIO_UART_BAUDRATE_115200;
settings.config.sw_xoff_char = 0x13;
settings.config.sw_xon_char = 0x11;
vm_dcl_control(uart_handle, VM_DCL_SIO_COMMAND_SET_DCB_CONFIG, (void *)&settings);
vm_dcl_register_callback(uart_handle,
VM_DCL_SIO_UART_READY_TO_READ,
(vm_dcl_callback)__retarget_irq_handler,
(void*)NULL);
retarget_device_handle = uart_handle;
}
int gpio_get_handle(int pin, VM_DCL_HANDLE *handle)
{
int i;
for (i = 0; i < VM_DCL_PIN_TABLE_SIZE; i++) {
if (pinHandleTable[i].gpio == pin) {
if (pinHandleTable[i].handle == VM_DCL_HANDLE_INVALID) {
pinHandleTable[i].handle = vm_dcl_open(VM_DCL_GPIO, pin);
}
*handle = pinHandleTable[i].handle;
return 0;
}
}
return -1;
}
void lcd_backlight_level(VMUINT32 ulValue)
{
VM_DCL_HANDLE pwm_handle;
vm_dcl_pwm_set_clock_t pwm_clock;
vm_dcl_pwm_set_counter_threshold_t pwm_config_adv;
vm_dcl_config_pin_mode(3, VM_DCL_PIN_MODE_PWM);
pwm_handle = vm_dcl_open(PIN2PWM(3), vm_dcl_get_owner_id());
vm_dcl_control(pwm_handle, VM_PWM_CMD_START, 0);
pwm_config_adv.counter = 100;
pwm_config_adv.threshold = ulValue;
pwm_clock.source_clock = 0;
pwm_clock.source_clock_division = 3;
vm_dcl_control(pwm_handle, VM_PWM_CMD_SET_CLOCK, (void *) (&pwm_clock));
vm_dcl_control(pwm_handle, VM_PWM_CMD_SET_COUNTER_AND_THRESHOLD,
(void *) (&pwm_config_adv));
vm_dcl_close(pwm_handle);
}
VMINT8 pinMode(VMUINT8 ulPin,VMUINT8 ulMode)
{
VM_DCL_HANDLE gpio_handle;
gpio_handle = vm_dcl_open(VM_DCL_GPIO, ulPin);
if(gpio_handle != VM_DCL_HANDLE_INVALID)
{
switch(ulMode)
{
case INPUT:
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
break;
case OUTPUT:
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT, NULL);
break;
case INPUT_PULLUP:
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_ENABLE_PULL, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_PULL_HIGH, NULL);
break;
case INPUT_PULLDN:
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_ENABLE_PULL, NULL);
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_SET_PULL_LOW, NULL);
break;
default:
break;
}
}
else
{
vm_log_info("gpio set pin mode fail");
return -1;
}
vm_dcl_close(gpio_handle);
return TRUE;
}
void TwoWire::begin(void) {
if(!changePinType(18, PIO_I2C, &i2c_handle))
return;
if(i2c_handle == VM_DCL_HANDLE_INVALID)
i2c_handle = vm_dcl_open(VM_DCL_I2C,0);
else
i2c_handle = g_APinDescription[18].ulHandle;
if(VM_DCL_HANDLE_INVALID == i2c_handle)
{
vm_log_info("begin, failed.i2c_handle:%d",i2c_handle);
}
setPinHandle(18, i2c_handle);
status = MASTER_IDLE;
}
VMINT8 digitalWrite(VMUINT8 ulPin,VMUINT8 ulData)
{
VM_DCL_HANDLE gpio_handle;
gpio_handle = vm_dcl_open(VM_DCL_GPIO, ulPin);
if(gpio_handle != VM_DCL_HANDLE_INVALID)
{
if(ulData == LOW)
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_WRITE_LOW, NULL);
else if(ulData == HIGH)
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_WRITE_HIGH, NULL);
}
else
{
vm_log_info("gpio write pin fail");
return -1;
}
vm_dcl_close(gpio_handle);
return TRUE;
}
// JS: i2c.setup(address, speed)
static v7_val_t i2c_setup(struct v7 *v7)
{
vm_dcl_i2c_control_config_t conf_data;
int result;
v7_val_t addressv = v7_arg(v7, 0);
v7_val_t speedv = v7_arg(v7, 1);
int address, speed;
if(!v7_is_number(addressv) || !v7_is_number(speedv)) {
printf("Invalid arguments\n");
return v7_create_undefined();
}
address = v7_to_number(addressv);
speed = v7_to_number(speedv);
if(speed >= 400) {
conf_data.transaction_mode = VM_DCL_I2C_TRANSACTION_HIGH_SPEED_MODE;
} else {
conf_data.transaction_mode = VM_DCL_I2C_TRANSACTION_FAST_MODE;
}
if(g_i2c_handle == VM_DCL_HANDLE_INVALID) {
g_i2c_handle = vm_dcl_open(VM_DCL_I2C, 0);
}
conf_data.reserved_0 = (VM_DCL_I2C_OWNER)0;
conf_data.get_handle_wait = TRUE;
conf_data.reserved_1 = 0;
conf_data.delay_length = 0;
conf_data.slave_address = (address << 1);
conf_data.fast_mode_speed = speed;
conf_data.high_mode_speed = 0;
result = vm_dcl_control(g_i2c_handle, VM_DCL_I2C_CMD_CONFIG, &conf_data);
return v7_create_number(result);
}
VMINT8 digitalRead(VMUINT8 ulPin)
{
VM_DCL_HANDLE gpio_handle;
vm_dcl_gpio_control_level_status_t data;
VMUINT8 ret;
gpio_handle = vm_dcl_open(VM_DCL_GPIO, ulPin);
if(gpio_handle != VM_DCL_HANDLE_INVALID)
{
vm_dcl_control(gpio_handle, VM_DCL_GPIO_COMMAND_READ, (void*)&data);
if (data.level_status == 1)ret = HIGH;
else ret = LOW;
}
else
{
vm_log_info("gpio read pin fail");
return -1;
}
vm_dcl_close(gpio_handle);
return ret;
}
void attachInterrupt(VMUINT32 pin, void (*callback)(void), VMUINT32 mode)
{
VM_DCL_HANDLE gpio_handle;
VM_DCL_HANDLE eint_handle;
vm_dcl_eint_control_config_t eint_config;
vm_dcl_eint_control_sensitivity_t sens_data;
vm_dcl_eint_control_hw_debounce_t deboun_time;
VM_DCL_STATUS status;
VMUINT8 i;
for(i=0;i<EXTERNAL_NUM_INTERRUPTS;i++)
{
if(gExinterruptsPio[i].pin == pin)
{
vm_log_info("open EINT number is %d",gExinterruptsPio[i].eint);
break;
}
}
if(i == EXTERNAL_NUM_INTERRUPTS)
{
vm_log_info("open EINT number error");
return;
}
detachInterrupt(pin);
gpio_handle = vm_dcl_open(VM_DCL_GPIO,pin);
if(gpio_handle == VM_DCL_HANDLE_INVALID)
{
vm_log_info("open eint gpio error, gpio_handle is %d", gpio_handle);
return;
}
switch(pin)
{
case 0:case 1:case 2:
vm_log_info("VM_DCL_GPIO_COMMAND_SET_MODE_1");
vm_dcl_control(gpio_handle,VM_DCL_GPIO_COMMAND_SET_MODE_1,NULL);
break;
case 13:case 18:case 46:case 52:
vm_log_info("VM_DCL_GPIO_COMMAND_SET_MODE_2");
vm_dcl_control(gpio_handle,VM_DCL_GPIO_COMMAND_SET_MODE_2,NULL);
break;
case 10:case 11:
vm_log_info("VM_DCL_GPIO_COMMAND_SET_MODE_3");
vm_dcl_control(gpio_handle,VM_DCL_GPIO_COMMAND_SET_MODE_3,NULL);
break;
case 25:
vm_log_info("VM_DCL_GPIO_COMMAND_SET_MODE_4");
vm_dcl_control(gpio_handle,VM_DCL_GPIO_COMMAND_SET_MODE_4,NULL);
break;
default:
break;
}
vm_dcl_control(gpio_handle,VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
vm_dcl_close(gpio_handle);
memset(&eint_config,0, sizeof(vm_dcl_eint_control_config_t));
memset(&sens_data,0, sizeof(vm_dcl_eint_control_sensitivity_t));
memset(&deboun_time,0, sizeof(vm_dcl_eint_control_hw_debounce_t));
eint_handle = vm_dcl_open(VM_DCL_EINT,gExinterruptsPio[i].eint);
if(VM_DCL_HANDLE_INVALID == eint_handle)
{
vm_log_info("open EINT error, eint_handle is %d",eint_handle);
return;
}
gExinterruptsPio[i].handle = eint_handle;
gExinterruptsPio[i].cb = callback;
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_MASK,NULL); // Usually, before we config eint, we mask it firstly.
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_MASK = %d", status);
}
status = vm_dcl_register_callback(eint_handle , VM_DCL_EINT_EVENT_TRIGGER,(vm_dcl_callback)eint_callback,(void*)NULL );
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_EVENT_TRIGGER = %d", status);
}
if(gExinterruptsPio[i].first == 0)
{
if (mode == CHANGE)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 0;
eint_config.auto_unmask = 1;
}
else
{
if(mode == FALLING)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 0;
eint_config.auto_unmask = 1;
}
else if(mode == RISING)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 1;
eint_config.auto_unmask = 1;
}
else
{
vm_log_info("mode not support = %d", mode);
}
}
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_SET_SENSITIVITY,(void *)&sens_data); /* set eint sensitivity */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_SET_SENSITIVITY = %d", status);
}
deboun_time.debounce_time = 1; // debounce time 1ms
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_SET_HW_DEBOUNCE,(void *)&deboun_time); /* set debounce time */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_SET_HW_DEBOUNCE = %d", status);
}
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_MASK,NULL); /* Usually, before we config eint, we mask it firstly. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_MASK = %d", status);
}
eint_config.debounce_enable = 0; // 1 means enable hw debounce, 0 means disable.
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_CONFIG,(void *)&eint_config); // Please call this api finally, because we will unmask eint in this command.
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_CONFIG = %d", status);
}
if (mode == CHANGE)
{
vm_dcl_eint_control_auto_change_polarity_t auto_change;
auto_change.auto_change_polarity = 1;
status = vm_dcl_control(eint_handle ,VM_DCL_EINT_COMMAND_SET_AUTO_CHANGE_POLARITY,(void *)&auto_change); // Please call this api finally, because we will unmask eint in this command.
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_CONFIG change = %d", status);
}
}
gExinterruptsPio[i].first ++;
vm_log_info("attach Interrupt ok.");
}
else
{
status = vm_dcl_control(eint_handle,VM_DCL_EINT_COMMAND_UNMASK,NULL); // call this function to unmask this eint.
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_DCL_EINT_COMMAND_CONFIG = %d", status);
}
}
}
static VM_DRV_TP_BOOL ctp_goodix_gt9xx_init(void) {
VM_DCL_HANDLE sda_handle, scl_handle;
VM_DCL_HANDLE eint_handle, reset_handle;
VM_DRV_TP_BOOL ack;
ctp_info_t ctp_info;
VMUINT16 reg_value;
VMUINT8 i = 0;
//turn on VSIM1
*VSIM1_CON2 = *VSIM1_CON2 | 0x0002;
*VSIM1_CON0 = *VSIM1_CON0 | 0x0001;
// init i2c
if (gpio_ctp_i2c_sda_pin != 0xFF) {
sda_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_i2c_sda_pin);
scl_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_i2c_scl_pin);
vm_dcl_control(sda_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(scl_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
CTP_DELAY_TIME = 3;
}
ctp_i2c_configure(CTP_SLAVE_ADDR, CTP_DELAY_TIME);
eint_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_eint_pin);
reset_handle = vm_dcl_open(VM_DCL_GPIO, gpio_ctp_reset_pin);
////////////////////////////reset//////////////////////////////////
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT, NULL);
vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_WRITE_LOW, NULL);
vm_dcl_control(reset_handle, VM_DCL_GPIO_COMMAND_SET_MODE_0, NULL);
vm_dcl_control(reset_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_OUT, NULL);
vm_dcl_control(reset_handle, VM_DCL_GPIO_COMMAND_WRITE_LOW, NULL);
delay_ms(5);
vm_dcl_control(reset_handle, VM_DCL_GPIO_COMMAND_WRITE_HIGH, NULL);
delay_ms(10);
//////////////////////////////////////////////////////////////////
vm_dcl_close(eint_handle);
vm_dcl_close(reset_handle);
//vm_dcl_control(eint_handle, VM_DCL_GPIO_COMMAND_SET_DIRECTION_IN, NULL);
//vm_dcl_control(eint_handle, gpio_ctp_eint_pin_M_EINT, NULL);
//EINT_Set_Sensitivity(custom_eint_get_channel(touch_panel_eint_chann), EDGE_SENSITIVE);
ctp_init_EINT();
ack = ctp_goodix_gt9xx_set_configuration();
if (ack == VM_DRV_TP_FALSE) {
vm_log_info("ctp_goodix_gt9xx_set_configuration fail!!!");
return VM_DRV_TP_FALSE;
}
vm_log_info("ctp_goodix_gt9xx_set_configuration OK!!!");
ack = ctp_goodix_gt9xx_get_information(&ctp_info);
if (ack == VM_DRV_TP_FALSE) {
vm_log_info("read information fail");
return VM_DRV_TP_FALSE;
}
return VM_DRV_TP_TRUE;
}
void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode)
{
VM_DCL_HANDLE eint_handle;
vm_eint_ctrl_config_t eint_config;
vm_eint_ctrl_set_sensitivity_t sens_data;
vm_eint_ctrl_set_hw_deounce_t deboun_time;
VM_DCL_STATUS status;
if(pin > EXTERNAL_NUM_INTERRUPTS)
return ;
detachInterrupt(pin);
if(!changePinType(gExinterruptsPio[pin].pin, PIO_EINT, &eint_handle))
return;
memset(&eint_config,0, sizeof(vm_eint_ctrl_config_t));
memset(&sens_data,0, sizeof(vm_eint_ctrl_set_sensitivity_t));
memset(&deboun_time,0, sizeof(vm_eint_ctrl_set_hw_deounce_t));
if(eint_handle == VM_DCL_HANDLE_INVALID)
eint_handle = vm_dcl_open(VM_DCL_EINT,gExinterruptsPio[pin].eint);
if(VM_DCL_HANDLE_INVALID == eint_handle)
{
vm_log_info("open EINT error");
return;
}
setPinHandle(gExinterruptsPio[pin].pin, eint_handle);
gExinterruptsPio[pin].handle = eint_handle;
gExinterruptsPio[pin].cb = callback;
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_MASK,NULL); /* Usually, before we config eint, we mask it firstly. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_MASK = %d", status);
}
status = vm_dcl_registercallback(eint_handle , VM_EVENT_EINT_TRIGGER,(VM_DCL_CALLBACK)eint_callback,(void*)NULL );
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EVENT_EINT_TRIGGER = %d", status);
}
if(gExinterruptsPio[pin].first == 0)
{
if (mode == CHANGE)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 0;
eint_config.auto_unmask = 1;
}
else
{
if (mode == FALLING)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 0;
eint_config.auto_unmask = 1;
}
else if (mode == RISING)
{
sens_data.sensitivity = 0;
eint_config.act_polarity = 1;
eint_config.auto_unmask = 1;
}
else
{
vm_log_info("mode not support = %d", mode);
}
}
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_SET_SENSITIVITY,(void *)&sens_data); /* set eint sensitivity */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_SET_SENSITIVITY = %d", status);
}
deboun_time.debounce_time = 1; /* debounce time 1ms */
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_SET_HW_DEBOUNCE,(void *)&deboun_time); /* set debounce time */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_SET_HW_DEBOUNCE = %d", status);
}
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_MASK,NULL); /* Usually, before we config eint, we mask it firstly. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_MASK = %d", status);
}
eint_config.debounce_en = 0; /* 1 means enable hw debounce, 0 means disable. */
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_CONFIG,(void *)&eint_config); /* Please call this api finally, because we will unmask eint in this command. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_CONFIG = %d", status);
}
if (mode == CHANGE)
{
vm_eint_ctrl_set_auto_change_pol_t auto_change;
auto_change.autoChangePol = 1;
status = vm_dcl_control(eint_handle ,VM_EINT_CMD_SET_AUTO_CHANGE_POLARTIY,(void *)&auto_change); /* Please call this api finally, because we will unmask eint in this command. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_CONFIG chage= %d", status);
}
}
gExinterruptsPio[pin].first ++;
}
else
{
status = vm_dcl_control(eint_handle,VM_EINT_CMD_UNMASK,NULL); /* call this function to unmask this eint. */
if(status != VM_DCL_STATUS_OK)
{
vm_log_info("VM_EINT_CMD_CONFIG = %d", status);
}
}
}
