int main(void)
{
/* Initialize CSP
* Not interfacing to any external devices, so we don't need to register
* a route
*/
printf("Initializing CSP\n");
csp_buffer_init(5, 256);
csp_init(MY_ADDRESS);
csp_route_start_task(500, 1);
/* Initialize example threads */
printf("Starting example tasks\n");
csp_thread_handle_t handle_server;
csp_thread_handle_t handle_client;
csp_thread_create(csp_server, "CSPSRV", 1000, NULL, 0, &handle_server);
csp_thread_create(csp_client, "CSPCLI", 1000, NULL, 0, &handle_client);
while (1)
{
csp_sleep_ms(100000);
}
return 0;
}
int can_mbox_init(can_iface_ctx_t *iface_ctx) {
int i;
mbox_t *m, *mbox;
mbox = iface_ctx->mbox;
for (i = 0; i < MBOX_NUM; i++) {
m = &mbox[i];
m->state = MBOX_FREE;
m->csp_can_socket = &iface_ctx->csp_can_socket;
m->mbox_pool_sem = &iface_ctx->mbox_pool_sem;
/* Init signal semaphore */
if (csp_bin_sem_create(&(m->signal_sem)) != CSP_SEMAPHORE_OK) {
csp_log_error("sem create");
return -1;
} else {
/* Take signal semaphore so the thread waits for tx data */
csp_bin_sem_wait(&(m->signal_sem), CSP_MAX_DELAY);
}
/* Create mailbox */
if(csp_thread_create(mbox_tx_thread, (signed char *)"mbox_tx", 1024, (void *)m, 3, &m->thread) != CSP_ERR_NONE) { //TODO: Adjust priority
csp_log_error("thread creation");
return -1;
}
}
/* Init mailbox pool semaphore */
csp_bin_sem_create(&iface_ctx->mbox_pool_sem);
return 0;
}
int main(int argc, char * argv[]) {
/* Init buffer system with 10 packets of maximum 300 bytes each */
csp_buffer_init(2, 800);
/* Init CSP with address MY_ADDRESS */
csp_init(MY_ADDRESS);
/* Start router task with 500 word stack, OS task priority 1 */
csp_route_start_task(500, 1);
/* Enable debug output from CSP */
if ((argc > 1) && (strcmp(argv[1], "-v") == 0)) {
printf("Debug eneabled\r\n");
csp_debug_toggle_level(4);
printf("Conn table\r\n");
csp_conn_print_table();
printf("Route table\r\n");
csp_route_print_table();
printf("Interfaces\r\n");
csp_route_print_interfaces();
}
int iret1, iret2;
csp_thread_handle_t handle_server;
iret1 = csp_thread_create(task_server, (signed char *) "SERVER", 1000, NULL, 0, &handle_server);
csp_thread_handle_t handle_client;
iret2 = csp_thread_create(task_client, (signed char *) "CLIENT", 1000, NULL, 0, &handle_client);
pthread_join(handle_client, NULL);
printf("Client thread returns: %d\n", iret2);
pthread_join(handle_server, NULL);
printf("Server thread returns: %d\n", iret1);
return 0;
}
int csp_route_start_task(unsigned int task_stack_size, unsigned int priority) {
int ret = csp_thread_create(csp_task_router, (signed char *) "RTE", task_stack_size, NULL, priority, &handle_router);
if (ret != 0) {
csp_log_error("Failed to start router task\n");
return CSP_ERR_NOMEM;
}
return CSP_ERR_NONE;
}
int main(int argc, char * argv[]) {
printf("Initialising CSP\r\n");
csp_buffer_init(10, 300);
csp_init(MY_ADDRESS);
csp_route_start_task(500, 1);
printf(argv[1]);
printf("Starting server task\r\n");
csp_thread_handle_t handle_server;
csp_thread_create(task_server, (signed char *) "SERVER", 1000, NULL, 0, &handle_server);
printf("Starting client task\r\n");
// csp_thread_handle_t handle_client;
// csp_thread_create(task_client, (signed char *) "CLIENT", 1000, NULL, 0, &handle_client);
/* while(1) {
csp_sleep_ms(1000);
csp_packet_t *packet;
csp_conn_t *conn;
packet = csp_buffer_get(10);
if (packet == NULL) {
printf("Failed to get buffer element\n");
return CSP_TASK_RETURN;
}
conn = csp_connect(CSP_PRIO_NORM, MY_ADDRESS, MY_PORT, 1000, CSP_O_NONE);
if(conn == NULL) {
printf("Connection failed\n");
csp_buffer_free(packet);
return CSP_TASK_RETURN;
}
char *msg = "Hello world";
msg = argc;
strcpy((char *) packet->data, msg);
packet->length = strlen(msg);
if (!csp_send(conn, packet, 1000)) {
printf("Send failed\n");
csp_buffer_free(packet);
}
csp_close(conn);
}*/
sendpacket();
while(1){
csp_sleep_ms(100000);
}
return 0;
}
int csp_can_init(uint8_t mode, struct csp_can_config *conf) {
int ret;
uint32_t mask;
/* Initialize packet buffer */
if (pbuf_init() != 0) {
csp_log_error("Failed to initialize CAN packet buffers\r\n");
return CSP_ERR_NOMEM;
}
/* Initialize CFP identifier */
if (id_init() != 0) {
csp_log_error("Failed to initialize CAN identification number\r\n");
return CSP_ERR_NOMEM;
}
if (mode == CSP_CAN_MASKED) {
mask = CFP_MAKE_DST((1 << CFP_HOST_SIZE) - 1);
} else if (mode == CSP_CAN_PROMISC) {
mask = 0;
csp_if_can.promisc = 1;
} else {
csp_log_error("Unknown CAN mode\r\n");
return CSP_ERR_INVAL;
}
can_rx_queue = csp_queue_create(CSP_CAN_RX_QUEUE_SIZE, sizeof(can_frame_t));
if (can_rx_queue == NULL) {
csp_log_error("Failed to create CAN RX queue\r\n");
return CSP_ERR_NOMEM;
}
ret = csp_thread_create(csp_can_rx_task, (signed char *) "CANRX",2048, NULL, 3, &can_rx_task);
if (ret != 0) {
csp_log_error("Failed to init CAN RX task\r\n");
return CSP_ERR_NOMEM;
}
/* Initialize CAN driver */
if (can_init(CFP_MAKE_DST(my_address), mask, csp_tx_callback, csp_rx_callback, conf) != 0) {
csp_log_error("Failed to initialize CAN driver\r\n");
return CSP_ERR_DRIVER;
}
/* Regsiter interface */
csp_route_add_if(&csp_if_can);
return CSP_ERR_NONE;
}
int main() {
csp_buffer_init(10, 300);
csp_init(MY_ADDRESS);
csp_route_start_task(500,1);
printf("Starting client task\r\n");
csp_thread_handle_t handle_client;
csp_thread_create(task_client, (signed char *) "CLIENT", 1000, NULL, 0, &handle_client);
while(1) {
csp_sleep_ms(100000);
}
return 0;
}
int csp_bridge_start(unsigned int task_stack_size, unsigned int task_priority, csp_iface_t * _if_a, csp_iface_t * _if_b) {
/* Set static references to A/B side of bridge */
if_a = _if_a;
if_b = _if_b;
static csp_thread_handle_t handle;
int ret = csp_thread_create(csp_bridge, "BRIDGE", task_stack_size, NULL, task_priority, &handle);
if (ret != 0) {
csp_log_error("Failed to start task");
return CSP_ERR_NOMEM;
}
return CSP_ERR_NONE;
}
int can_init(csp_iface_t *csp_if_can, uint32_t id, uint32_t mask, can_tx_callback_t atxcb, can_rx_callback_t arxcb, struct csp_can_config *conf) {
struct ifreq ifr;
struct sockaddr_can addr;
csp_thread_handle_t rx_thread;
int *can_socket;
can_iface_ctx_t *iface_ctx;
iface_ctx = get_available_interface_ctx();
if (iface_ctx == NULL) {
return -1;
}
csp_if_can->driver = (void *)iface_ctx;
iface_ctx->csp_can_socket.csp_if_can = csp_if_can;
can_socket = &iface_ctx->csp_can_socket.can_socket;
csp_assert(conf && conf->ifc);
txcb = atxcb;
rxcb = arxcb;
/* Create socket */
if ((*can_socket = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
csp_log_error("socket: %s", strerror(errno));
return -1;
}
/* Locate interface */
strncpy(ifr.ifr_name, conf->ifc, IFNAMSIZ - 1);
if (ioctl(*can_socket, SIOCGIFINDEX, &ifr) < 0) {
csp_log_error("ioctl: %s", strerror(errno));
return -1;
}
/* Bind the socket to CAN interface */
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
if (bind(*can_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
csp_log_error("bind: %s", strerror(errno));
return -1;
}
/* Set promiscuous mode */
if (mask) {
struct can_filter filter;
filter.can_id = id;
filter.can_mask = mask;
if (setsockopt(*can_socket, SOL_CAN_RAW, CAN_RAW_FILTER, &filter, sizeof(filter)) < 0) {
csp_log_error("setsockopt: %s", strerror(errno));
return -1;
}
}
/* Set read timeout */
{
struct timeval tv = {
.tv_sec = 0,
.tv_usec = 1000,
};
if (setsockopt(*can_socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
csp_log_error("setsockopt: %s", strerror(errno));
return -1;
}
}
/* Create receive thread */
if(csp_thread_create(mbox_rx_thread, (signed char *)"mbox_rx", 1024, (void *)&iface_ctx->csp_can_socket, 3, &rx_thread) != CSP_ERR_NONE) { //TODO: Adjust priority
csp_log_error("thread creation");
return -1;
}
/* Create mailbox pool */
if (can_mbox_init(iface_ctx) != 0) {
csp_log_error("Failed to create tx thread pool");
return -1;
}
return 0;
}
