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;
}
}
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 retarget_setup(void)
{
VM_DCL_HANDLE uart_handle;
vm_dcl_sio_control_dcb_t settings;
if (retarget_device_handle != -1)
{
return;
}
#if defined(__HDK_LINKIT_ONE_V1__)
vm_dcl_config_pin_mode(VM_PIN_D0, VM_DCL_PIN_MODE_UART);
vm_dcl_config_pin_mode(VM_PIN_D1, VM_DCL_PIN_MODE_UART);
#elif defined(__HDK_LINKIT_ASSIST_2502__)
vm_dcl_config_pin_mode(VM_PIN_P8, VM_DCL_PIN_MODE_UART);
vm_dcl_config_pin_mode(VM_PIN_P9, VM_DCL_PIN_MODE_UART);
#endif
g_owner_id = vm_dcl_get_owner_id();
uart_handle = vm_dcl_open(VM_DCL_SIO_UART_PORT1, g_owner_id);
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);
retarget_rx_signal_id = vm_signal_create();
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;
}
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);
}
}
}
