esp_err_thal_gpio_config_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull_mode) { gpio_pull_mode_t esp_pull_mode; switch (pull_mode) { case GPIO_PULLUP: esp_pull_mode = GPIO_PULLUP_ONLY; break; case GPIO_PULLDOWN: esp_pull_mode = GPIO_PULLDOWN_ONLY; break; case GPIO_PULLNONE: esp_pull_mode = GPIO_PULLUP_DOWN_DISABLE; break; default: return ESP_ERR_INVALID_ARG; } return gpio_pullup_dis(gpio_num); // Ensure pull-up/down is initially disabled, then set as needed. if (pull_mode != GPIO_PULLNONE) { return gpio_pulldown_dis(gpio_num); // Ensure pull-up/down is initially disabled, then set as needed. } return ESP_OK; // Should not reach here if invalid arg is handled. }
esp_err_thal_gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t direction) { return hal_gpio_set_mode(gpio_num, direction); // Direction is part of mode in ESP-IDF }
// Configure LEDC peripheral (example configuration - needs to be adjusted for bbLaser) #define LEDC_TIMER LEDC_TIMER_0 #define LEDC_MODE LEDC_LOW_SPEED_MODE #define LEDC_OUTPUT_IO (5) // Example GPIO for PWM output - MUST BE CONFIGURED FOR LASER CONTROL #define LEDC_CHANNEL LEDC_CHANNEL_0 #define LEDC_DUTY_RES LEDC_TIMER_10_BIT // Resolution of duty cycle: 10 bits (0-1023) #define LEDC_FREQUENCY (5000) // PWM frequency in Hz - ADJUST FOR LASER REQUIREMENTS
esp_err_thal_pwm_init(pwm_channel_t channel, gpio_num_t gpio_num, uint32_t frequency_hz, uint32_t duty_cycle_percent) { ledc_timer_config_t ledc_timer = { .duty_resolution = LEDC_DUTY_RES, // resolution of PWM duty .freq_hz = frequency_hz, // frequency of PWM signal .speed_mode = LEDC_MODE, // timer mode .timer_num = LEDC_TIMER, // timer index .clk_cfg = LEDC_AUTO_CLK, // Auto select the source clock }; ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
esp_err_tdriver_laser_set_intensity(uint32_t intensity_percent) { if (intensity_percent > 100) intensity_percent = 100; current_intensity = intensity_percent; if (current_laser_state == LASER_STATE_ON) { // Only set PWM if laser is ON ESP_ERROR_CHECK(hal_pwm_set_duty_cycle(laser_pwm_channel, intensity_percent)); } return ESP_OK; }
#define MOTOR_STEP_PULSE_DELAY_US 5 // Minimum delay for step pulse, adjust as needed
typedefstruct { gpio_num_t step_gpio; gpio_num_t dir_gpio; gpio_num_t enable_gpio; int32_t current_position; // Track motor position (optional, if no encoder) } motor_config_t;
staticmotor_config_t motor_configs[2]; // MOTOR_X and MOTOR_Y
for (int i = 0; i < abs(steps); i++) { ESP_ERROR_CHECK(hal_gpio_set_level(config->step_gpio, GPIO_LEVEL_HIGH)); ets_delay_us(MOTOR_STEP_PULSE_DELAY_US); // Short pulse ESP_ERROR_CHECK(hal_gpio_set_level(config->step_gpio, GPIO_LEVEL_LOW)); ets_delay_us(step_delay_us - MOTOR_STEP_PULSE_DELAY_US); // Delay between steps
esp_err_tdriver_motor_set_position(motor_axis_t axis, int32_t position) { // For simple stepper without encoder, this is just setting the tracked position, not actual motor position control. // For closed-loop control (with encoder), more complex logic is needed to move to target position. motor_configs[axis].current_position = position; return ESP_OK; }
esp_err_tservice_vector_graphics_generate_motor_path(constvector_data_t *vector_data) { // Example: Placeholder - In real implementation, this function would: // 1. Process vector points (commands like MOVE_TO, LINE_TO, etc.) // 2. Generate a sequence of motor steps (X, Y movements) and laser intensity changes // 3. Optimize path for speed and smoothness (e.g., acceleration/deceleration) ESP_LOGI(TAG, "Generating motor path (placeholder)"); if (vector_data == NULL || vector_data->points == NULL) { ESP_LOGW(TAG, "No vector data to process"); return ESP_OK; // Or return error if vector data is required }
for (uint32_t i = 0; i < vector_data->point_count; i++) { vector_point_t *point = &vector_data->points[i]; ESP_LOGD(TAG, "Point %u: X=%u, Y=%u, Intensity=%u, Command=%u", i, point->x, point->y, point->intensity, point->command); // ... (Motor control and laser intensity setting logic would go here) }
// Example: Assume we have vector data in 'my_vector_data' (obtained from SD card or stream) externvector_data_t my_vector_data; // Assume this is populated elsewhere
while (1) { if (my_vector_data.points != NULL) { ESP_LOGI(TAG, "Processing vector data..."); service_vector_graphics_generate_motor_path(&my_vector_data); // Generate motor path from vector data // ... (Further processing to execute motor movements and laser control based on generated path)
// Example: Simple loop to move to each point (very basic and inefficient, for illustration only) for (uint32_t i = 0; i < my_vector_data.point_count; i++) { vector_point_t *point = &my_vector_data.points[i]; // Example motor control (replace with proper path planning and motor control logic) driver_motor_step(MOTOR_X, point->x, MOTOR_DIRECTION_CW, 1000); // Example speed 1000 Hz driver_motor_step(MOTOR_Y, point->y, MOTOR_DIRECTION_CW, 1000); driver_laser_set_intensity(point->intensity * 100 / 255); // Scale intensity to 0-100% if (point->command == 2) { // LASER_ON command driver_laser_set_state(LASER_STATE_ON); } elseif (point->command == 3) { // LASER_OFF command driver_laser_set_state(LASER_STATE_OFF); } vTaskDelay(pdMS_TO_TICKS(10)); // Small delay between points (adjust as needed) } ESP_LOGI(TAG, "Vector data processing complete."); // ... (Free vector data memory, etc.) my_vector_data.points = NULL; // Reset for next data } else { // No vector data to process, wait for data or do other background tasks vTaskDelay(pdMS_TO_TICKS(100)); } } }
ESP_LOGI(TAG_MAIN, "bbLaser Projector Firmware initialized and running.");
// Main application loop (can be minimal in this example, projector task handles most work) while (1) { vTaskDelay(pdMS_TO_TICKS(1000)); // Example: Sleep for 1 second // ... (Optional: Add other background tasks or monitoring here) } }
