//Main routine void ICACHE_FLASH_ATTR user_init(void) { stdoutInit(); os_delay_us(100000); CFG_Load(); ioInit(); WIFI_Connect(wifiConnectCb); httpdInit(builtInUrls, sysCfg.httpd_port); if(sysCfg.ntp_enable==1) { sntp_init(sysCfg.ntp_tz); //timezone } if(sysCfg.mqtt_enable==1) { MQTT_InitConnection(&mqttClient, (uint8_t *)sysCfg.mqtt_host, sysCfg.mqtt_port, sysCfg.mqtt_use_ssl ); MQTT_InitClient(&mqttClient, (uint8_t *)sysCfg.mqtt_devid, (uint8_t *)sysCfg.mqtt_user, (uint8_t *)sysCfg.mqtt_pass, sysCfg.mqtt_keepalive,1); MQTT_OnConnected(&mqttClient, mqttConnectedCb); MQTT_OnDisconnected(&mqttClient, mqttDisconnectedCb); MQTT_OnPublished(&mqttClient, mqttPublishedCb); MQTT_OnData(&mqttClient, mqttDataCb); } if(sysCfg.sensor_dht22_enable) DHTInit(SENSOR_DHT22, 30000); if(sysCfg.sensor_ds18b20_enable) ds_init(30000); broadcastd_init(); thermostat_init(30000); /* //Netbios to set the name struct softap_config wiconfig; os_memset(netbios_name, ' ', sizeof(netbios_name)-1); if(wifi_softap_get_config(&wiconfig)) { int i; for(i = 0; i < sizeof(netbios_name)-1; i++) { if(wiconfig.ssid[i] < ' ') break; netbios_name[i] = wiconfig.ssid[i]; }; } else os_sprintf(netbios_name, "ESP8266"); netbios_name[sizeof(netbios_name)-1]='\0'; netbios_init(); */ os_printf("\nRelay Board Ready\n"); os_printf("Free heap size:%d\n",system_get_free_heap_size()); #ifdef CGIPWM_H //Mind the PWM pin!! defined in pwm.h duty=0; pwm_init( 50, &duty); pwm_set_duty(duty, 0); pwm_start(); #endif //OLEDInit(); }
iram void gpios_periodic(void) { gpio_t *gpio; const gpio_config_entry_t *cfg; unsigned int current; unsigned int duty; bool_t pwm_changed = false; for(current = 0; current < gpio_size; current++) { gpio = &gpios[current]; cfg = get_config(gpio); if((cfg->mode == gpio_counter) && (gpio->counter.debounce != 0)) { if(gpio->counter.debounce >= 10) gpio->counter.debounce -= 10; // 10 ms per tick else gpio->counter.debounce = 0; if(gpio->counter.debounce == 0) arm_counter(gpio); } if((cfg->mode == gpio_timer) && (gpio->timer.delay > 0)) { if(gpio->timer.delay >= 10) gpio->timer.delay -= 10; // 10 ms per tick else gpio->timer.delay = 0; if(gpio->timer.delay == 0) { set_output(gpio, !get_input(gpio)); if(cfg->timer.repeat) gpio->timer.delay = cfg->timer.delay; } } if((cfg->mode == gpio_pwm) && (gpio->pwm.delay_top > 0)) { if(++gpio->pwm.delay_current > gpio->pwm.delay_top) { gpio->pwm.delay_current = 0; duty = pwm_get_duty(gpio->pwm.channel); if(gpio->pwm.direction == gpio_up) { if(duty < gpio->pwm.min_duty) duty = gpio->pwm.min_duty; if(duty < 16) duty = 16; duty *= 115; duty /= 100; if(duty >= gpio->pwm.max_duty) { duty = gpio->pwm.max_duty; gpio->pwm.direction = gpio_down; } } else { if(duty > gpio->pwm.max_duty) duty = gpio->pwm.max_duty; duty *= 100; duty /= 115; if(duty <= gpio->pwm.min_duty) { duty = gpio->pwm.min_duty; gpio->pwm.direction = gpio_up; } if(duty < 16) { duty = 16; gpio->pwm.direction = gpio_up; } } pwm_changed = true; pwm_set_duty(duty, gpio->pwm.channel); } } } if(pwm_changed) pwm_start(); }
irom app_action_t application_function_gpio_set(application_parameters_t ap) { unsigned int gpio_index; gpio_t *gpio; const gpio_config_entry_t *cfg; gpio_index = atoi((*ap.args)[1]); if(!(gpio = find_gpio(gpio_index))) { snprintf(ap.dst, ap.size, "gpio-set: invalid gpio %u\n", gpio_index); return(app_action_error); } cfg = get_config(gpio); switch(cfg->mode) { case(gpio_disabled): { snprintf(ap.dst, ap.size, "gpio-set: gpio %s is disabled\n", gpio->name); return(app_action_error); } case(gpio_input): { snprintf(ap.dst, ap.size, "gpio-set: gpio %s is input\n", gpio->name); return(app_action_error); } case(gpio_counter): { if(ap.nargs < 3) gpio->counter.count = 0; else gpio->counter.count = atoi((*ap.args)[2]); break; } case(gpio_output): { if(ap.nargs < 3) { snprintf(ap.dst, ap.size, "gpio-set: missing arguments\n"); return(app_action_error); } set_output(gpio, !!atoi((*ap.args)[2])); break; } case(gpio_timer): { if(ap.nargs == 3) trigger_timer(gpio, !!atoi((*ap.args)[2])); else trigger_timer(gpio, !gpio->timer.delay); break; } case(gpio_pwm): { unsigned int min_duty; unsigned int max_duty; unsigned int delay; min_duty = 0; max_duty = 0; delay = 0; if(ap.nargs > 2) min_duty = atoi((*ap.args)[2]); if(ap.nargs > 3) max_duty = atoi((*ap.args)[3]); if(ap.nargs > 4) delay = atoi((*ap.args)[4]); if(min_duty > 65535) { snprintf(ap.dst, ap.size, "gpio-set(pwm): min_duty too large: %u > 65535\n", min_duty); return(app_action_error); } if(max_duty > 65535) { snprintf(ap.dst, ap.size, "gpio-set(pwm): max_duty too large: %u > 65535\n", max_duty); return(app_action_error); } if(delay > 100) { snprintf(ap.dst, ap.size, "gpio-set: gpio %s, delay %u%% > 100%%\n", gpio->name, delay); return(app_action_error); } gpio->pwm.min_duty = min_duty; gpio->pwm.max_duty = max_duty; gpio->pwm.delay_top = delay; gpio->pwm.direction = gpio_up; pwm_set_duty(min_duty, gpio->pwm.channel); pwm_start(); break; } case(gpio_i2c): { snprintf(ap.dst, ap.size, "gpio-set: gpio %s is reserved for i2c\n", gpio->name); return(app_action_error); } default: { snprintf(ap.dst, ap.size, "gpio-set: cannot set gpio %u\n", cfg->mode); return(app_action_error); } } dump(&config->gpios, gpio, ap.size, ap.dst); return(app_action_normal); }
int led_set_brightness(enum ec_led_id led_id, const uint8_t *brightness) { pwm_set_duty(PWM_CH_LED_RED, brightness[EC_LED_COLOR_RED]); pwm_set_duty(PWM_CH_LED_GREEN, brightness[EC_LED_COLOR_GREEN]); return EC_SUCCESS; }
static void _exec_spindle_speed(float *value, float *flag) { cm_set_spindle_speed_parameter(MODEL, value[0]); pwm_set_duty(PWM_1, cm_get_spindle_pwm(cm.gm.spindle_mode) ); // update spindle speed if we're running }
static void pwm_kblight_shutdown(void) { pwm_set_duty(PWM_CH_KBLIGHT, 0); }
/** * Set LED color * * @param color Enumerated color value */ static void set_color(enum led_color color) { pwm_set_duty(PWM_CH_LED_RED, color_brightness[color][0]); pwm_set_duty(PWM_CH_LED_GREEN, color_brightness[color][1]); }
static void _exec_spindle_speed(uint8_t i, float speed) { cm_set_spindle_speed_parameter(speed); pwm_set_duty(PWM_1, cm_get_spindle_pwm(gm.spindle_mode) ); // update spindle speed if we're running }
static void pwm_kblight_suspend(void) { pwm_set_duty(PWM_CH_KBLIGHT, 0); }
/* void pid_loop() Calculates the updated PID output and parameters for each iteration. */ void pid_loop() { if (pid_state != PID_RUNNING) return; uint32 dummy_time; boolean is_update_pid = timer_is_elapsed32((pid_last_timestamp + PID_LOOP_WAIT_IN_NS), &dummy_time); if (!is_update_pid) { DEBUG_MSG_HIGH(DEBUG_MODULE_PID, "Timer not expired. Time: %d", dummy_time); return; } /* Update the last time PID was read for scheduling next iteration. */ pid_last_timestamp = timer_read32(); /* Read updated temperatures. If last reading was invalid, skip this PID loop iteration. */ therm_reading_t *temp = &(pid_params.temp); therm_read(temp); if (!temp->is_valid) { DEBUG_MSG_HIGH(DEBUG_MODULE_PID, "Temperature read failed"); return; } /* Do PID calculation. */ float t_current = pid_params.temp.temperature; float t_desired = pid_params.temp_setpoint; pid_gain_params *gain_p = &(pid_params.gain); pid_error_params *error_p = &(pid_params.error); float err, err_i, err_d; err = t_desired - t_current; err_i = err + error_p->err_i; err_d = err - error_p->err; float p, i, d; p = gain_p->k_p * err; i = gain_p->k_i * err_i; d = gain_p->k_d * err_d; /* Scale/saturate the PID output and set the duty cycle. */ float pid_raw = p + i + d; /* Add 0.5 to do rounding with truncation. */ float pid_scaled = pid_raw + 0.5; pid_scaled = MAX(pid_raw, 0); pid_scaled = MIN(pid_scaled, 100); pwm_set_duty((uint32)pid_scaled); /* Calculate saturation error for anti-windup loop. */ float err_saturate = (pid_scaled - pid_raw) * (gain_p->k_windup); /* Update error for next iteration. */ error_p->err = err; error_p->err_d = err_d; error_p->err_i = err_i + err_saturate; DEBUG_MSG_MED(DEBUG_MODULE_PID, "err: %5.2f, err_d: %5.2f, err_i: %5.2f, err_sat: %5.2f", error_p->err, error_p->err_d, error_p->err_i, err_saturate); DEBUG_MSG_MED(DEBUG_MODULE_PID, "pid_raw: %5.2f, pid_scaled: %5.2f", pid_raw, pid_scaled); }
// initialize the custom stuff that goes beyond esp-link void user_init() { // Initialize the GPIO subsystem. gpio_init(); /* ====================================== */ /* UART */ /* ====================================== */ // Initialize UART0 and UART1 /* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */ uart_init( BIT_RATE_115200, BIT_RATE_115200 ); // uart0_sendStr( "\nUART0 - USED TO PROGRAM THE MODULE\n" ); os_printf("\n===================\nUART1 - DEBUG OUPUT\n===================\n"); /* NOTE: PWM CANNOT BE USED SIMULTANEOUSLY WITH HW TIMER */ #if 0 /* ====================================== */ /* PWM */ /* ====================================== */ uint32 pwm_period = 1000; uint32 pwm_duty[PWM_CHANNEL] = {0}; uint32 io_info[][3] = { {PWM_0_OUT_IO_MUX,PWM_0_OUT_IO_FUNC,PWM_0_OUT_IO_NUM}, {PWM_1_OUT_IO_MUX,PWM_1_OUT_IO_FUNC,PWM_1_OUT_IO_NUM}, }; /* PIN FUNCTION INIT FOR PWM OUTPUT */ pwm_init(pwm_period, pwm_duty, PWM_CHANNEL, io_info); /* set pwm_duty cycle */ pwm_set_duty (14185, 0); pwm_set_duty (22222, 1); // todo: explain why 22222 is the highest possible value /* start PWM */ pwm_start(); // NOTE: PWM causes spikes in other GPIOs #endif /* ====================================== */ /* GPIO INTERRPUT */ /* ====================================== */ /* Set GPIO12 in GPIO mode */ PIN_FUNC_SELECT( PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12 ); /* Set GPIO12 as input */ GPIO_DIS_OUTPUT( GPIO_ID_PIN(12) ); /* Disable all GPIO interrupts */ ETS_GPIO_INTR_DISABLE(); /* Set a GPIO callback function */ ETS_GPIO_INTR_ATTACH( gpioCallback, NULL ); /* Configure the type of edge */ gpio_pin_intr_state_set( GPIO_ID_PIN(12), GPIO_PIN_INTR_ANYEDGE ); ETS_GPIO_INTR_ENABLE(); /* ====================================== */ /* SOFTWARE TIMER */ /* ====================================== */ // Set GPIO0 to output mode PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0); //Set GPIO0 low gpio_output_set(0, RELAY_PIN, RELAY_PIN, 0); /* disarm timer */ os_timer_disarm((ETSTimer*)&some_timer); /* set callback */ os_timer_setfn((ETSTimer*)&some_timer, (os_timer_func_t *) softwareTimerCallback, NULL); /* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */ os_timer_arm((ETSTimer*)&some_timer, 10, 1); /* ====================================== */ /* OS TASK */ /* ====================================== */ /* setup OS task */ // system_os_task(user_procTask, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen); /* send a message to OS task (fire task) */ // system_os_post(user_procTaskPrio, 0, 0 ); /* ====================================== */ /* HARDWARE TIMER */ /* ====================================== */ /* The hardware timer is used to indicate when a complete IR message frame should have * arrived in order to process the received data and calculate the IR command. * * It is configured in "one-shot" mode. It is started when the beginning of an * IR message frame is detected and stopped after the complete message frame has been read. * This means that the duration of the HW timer should be longer than the duration of * the longest message frame. In the NEC IR tranmission protocol all message frames have * a duration of approximately 67.5ms. */ /* load the HW TIMER */ uint32 ticks = usToTicks(70000); // 70ms RTC_REG_WRITE(FRC1_LOAD_ADDRESS, ticks); /* register callback function */ ETS_FRC_TIMER1_INTR_ATTACH( hwTimerCallback, NULL ); /* enable interrupts */ TM1_EDGE_INT_ENABLE(); ETS_FRC1_INTR_ENABLE(); /* don't start timer yet */ /* the timer is started inside the GPIO INT callback */ /* ====================================== */ /* UDP SERVER */ /* ====================================== */ /* usage: echo <data> | nc -wl -u <ip address> <port> * example: echo "foo" | nc -w1 -u 192.168.1.187 7777 */ /* allocate space for server */ pUdpServer = (struct espconn *) os_zalloc(sizeof(struct espconn)); /* clear allocated memory */ ets_memset(pUdpServer, 0, sizeof(struct espconn)); /* create the server */ espconn_create(pUdpServer); /* set the type of server */ pUdpServer->type = ESPCONN_UDP; /* allocate memory for UDP settings */ pUdpServer->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp)); /* set the port that the server will be listening to */ pUdpServer->proto.udp->local_port = 7777; /* register the callback */ espconn_regist_recvcb(pUdpServer, udpServerRxCb); /* start listening */ if (espconn_create(pUdpServer)) { while (1) { os_printf("Error creating a UDP server\n"); } } /* ====================================== */ /* WIFI */ /* ====================================== */ wifi_set_opmode(STATION_MODE); wifi_station_get_config_default(&stconf); // os_strncpy((char*) stconf.ssid, "TP-LINK_2.4GHz_FC2E51", 32); // os_strncpy((char*) stconf.password, "tonytony", 64); os_strncpy((char*) stconf.ssid, "WLAN-PUB", 32); os_strncpy((char*) stconf.password, "", 64); // os_strncpy((char*) stconf.ssid, "MAD air", 32); // os_strncpy((char*) stconf.password, "glioninlog", 64); stconf.bssid_set = 0; wifi_station_set_config(&stconf); // /* ====================================== */ // /* WS2812 LED STRIP */ // /* ====================================== */ // // /* NOTE: UART1 and I2S share same GPIO. Cannot use simultaneously. */ // ws2812_init(); // // /* G R B */ // uint8_t ledout[] = { // 0xff, 0x00, 0x00, //4th //// 0xff, 0x00, 0x00, //3rd //// 0x00, 0xff, 0x00, //2nd //// 0x00, 0x00, 0xff, //1st // }; // //#if 0 // os_printf("\r\nB R G: %x %x %x\r\n", ledout[0], ledout[1],ledout[2]); //#endif // // ws2812_push( ledout, sizeof( ledout ) ); /* ====================================== */ /* TCP CONNECTION */ /* ====================================== */ /* allocate space for server */ pTcpConn = (struct espconn *) os_zalloc(sizeof(struct espconn)); /* clear allocated memory */ ets_memset(pTcpConn, 0, sizeof(struct espconn)); /* set the type of connection */ pTcpConn->type = ESPCONN_TCP; /* set state to NONE */ pTcpConn->state = ESPCONN_NONE; /* allocate memory for TCP settings */ pTcpConn->proto.tcp = (esp_tcp *) os_zalloc(sizeof(esp_tcp)); /* set the port that the connection will be listening to */ pTcpConn->proto.tcp->local_port = espconn_port(); /* set the remote port and IP address */ pTcpConn->proto.tcp->remote_port = 80; os_memcpy(pTcpConn->proto.tcp->remote_ip, server_ip_address, sizeof(server_ip_address)); /* register callbacks */ espconn_regist_connectcb(pTcpConn, tcpConnCb); espconn_regist_reconcb(pTcpConn, tcpReconnCb); /* disarm timer */ os_timer_disarm((ETSTimer*)&wifi_setup_timer); /* set callback */ os_timer_setfn((ETSTimer*)&wifi_setup_timer, (os_timer_func_t *) wifiConnectTimerCb, NULL); /* arm the timer -> os_timer_arm(<pointer>, <period in ms>, <fire periodically>) */ os_timer_arm((ETSTimer*)&wifi_setup_timer, 5000, 1); return; }
int main (void) { /* variables for the UART0 (USB connection) */ unsigned int c = 0, c2 = 0, c3 = 0; // Variable for reading UARTS char buffer[MAX_MSG_SIZE]; char buffer2[MAX_MSG_SIZE]; char buffer3[MAX_MSG_SIZE]; int idx = 0, idx2 = -1, idx3 = -1; int len2 = 0; int len3 = 0; char meas_buffer[TX_BUFF_SIZE]; int txi = 0; int txtop=0; unsigned int i = 0; char *ptr; unsigned char hli_mutex = 0; unsigned int gps = 0; unsigned int imu = 0; signed int ratio = 0; uint16_t xacc = 0; uint8_t xacca[2]; char s[64]; char rmc[256]; awake_flag = 0; #ifdef RF_TEST_IDX uint8_t gps_rf_test_idx = 0; uint8_t imu_rf_test_idx = 0; #endif /* set outputs */ PORTL = 0xff; // Turn off LEDS DDRL = (1<<LED1) | (1<<LED2) | (1<<LED3) | (1<<LED4); // Set pins for LED as output pwm_init(); spiInit(); /* initialize UARTS */ uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); // USB connection uart2_init( UART_BAUD_SELECT(UART2_BAUD_RATE,F_CPU) ); // APC220 radio uart3_init( UART_BAUD_SELECT(UART3_BAUD_RATE,F_CPU) ); // UP-501 GPS /* Interrupt stuff for ADIS */ PCICR |= 1<<PCIE2; // Enable interrupt PORTK PCMSK2 |= (1<<PCINT23); // interrupt in PCINT23 /* now enable interrupt, since UART library is interrupt controlled */ sei(); spiTransferWord(0xBE80); // ADSI software reset _delay_ms(500); /* Set GPS to a faster baud and update UART speed */ //uart3_puts("$PMTK251,115200*1F"); uart3_puts("$PMTK251,57600*2C\r\n"); //uart3_puts("$PMTK251,38400*27"); //uart3_puts("$PMTK251,0*28"); _delay_ms(500); // uart3_init( UART_BAUD_SELECT(115200,F_CPU) ); uart3_init( UART_BAUD_SELECT(57600,F_CPU) ); //uart3_init( UART_BAUD_SELECT(38400,F_CPU) ); /* 115200 seems to be a little bit unstable, at least testing via radio*/ adis_reset_factory(); adis_set_sample_rate(); while (1) { /* Read each UART serially and check each of them for data, if there is handle it */ c = uart_getc(); c2 = uart2_getc(); c3 = uart3_getc(); // Stop motors when connection is lost if (awake_flag > AWAKE_THRESHOLD) { pwm_set_duty(RC1, 0 ); pwm_set_duty(RC2, 0 ); }; if(tx_counter >= TX_READY) { //empty buffer for (txi = 0; txi < txtop; txi++) { uart2_putc(meas_buffer[txi]); // Sending buffered data to RF } txtop = 0; #ifdef AUTO_SHUTDOWN_ENABLE awake_flag++; #endif PORTL ^= (1<<LED2); tx_counter -= TX_READY; } if (adis_ready_counter >= ADIS_READY) { adis_decode_burst_read_pack(&adis_data_decoded); adis_reduce_decoded_burst(); // Reduce data ammount #ifdef LOG_ENABLE hli_send(package(sizeof(adis8_t), 0x14, 0x0D, &adis_data_decoded), sizeof(adis8_t)); // Log to SD card #endif #ifdef RF_TEST_IDX memcpy(&adis_data_decoded_reduced.zgyro[0],&imu_rf_test_idx,1); if (imu_rf_test_idx == 255) imu_rf_test_idx = 1; else imu_rf_test_idx++; memcpy(&meas_buffer[txtop], (char *)package(sizeof(adis8_reduced_t), 0x14, 0x0F, &adis_data_decoded_reduced),sizeof(adis8_reduced_t)+6); #endif #ifndef RF_TEST_IDX memcpy(&meas_buffer[txtop], (char *)package(sizeof(adis8_reduced_t), 0x14, 0x0E, &adis_data_decoded_reduced),sizeof(adis8_reduced_t)+6); #endif txtop=txtop+sizeof(adis8_reduced_t)+6; adis_ready_counter -= ADIS_READY; PORTL ^= (1<<LED4); } /* Reading from radio */ if ( c2 & UART_NO_DATA ) {} else // Data available { //if data is $, set a flag, read next byte, set that value as the length, read while incrementing index until length reached, parse //uart_putc(c2); if (idx2 == 0) { // We should buffer a packet len2 = c2+5; // Set length } if ( (idx2 < len2) && (idx2 >= 0)) { // We are buffering buffer2[idx2] = c2; idx2++; if (idx2 == len2) { // We now have a full packet if (parse(&rfmsg, buffer2)) { PORTL ^= (1<<LED1); process(&rfmsg); } idx2 = -1; // Set flag in new packet mode #ifdef DEBUG //puts_msg(&rfmsg); #endif } } if (c2 == '$') { // We have a possible message comming // PORTL ^= (1<<LED4); idx2 = 0; // Set "flag" } } /* Reading from GPS */ if ( c3 & UART_NO_DATA ) {} else // Data available { /* Transmitting NMEA GPS sentences to the HLI */ if (c3 == '$') { // We have a possible message comming //PORTL ^= (1<<LED3); len3 = 0; // Set "flag" } if (len3 >= 0) { // We are buffering buffer3[len3] = c3; len3++; if (c3 == '\n') { // We now have a full packet if(buffer3[4] != 'S') { // Disable GSV and GSA messages #ifdef LOG_ENABLE hli_send(package(len3, 0x1E, 0x06, buffer3), len3); // Log to SD card #endif if (rmc_cut(buffer3,rmc)) { // Invalid RMC data } else { #ifdef RF_TEST_IDX memcpy(&rmc[0],&gps_rf_test_idx,1); if (gps_rf_test_idx == 255) gps_rf_test_idx = 1; else gps_rf_test_idx++; memcpy(&meas_buffer[txtop], (char *)package(rmc_idx, 30, 31, rmc),rmc_idx+6); #endif #ifndef RF_TEST_IDX memcpy(&meas_buffer[txtop], (char *)package(rmc_idx, 30, 6, rmc),rmc_idx+6); #endif txtop=txtop+rmc_idx+6; PORTL ^= (1<<LED3); } len3 = -1; // Set flag in new packet mode } } } } } return 1; }
int main(int ac, char** av) { unsigned int i = 0; pwm_t pwm; if (pwm_init(&pwm) == -1) { return -1; } if (pwm_mux_init() == -1) { pwm_fini(&pwm); return -1; } pwm_disable(&pwm); pwm_set_clk_div(&pwm, (unsigned int)(19200000.0 / 19200.0)); pwm_set_freq(&pwm, 500); #if 0 /* problem */ pwm_mux_sel(0); #else /* no problem */ pwm_mux_sel(1); #endif while (1) { static unsigned int i = 0; unsigned int delay_us; /* const char c = getchar(); */ static const char fu[] = { 'l', 'r' }; const char c = fu[(++i) & 1]; unsigned int do_pwm = 0; if (c == 'l') { printf("-- l\n"); pwm_set_duty(&pwm, 39); delay_us = 50000; /* delay_us = 10000; */ do_pwm = 1; } else if (c == 'r') { printf("-- r\n"); pwm_set_duty(&pwm, 10); delay_us = 10000; do_pwm= 1; } if (do_pwm) { pwm_enable(&pwm); usleep(delay_us); pwm_disable(&pwm); usleep(1000000); } } pwm_mux_fini(); pwm_fini(&pwm); return 0; }
void lcd_close_backlight(void) { pwm_set_duty(LCD_BACKLIGHT_PWM_CHN, 0); }