多個modules,開thread去執行at commands
記錄IMEI+確認FW version
家庭代工用
create by Gemini...
#include <errno.h>
#include <fcntl.h>
#include <libudev.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#define TIMEOUT_MS 3000 // Timeout in milliseconds
#define MAX_BUFFER_SIZE 256
#define MAX_AT_RESPONSE 16
#define MAX_DEVICE_PATH 64 // Define a constant for device path size
// Structure to hold AT command and its response time
typedef struct {
char command[16];
double response_time;
} ATCommand;
// Structure to hold the AT command responses
typedef struct {
char device_path[MAX_DEVICE_PATH]; // Use the defined constant
char response[MAX_BUFFER_SIZE];
} DeviceResponse;
DeviceResponse device_responses[MAX_AT_RESPONSE];
pthread_mutex_t response_mutex = PTHREAD_MUTEX_INITIALIZER;
int response_count = 0;
// Function prototypes (for clarity)
int open_serial_port(const char *port_name);
int send_at_command(int fd, const char *command, char *response,
size_t response_size, double response_time);
void close_serial_port(int fd);
void *process_device(void *arg);
int find_tty_acm(int argc, char *argv[], int *get_count,
char dev_path[][MAX_DEVICE_PATH]); // Use the defined constant
void GetResponseData(char *input, char *output, size_t array_size,
int line_sopt);
ATCommand ATCS[] = {
{"at", 0.3}, // Example response time of 300ms (converted to seconds)
{"at+cgsn", 0.4}, // Example response time of 400ms
{"ati1", 0.4}, // Example response time of 400ms
};
int open_serial_port(const char *port_name) {
int fd = open(port_name, O_RDWR | O_NOCTTY | O_NDELAY);
if (fd == -1) {
perror("open_serial_port: open failed");
return -1;
}
struct termios tty;
memset(&tty, 0, sizeof(tty));
if (tcgetattr(fd, &tty) != 0) {
perror("open_serial_port: tcgetattr failed");
close(fd);
return -1;
}
cfsetospeed(&tty, B115200); // Set baud rate (adjust as needed)
cfsetispeed(&tty, B115200);
tty.c_cflag &= ~PARENB; // No parity
tty.c_cflag &= ~CSTOPB; // 1 stop bit
tty.c_cflag &= ~CSIZE;
tty.c_cflag |= CS8; // 8 data bits
tty.c_cflag &= ~CRTSCTS; // No hardware flow control
tty.c_cflag |= CREAD | CLOCAL; // Enable read and ignore control lines
tty.c_lflag &= ~ICANON; // Disable canonical mode
tty.c_lflag &= ~ECHO; // Disable echo
tty.c_lflag &= ~ECHOE; // Disable erasure
tty.c_lflag &= ~ECHONL; // Disable new-line echo
tty.c_lflag &= ~ISIG; // Disable interpretation of interrupt, quit, and
// suspend characters
tty.c_iflag &= ~(IXON | IXOFF | IXANY); // Disable software flow control
tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR |
ICRNL); // Disable special handling of received bytes
tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes
tty.c_oflag &=
~ONLCR; // Prevent conversion of newline to carriage return/line feed
tty.c_cc[VTIME] = TIMEOUT_MS / 100; // Timeout in deciseconds (correct)
tty.c_cc[VMIN] = 0; // Minimum number of characters to receive
if (tcsetattr(fd, TCSANOW, &tty) != 0) {
perror("open_serial_port: tcsetattr failed");
close(fd);
return -1;
}
return fd;
}
int send_at_command(int fd, const char *command, char *response,
size_t response_size, double response_time) {
tcflush(fd, TCIFLUSH); // Flush the input buffer
ssize_t bytes_written = write(fd, command, strlen(command));
if (bytes_written < 0) {
perror("send_at_command: write failed");
return -1;
}
memset(response, 0, response_size);
size_t total_bytes_read = 0;
struct timeval start_time, current_time;
gettimeofday(&start_time, NULL); // Use gettimeofday for better precision
while (total_bytes_read < response_size - 1) {
ssize_t bytes_read = read(fd, response + total_bytes_read,
response_size - 1 - total_bytes_read);
if (bytes_read < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
gettimeofday(¤t_time, NULL);
double elapsed_time =
(current_time.tv_sec - start_time.tv_sec) +
(current_time.tv_usec - start_time.tv_usec) / 1000000.0;
if (elapsed_time > response_time) {
tcflush(fd, TCIFLUSH); // clear the buffer
fprintf(stderr, "send_at_command: Timeout occurred\n");
return -1; // Timeout occurred
}
usleep(10000); // small delay before retry (10ms)
continue; // retry read
} else {
perror("send_at_command: read failed");
return -1;
}
}
if (bytes_read == 0) {
// End of file or no more data
break;
}
total_bytes_read += bytes_read;
if (strstr(response, "OK\r\n") != NULL) {
break; // Stop reading when OK is received.
}
}
response[total_bytes_read] = '\0'; // Null-terminate the string
return 0;
}
void close_serial_port(int fd) { close(fd); }
void *process_device(void *arg) {
int serial_fd;
char *dev_path = (char *)arg;
char response[MAX_BUFFER_SIZE];
int at_command_count =
sizeof(ATCS) / sizeof(ATCS[0]); // Calculate number of AT commands
printf("Thread processing device: %s\n", dev_path);
serial_fd = open_serial_port(dev_path);
if (serial_fd == -1) {
fprintf(stderr, "Error opening serial port: %s\n", strerror(errno));
return NULL;
}
// Send AT commands
for (int i = 0; i < at_command_count; i++) {
char command[32]; // Ensure enough space for the command
snprintf(command, sizeof(command), "%s\r", ATCS[i].command); // Append \r
if (send_at_command(serial_fd, command, response, sizeof(response),
ATCS[i].response_time) == 0) {
printf("Response to '%s': %s\n", ATCS[i].command, response);
pthread_mutex_lock(&response_mutex);
if (response_count < MAX_AT_RESPONSE) {
strncpy(device_responses[response_count].device_path, dev_path,
MAX_DEVICE_PATH - 1);
device_responses[response_count].device_path[MAX_DEVICE_PATH - 1] =
'\0'; // Ensure null termination
strncpy(device_responses[response_count].response, response,
MAX_BUFFER_SIZE - 1);
device_responses[response_count].response[MAX_BUFFER_SIZE - 1] =
'\0'; // Ensure null termination
response_count++; // Increment response count
} else {
fprintf(stderr, "Response buffer is full!\n");
}
pthread_mutex_unlock(&response_mutex);
} else {
fprintf(stderr, "Error sending command '%s'\n", ATCS[i].command);
}
}
close_serial_port(serial_fd);
pthread_exit(NULL);
}
int find_tty_acm(int argc, char *argv[], int *get_count,
char dev_path[][MAX_DEVICE_PATH]) {
if (argc != 4) {
fprintf(stderr, "Usage: %s \n", argv[0]); // Corrected Usage message
return 1;
}
const char *target_vid = argv[1];
const char *target_pid = argv[2];
const char *target_bInterfaceNumber = argv[3];
struct udev *udev = udev_new();
if (!udev) {
fprintf(stderr, "Failed to create udev object\n");
return 1;
}
struct udev_enumerate *enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "tty");
udev_enumerate_add_match_property(enumerate, "ID_VENDOR_ID", target_vid);
udev_enumerate_add_match_property(enumerate, "ID_MODEL_ID", target_pid);
udev_enumerate_scan_devices(enumerate);
struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
struct udev_list_entry *entry;
int i = 0;
udev_list_entry_foreach(entry, devices) {
const char *path = udev_list_entry_get_name(entry);
struct udev_device *dev = udev_device_new_from_syspath(udev, path);
if (!dev) {
fprintf(stderr, "Error creating udev_device from syspath: %s\n", path);
continue; // Skip to the next device
}
const char *devnode = udev_device_get_devnode(dev);
const char *bInterface =
udev_device_get_property_value(dev, "ID_USB_INTERFACE_NUM");
if (devnode && bInterface &&
strcmp(bInterface, target_bInterfaceNumber) == 0) {
if (i < MAX_AT_RESPONSE) { // Check for overflow
strncpy(dev_path[i], devnode, MAX_DEVICE_PATH - 1); // Use strncpy
dev_path[i][MAX_DEVICE_PATH - 1] = '\0'; // Null-terminate
printf("Found device: %s\n", devnode);
i++;
(*get_count)++;
} else {
fprintf(stderr, "Too many devices found. Increase MAX_AT_RESPONSE.\n");
break;
}
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate); // Free enumerate object
udev_unref(udev);
return 0;
}
void GetResponseData(char *input, char *output, size_t array_size,
int line_sopt) {
char *line, *saveptr;
int stop = 0;
output[0] = '\0'; // Initialize output string
line = strtok_r(input, "\n", &saveptr);
while (line != NULL) {
if (stop == line_sopt) {
strncpy(output, line, array_size - 1); // Use strncpy for safety
output[array_size - 1] = '\0'; // Ensure null termination
return;
}
line = strtok_r(NULL, "\n", &saveptr);
stop++;
}
output[0] = '\0'; // If line_sopt is out of range, return an empty string
}
int main(int argc, char *argv[]) {
int device_count = 0;
char dev_path[MAX_AT_RESPONSE]
[MAX_DEVICE_PATH]; // Array to store device paths
pthread_t threads[MAX_AT_RESPONSE]; // Array to store thread IDs
int thread_creation_result;
if (find_tty_acm(argc, argv, &device_count, dev_path) != 0) {
fprintf(stderr, "find_tty_acm failed\n");
exit(EXIT_FAILURE);
}
printf("Loop count: %d\n", device_count);
if (device_count == 0) {
printf("No devices found. Exiting.\n");
exit(EXIT_SUCCESS);
}
// Create threads for each device found
for (int i = 0; i < device_count; i++) {
printf("Creating thread for device: %s\n", dev_path[i]);
thread_creation_result =
pthread_create(&threads[i], NULL, process_device, (void *)dev_path[i]);
if (thread_creation_result != 0) {
fprintf(stderr, "ERROR; return code from pthread_create() is %d\n",
thread_creation_result);
exit(EXIT_FAILURE);
}
}
// Wait for all threads to complete
for (int i = 0; i < device_count; i++) {
pthread_join(threads[i], NULL);
}
// Write responses to file
FILE *fp = fopen("device_responses.txt", "w");
if (fp == NULL) {
perror("Error opening file");
exit(EXIT_FAILURE);
}
char imei[16];
char fw[64];
for (int i = 0; i < device_count; i++) { // Iterate through each device
memset(imei, 0, sizeof(imei));
memset(fw, 0, sizeof(fw));
// Find the responses for the current device
char *imei_response = NULL;
char *fw_response = NULL;
for (int j = 0; j < response_count; j++) {
if (strncmp(device_responses[j].device_path, dev_path[i],
MAX_DEVICE_PATH) == 0) {
// Match the Device Path
if (strstr(device_responses[j].response, "at+cgsn") != NULL) {
imei_response = device_responses[j].response;
} else if (strstr(device_responses[j].response, "ati1") != NULL) {
fw_response = device_responses[j].response;
}
}
}
if (imei_response) {
GetResponseData(imei_response, imei, sizeof(imei), 1);
fprintf(fp, "IMEI: %s", imei);
} else {
fprintf(fp, "IMEI: Not found\n");
}
if (fw_response) {
GetResponseData(fw_response, fw, sizeof(fw), 3);
if (strlen(fw) > 0) {
if (strstr(fw, "REVISION 02.000") != NULL) {
fprintf(fp, ", OK , FW: %s", fw);
} else
fprintf(fp, ", FAILED, FW: %s", fw);
} else {
fprintf(fp, "FW: Not found\n");
}
} else {
fprintf(fp, "FW: Not found\n");
}
fprintf(fp, "\n"); // Add a new line to separate devices.
}
fclose(fp);
printf("All threads completed. Responses written to device_responses.txt\n");
exit(EXIT_SUCCESS);
}
Compile
$ gcc find_modules.c -o find_modules -ludev
$ ./find_modules 1e2d 0069 04
