uint16_t battery_read() {
uint8_t txbuf[1];
uint8_t rxbuf[43 + 2];
uint16_t Vbat = 0;
txbuf[0] = 0x08;
if (i2c_master_transaction_2(0, stm_eps_node_v, &txbuf, 1, &rxbuf, 43 + 2, eps_delay) == E_NO_ERR) {
memcpy(&Vbat, &rxbuf[10], 2);
i2c_lock_flag = 0;
}
else {
i2c_lock_flag ++;
if (i2c_lock_flag >= 3) {
power_control(5, OFF);
i2c_lock_flag = 0;
}
}
return csp_ntoh16(Vbat);
}
/*
* 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;
}
int eps_slave_hk(struct command_context *ctx) {
int bintmp;
printf("Requesting EPS HK data\r\n");
eps_hk_1_t * chkparam;
i2c_frame_t * frame;
frame = csp_buffer_get(I2C_MTU);
frame->dest = slave_node;
frame->data[0] = EPS_PORT_HK; // Ping port
frame->len = 1;
frame->len_rx = 2 + (uint8_t) sizeof(eps_hk_1_t);
frame->retries = 0;
if (i2c_send(0, frame, 0) != E_NO_ERR) {
csp_buffer_free(frame);
return CMD_ERROR_NOMEM;
}
if (i2c_receive(0, &frame, 20) != E_NO_ERR)
return CMD_ERROR_FAIL;
chkparam = (eps_hk_1_t *)&frame->data[2];
chkparam->pv[0] = csp_ntoh16(chkparam->pv[0]);
chkparam->pv[1] = csp_ntoh16(chkparam->pv[1]);
chkparam->pv[2] = csp_ntoh16(chkparam->pv[2]);
chkparam->pc = csp_ntoh16(chkparam->pc);
chkparam->bv = csp_ntoh16(chkparam->bv);
chkparam->sc = csp_ntoh16(chkparam->sc);
chkparam->temp[0] = csp_ntoh16(chkparam->temp[0]);
chkparam->temp[1] = csp_ntoh16(chkparam->temp[1]);
chkparam->temp[2] = csp_ntoh16(chkparam->temp[2]);
chkparam->temp[3] = csp_ntoh16(chkparam->temp[3]);
chkparam->temp[4] = csp_ntoh16(chkparam->temp[4]);
chkparam->temp[5] = csp_ntoh16(chkparam->temp[5]);
chkparam->latchup[0] = csp_ntoh16(chkparam->latchup[0]);
chkparam->latchup[1] = csp_ntoh16(chkparam->latchup[1]);
chkparam->latchup[2] = csp_ntoh16(chkparam->latchup[2]);
chkparam->latchup[3] = csp_ntoh16(chkparam->latchup[3]);
chkparam->latchup[4] = csp_ntoh16(chkparam->latchup[4]);
chkparam->latchup[5] = csp_ntoh16(chkparam->latchup[5]);
chkparam->sw_errors = csp_ntoh16(chkparam->sw_errors);
chkparam->bootcount = csp_ntoh16(chkparam->bootcount);
printf("ADC sample:\r\n");
printf("Temp 1 %"PRId16"\r\n", chkparam->temp[0]);
printf("Temp 2 %"PRId16"\r\n", chkparam->temp[1]);
printf("Temp 3 %"PRId16"\r\n", chkparam->temp[2]);
printf("Temp PCB %"PRId16"\r\n", chkparam->temp[3]);
printf("BV %u\r\n", chkparam->bv);
printf("PC %u\r\n", chkparam->pc);
printf("SC %u\r\n", chkparam->sc);
printf("PV1 %u\r\n", chkparam->pv[0]);
printf("PV2 %u\r\n", chkparam->pv[1]);
printf("PV3 %u\r\n", chkparam->pv[2]);
printf("Latch up 1 %u\r\n", chkparam->latchup[0]);
printf("Latch up 2 %u\r\n", chkparam->latchup[1]);
printf("Latch up 3 %u\r\n", chkparam->latchup[2]);
printf("Latch up 4 %u\r\n", chkparam->latchup[3]);
printf("Latch up 5 %u\r\n", chkparam->latchup[4]);
printf("Latch up 6 %u\r\n", chkparam->latchup[5]);
printf("User Channel Status %02X ; \r\n", chkparam->channel_status);
bintmp = chkparam->channel_status;
int n;
for(n=0; n<8; n++)
{
if((bintmp & 0x80) !=0)
{
printf("1");
}
else
{
printf("0");
}
if (n==3)
{
printf(" "); /* insert a space between nybbles */
}
bintmp = bintmp<<1;
}
printf("\r\n");
printf("Battery temperature 1 %"PRId16"\r\n", chkparam->temp[4]);
printf("Battery temperature 2 %"PRId16"\r\n", chkparam->temp[5]);
printf("Reset %d BootCount %d SW Err %d PPT mode %d\r\n",chkparam->reset,chkparam->bootcount,chkparam->sw_errors,chkparam->ppt_mode);
csp_buffer_free(frame);
return CMD_ERROR_NONE;
}
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;
}
static int csp_can_process_frame(can_frame_t *frame) {
pbuf_element_t *buf;
uint8_t offset;
can_id_t id = frame->id;
/* Bind incoming frame to a packet buffer */
buf = pbuf_find(id, CFP_ID_CONN_MASK, NULL);
/* Check returned buffer */
if (buf == NULL) {
if (CFP_TYPE(id) == CFP_BEGIN) {
buf = pbuf_new(id, NULL);
if (buf == NULL) {
csp_log_warn("No available packet buffer for CAN\r\n");
csp_if_can.rx_error++;
return CSP_ERR_NOMEM;
}
} else {
csp_log_warn("Out of order MORE frame received for can id 0x%"PRIx32"; remain is %u\r\n",
(uint32_t)id, CFP_REMAIN(id));
csp_if_can.frame++;
return CSP_ERR_INVAL;
}
}
/* Reset frame data offset */
offset = 0;
switch (CFP_TYPE(id)) {
case CFP_BEGIN:
/* Discard packet if DLC is less than CSP id + CSP length fields */
if (frame->dlc < sizeof(csp_id_t) + sizeof(uint16_t)) {
csp_log_warn("Short BEGIN frame received\r\n");
csp_if_can.frame++;
pbuf_free(buf, NULL);
break;
}
/* Check for incomplete frame */
if (buf->packet != NULL) {
/* Reuse the buffer */
csp_log_warn("Incomplete frame\r\n");
csp_if_can.frame++;
} else {
/* Allocate memory for frame */
buf->packet = csp_buffer_get(csp_buffer_size() - CSP_BUFFER_PACKET_OVERHEAD);
if (buf->packet == NULL) {
csp_log_error("Failed to get buffer for CSP_BEGIN packet\r\n");
csp_if_can.frame++;
pbuf_free(buf, NULL);
break;
}
}
/* Copy CSP identifier and length*/
memcpy(&(buf->packet->id), frame->data, sizeof(csp_id_t));
buf->packet->id.ext = csp_ntoh32(buf->packet->id.ext);
memcpy(&(buf->packet->length), frame->data + sizeof(csp_id_t), sizeof(uint16_t));
buf->packet->length = csp_ntoh16(buf->packet->length);
/* Reset RX count */
buf->rx_count = 0;
/* Set offset to prevent CSP header from being copied to CSP data */
offset = sizeof(csp_id_t) + sizeof(uint16_t);
/* Set remain field - increment to include begin packet */
buf->remain = CFP_REMAIN(id) + 1;
/* Note fall through! */
case CFP_MORE:
/* Check 'remain' field match */
if (CFP_REMAIN(id) != buf->remain - 1) {
csp_log_error("CAN frame lost in CSP packet, %u vs. %u\r\n",
CFP_REMAIN(id),buf->remain - 1);
pbuf_free(buf, NULL);
csp_if_can.frame++;
break;
}
/* Decrement remaining frames */
buf->remain--;
/* Check for overflow */
if ((buf->rx_count + frame->dlc - offset) > buf->packet->length) {
csp_log_error("RX buffer overflow\r\n");
csp_if_can.frame++;
pbuf_free(buf, NULL);
break;
}
/* Copy dlc bytes into buffer */
memcpy(&buf->packet->data[buf->rx_count], frame->data + offset, frame->dlc - offset);
buf->rx_count += frame->dlc - offset;
/* Check if more data is expected */
if (buf->rx_count != buf->packet->length)
break;
/* Data is available */
csp_new_packet(buf->packet, &csp_if_can, NULL);
/* Drop packet buffer reference */
buf->packet = NULL;
/* Free packet buffer */
pbuf_free(buf, NULL);
break;
default:
csp_log_warn("Received unknown CFP message type\r\n");
pbuf_free(buf, NULL);
break;
}
return CSP_ERR_NONE;
}
