int csp_cmp(uint8_t node, uint32_t timeout, uint8_t code, int membsize, struct csp_cmp_message * msg) { msg->type = CSP_CMP_REQUEST; msg->code = code; int status = csp_transaction(CSP_PRIO_NORM, node, CSP_CMP, timeout, msg, membsize, msg, membsize); if (status == 0) return CSP_ERR_TIMEDOUT; return CSP_ERR_NONE; }
int obc_boot_count_get(uint32_t *boot_count, int timeout) { int ret = csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_BOOT_COUNT, timeout, NULL, 0, boot_count, sizeof(uint32_t)); if (ret > 0) *boot_count = csp_ntoh32(*boot_count); else *boot_count = 0; return ret; }
void obc_load_image(const char * path) { uint32_t remote_crc; if (!csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_LOAD_IMG, 10000, (void *) path, strlen(path)+1, &remote_crc, sizeof(uint32_t))) return; remote_crc = csp_ntoh32(remote_crc); printf("Remote CRC %"PRIX32"\r\n", remote_crc); }
/** Copy image from RAM (src) to ROM (typically 0x48000000) */ void obc_ram_to_rom(uint32_t size, uint32_t checksum, uint32_t src, uint32_t dst) { obc_ram_to_rom_t txbuf; txbuf.size = csp_hton32(size); txbuf.checksum = csp_hton32(checksum); txbuf.src = csp_hton32(src); txbuf.dst = csp_hton32(dst); csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_RAM_TO_ROM, 0, &txbuf, sizeof(obc_ram_to_rom_t), NULL, 0); }
void csp_uptime(uint8_t node, uint32_t timeout) { uint32_t uptime = 0; int status = csp_transaction(CSP_PRIO_NORM, node, CSP_UPTIME, timeout, NULL, 0, &uptime, sizeof(uptime)); if (status == 0) { printf("Network error\r\n"); return; } uptime = csp_ntoh32(uptime); printf("Uptime of node %u is %u s\r\n", (unsigned int) node, (unsigned int) uptime); }
void csp_buf_free(uint8_t node, uint32_t timeout) { uint32_t size = 0; int status = csp_transaction(CSP_PRIO_NORM, node, CSP_BUF_FREE, timeout, NULL, 0, &size, sizeof(size)); if (status == 0) { printf("Network error\r\n"); return; } size = csp_ntoh32(size); printf("Free buffers at node %u is %u\r\n", (unsigned int) node, (unsigned int) size); }
void obc_boot_conf(uint32_t checksum, uint32_t boot_counts, const char * path) { char buf[100]; checksum = csp_hton32(checksum); boot_counts = csp_hton32(boot_counts); memcpy(buf, &checksum, 4); memcpy(&buf[4], &boot_counts, 4); strncpy(buf + 8, path, 100-8); csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_BOOT_CONF, 0, buf, strlen(path)+1+4+4, NULL, 0); }
/** * Execute an OBC timesync * Sends a timespec to the OBC and returns the value back from the OBC. * Use the value tv_sec = 0, if you don't wish to update time but only get time back. * @param time timespec_t seconds and nanoseconds * @param timeout timeout in [ms] */ void obc_timesync(timestamp_t * time, int timeout) { time->tv_sec = csp_hton32(time->tv_sec); time->tv_nsec = csp_hton32(time->tv_nsec); if (csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_TIMESYNC, timeout, time, sizeof(timestamp_t), time, sizeof(timestamp_t)) > 0) { time->tv_sec = csp_ntoh32(time->tv_sec); time->tv_nsec = csp_ntoh32(time->tv_nsec); } else { time->tv_sec = 0; time->tv_nsec = 0; } }
void csp_memfree(uint8_t node, uint32_t timeout) { uint32_t memfree; int status = csp_transaction(CSP_PRIO_NORM, node, CSP_MEMFREE, timeout, NULL, 0, &memfree, sizeof(memfree)); if (status == 0) { printf("Network error\r\n"); return; } /* Convert from network to host order */ memfree = csp_ntoh32(memfree); printf("Free Memory at node %u is %u bytes\r\n", node, (unsigned int) memfree); }
/* * Send a remote shell command to obc. * @param command: the command to be sent. * @param response: the remote response from obc, NULL for no response needed. * @param returned: the returned value of the command. * Function returns the csp_transaction() value, which is normally the size of the payload. */ int send_remote_shell_command(char * command, char * response, int * returned) { int timeout = 5000; int8_t dest = 1; int8_t d_port = OBC_PORT_CUSTOM_REMOTE_SHELL; remoteShell_packet_t command_out; memset(&command_out, 0, sizeof(remoteShell_packet_t)); printf("sending a message to host %d:%d.\"%s\".\r\n", dest, d_port, command); int reply_size = sizeof(remoteShell_packet_t); memcpy(command_out.command_text, command, strlen(command)); command_out.returned = csp_hton16(-42); // yeah. remoteShell_packet_t * reply; if (!response) { timeout = 100; reply = NULL; reply_size = 0; } else { reply = calloc(sizeof(remoteShell_packet_t), 1); } printf("packet size: %lu.\nBuffer content: %s.\n", sizeof(remoteShell_packet_t), command_out.command_text); int packet_status = csp_transaction(CSP_PRIO_NORM, dest, d_port, timeout, &command_out , sizeof(remoteShell_packet_t), reply, reply_size); if (response) { reply->returned = csp_ntoh16(reply->returned); *returned = reply->returned; response = reply->command_text; printf("status = %d, original message:%s\nFunction returned = %d\n", packet_status, reply->command_text, reply->returned); } else { *returned = 0; printf("status = %d, NULL passed, not waiting for reply.\n", packet_status); } if (reply) free(reply); return packet_status; }
void csp_reboot(uint8_t node) { uint32_t magic_word = csp_hton32(0x80078007); csp_transaction(CSP_PRIO_NORM, node, CSP_REBOOT, 0, &magic_word, sizeof(magic_word), NULL, 0); }
int cmd_testtools_ls2sd(struct command_context *ctx) { remoteShell_packet_t * message_send; remoteShell_packet_t * message_reply; char remote_path[REMOTE_MESSAGE_SIZE]; message_send = (remoteShell_packet_t *) calloc(sizeof(remoteShell_packet_t), sizeof(char)); message_reply = (remoteShell_packet_t *) calloc(sizeof(remoteShell_packet_t), sizeof(char)); unsigned int now; char * out_buffer = calloc(10240, 1); if (!(message_send && message_reply)) { printf("Houston: calloc error.\n"); goto err; } if (!(out_buffer)) { printf("Houston: malloc error.\n"); goto err; } memset(remote_path, 0, REMOTE_MESSAGE_SIZE); int start = 0; // 0 means from start. int file_count = 0; int lastfilecount = 0; do { message_send->returned = csp_hton16(start); memcpy(message_reply, message_send, sizeof(remoteShell_packet_t)); sprintf(remote_path, "/sd/"); memcpy(message_send->command_text, remote_path, REMOTE_MESSAGE_SIZE); int packet_status = csp_transaction(CSP_PRIO_NORM, NODE_OBC, OBC_PORT_FTP_LIST, 6000, message_send , sizeof(remoteShell_packet_t), message_reply, sizeof(remoteShell_packet_t)); message_reply->returned = csp_ntoh16(message_reply->returned); file_count = message_reply->returned; printf("status = %d, ", packet_status); if (packet_status == sizeof(remoteShell_packet_t)) { now = (unsigned)time(NULL); if (message_reply->returned < 0) { printf("returned value = %d, ls failed. Re-formatting may required.\n", message_reply->returned); goto err; } memcpy(remote_path, message_reply->command_text, REMOTE_MESSAGE_SIZE); printf("%d files, path in sd is %s\n", message_reply->returned, remote_path); printf("successed listing files.\n"); } else { printf("failed!\nNETWORK ERROR\n"); goto err; } /* Then download list file. */ char local_path[PATH_MAX]; // no need to malloc since it is part of remote_path memset(local_path, 0, PATH_MAX); getcwd(local_path, sizeof(local_path)); strcat(local_path, "/"); strcat(local_path, my_basename_1(remote_path)); printf("local path is: %s\n", local_path); int download_status = ftp_download(NODE_OBC, OBC_PORT_FTP, local_path, ftp_backend, ftp_chunk_size, 0, 0, remote_path, &ftp_size); if (download_status != 0) { ftp_done(0); goto err; } if (ftp_status_reply() != 0) { ftp_done(0); goto err; } if (ftp_crc() != 0) { ftp_done(0); goto err; } ftp_done(1); usleep(100 * 1000); // 100 ms char remove_command[50]; memset(remove_command, 0, 50); sprintf(remove_command, "<rm|%s>", remote_path); int remove_status = -1; send_remote_shell_command(remove_command, NULL, &remove_status); printf("remove status: %d\n", remove_status); int decompress_result = decompress_file_to_buffer(local_path, out_buffer, (uint32_t) 10240); if (decompress_result < 0) { printf("Decompress of %s failed. Maybe try to decompress this file in shell?\n", local_path); goto err; } char * pc_start; char * pc_end; int found_timestamp = 0; pc_start = strchr(out_buffer, parse_start); pc_end = strchr(out_buffer, parse_end); if (!(pc_start && pc_end)) printf("timestamp not found. ugh.\n"); else { found_timestamp = 1; pc_start += sizeof(char); } if (found_timestamp) { char list_time[32]; memset(&list_time, 0, sizeof(list_time)); memcpy(&list_time, pc_start, (pc_end - pc_start)); printf("current time:%u, list time:%s\nTime difference: %d seconds.\n", now , list_time, (now - (unsigned)atoi(list_time))); printf("%s\n", pc_end + sizeof(char)); } else { printf("current time:%u, list time: unavailable\n", (unsigned)time(NULL)); printf("%s\n", out_buffer); } char * last_legal_line = NULL; char * second_last_line = NULL; last_legal_line = strrchr(out_buffer, '\n'); if (!last_legal_line) { printf("cannot find new line what happend?\n"); break; } int i; for (i = 1; i < 32; ++i) { if (*(last_legal_line - i) == '\n' ) { second_last_line = last_legal_line - i; break; } } if (!second_last_line) { printf("cannot find new line what happend? quitting..\n"); goto err; } char line[32] = {0}; memcpy(line, second_last_line + 1, last_legal_line - second_last_line); sscanf (line, "%d\t", &lastfilecount); if (lastfilecount == file_count) printf("Finished listing.\n"); else printf("downloading next listing file...\n"); start = lastfilecount; memset(out_buffer, 0, 10240); } while (lastfilecount < file_count); /* cleaning starts. */ if (out_buffer) free(out_buffer); if (message_send) free(message_send); if (message_reply) free(message_reply); return 0; /* Exception handlers */ err: if (out_buffer) free(out_buffer); if (message_send) free(message_send); if (message_reply) free(message_reply); return CMD_ERROR_FAIL; }
int cmd_testtools_packet(struct command_context *ctx) { if (ctx->argc != 2) return CMD_ERROR_SYNTAX; int8_t dest = atoi(ctx->argv[1]); int8_t d_port = OBC_PORT_CUSTOM_REMOTE_SHELL; char *message; // this goes to the space char *command; // got this from input command = calloc(REMOTE_MESSAGE_SIZE, sizeof(char)); char c; int quit = 0, execute = 0; unsigned int cursor = 0; printf("Type the command here, hit enter to send, ctrl+x to cancel:\r\n"); /* Wait for ^q to quit. */ while (quit == 0) { /* Get character */ c = getchar(); switch (c) { /* CTRL + X */ case 0x18: quit = 1; break; /* Backspace */ case CONTROL('H'): case 0x7f: if (cursor > 0) { putchar('\b'); putchar(' '); putchar('\b'); cursor--; } break; /* RETURN */ case '\r': execute = 1; quit = 1; break; default: putchar(c); if (command == NULL) { command = calloc(REMOTE_MESSAGE_SIZE, 1); } if ((command != NULL) && (cursor < REMOTE_MESSAGE_SIZE)) command[cursor++] = c; break; } } if (execute) { printf("\n----------\nPress enter to send this command, or any key to abort:\r\n"); printf("%s", command); c = getchar(); if (c != '\r') { return CMD_ERROR_INVALID; } } putchar('\n'); int overhead = 3; message = (char*)calloc(REMOTE_MESSAGE_SIZE + overhead, sizeof(char)); //reply = (char * )calloc(REMOTE_MESSAGE_SIZE + overhead, sizeof(char)); //the overhead of <,> and \0 if (!message) { printf("calloc() failed!\n"); return CMD_ERROR_FAIL; } message[0] = '<'; //message[0] = '<'; message[1] = '|'; for (uint8_t i = 0; i < cursor; i++) { if (command[i] == ' ') { message[i + 1] = '|'; } else { message[i + 1] = command[i]; } } /* message[cursor + 2] = '|'; message[cursor + 3] = '>'; message[cursor + 4] = '\0'; */ message[cursor + 1] = '>'; message[cursor + 2] = '\0'; message[cursor + 3] = '\0'; printf("sending a message to host %d:%d.\"%s\".\r\n", dest, d_port, message); //int buffer_result = sprintf(buffer,"%s", message); //csp_packet_t * reply_packet; remoteShell_packet_t sending; memcpy(sending.command_text, message, 50); sending.returned = csp_hton16(-42); // yeah. remoteShell_packet_t reply; reply.returned = csp_hton16(-43); reply.command_text[0] = '\0'; printf("packet size: %lu.\nBuffer content: %s.\n", sizeof(remoteShell_packet_t), sending.command_text); int packet_status = csp_transaction(CSP_PRIO_NORM, dest, d_port, 5000, &sending , sizeof(remoteShell_packet_t), &reply, sizeof(remoteShell_packet_t)); reply.returned = csp_ntoh16(reply.returned); printf("status = %d, original message:%s\nReply = %d\n", packet_status, reply.command_text, reply.returned); free(message); free(command); return reply.returned; }
/** * @brief Requests and prints remote routing table * @param[in] uint8_t first node in chunk of nodes requested * @param[out] int8_t return code */ int8_t csp_route_print_remote_table(uint8_t node) { //sizeof(csp_route_info) = 11, so 14*12 = 164 bytes int routes_requested = 14; int status; uint32_t timeout = 1000;//just chose smallish value, can change uint8_t routes_left,k,i = 0; uint8_t params[2]; status = csp_transaction(CSP_PRIO_NORM,node,CSP_GET_ROUTE,timeout, NULL, 0, &routes_left, sizeof(routes_left)); if(status <= 0){ printf("Timeout or other error\r\n"); return CSP_ERR_TX; } //routes_requested is our default number of nodes to ask for, //so if fewer routes exist, change it to routes_left if(routes_left < routes_requested){ routes_requested = routes_left; } csp_route_info returned_routes[routes_requested]; uint8_t return_buf[sizeof(routes_left)+sizeof(returned_routes)]; printf("Routing table for %u\r\n",node); printf("Node Interface Address\r\n"); //request routing table of node, asking for routes_requested per transaction while(1){ params[0] = i; params[1] = routes_requested; memset(returned_routes,0x00,sizeof(returned_routes)); status = csp_transaction(CSP_PRIO_NORM,node,CSP_GET_ROUTE,timeout, ¶ms[0],sizeof(params),&return_buf[0], (sizeof(routes_left) +sizeof(csp_route_info)*routes_requested)); if(status <= 0){ printf("Timeout or other error\r\n"); return CSP_ERR_TX; } memcpy(&routes_left,&return_buf[0],sizeof(routes_left)); memcpy(&returned_routes[0], &return_buf[1], (sizeof(csp_route_info)*routes_requested)); for(k = 0; k < routes_requested; k++){ if((i+k) > CSP_ROUTE_COUNT){ goto out_of_nodes; } //no route if name_buffer NULL if(returned_routes[k].name_buffer[0] != 0x00) { if(returned_routes[k].node != CSP_DEFAULT_ROUTE){ printf("%4u %-9s %u\r\n",returned_routes[k].node, returned_routes[k].name_buffer, returned_routes[k].nexthop_mac_addr); } else printf(" * %-9s %u\r\n",returned_routes[k].name_buffer, returned_routes[k].nexthop_mac_addr); } else goto out_of_nodes;//if entry NULL, out of nodes } if(routes_left == 0){ goto out_of_nodes; } else if(routes_left < routes_requested){ routes_requested = routes_left; } i = returned_routes[k].node + 1;//next index 1 after last received } out_of_nodes: return CSP_ERR_NONE; }
void obc_boot_del(void) { uint32_t checksum = csp_hton32(0x80078007); csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_BOOT_CONF, 0, &checksum, 4, NULL, 0); }
/** * Jump to an address in RAM * This function is only useful after the load command has been executed, or an image * has been uploaded to RAM. * @param addr */ void obc_jump_ram(uint32_t addr) { addr = csp_hton32(addr); csp_transaction(CSP_PRIO_NORM, node_obc, OBC_PORT_JUMP, 0, &addr, sizeof(uint32_t), NULL, 0); }