Beispiel #1
0
int
ubigen_write_leb(ubi_info_t u, ubigen_action_t action)
{
	int rc = 0;
	size_t read = 0;

	clear_buf(u);
	write_ec_hdr(u);

	rc = fill_data_buffer_from_file(u, &read);
	if (rc != 0)
		return rc;

	if (u->v->vol_type == UBI_VID_STATIC)  {
		add_static_info(u, read, action);
	}

	u->v->lnum = cpu_to_ubi32(u->blks_written);

	if (action & MARK_AS_UPDATE) {
		u->v->copy_flag = (u->v->copy_flag)++;
	}

	write_vid_hdr(u, action);
	rc = write_to_output_stream(u);
	if (rc != 0)
		return rc;

	/* Update current handle */
	u->bytes_read += read;
	u->blks_written++;
	return 0;
}
int main()
{
	freopen("robot_direct_prob_info.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T, N, i;
	scanf("%d", &T);

	while (T--) 
	{
		scanf("%d", &N);
		// east->west->south->north
		for (i = 0; i < 4; i++)
		{
			int x;
			scanf("%d", &x);
			prob[i] = x / 100.0;
		}

		double ans = 0.0;
		ans = get_prob(50, 50, N);

		printf("%f\n", ans);

		clear_buf();
	}

	return 0;
}
Beispiel #3
0
/*
 * Function change_switch
 * ----------------------
 *  get contact status, tos command 'C9'
 *
 *  return: contact status
 *
 */
int get_contact_status(int contact_id) {
  Serial_Message msg;
  char input_buf[4];
  char contact_buf[5];
  char *buf_ptr = contact_buf;

  *buf_ptr = 'C';
  buf_ptr++;
  /* Give more space if contact_id is bigger than 1 */
  if (contact_id > 9) {
    k_memcpy(buf_ptr, int_to_string[contact_id], 2);
    buf_ptr += 2;
  } else {
    k_memcpy(buf_ptr, int_to_string[contact_id], 1);
    buf_ptr += 1;
  }
  *(buf_ptr) = '\015';
  buf_ptr++;
  *(buf_ptr) = '\0';
  msg.output_buffer = contact_buf;
  msg.input_buffer = input_buf;
  msg.len_input_buffer = sizeof(input_buf);

  clear_buf();
  send(serial_port, &msg);
  cmd_sleep();
  /*
  int i = 0;
  kprintf("Got Message:");
  for (i = 0; i < 6; i++) {
    kprintf("%x ", input_buf[i]);
  }
  kprintf("\n");*/
  return input_buf[1] - '0';
}
int main()
{
	freopen("double_encodings.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T, tc, i, j, k;
	scanf("%d", &T);

	for (tc = 1; tc <= T; tc++)
	{
		// input:
		a_cnt = 0, b_cnt = 0, c_cnt = 0;

		input_target_words();
		//print_target_words(a_cnt, b_cnt, c_cnt);

		// solve:
		matched_cnt = 0;
		no_match = false;
		ed_idx = -1;

		/* check matched with B and C*/
		check_matched();
		//print_target_words(a_cnt, b_cnt, c_cnt);

		// output:
		print_outputs();

		// clear buf:
		clear_buf();
	}

	return 0;
}
Beispiel #5
0
/*  DoCreateStringOutput (static)
 *
 *  Private function used to send a C-string through the 1847 creator and
 *  eventually pipe the 1847 output to a file.
 */
static int DoCreateStringOutput(const char *pStr,
				   int nPart,
				   emsMIMEtypeP mimePtr,
				   createStatePtr pState,
				   FILE *fOut)
{
	BufTypePtr pTmpBuf = make_buf();
	int ret = RFC1847_FAIL;

	if (pTmpBuf)
	{
		// Manually setup the buffer structure -- kind of ugly, but
		// more effiecient than copying the string
		pTmpBuf->buf = (char *) pStr;
		pTmpBuf->len = strlen(pStr);
		pTmpBuf->buf_size = pTmpBuf->len + 1;
		resetpos_buf(pTmpBuf);

		// Now output the buffer
		ret = DoCreatePartsOutput(mimePtr,
			((nPart == 1) ? pTmpBuf : NULL), /* Part 1 */
			((nPart == 2) ? pTmpBuf : NULL), /* Part 2 */
			pState,
			fOut);

		clear_buf(pTmpBuf); // Unassociate buffer with string
		delete_buf(pTmpBuf); // Delete buffer struct -- AFTER we clear it's contents
	}
	else
		return (FALSE); // Could not create buffer

	return (ret != RFC1847_FAIL);
}
Beispiel #6
0
int main()
{
	setbuf(stdout, NULL);

	int T, tc, i;
	scanf("%d", &T);
	
	for (tc = 1; tc <= T; tc++)
	{
		scanf("%s %s", &str1, &str2);
		size_t len1, len2;
		for (len1 = 0; str1[len1]; len1++);
		for (len2 = 0; str2[len2]; len2++);

		bool ans = one_edit_away(str1, str2, len1, len2);

		if (ans)
			printf("Yes, Right!\n");
		else
			printf("No way T.T\n");

		clear_buf();
	}

	return 0;
}
int main()
{
	setbuf(stdout, NULL);
	
	int T, tc, i, j;
	scanf("%d", &T);

	for (tc = 1; tc <= T; tc++)
	{
		// inputs
		scanf("%d%d", &N, &M);

		/* Save the suspects info to suspects array*/	
		for (i = 0; i < M; i++)
			scanf("%d", &suspects[i]);

		// solve
		/* Play games */
		for (i = 0; i < M; i++)
		{
			/* suspect get 1 point always */
			int curr_suspt = suspects[i];
			players[curr_suspt]++;

			/* get the answers from players*/
			/* player : 1, 2, 3 ... */
			int losers = 0;
			for (j = 1; j <= N; j++)
			{
				int x; 
				scanf("%d", &x);
				
				/* get the points if answer == suspect in this game */
				if (x == curr_suspt && j != curr_suspt)
					players[j]++;
				/* count players who write wrong answer */
				else if (j != curr_suspt)
					losers++;
			}

			/* current suspect gets more points from losers */
			players[curr_suspt] += losers;
		}

		// output
		/* print each player's game point */
		for (i = 1; i <= N; i++)
			printf("%d ", players[i]);
		printf("\n");

		// clear buffer for next games
		clear_buf();
	}

	return 0;
}
Beispiel #8
0
int get_char(void)
{
        int ch = getchar();

        if (ch == '\n')
                ungetc(ch, stdin);

        clear_buf();

        return ch;
}
Beispiel #9
0
void	fill_header(char *name, char *comment, header_t *header)
{
  if (my_strlen(name) > PROG_NAME_LENGTH)
    {
      my_putstr("Error : The Name is too long\n");
      exit(EXIT_FAILURE);
    }
  if (my_strlen(comment) > COMMENT_LENGTH)
    {
      my_putstr("Error : The comment is too long\n");
      exit(EXIT_FAILURE);
    }
  if (verif_endian() == 1)
    header->magic = INVERT_ENDIAN(COREWAR_EXEC_MAGIC);
  clear_buf(header->prog_name, PROG_NAME_LENGTH + 1);
  my_strcpy(header->prog_name, name);
  header->prog_size = 0;
  clear_buf(header->comment, COMMENT_LENGTH + 1);
  my_strcpy(header->comment, comment);
}
void
test_crypto (const struct crypto_options *co, struct frame* frame)
{
  int i, j;
  struct gc_arena gc = gc_new ();
  struct buffer src = alloc_buf_gc (TUN_MTU_SIZE (frame), &gc);
  struct buffer work = alloc_buf_gc (BUF_SIZE (frame), &gc);
  struct buffer encrypt_workspace = alloc_buf_gc (BUF_SIZE (frame), &gc);
  struct buffer decrypt_workspace = alloc_buf_gc (BUF_SIZE (frame), &gc);
  struct buffer buf = clear_buf();

  /* init work */
  ASSERT (buf_init (&work, FRAME_HEADROOM (frame)));

  msg (M_INFO, "Entering " PACKAGE_NAME " crypto self-test mode.");
  for (i = 1; i <= TUN_MTU_SIZE (frame); ++i)
    {
      update_time ();

      msg (M_INFO, "TESTING ENCRYPT/DECRYPT of packet length=%d", i);

      /*
       * Load src with random data.
       */
      ASSERT (buf_init (&src, 0));
      ASSERT (i <= src.capacity);
      src.len = i;
      ASSERT (rand_bytes (BPTR (&src), BLEN (&src)));

      /* copy source to input buf */
      buf = work;
      memcpy (buf_write_alloc (&buf, BLEN (&src)), BPTR (&src), BLEN (&src));

      /* encrypt */
      openvpn_encrypt (&buf, encrypt_workspace, co, frame);

      /* decrypt */
      openvpn_decrypt (&buf, decrypt_workspace, co, frame);

      /* compare */
      if (buf.len != src.len)
	msg (M_FATAL, "SELF TEST FAILED, src.len=%d buf.len=%d", src.len, buf.len);
      for (j = 0; j < i; ++j)
	{
	  const uint8_t in = *(BPTR (&src) + j);
	  const uint8_t out = *(BPTR (&buf) + j);
	  if (in != out)
	    msg (M_FATAL, "SELF TEST FAILED, pos=%d in=%d out=%d", j, in, out);
	}
    }
  msg (M_INFO, PACKAGE_NAME " crypto self-test mode SUCCEEDED.");
  gc_free (&gc);
}
Beispiel #11
0
char set_interval()
{
    interval = current_command[1];

    clear_buf();

    if (interval >= INTERVAL_1US && interval <= INTERVAL_500MS)
        return STATE_GET_COMMAND;

    interval = INTERVAL_1US;    
    return STATE_UNKNOWN_COMMAND;
}
Beispiel #12
0
/* Read a move string from a stream.
   Returns the length of the string if successfull (a move string is found).
   Returns -1 if EOF is reached, or 0 if the word isn't a move string.  */
static int
read_move(char *word, int lim, FILE *fp)
{
	int i;
	int c;

	/* Skip leading spaces.  */
	do {
		c = fgetc(fp);
	} while (isspace(c));

	if (c == EOF)
		return -1;

	/* Save the first character of the word.  */
	*word++ = (char)c;

	/* The word is not a move string.  */
	if (!isalpha(c)) {
		/* If the line starts with a '[' we skip the whole line.
		   Skipping until the closing ']' wouldn't be safe because
		   PGN files often have those pairs broken.  */
		if (c == '[')
			clear_buf(fp);
		/* Skip everything inside brackets.  */
		else if (c == '(' || c == '{') {
			int open_b = c;	/* opening bracket */
			int close_b;	/* closing bracket */
			int nb = 1;	/* num. of brackets */
			if (c == '(')
				close_b = ')';
			else
				close_b = '}';
			while ((c = fgetc(fp)) != EOF) {
				if (c == open_b)
					nb++;
				else if (c == close_b && --nb <= 0)
					break;
			}
		}
		return 0;
	}
	/* Get the rest of the move string.  */
	for (i = 1; i < lim - 1; i++) {
		c = fgetc(fp);
		if (isspace(c))
			break;
		*word++ = (char)c;
	}
	*word = '\0';

	return i;
}
Beispiel #13
0
void reset()
{
    stop();

    clear_buf();
    mode = MODE_INTERVAL;
    trigger = TRIGGER_IMMEDIATE;
    interval = INTERVAL_1MS;
    trigger_pins = 0;
    state = STATE_GET_COMMAND;
    tick = 0;
    led(0,1,0);
}
Beispiel #14
0
char set_mode()
{
    mode = current_command[1];

    clear_buf();

    if (mode == MODE_INTERVAL)
       return STATE_GET_COMMAND;
    if (mode == MODE_EVENT)
       return STATE_GET_COMMAND;

    mode = MODE_INTERVAL;
    return STATE_UNKNOWN_COMMAND;
}
Beispiel #15
0
int main()
{
	setbuf(stdout, NULL);

	int T, tc;
	scanf("%d", &T);
	for (tc = 1; tc <= T; tc++)
	{
		scanf("%d%d", &n, &k);
		printf("\n Minimum number of trials in worst cases with %d eggs %d floors is %d\n", n, k, drop_eggs());
		clear_buf();
	}

	return 0;
}
Beispiel #16
0
void
menu_char(int x_adjust, int menu_wid, int odd, register unsigned char *menu_border)
{
    register int    i, j, k;
    int embold = 1;
    int base;
    int totwid = font.width;
    /* Read in the character bit map, with two blank lines on each end. */
    for (i = 0; i < 2; i++)
	clear_buf (totwid, filterbuf[i]);
    for (i = font.height + 1; i >= 2; i--)
	fill_buf (font.width, filterbuf[i]);
    for (i = font.height + 2; i < font.height + 4; i++)
	clear_buf (totwid, filterbuf[i]);

    for (k=0; k<embold; k++)
	for (i=2; i<font.height+2; i++)
	    for (j=totwid+1; j>=2; j--)
		filterbuf[i][j+1] |= filterbuf[i][j];

    /* Initial base line for filtering depends on odd flag. */
    base = (odd ? 1 : 2);

    /* Change bits in menu that correspond to character bitmap. */
    for (i = font.height + base, k = 0; i >= base; i--, k++)
    {
	register RGBpixel *menu;
	menu = menu_addr + k * menu_wid + x_adjust;
	for (j = 0; j < (totwid + 3) - 1; j++, menu++ )
	    if ( filterbuf[i][j] )
	    {
		COPYRGB(*menu, menu_border);
	    }
    }
    return;
}
int main()
{
	freopen("words.txt", "r", stdin);
	setbuf(stdout, NULL);
	int n, i, len;
	scanf("%d", &n);
	
	while (n--) 
	{
		scanf("%s", str);
		printf("%s is unique?(0:false, 1:true): ", str);
		for (len = 0; str[len]; len++);
		printf("length = %d\n", len);
		printf("%d\n", is_uniq_chars(str, len));
		clear_buf();
	}
}
Beispiel #18
0
void do_replay (CHAR_DATA *ch, char *argument)
{
    if (IS_NPC(ch))
    {
	send_to_char("You can't replay.\n\r",ch);
	return;
    }

    if (buf_string(ch->pcdata->buffer)[0] == '\0')
    {
	send_to_char("You have no tells to replay.\n\r",ch);
	return;
    }

    page_to_char(buf_string(ch->pcdata->buffer),ch);
    clear_buf(ch->pcdata->buffer);
}
int main() {
	freopen("statements.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T, x;
	scanf("%d", &T);
	
	while (T--) {
		scanf(" %[^\n]\n", str);

		x = 0;
		x = find_value();
		printf("%d\n", x);
		
		clear_buf();
	}

	return 0;
}
int main() 
{
	freopen("statements.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T;
	scanf("%d", &T);

	while (T--) 
	{
		scanf(" %[^\n]\n", str);

		int i = 0, no1 = 0, no2 = 0;
		while (str[i])
		{
			if (no1 == 0 && str[i] >= 48 && str[i] <= 57)
			{
				while (str[i] >= 48 && str[i] <= 57)
				{
					no1 = no1 * 10 + (str[i] - '0');
					i++;
				}
			}
			else if (no2 == 0 && str[i] >= 48 && str[i] <= 57)
			{
				while (str[i] >= 48 && str[i] <= 57)
				{
					no2 = no2 * 10 + (str[i] - '0');
					i++;
				}
			}

			i++;
		}

		printf("%d\n", no2 - no1);

		clear_buf();
	}

	return 0;
}
int main()
{
	freopen("events_info_for_patroling.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T, tc, i, a, b;
	scanf("%d", &T);
	for (tc = 1; tc <= T; tc++)
	{
		scanf("%d%d", &N, &evnts);

		evnts++;
		row[0] = col[0] = 1; // 첫번째 사건
		row[1] = col[1] = N; // 두번째 사건
		// 실제 입력되는 사건 3번째라고 두고,
		for (i = 2; i <= evnts; i++)
			scanf("%d%d", &row[i], &col[i]);

		a = b = 0;
		a = min_Dist(2, 1) + get_Dist(0, 2);
		b = min_Dist(2, 0) + get_Dist(1, 2);

		printf("%d\n", min(a, b));

		if (a < b)
		{
			puts("1");
			construct(2, 1, 1);
		}
		else
		{
			puts("2");
			construct(2, 0, 2);
		}

		clear_buf();
	}

	return 0;
}
Beispiel #22
0
void train_test() {
  /* Check contact 2 should return 2 */
  disable_keyboard();
  Serial_Message msg;
  char input_buf[4];
  char contact_buf[5];
  char *buf_ptr = contact_buf;
  int contact_id = 2;

  *buf_ptr = 'C';
  buf_ptr++;
  /* Give more space if contact_id is bigger than 1 */
  if (contact_id > 9) {
    k_memcpy(buf_ptr, int_to_string[contact_id], 2);
    buf_ptr += 2;
  } else {
    k_memcpy(buf_ptr, int_to_string[contact_id], 1);
    buf_ptr += 1;
  }
  *(buf_ptr) = '\015';
  buf_ptr++;
  *(buf_ptr) = '\0';
  msg.output_buffer = contact_buf;
  msg.input_buffer = input_buf;
  msg.len_input_buffer = sizeof(input_buf);

  clear_buf();
  kprintf("Send Message:");
  send(serial_port, &msg);
  cmd_sleep();
  int i = 0;
  kprintf("Got Message:");
  for (i = 0; i < sizeof(input_buf); i++) {
    kprintf("%x ", input_buf[i]);
  }
  kprintf("\n");
  kprintf("Result = %d, shoulde be 1", input_buf[1] - '0');
  enable_keyboard();
}
Beispiel #23
0
int main()
{
	freopen("making_maze.txt", "r", stdin);
	setbuf(stdout, NULL);

	int T;
	scanf("%d", &T);

	while (T--) {
		scanf("%d%d", &H, &W);
		int i, j;
		for (i = 0; i < H; i++)
			scanf("%s", MAP[i]);
		// start point
		scanf("%d%d", &st.u, &st.v);
		// move count
		scanf("%d", &M);
		// moving info
		for (i = 0; i < M; i++)
			scanf("%d%d", &mrow[i], &mcol[i]);

		// initialize board with -1
		for (i = 0; i < H; i++)
			for (j = 0; j < W; j++)
				board[i][j] = -1;
		board[st.u][st.v] = 0;

		// solve
		int max_mv = 0;
		max_mv = bfs();
		// output
		printf("%d\n", max_mv);
		// clear buffer
		clear_buf();
	}
	return 0;
}
Beispiel #24
0
HIDDEN void
do_Char(int c, int xpos, int ypos, int odd)
{
    register int    i, j;
    int base;
    int     	totwid = font.width;
    int     	down;
    static float	resbuf[FONTBUFSZ];
    static RGBpixel fbline[FONTBUFSZ];
#if DEBUG_STRINGS
    fb_log( "do_Char: c='%c' xpos=%d ypos=%d odd=%d\n",
	    c, xpos, ypos, odd );
#endif

    /* read in character bit map, with two blank lines on each end */
    for (i = 0; i < 2; i++)
	clear_buf (totwid, filterbuf[i]);
    for (i = font.height + 1; i >= 2; i--)
	fill_buf (font.width, filterbuf[i]);
    for (i = font.height + 2; i < font.height + 4; i++)
	clear_buf (totwid, filterbuf[i]);

    (void)SignedChar( font.dir[c].up );
    down = SignedChar( font.dir[c].down );

    /* Initial base line for filtering depends on odd flag. */
    base = (odd ? 1 : 2);


    /* Produce a RGBpixel buffer from a description of the character and
       the read back data from the frame buffer for anti-aliasing.
    */
    for (i = font.height + base; i >= base; i--)
    {
	squash(	filterbuf[i - 1],	/* filter info */
		filterbuf[i],
		filterbuf[i + 1],
		resbuf,
		totwid + 4
	    );
	fb_read( fbp, xpos, ypos - down + i, (unsigned char *)fbline, totwid+3);
	for (j = 0; j < (totwid + 3) - 1; j++)
	{
	    register int tmp;
	    /* EDITOR'S NOTE : do not rearrange this code,
	       the SUN compiler can't handle more
	       complex expressions. */
	    tmp = fbline[j][RED] & 0377;
	    fbline[j][RED] =
		(int)(paint[RED]*resbuf[j]+(1-resbuf[j])*tmp);
	    fbline[j][RED] &= 0377;
	    tmp = fbline[j][GRN] & 0377;
	    fbline[j][GRN] =
		(int)(paint[GRN]*resbuf[j]+(1-resbuf[j])*tmp);
	    fbline[j][GRN] &= 0377;
	    tmp = fbline[j][BLU] & 0377;
	    fbline[j][BLU] =
		(int)(paint[BLU]*resbuf[j]+(1-resbuf[j])*tmp);
	    fbline[j][BLU] &= 0377;
	}
	fb_write( fbp, xpos, ypos - down + i, (unsigned char *)fbline,  totwid+3 );
    }
    return;
}
Beispiel #25
0
/**
 * owhere <var> <value>
 */
void do_owhere(struct char_data *ch, const char *argument)
{
    struct buf_type *buffer;
    OBJ_CMP_FN *cmp_fn;
    char buf[MAX_INPUT_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    int iter;

    if (ch == NULL || IS_NPC(ch))
        return;

    if (argument[0] == '\0') {
        send_to_char("\n\rFind what?\n\r", ch);
        return;
    }

    cmp_fn = NULL;
    one_argument(argument, arg);

    if (argument[0] == '?' || !str_prefix(argument, "help")) {
        show_help(ch->desc, "owhere", NULL);
        return;
    }

    buffer = new_buf();
    if (!str_prefix(argument, "list")) {
        add_buf(buffer, "owhere: searchable property list\n\r");
        for (iter = 0; obj_flags[iter].var[0] != '\0'; iter++) {
            sprintf(buf, "%-18.17s", obj_flags[iter].var);
            add_buf(buffer, buf);
            if ((iter % 2) == 1)
                add_buf(buffer, "\n\r");
        }
        add_buf(buffer, "\n\r");
        page_to_char(buf_string(buffer), ch);
        return;
    }

    sprintf(buf, "`#QUERY``: owhere %s\n\r\n\r", argument);
    add_buf(buffer, buf);

    for (iter = 0; obj_flags[iter].var[0] != '\0'; iter++) {
        if (!str_prefix(arg, obj_flags[iter].var)) {
            cmp_fn = (OBJ_CMP_FN *)obj_flags[iter].fn;
            argument = one_argument(argument, arg);
            break;
        }
    }

    if (cmp_fn == NULL)
        cmp_fn = obj_cmp_name;


    if (argument[0] == '?' || argument[0] == '\0') {
        clear_buf(buffer);
        sprintf(buf, "`#SYNTAX``:\n\r    owhere %s <value>:\n\r\n\r", arg);
        add_buf(buffer, buf);

        (*cmp_fn)(object_iterator_start(&object_empty_filter), argument, buffer);
        page_to_char(buf_string(buffer), ch);
    } else {
        struct gameobject *obj, *opending;
        struct gameobject *in_obj;
        char *clr1;
        char *clr2;
        int number;

        number = 0;

        opending = object_iterator_start(&object_empty_filter);
        while ((obj = opending) != NULL) {
            opending = object_iterator(obj, &object_empty_filter);

            if (can_see_obj(ch, obj)
                && (*cmp_fn)(obj, argument, NULL)) {
                number++;
                if (number == 1) {
                    sprintf(buf, "#   vnum   name                        where                      room\n\r");
                    add_buf(buffer, buf);
                    sprintf(buf, "=== ====== =========================== ========================== =====\n\r");

                    add_buf(buffer, buf);
                }

                for (in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj)
                    continue;

                if (in_obj->carried_by != NULL
                    && can_see(ch, in_obj->carried_by)
                    && in_obj->carried_by->in_room != NULL) {
                    clr1 = uncolor_str(obj->short_descr);
                    clr2 = uncolor_str(PERS(in_obj->carried_by, ch));
                    sprintf(buf, "%-3d %-7ld  %-26.26s  %-25.25s  %-7ld\n\r",
                            number,
                            obj->objprototype->vnum,
                            clr1,
                            clr2,
                            in_obj->carried_by->in_room->vnum);
                    free_string(clr1);
                    free_string(clr2);
                } else if (in_obj->in_room != NULL && can_see_room(ch, in_obj->in_room)) {
                    clr1 = uncolor_str(obj->short_descr);
                    clr2 = uncolor_str(in_obj->in_room->name);

                    sprintf(buf, "%-3d %-7ld  %-26.26s  %-25.25s  %-7ld\n\r",
                            number,
                            obj->objprototype->vnum,
                            clr1,
                            clr2,
                            in_obj->in_room->vnum);
                    free_string(clr1);
                    free_string(clr2);
                } else {
                    clr1 = uncolor_str(obj->short_descr);

                    sprintf(buf, "%-3d %-7ld  %-26.26s\n\r",
                            number,
                            obj->objprototype->vnum,
                            clr1);
                    free_string(clr1);
                }

                buf[0] = UPPER(buf[0]);
                add_buf(buffer, buf);

                if (number >= MAX_RETURN)
                    break;
            }
        }


        if (number == 0)
            send_to_char("Nothing like that in heaven or earth.\n\r", ch);
        else
            page_to_char(buf_string(buffer), ch);
    }

    free_buf(buffer);
}
Beispiel #26
0
char run()
{
    unsigned long period = (SysCtlClockGet() / multi2hz(interval)) / 2;

    stop();

    led(1,0,0);

    clear_buf();

    if (mode == MODE_INTERVAL)
    {
        ROM_IntEnable(INT_TIMER0A);
        ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, period - 1);
        ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
        ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
 
        if (trigger == TRIGGER_IMMEDIATE)
        {
            ROM_TimerEnable(TIMER0_BASE, TIMER_A);
        }
        else if (trigger == TRIGGER_PIN_RISING)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, trigger_pins, GPIO_RISING_EDGE);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }
        else if (trigger == TRIGGER_PIN_FALLING)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, trigger_pins, GPIO_FALLING_EDGE);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }
        else if (trigger == TRIGGER_PIN_BOTH)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, 1, GPIO_BOTH_EDGES);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }
    }
    else if (mode == MODE_EVENT)
    {
        if (trigger == TRIGGER_PIN_FALLING)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, trigger_pins, GPIO_FALLING_EDGE);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }
        else if (trigger == TRIGGER_PIN_RISING)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, trigger_pins, GPIO_RISING_EDGE);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }
        else if (trigger == TRIGGER_PIN_BOTH)
        {
            ROM_GPIOIntTypeSet(GPIO_PORTB_BASE, trigger_pins, GPIO_BOTH_EDGES);
            ROM_GPIOPinIntClear(GPIO_PORTB_BASE, 0xff);
            ROM_GPIOPinIntEnable(GPIO_PORTB_BASE, trigger_pins);
            ROM_IntEnable(INT_GPIOB);
        }

        HWREG(NVIC_ST_CURRENT) = 0;
    }
    ROM_IntMasterEnable();

    sampling = SAMPLING_ON;

    return STATE_GET_COMMAND;
}
Beispiel #27
0
int main(int argc, char *argv[]) {
    /* Avoid unused parameter warning */
    (void)argv;
    // set scpi lib debug level: 0 for no debug info, 10 for lots

    switch (argc) {
    case 1:
        fputs(
                "\nUsage: stlink-access-test [anything at all] ...\n"
                "\n*** Notice: The stlink firmware violates the USB standard.\n"
                "*** Because we just use libusb, we can just tell the kernel's\n"
                "*** driver to simply ignore the device...\n"
                "*** Unplug the stlink and execute once as root:\n"
                "modprobe -r usb-storage && modprobe usb-storage quirks=483:3744:i\n\n",
                stderr);
        return EXIT_FAILURE;
    default:
        break;
    }

    stlink_t *sl = stlink_v1_open(99, 1);
    if (sl == NULL)
        return EXIT_FAILURE;

    // we are in mass mode, go to swd
    stlink_enter_swd_mode(sl);
    stlink_current_mode(sl);
    stlink_core_id(sl);
    //----------------------------------------------------------------------

    stlink_status(sl);
    //stlink_force_debug(sl);
    stlink_reset(sl);
    stlink_status(sl);
    // core system control block
    stlink_read_mem32(sl, 0xe000ed00, 4);
    DLOG("cpu id base register: SCB_CPUID = got 0x%08x expect 0x411fc231\n", read_uint32(sl->q_buf, 0));
    // no MPU
    stlink_read_mem32(sl, 0xe000ed90, 4);
    DLOG("mpu type register: MPU_TYPER = got 0x%08x expect 0x0\n", read_uint32(sl->q_buf, 0));

#if 0
    stlink_read_mem32(sl, 0xe000edf0, 4);
    DD(sl, "DHCSR = 0x%08x", read_uint32(sl->q_buf, 0));

    stlink_read_mem32(sl, 0x4001100c, 4);
    DD(sl, "GPIOC_ODR = 0x%08x", read_uint32(sl->q_buf, 0));
#endif
#if 0
    // happy new year 2011: let blink all the leds
    // see "RM0041 Reference manual - STM32F100xx advanced ARM-based 32-bit MCUs"

#define GPIOC		0x40011000 // port C
#define GPIOC_CRH	(GPIOC + 0x04) // port configuration register high
#define GPIOC_ODR	(GPIOC + 0x0c) // port output data register
#define LED_BLUE	(1<<8) // pin 8
#define LED_GREEN	(1<<9) // pin 9
    stlink_read_mem32(sl, GPIOC_CRH, 4);
    uint32_t io_conf = read_uint32(sl->q_buf, 0);
    DLOG("GPIOC_CRH = 0x%08x\n", io_conf);

    // set: general purpose output push-pull, output mode, max speed 10 MHz.
    write_uint32(sl->q_buf, 0x44444411);
    stlink_write_mem32(sl, GPIOC_CRH, 4);

    memset(sl->q_buf, 0, sizeof(sl->q_buf));
    for (int i = 0; i < 100; i++) {
        write_uint32(sl->q_buf, LED_BLUE | LED_GREEN);
        stlink_write_mem32(sl, GPIOC_ODR, 4);
        /* stlink_read_mem32(sl, 0x4001100c, 4); */
        /* DD(sl, "GPIOC_ODR = 0x%08x", read_uint32(sl->q_buf, 0)); */
        usleep(100 * 1000);

        memset(sl->q_buf, 0, sizeof(sl->q_buf));
        stlink_write_mem32(sl, GPIOC_ODR, 4); // PC lo
        usleep(100 * 1000);
    }
    write_uint32(sl->q_buf, io_conf); // set old state

#endif
#if 0
    // TODO rtfm: stlink doesn't have flash write routines
    // writing to the flash area confuses the fw for the next read access

    //stlink_read_mem32(sl, 0, 1024*6);
    // flash 0x08000000 128kB
    fputs("++++++++++ read a flash at 0x0800 0000\n", stderr);
    stlink_read_mem32(sl, 0x08000000, 1024 * 6); //max 6kB
    clear_buf(sl);
    stlink_read_mem32(sl, 0x08000c00, 5);
    stlink_read_mem32(sl, 0x08000c00, 4);
    mark_buf(sl);
    stlink_write_mem32(sl, 0x08000c00, 4);
    stlink_read_mem32(sl, 0x08000c00, 256);
    stlink_read_mem32(sl, 0x08000c00, 256);
#endif
#if 0
    // sram 0x20000000 8kB
    fputs("\n++++++++++ read/write 8bit, sram at 0x2000 0000 ++++++++++++++++\n\n", stderr);
    memset(sl->q_buf, 0, sizeof(sl->q_buf));
    mark_buf(sl);
    //stlink_write_mem8(sl, 0x20000000, 16);

    //stlink_write_mem8(sl, 0x20000000, 1);
    //stlink_write_mem8(sl, 0x20000001, 1);
    stlink_write_mem8(sl, 0x2000000b, 3);
    stlink_read_mem32(sl, 0x20000000, 16);
#endif
#if 0
    // a not aligned mem32 access doesn't work indeed
    fputs("\n++++++++++ read/write 32bit, sram at 0x2000 0000 ++++++++++++++++\n\n", stderr);
    memset(sl->q_buf, 0, sizeof(sl->q_buf));
    mark_buf(sl);
    stlink_write_mem32(sl, 0x20000000, 1);
    stlink_read_mem32(sl, 0x20000000, 16);
    mark_buf(sl);
    stlink_write_mem32(sl, 0x20000001, 1);
    stlink_read_mem32(sl, 0x20000000, 16);
    mark_buf(sl);
    stlink_write_mem32(sl, 0x2000000b, 3);
    stlink_read_mem32(sl, 0x20000000, 16);

    mark_buf(sl);
    stlink_write_mem32(sl, 0x20000000, 17);
    stlink_read_mem32(sl, 0x20000000, 32);
#endif
#if 0
    // sram 0x20000000 8kB
    fputs("++++++++++ read/write 32bit, sram at 0x2000 0000 ++++++++++++\n", stderr);
    memset(sl->q_buf, 0, sizeof(sl->q_buf));
    mark_buf(sl);
    stlink_write_mem8(sl, 0x20000000, 64);
    stlink_read_mem32(sl, 0x20000000, 64);

    mark_buf(sl);
    stlink_write_mem32(sl, 0x20000000, 1024 * 8); //8kB
    stlink_read_mem32(sl, 0x20000000, 1024 * 6);
    stlink_read_mem32(sl, 0x20000000 + 1024 * 6, 1024 * 2);
#endif
#if 1
    reg regs;
    stlink_read_all_regs(sl, &regs);
    stlink_step(sl);
    fputs("++++++++++ write r0 = 0x12345678\n", stderr);
    stlink_write_reg(sl, 0x12345678, 0);
    stlink_read_reg(sl, 0, &regs);
    stlink_read_all_regs(sl, &regs);
#endif
#if 0
    stlink_run(sl);
    stlink_status(sl);

    stlink_force_debug(sl);
    stlink_status(sl);
#endif
#if 0 /* read the system bootloader */
    fputs("\n++++++++++ reading bootloader ++++++++++++++++\n\n", stderr);
    stlink_fread(sl, "/tmp/barfoo", sl->sys_base, sl->sys_size);
#endif
#if 0 /* read the flash memory */
    fputs("\n+++++++ read flash memory\n\n", stderr);
    /* mark_buf(sl); */
    stlink_read_mem32(sl, 0x08000000, 4);
#endif
#if 0 /* flash programming */
    fputs("\n+++++++ program flash memory\n\n", stderr);
    stlink_fwrite_flash(sl, "/tmp/foobar", 0x08000000);
#endif
#if 0 /* check file contents */
    fputs("\n+++++++ check flash memory\n\n", stderr);
    {
        const int res = stlink_fcheck_flash(sl, "/tmp/foobar", 0x08000000);
        printf("_____ stlink_fcheck_flash() == %d\n", res);
    }
#endif
#if 0
    fputs("\n+++++++ sram write and execute\n\n", stderr);
    stlink_fwrite_sram(sl, "/tmp/foobar", sl->sram_base);
    stlink_run_at(sl, sl->sram_base);
#endif

#if 0
    stlink_run(sl);
    stlink_status(sl);
    //----------------------------------------------------------------------
    // back to mass mode, just in case ...
    stlink_exit_debug_mode(sl);
    stlink_current_mode(sl);
    stlink_close(sl);
#endif

    //fflush(stderr); fflush(stdout);
    return EXIT_SUCCESS;
}
Beispiel #28
0
void sim900_connect(void)
{
    uint8_t i = 0;
    uint8_t retry = 3;

    printk("connect...\r\n");

    while(1) {
        switch(status) {
            case STATUS_POWERON:
                sim900_poweron();
                clear_rx_buf();

                printk("wait for at done\r\n");
                for(i = 0; i < retry; i++) {
                    sim900_write("AT\r\n", 4);
                    //sim900_wait(5000000);
                    OSTimeDlyHMSM(0, 0, 0, 400);
                    if(!check_at()) {
                        status = STATUS_CONFIG;
                        break;
                    }
                    clear_rx_buf();
                }
                break;

                //case STATUS_INIT:
            case STATUS_CONFIG:
                printk("wait for config done\r\n");
                OSTimeDlyHMSM(0, 0, 10, 0);
                sim900_write("AT+CREG?\r\n", 10);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CIPMODE=1\r\n", 14);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CGATT?\r\n", 11);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CSTT=\"CMNET\"\r\n", 17);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CIICR\r\n", 10);
                OSTimeDlyHMSM(0, 0, 2, 0);
                printk("try to get ip address\r\n");
                sim900_write("AT+CIFSR\r\n", 10);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CGATT=1\r\n", 12);
                OSTimeDlyHMSM(0, 0, 0, 100);
                sim900_write("AT+CGSN\r\n", 9);
                OSTimeDlyHMSM(0, 0, 0, 100);
                status = STATUS_CONNECTING;
                break;
            case STATUS_CONNECTING:
                printk("wait for connecting...\r\n");
                sim900_write("AT+CIPSTATUS\r\n", 14);
                OSTimeDlyHMSM(0, 0, 2, 0);
                for(i = 0; i < 1; i++) {
                    clear_rx_buf();
                    sim900_write(connect_cmd, strlen((char *)&connect_cmd[0]));
                    OSTimeDlyHMSM(0, 0, 3, 0);
                    if(!check_at())  {
                        status = STATUS_CONNECTED;
                        break;
                    }
                    clear_rx_buf();
                }
                if(i >= 1) {		//retry failed
                    sim900_write("+++\r\n", 5);
                    OSTimeDlyHMSM(0, 0, 1, 0);
                    sim900_write("AT+CIPCLOSE\r\n", 13);
                    OSTimeDlyHMSM(0, 0, 1, 0);
                    sim900_write("AT+CIPSHUT\r\n", 12);
                    OSTimeDlyHMSM(0, 0, 1, 0);
                    status = STATUS_CONFIG;
                }
                break;
            case STATUS_CONNECTED:
                printk("Connect done!\r\n");
                clear_buf();
                return;
            default:
                break;
        }
    }
}
Beispiel #29
0
int main(int argc, char *argv[]) {
	// set scpi lib debug level: 0 for no debug info, 10 for lots
	const int scsi_verbose = 2;
	char *dev_name;

	switch (argc) {
	case 1:
		fputs(
			"\nUsage: stlink-access-test /dev/sg0, sg1, ...\n"
				"\n*** Notice: The stlink firmware violates the USB standard.\n"
				"*** If you plug-in the discovery's stlink, wait a several\n"
				"*** minutes to let the kernel driver swallow the broken device.\n"
				"*** Watch:\ntail -f /var/log/messages\n"
				"*** This command sequence can shorten the waiting time and fix some issues.\n"
				"*** Unplug the stlink and execute once as root:\n"
				"modprobe -r usb-storage && modprobe usb-storage quirks=483:3744:lrwsro\n\n",
			stderr);
		return EXIT_FAILURE;
	case 2:
		dev_name = argv[1];
		break;
	default:
		return EXIT_FAILURE;
	}

	fputs("*** stlink access test ***\n", stderr);
	fprintf(stderr, "Using sg_lib %s : scsi_pt %s\n", sg_lib_version(),
		scsi_pt_version());

	stlink_t *sl = stlink_quirk_open(dev_name, scsi_verbose);
	if (sl == NULL)
		return EXIT_FAILURE;

	// we are in mass mode, go to swd
	stlink_enter_swd_mode(sl);
	stlink_current_mode(sl);
	stlink_core_id(sl);
	//----------------------------------------------------------------------

	stlink_status(sl);
	//stlink_force_debug(sl);
	stlink_reset(sl);
	stlink_status(sl);
#if 0
	// core system control block
	stlink_read_mem32(sl, 0xe000ed00, 4);
	DD(sl, "cpu id base register: SCB_CPUID = got 0x%08x expect 0x411fc231", read_uint32(sl->q_buf, 0));
	// no MPU
	stlink_read_mem32(sl, 0xe000ed90, 4);
	DD(sl, "mpu type register: MPU_TYPER = got 0x%08x expect 0x0", read_uint32(sl->q_buf, 0));

	stlink_read_mem32(sl, 0xe000edf0, 4);
	DD(sl, "DHCSR = 0x%08x", read_uint32(sl->q_buf, 0));

	stlink_read_mem32(sl, 0x4001100c, 4);
	DD(sl, "GPIOC_ODR = 0x%08x", read_uint32(sl->q_buf, 0));
#endif
#if 0
	// happy new year 2011: let blink all the leds
	// see "RM0041 Reference manual - STM32F100xx advanced ARM-based 32-bit MCUs"

#define GPIOC		0x40011000 // port C
#define GPIOC_CRH	(GPIOC + 0x04) // port configuration register high
#define GPIOC_ODR	(GPIOC + 0x0c) // port output data register
#define LED_BLUE	(1<<8) // pin 8
#define LED_GREEN	(1<<9) // pin 9
	stlink_read_mem32(sl, GPIOC_CRH, 4);
	uint32_t io_conf = read_uint32(sl->q_buf, 0);
	DD(sl, "GPIOC_CRH = 0x%08x", io_conf);

	// set: general purpose output push-pull, output mode, max speed 10 MHz.
	write_uint32(sl->q_buf, 0x44444411);
	stlink_write_mem32(sl, GPIOC_CRH, 4);

	clear_buf(sl);
	for (int i = 0; i < 100; i++) {
		write_uint32(sl->q_buf, LED_BLUE | LED_GREEN);
		stlink_write_mem32(sl, GPIOC_ODR, 4);
		/* stlink_read_mem32(sl, 0x4001100c, 4); */
		/* DD(sl, "GPIOC_ODR = 0x%08x", read_uint32(sl->q_buf, 0)); */
		delay(100);

		clear_buf(sl);
		stlink_write_mem32(sl, GPIOC_ODR, 4); // PC lo
		delay(100);
	}
	write_uint32(sl->q_buf, io_conf); // set old state

#endif
#if 0
	// TODO rtfm: stlink doesn't have flash write routines
	// writing to the flash area confuses the fw for the next read access

	//stlink_read_mem32(sl, 0, 1024*6);
	// flash 0x08000000 128kB
	fputs("++++++++++ read a flash at 0x0800 0000\n", stderr);
	stlink_read_mem32(sl, 0x08000000, 1024 * 6); //max 6kB
	clear_buf(sl);
	stlink_read_mem32(sl, 0x08000c00, 5);
	stlink_read_mem32(sl, 0x08000c00, 4);
	mark_buf(sl);
	stlink_write_mem32(sl, 0x08000c00, 4);
	stlink_read_mem32(sl, 0x08000c00, 256);
	stlink_read_mem32(sl, 0x08000c00, 256);
#endif
#if 0
	// sram 0x20000000 8kB
	fputs("\n++++++++++ read/write 8bit, sram at 0x2000 0000 ++++++++++++++++\n\n", stderr);
	clear_buf(sl);
	stlink_write_mem8(sl, 0x20000000, 16);

	mark_buf(sl);
	stlink_write_mem8(sl, 0x20000000, 1);
	stlink_write_mem8(sl, 0x20000001, 1);
	stlink_write_mem8(sl, 0x2000000b, 3);
	stlink_read_mem32(sl, 0x20000000, 16);
#endif
#if 0
	// a not aligned mem32 access doesn't work indeed
	fputs("\n++++++++++ read/write 32bit, sram at 0x2000 0000 ++++++++++++++++\n\n", stderr);
	clear_buf(sl);
	stlink_write_mem8(sl, 0x20000000, 32);

	mark_buf(sl);
	stlink_write_mem32(sl, 0x20000000, 1);
	stlink_read_mem32(sl, 0x20000000, 16);
	mark_buf(sl);
	stlink_write_mem32(sl, 0x20000001, 1);
	stlink_read_mem32(sl, 0x20000000, 16);
	mark_buf(sl);
	stlink_write_mem32(sl, 0x2000000b, 3);
	stlink_read_mem32(sl, 0x20000000, 16);

	mark_buf(sl);
	stlink_write_mem32(sl, 0x20000000, 17);
	stlink_read_mem32(sl, 0x20000000, 32);
#endif
#if 0
	// sram 0x20000000 8kB
	fputs("++++++++++ read/write 32bit, sram at 0x2000 0000 ++++++++++++\n", stderr);
	mark_buf(sl);
	stlink_write_mem8(sl, 0x20000000, 64);
	stlink_read_mem32(sl, 0x20000000, 64);

	mark_buf(sl);
	stlink_write_mem32(sl, 0x20000000, 1024 * 8); //8kB
	stlink_read_mem32(sl, 0x20000000, 1024 * 6);
	stlink_read_mem32(sl, 0x20000000 + 1024 * 6, 1024 * 2);
#endif
#if 0
	stlink_read_all_regs(sl);
	stlink_step(sl);
	fputs("++++++++++ write r0 = 0x12345678\n", stderr);
	stlink_write_reg(sl, 0x12345678, 0);
	stlink_read_reg(sl, 0);
	stlink_read_all_regs(sl);
#endif
#if 0
	stlink_run(sl);
	stlink_status(sl);

	stlink_force_debug(sl);
	stlink_status(sl);
#endif
#if 1 /* read the system bootloader */
	fputs("\n++++++++++ reading bootloader ++++++++++++++++\n\n", stderr);
	stlink_fread(sl, "/tmp/barfoo", sl->sys_base, sl->sys_size);
#endif
#if 0 /* read the flash memory */
	fputs("\n+++++++ read flash memory\n\n", stderr);
	/* mark_buf(sl); */
	stlink_read_mem32(sl, 0x08000000, 4);
#endif
#if 0 /* flash programming */
	fputs("\n+++++++ program flash memory\n\n", stderr);
	stlink_fwrite_flash(sl, "/tmp/foobar", 0x08000000);
#endif
#if 0 /* check file contents */
	fputs("\n+++++++ check flash memory\n\n", stderr);
	{
	  const int res = stlink_fcheck_flash(sl, "/tmp/foobar", 0x08000000);
	  printf("_____ stlink_fcheck_flash() == %d\n", res);
	}
#endif
#if 0
	fputs("\n+++++++ sram write and execute\n\n", stderr);
	stlink_fwrite_sram(sl, "/tmp/foobar", sl->sram_base);
	stlink_run_at(sl, sl->sram_base);
#endif

	stlink_run(sl);
	stlink_status(sl);
	//----------------------------------------------------------------------
	// back to mass mode, just in case ...
	stlink_exit_debug_mode(sl);
	stlink_current_mode(sl);
	stlink_close(sl);

	//fflush(stderr); fflush(stdout);
	return EXIT_SUCCESS;
}
void replay(struct char_data *ch) {
    page_to_char(buf_string(ch->pcdata->buffer), ch);
    clear_buf(ch->pcdata->buffer);
    return;
}