void cgc_send_message(message_t *m) { char buf[100]; cgc_sprintf(buf, "%08d - %s\n", m->id, m->topic); send_string(buf); send_string(m->body); }
void set_event(uint8_t event_number) { uint8_t which_pin = events[event_number].pin; actual_events[which_pin] = event_number; switch(which_pin) { case EXP0_PC2: case EXP1_PD4: case EXP2_PD7: case EXP3_PB0: set_pin(which_pin, events[event_number].pin_state); break; case PWM0_PD6: case PWM1_PD5: // not implemented yet case PWM2_PB1: // not implemented yet case PWM3_PD3: run_pwm(which_pin, &events[event_number]); break; default:break; } int32_t time = current_time(); // event_time char formatted_date[30]; timeToString(time, formatted_date); send_string(formatted_date); send_string(" "); print_event(event_number); }
OPENVPN_EXPORT int openvpn_plugin_func_v1 (openvpn_plugin_handle_t handle, const int type, const char *argv[], const char *envp[]) { struct auth_pam_context *context = (struct auth_pam_context *) handle; if (type == OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY && context->foreground_fd >= 0) { /* get username/password from envp string array */ const char *username = get_env ("username", envp); const char *password = get_env ("password", envp); if (username && strlen (username) > 0 && password) { if (send_control (context->foreground_fd, COMMAND_VERIFY) == -1 || send_string (context->foreground_fd, username) == -1 || send_string (context->foreground_fd, password) == -1) { fprintf (stderr, "AUTH-PAM: Error sending auth info to background process\n"); } else { const int status = recv_control (context->foreground_fd); if (status == RESPONSE_VERIFY_SUCCEEDED) return OPENVPN_PLUGIN_FUNC_SUCCESS; if (status == -1) fprintf (stderr, "AUTH-PAM: Error receiving auth confirmation from background process\n"); } } } return OPENVPN_PLUGIN_FUNC_ERROR; }
atlsci_led_ret_t atlsci_led(int sensor_type, int action) { char * led_on = "L,1"; //Turn on LEDs char * led_off = "L,0"; //Turn off LEDs char * led_query = "L,?"; //Query LEDs uint8_t rx_buffer[STRING_SIZE] = {0}; int ret = set_sensor_address(i2c_context, sensor_type); switch (action) { case ATLSCI_LED_ON: ret = send_string(i2c_context, led_on); break; case ATLSCI_LED_OFF: ret = send_string(i2c_context, led_off); break; case ATLSCI_LED_QUERY: ret = send_string(i2c_context, led_query); break; default: ret = -1; break; } if (ret == MRAA_SUCCESS) { ret = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer)); if(action == ATLSCI_LED_QUERY) printf("%s\n", rx_buffer); return parse_atlsci_led(rx_buffer, action); } log_mraa_response("atlsci_led()", ret); return parse_atlsci_led(rx_buffer, action); }
int main(void) { /* Setup IO */ DDRD = (1 << DDD5) | (1 << DDD6) | (1 << DDD7); DDRB = (1 << DDB0); PORTC = (1 << PC2) | (1 << PC3) | (1 << PC4) | (1 << PC5); PCMSK1 = (1 << PCINT10) | (1 << PCINT11) | (1 << PCINT12) | (1 << PCINT13); UBRR0H = 0; UBRR0L = 103; UCSR0B = (1 << TXEN0); send_string("Hello\n"); /* Duplicate */ for (;;) { send_string("Cloning\n"); clone(C, 2, B, 0); clone(C, 3, D, 7); clone(C, 4, D, 6); clone(C, 5, D, 5); send_string("Sleeping\n"); PCICR |= (1 << PCIE1); intsleep(PWR_DOWN); PCICR &= ~(1 << PCIE1); send_string("Woke up\n"); } }
int main(void) { int i; /* Init the Display */ lcd_init(2); /* Clear the screen */ lcd_putc('\f'); /* Send the message */ send_string(5, INITMESSAGE); while (1) { /* Display on the first line after button press */ while(lcd.button == 1) { } lcd_putc('\f'); send_string(1000, MESSAGE1); while(lcd.button == 1) { } lcd_putc('\f'); /* New line */ lcd_putc('\n'); send_string(5, MESSAGE2); /* Add delay for button debouncing */ delay_ms(500); } return 0; }
/* * Temperature compensation is only enable for pH, DO, and Conductivity sensor. * ORP does not have this feature. The value that it takes is expressed in float value nn.n */ atlsci_temp_comp_ret_t atlsci_temp_comp(int sensor_type, atlsci_temp_comp_param param, float value) { atlsci_temp_comp_ret_t ret; uint8_t rx_buffer[STRING_SIZE] = {0}; char cal_temp[TEMP_COMP_SIZE] = "T,"; int success = set_sensor_address(i2c_context, sensor_type); char *pt_cal = cal_temp; switch(param) { case SET_TEMPERATURE: sprintf(pt_cal + TEMP_COMP_INDEX, "%.1f", value); success = send_string(i2c_context, cal_temp); break; case QUERY_TEMPERATURE: success = send_string (i2c_context, cal_query); break; default: return atlsci_temp_comp_fail(param); } if (success == MRAA_SUCCESS) { success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer)); if(param == QUERY_TEMPERATURE) printf("%s\n", rx_buffer); //First bit of rx_buffer will be '1' if write is successful ret.success = (int)rx_buffer[0]; } else { log_mraa_response("atlsci_temp_comp()", success); ret.success = -1; } return ret; }
int main(void) { struct DataPackage* pkg; uint8_t i; uint8_t buffer[20]; rfm_init(RX_MODE); init_uart(); DDRD &= ~(1<<PD2); PORTD |= 1<<PD2; while(1) { pkg = receivePackageBlocking(); if(pkg->pkgSize > 0) { send_string("RICHTIG\r\n"); /* for(i=0; i<pkg->pkgSize-DATA_PKG_HEAD_SIZE; i++) { itoa(pkg->pkgData[i], (char*)buffer, 16); send_string(buffer); send_string("\r\n"); }*/ } else { send_string("FALSCH\r\n"); } deleteDataPackage(pkg); } }
void main(void) { WDTCTL = WDTPW + WDTHOLD; // stop watchdog timer lcd_init(); send_string("Manpreet Singh"); send_command(0xC0); send_string("Minhas"); while(1){} }
int main (int argc, char *argv[]) { optarg = (char *)malloc(100*sizeof(char)); //fill optarg with the path to the serial transmitter find_serial_transmitter(); FILE *log_file; char buf[1000]; char *str_array[140]={"\0"}; int i=0; //Open the FM stations log file that will become the device database log_file = fopen("log.txt","r"); if (!log_file){ printf("ERROR: Could not open FM Stations log file for reading.\n"); return -1; } //create a connection over the virtual serial port open_port(); //send the start sequence perror("START SEQUENCE:\n"); send_string("$$$"); printf("\n\n"); //wait a while to make sure the device has detected the start sequence and is ready for data usleep(5000000); //parse the log file line by line while (fgets(buf,1000, log_file)!=NULL) { //keep track of each line str_array[i] = buf; strip_newline( str_array[i], 210); //prepare, parse, and transmit the data within each line parse_line(line_prep(str_array[i])); i++; } //close the log file fclose(log_file); //make sure the device has had enough time to write all the data before sending end sequence usleep(4000000); //send the end sequence printf("END SEQUENCE:\n"); send_string("^^^"); printf("\n\n"); //terminate the virtual serial port connection serialport_close(fd); return 0; }
int parse_line(char * in_line){ int i = 0; int initial_length = strlen(in_line); printf("chars parsed: %d\n", initial_length); char * token = strtok_single(in_line, " "); /* walk through other tokens */ //The first call you use a char array which has the elements you want parsed. //The second time you call it you pass it NULL as the first parameter to tell function //to resume from the last spot in the string. Once the first call is made your char //array receives the parsed string. If you don't put NULL you would lose your place //and effectivly the last part of your string. if (initial_length > 10){ if (initial_length >= 200){ //grid population send_byte((uint8_t)*(token)); printf("%s ", token); while(token){ i++; token = strtok_single(NULL, " "); if (i < 100) { send_byte((uint8_t)*(token)); printf("%s ",token); } usleep(200000); } printf("\n"); } else{ //Station line //printf("callsign:%s\n", token); send_string(token); if (strlen(token) < 8) { int k=0; for (k=0; k< 8-strlen(token); k++) { send_string(" "); } } while(token){ i++; token = strtok_single(NULL, " "); if (i < 6) send_float(token); //if (i < 6) printf("float:%s ",token); usleep(200000); } } } else{ send_float(token); //printf("num_stations: %s\n",token); } printf("\n"); return 0; }
/* handle_response -- accept a response from stdin (the gnu process) and pass the information on to the relevant client. */ static void handle_response (void) { char buf[GSERV_BUFSZ+1]; int offset=0; int s; int len = 0; int result_len; /* read in "n/m:" (n=client fd, m=message length) */ while (offset < GSERV_BUFSZ && ((len = read(0,buf+offset,1)) > 0) && buf[offset] != ':') { offset += len; } if (len < 0) { perror(progname); fprintf(stderr,"%s: unable to read\n",progname); exit(1); } /* parse the response from emacs, getting client fd & result length */ buf[offset] = '\0'; sscanf(buf,"%d/%d", &s, &result_len); while (result_len > 0) { if ((len = read(0,buf,min2(result_len,GSERV_BUFSZ))) < 0) { perror(progname); fprintf(stderr,"%s: unable to read\n",progname); exit(1); } buf[len] = '\0'; send_string(s,buf); result_len -= len; } /* eat the newline */ while ((len = read(0,buf,1)) == 0) ; if (len < 0) { perror(progname); fprintf(stderr,"%s: unable to read\n",progname); exit(1); } if (buf[0] != '\n') { fprintf(stderr,"%s: garbage after result\n",progname); exit(1); } /* send the newline */ buf[1] = '\0'; send_string(s,buf); close(s); } /* handle_response */
static void docmd(char **cmd) { int i; if (cmd[0] == NULL) { help(); return; } if (cmd[1] && cmd[2]) { printf("%s\n", lang_toolong); help(); return; } if (strcmp(cmd[0], lang_look[0]) == 0 || strcmp(cmd[0], lang_look[1]) == 0) { send_string("descr\r\n"); return; } if (strcmp(cmd[0], lang_inv[0]) == 0 || strcmp(cmd[0], lang_inv[1]) == 0) { send_string("inv\r\n"); return; } if (strcmp(cmd[0], lang_get) == 0) { call_with_arg(get, cmd[1], lang_getdrop_explain, lang_get); return; } if (strcmp(cmd[0], lang_drop) == 0) { call_with_arg(drop, cmd[1], lang_getdrop_explain, lang_drop); return; } if (strcmp(cmd[0], lang_poke) == 0) { if (cmd[1] && cmd[1][0] == '-') cmd[1]++; call_with_arg(poke, cmd[1], lang_poke_explain, lang_poke); return; } for (i = 0; i < 6; i++) { if (strcmp(cmd[0], lang_directions[i][0]) == 0 || strcmp(cmd[0], lang_directions[i][1]) == 0) { go(i); return; } } /* accept standard command "l" in any language, unless it is assigned * another meaning */ if (strcmp(cmd[0], "l") == 0) { send_string("descr\r\n"); return; } printf("%s\n", lang_huh); help(); }
void run_task(uint8_t *Task) { switch(Task[2]) { case '0': send_string("boot"); break; case '1': page_address = Task[9] << 8; page_address |= Task[8]; readFlashPage(page_address, 128); send_buff(gBuffer, 128); Task[2] = 0; break; case '2': Task[2] = 0; break; case '3': page_address = Task[9] << 8; page_address |= Task[8]; for (uint16_t i = 0; i < SPM_PAGESIZE; i++) gBuffer[i] = data_buffer[i + 16]; writeFlashPage(page_address,SPM_PAGESIZE); send_string("page done"); Task[2] = 0; break; case '4': eraseFlash(); send_string("erase ok"); Task[2] = 0; break; case '5': Task[2] = 0; break; case '6': fill_page(); send_buff(gBuffer, 256); Task[2] = 0; break; case '7': blink_led(); Task[2] = 0; break; case '8': MCUCR |= 1<<IVCE; MCUCR = 0<<IVSEL; send_string("jump ok"); jump_to_app(); // Jump to application sector Task[2] = 0; break; default: Task[2] = 0; } }
Service* service_request (string service_name) { int socket; Service_description* s_description = NULL; if (service_name == "" || !socket_initialization_client (&socket, SR_address, SR_port)) return NULL; if (send_string (socket, "get_service") && receive_int (socket) != -1 && send_string (socket, service_name)) s_description = receive_service_description (socket); close(socket); return (s_description == NULL) ? NULL : new Service (s_description); }
int main() { type2_vals t2v; unsigned char* ScreenBuf[MAX_LINES]; unsigned LineCnt; #ifndef DEBUG type2_negotiate(&t2v); #else (void)t2v; #endif transmit_all(STDOUT, "l23k", 4); send_string(STDERR, "GOING\n"); LineCnt = ReadScreen(ScreenBuf); for (unsigned Index = 0; Index < 64; ++Index) { send_string(STDERR, "LOOP\n"); send_string(STDOUT, "0\n"); LineCnt = ReadScreen(ScreenBuf); } send_string(STDOUT, "shuf\n"); LineCnt = ReadScreen(ScreenBuf); send_string(STDOUT, "4986\n"); LineCnt = ReadScreen(ScreenBuf); send_string(STDOUT, "4\n"); LineCnt = ReadScreen(ScreenBuf); send_string(STDOUT, "dupr\n"); LineCnt = ReadScreen(ScreenBuf); char* s = (char *)ScreenBuf[LineCnt - 2]; s = strchr(s, ':'); s += 2; int m = strtol(s, NULL, 10); unsigned char secret[4]; cgc_memcpy(secret, (void *)&m, 4); secret[0] ^= 0x14; secret[1] ^= 0x15; secret[2] ^= 0x16; secret[3] ^= 0x17; send_string(STDERR, (char *)s); send_string(STDERR, "----->\n"); type2_submit((unsigned char *)secret, 4); send_string(STDOUT, "quit\n"); }
static atlsci_cal_ret_t atlsci_cal_ph(atlsci_cal_param_t param, float value) { atlsci_cal_ret_t ret; int success = set_sensor_address(i2c_context, ATLSCI_PH); uint8_t rx_buffer[STRING_SIZE] = {0}; char cal_low[PH_CAL_LOW_SIZE] = "Cal,low,"; char cal_mid[PH_CAL_MID_SIZE] = "Cal,mid,"; char cal_high[PH_CAL_HIGH_SIZE] = "Cal,high"; char *pt_cal = NULL; switch(param.cal_ph) { case PH_CALIBRATION_CLEAR: success = send_string(i2c_context, cal_clear); break; case PH_CALIBRATION_QUERY: success = send_string(i2c_context, cal_query); break; case PH_LOW_CALIBRATION_POINT: pt_cal = cal_low; sprintf(pt_cal + PH_INDEX_LOW, "%.2f", value); success = send_string(i2c_context, cal_low); break; case PH_MID_CALIBRATION_POINT: pt_cal = cal_mid; sprintf((pt_cal + PH_INDEX_MID), "%.2f", value); success = send_string(i2c_context, cal_mid); break; case PH_HIGH_CALIBRATION_POINT: pt_cal = cal_high; sprintf((pt_cal + PH_INDEX_HIGH), "%.2f", value); success = send_string(i2c_context, cal_high); break; default: return atlsci_cal_fail(param); } if (success == MRAA_SUCCESS) { success = mraa_i2c_read(i2c_context, rx_buffer, sizeof(rx_buffer)); if(param.cal_ph == PH_CALIBRATION_QUERY) { ret.query = malloc(QUERY_SIZE); //ret.query = rx_buffer; uint8_t * rx_ptr = rx_buffer; rx_ptr++; sprintf(ret.query, "%s", rx_ptr); } //First bit of rx_buffer will be '1' if write is successful ret.success = (int)rx_buffer[0]; } else { log_mraa_response("atlsci_cal_ph()", success); ret.success = -1; } return ret; }
/** * Checks each of the cliff sensors and returns 1 if the sensor is tripped and prints to putty which sensor was tripped. * @param sensor_status - the robot **/ int check_cliff(oi_t *sensor_status) { int stop = 0; oi_update(sensor_status); if(old_cl != sensor_status->cliff_left) { old_cl = sensor_status->cliff_left; if(old_cl == 1) { oi_set_wheels(0, 0); stop = 1; send_string("Cliff Left Detected!"); } } else if(old_cfl != sensor_status->cliff_frontleft) { old_cfl = sensor_status->cliff_frontleft; if(old_cfl == 1) { oi_set_wheels(0, 0); stop = 1; send_string("Cliff Front Left Detected!"); } } else if(old_cfr != sensor_status->cliff_frontright) { old_cfr = sensor_status->cliff_frontright; if(old_cfr == 1) { oi_set_wheels(0, 0); stop = 1; send_string("Cliff Front Right Detected!"); } } else if(old_cr != sensor_status->cliff_right) { old_cr = sensor_status->cliff_right; if(old_cr == 1) { oi_set_wheels(0, 0); stop = 1; send_string("Cliff Right Detected!"); } } return stop; }
bool unregister_service (Service_description* s_description) { int socket; bool result = false; if (s_description == NULL || !socket_initialization_client (&socket, SR_address, SR_port)) return false; if (send_string (socket, "remove_service") && receive_int (socket) != -1 && send_string (socket, s_description->name) && send_string (socket, s_description->address) && send_string (socket, s_description->port)) result = true; close(socket); return result; }
void print_events() { char ts[30]; send_string("Number of events: "); sprintf(ts, "%d", events_count); send_string(ts); send_enter(); for (uint8_t i = 0; i < events_count; i++) { print_event(i); } }
bool register_service_provider (string address, string port) { int socket; bool result = false; if (!check_address (address) || atoi(port.c_str()) < 1023 || atoi(port.c_str()) > 65535 || !socket_initialization_client (&socket, SR_address, SR_port)) return false; if (send_string (socket, "add_service_provider") && receive_int (socket) != -1 && send_string (socket, address) && send_string (socket, port)) result = true; close(socket); return result; }
void cgc_do_read(const char *str) { if (str[1] != ' ') { send_string("Missing required argument.\n"); return; } int id = cgc_strtol(&str[2], NULL, 10); message_t *m = cgc_find_message(id); if (m) cgc_send_message(m); else send_string("Message ID not found.\n"); }
static int do_ftp_auth (const char *username, const char *password) { struct sockaddr_in local_address; unsigned long inaddr; int my_socket; char answer[4]; memset ((char *) &local_address, 0, sizeof (local_address)); local_address.sin_family = AF_INET; /* FIXME: extract the ftp port with the proper function */ local_address.sin_port = htons (21); /* Convert localhost to usable format */ if ((inaddr = inet_addr ("127.0.0.1")) != INADDR_NONE) memcpy ((char *) &local_address.sin_addr, (char *) &inaddr, sizeof (inaddr)); if ((my_socket = socket (AF_INET, SOCK_STREAM, 0)) < 0) { if (!isDaemon) fprintf (stderr, "do_auth: can't create socket\n"); return 0; } if (connect (my_socket, (struct sockaddr *) &local_address, sizeof (local_address)) < 0) { fprintf (stderr, "do_auth: can't connect to ftp daemon for authentication\n"); close (my_socket); return 0; } send_string (my_socket, "user "); send_string (my_socket, username); send_string (my_socket, "\r\n"); if (!ftp_answer (my_socket, "331")) { send_string (my_socket, "quit\r\n"); close (my_socket); return 0; } next_line (my_socket); /* Eat all the line */ send_string (my_socket, "pass "); send_string (my_socket, password); send_string (my_socket, "\r\n"); socket_read_block (my_socket, answer, 3); answer[3] = 0; send_string (my_socket, "\r\n"); send_string (my_socket, "quit\r\n"); close (my_socket); if (strcmp (answer, "230") == 0) return 1; return 0; }
void send_int(char *name, int integer) /* includefile */ { send_string(name); if (swapout) swap_int(&integer); fwrite(&integer,sizeof(int),1,output); /*fprintf(stderr,"%d\n",integer);*/ }
/* adds bouquet at the end of the bouquetlist */ void CZapitClient::addBouquet(const char * const name) { if (send(CZapitMessages::CMD_BQ_ADD_BOUQUET)) send_string(name); close_connection(); }
void send_user(connection_t *connection) { char cmdstr[DEFBUFFSIZE]; memset(cmdstr, '\0', sizeof cmdstr); snprintf(cmdstr, DEFBUFFSIZE, "USER %s %s %s :%s\r\n", connection->config->name, "hostname", "servername", connection->config->realname); send_string(connection, cmdstr); }
void send_long(char *name, long integer) /* includefile */ { send_string(name); if (swapout) swap_long(&integer); fwrite(&integer,sizeof(long),1,output); /*fprintf(stderr,"%ld\n",integer);*/ }
int cmd_get(int sockfd, char *line, uint32_t cmd, t_param *param) { t_command command; char *src; char *dst; command.magic = MAGIC_CMD; command.command = cmd; if (!get_2_params(line, &src, &dst)) { printf(INVALID_ARG_GET "\n"); return (0); } if (!send_data(sockfd, &command, sizeof(t_command))) { param->to_deco = 1; printf(SEND_CMD_FAIL "\n"); return (0); } if (!send_string(sockfd, src, ft_strlen(src))) { printf(SEND_STRING_FAIL "\n"); return (0); } if (!(get_response(sockfd, dst, param))) return (0); return (1); }
void PJON::update() { for(uint8_t i = 0; i < MAX_PACKETS; i++) { if(packets[i].state != NULL) if(micros() - packets[i].registration > packets[i].timing + pow(packets[i].attempts, 2)) packets[i].state = send_string(packets[i].device_id, packets[i].content, packets[i].length); if(packets[i].state == ACK) { if(!packets[i].timing) this->remove(i); else { packets[i].attempts = 0; packets[i].registration = micros(); packets[i].state = TO_BE_SENT; } } if(packets[i].state == FAIL) { packets[i].attempts++; if(packets[i].attempts > MAX_ATTEMPTS) { this->_error(CONNECTION_LOST, packets[i].device_id); if(!packets[i].timing) this->remove(i); else { packets[i].attempts = 0; packets[i].registration = micros(); packets[i].state = TO_BE_SENT; } } } } }
/* Send a 407 Proxy Authenticate Required response. */ static int send_proxy_authenticate(struct fdinfo *fdn, int stale) { char *buf = NULL; size_t size = 0, offset = 0; int n; strbuf_append_str(&buf, &size, &offset, "HTTP/1.0 407 Proxy Authentication Required\r\n"); strbuf_append_str(&buf, &size, &offset, "Proxy-Authenticate: Basic realm=\"Ncat\"\r\n"); #if HAVE_HTTP_DIGEST { char *hdr; hdr = http_digest_proxy_authenticate("Ncat", stale); strbuf_sprintf(&buf, &size, &offset, "Proxy-Authenticate: %s\r\n", hdr); free(hdr); } #endif strbuf_append_str(&buf, &size, &offset, "\r\n"); if (o.debug > 1) logdebug("RESPONSE:\n%s", buf); n = send_string(fdn, buf); free(buf); return n; }