void adc_callback(void* parameter, VM_DCL_EVENT event, VM_DCL_HANDLE device_handle)
{
vm_dcl_callback_data_t *data;
vm_dcl_adc_measure_done_confirm_t * result;
vm_dcl_adc_control_send_stop_t stop_data;
VMINT status = 0;
if(parameter!=NULL)
{
data = ( vm_dcl_callback_data_t*)parameter;
result = (vm_dcl_adc_measure_done_confirm_t *)(data->local_parameters);
if( result != NULL )
{
double *p;
p =(double*)&(result->value);
g_adc_result = (unsigned int)*p;
vm_log_info("get adc data is %d",g_adc_result);
}
}
// Stop ADC
stop_data.owner_id = vm_dcl_get_owner_id();
status = vm_dcl_control(g_adc_handle,VM_DCL_ADC_COMMAND_SEND_STOP,(void *)&stop_data);
vm_dcl_close(g_adc_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;
}
}
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;
}
size_t UARTClass::write( const uint8_t uc_data )
{
VM_DCL_STATUS status;
VM_DCL_BUFFER_LENGTH writen_len = 0;
int count = 0;
if(uart_handle != -1)
{
status = vm_dcl_write(uart_handle,(VM_DCL_BUFFER*)&uc_data,1,&writen_len,vm_dcl_get_owner_id());
while((status<VM_DCL_STATUS_OK || writen_len != 1) && (count < 3))
{
delayMicroseconds(10);
count++;
status = vm_dcl_write(uart_handle,(VM_DCL_BUFFER*)&uc_data,1,&writen_len,vm_dcl_get_owner_id());
}
return writen_len;
}
return 0;
}
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);
}
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 UartIrqHandler(void* parameter, VM_DCL_EVENT event, VM_DCL_HANDLE device_handle)
{
if(event == VM_DCL_SIO_UART_READY_TO_READ)
{
char data[SERIAL_BUFFER_SIZE];
int i;
VM_DCL_STATUS status;
VM_DCL_BUFFER_LENGTH returned_len;
status = vm_dcl_read(device_handle,(VM_DCL_BUFFER*)data,SERIAL_BUFFER_SIZE,&returned_len,vm_dcl_get_owner_id());
if(status<VM_DCL_STATUS_OK)
{
vm_log_info((char*)"read failed");
}
if(device_handle == g_APinDescription[0].ulHandle)
{
for(i=0;i<returned_len;i++)
{
Serial1._rx_buffer->store_char(data[i]);
}
}
else
{
for(i=0;i<returned_len;i++)
{
Serial._rx_buffer->store_char(data[i]);
}
}
}
else
{
}
}
