C++ set_address函数代码示例

PROCESS_THREAD(snd_process, ev, data){
	static struct etimer et;
	static struct simple_udp_connection broadcast_connection;
	static uip_ipaddr_t mcast_allnodes_address;

PROCESS_BEGIN();
	etimer_set(&et, CLOCK_SECOND*HOW_MUCH_TIME);
	set_address();
	simple_udp_register(&broadcast_connection, UDP_PORT, NULL,UDP_PORT, 		callback_function);
	mcast_allnodes_address=get_multicast_all_nodes_addr();

	while(1){//A broadcast message is sent periodically
		PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et));
		simple_udp_sendto(&broadcast_connection, "Hello", 5, (const 		uip_ipaddr_t*)&mcast_allnodes_address);
		etimer_reset(&et);
		}
	
PROCESS_END();
}

int main ( int argc, char **argv)
{
	struct sockaddr_in peer;
	SOCKET s;

	INIT();

	set_address(argv[1], argv[2], &peer, "upd");
	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (!isvalidsock(s))
		error(1, errno, "error in call socket()");

	if (connect(s, (struct sockaddr *)&peer, sizeof(peer)))
		error (1, errno, "error in call connect");

	udpclient(s, &peer);

	EXIT(0);
}

int LidarLiteI2C::probe()
{
	// cope with both old and new I2C bus address
	const uint8_t addresses[2] = {LL40LS_BASEADDR, LL40LS_BASEADDR_OLD};

	// more retries for detection
	_retries = 10;

	for (uint8_t i = 0; i < sizeof(addresses); i++) {
		uint8_t who_am_i = 0, max_acq_count = 0;

		// set the I2C bus address
		set_address(addresses[i]);

		/* register 2 defaults to 0x80. If this matches it is
		   almost certainly a ll40ls */
		if (read_reg(LL40LS_MAX_ACQ_COUNT_REG, max_acq_count) == OK && max_acq_count == 0x80) {
			// very likely to be a ll40ls. This is the
			// default max acquisition counter
			goto ok;
		}

		if (read_reg(LL40LS_WHO_AM_I_REG, who_am_i) == OK && who_am_i == LL40LS_WHO_AM_I_REG_VAL) {
			// it is responding correctly to a
			// WHO_AM_I. This works with older sensors (pre-production)
			goto ok;
		}

		debug("probe failed reg11=0x%02x reg2=0x%02x\n",
		      (unsigned)who_am_i,
		      (unsigned)max_acq_count);
	}

	// not found on any address
	return -EIO;

ok:
	_retries = 3;

	// reset the sensor to ensure it is in a known state with
	// correct settings
	return reset_sensor();
}

/*
  implement wrapper for PX4 I2C driver
 */
bool PX4_I2C::do_transfer(uint8_t address, const uint8_t *send, uint32_t send_len, uint8_t *recv, uint32_t recv_len)
{
    if (!init_done) {
        init_done = true;
        // we do late init() so we can setup the device paths
        snprintf(devname, sizeof(devname), "AP_I2C_%u", instance);
        snprintf(devpath, sizeof(devpath), "/dev/api2c%u", instance);
        init_ok = (init() == OK);
        if (init_ok) {
            instance++;
        }
    }
    if (!init_ok) {
        return false;
    }
    set_address(address);
    bool ret = (transfer(send, send_len, recv, recv_len) == OK);
    return ret;
}

void Extsram::write_data(uint16_t start_address, uint16_t amount_of_bytes, uint32_t flash_address){
	uint16_t a;
	uint8_t byte;
	data_p_mode = out;
	addr_p_mode = out;
	for(a=0; a<amount_of_bytes; a++){
		set_address(start_address+a);
		byte = pgm_read_byte(Emulator::eeprom1_image_address+a);
		*data_p = byte;
		//_delay_us(20);
		ce = low;
		we = low;
		//_delay_us(20);
		ce = hi;
		we = hi;
		//_delay_us(20);
	}
	default_mode();
	//l.L2 = Leds::off;
}

void Extsram::read_data_and_transmit(uint16_t start_address, uint16_t amount_of_bytes, Bluetooth* bt){
/*
 * reads provided amount of bytes to bt
 */
	uint16_t a;
	uint8_t byte;
	read_sram_mode();
	oe = low;
	for(a=0; a<amount_of_bytes; a++){
		set_address(start_address+a);
		//_delay_us(20);
		ce = low;
		//_delay_us(20);
		byte = *data_v;
		//byte = 'u';
		bt->put_c(byte);
		ce = hi;
	}
	default_mode();
}

/*
创建隧道对象函数
*/
Tunnel *tunnel_new_client (const char *host, int host_port)
{
	
	const char *remote;
	int remote_port;
	Tunnel *tunnel;
	tunnel=(Tunnel *)malloc(sizeof(Tunnel));
	if(tunnel==NULL)
	{
		return NULL;
	}
	tunnel->in_fd=INVALID_SOCKET;
	tunnel->out_fd=INVALID_SOCKET;
	tunnel->server_socket=INVALID_SOCKET;
	tunnel->dest.host_name=host;
	tunnel->dest.host_port=host_port;
	tunnel->dest.user_agent=NULL;
	
	tunnel->content_length=DEFAULT_CONTENT_LENGTH;
	tunnel->buf_ptr=tunnel->buf;
    tunnel->buf_len=0;
	/*
    tunnel->in_total_raw=0;
	tunnel->in_total_data=0;
	tunnel->out_total_raw=0;
	tunnel->out_total_data=0;
	*/
	tunnel->strict_content_length=FALSE;
	tunnel->bytes=0;
	remote=tunnel->dest.host_name;
	remote_port=tunnel->dest.host_port;
	if(set_address(&tunnel->address,remote,remote_port)==-1)
	{
		free(tunnel);
		return NULL;
	}
	//tunnel->keep_alive = DEFAULT_KEEP_ALIVE;
	//tunnel->max_connection_age =  DEFAULT_MAX_CONNECTION_AGE;
	//tunnel->out_connect_time = DEFAULT_OUT_CONNECTION_TIME;
	return tunnel;
}

/* function to merge two empty gaps if they are next to each other. */
void remove_double_gaps(long *memory)
{
	long index;
	index = BLOCK_START;
	while(1)
	{
		if(block_is_used(memory[index]) == 0 && block_is_used(memory[get_index(memory[index])]) == 0)
		{
			memory[index] = set_address(memory[get_index(memory[index])], 0); 
			/* to take care of a removal between to empty gaps. */
			remove_double_gaps(memory);
			break;
		}

		index = get_index(memory[index]);
		if(index >= memory[BLOCK_MAX_INDEX])
		{
			break;
		}
	}
}

/* send general call on I2C bus to syncronise all LEDs */
int
OREOLED::send_general_call()
{
	int ret = -ENODEV;

	/* set I2C address to zero */
	set_address(0);

	/* prepare command : 0x01 = general hardware call, 0x00 = I2C address of master (but we don't act as a slave so set to zero)*/
	uint8_t msg[] = {0x01, 0x00};

	/* send I2C command */
	if (transfer(msg, sizeof(msg), nullptr, 0) == OK) {
		ret = OK;
	}

	/* record time */
	_last_gencall = hrt_absolute_time();

	return ret;
}

int new_tcp_client(const char *host, short port)
{
	int fd;
	struct sockaddr_in address;

	fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd == -1) {
		perror("socket");
		return -1;
	}

	set_address(host, port, &address);

	if (connect(fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
		perror("connect");
		close(fd);
		return -1;
	}

	return fd;
}

int TCPSocketConnection::connect(const char *host, const int port) {
    if (init_socket(SOCK_STREAM, IPPROTO_TCP) < 0) {
        DBG_SOCKET("Failed to create tcp socket");
        return -1;
    }

    if (set_address(host, port) != 0) {
        DBG_SOCKET("Failed to set address (tcp)");
        return -1;
    }

    if (_cc3000_module->_socket.connect(_sock_fd, (const sockaddr *)&_remote_host, sizeof(_remote_host)) < 0) {
        DBG_SOCKET("Failed to connect (tcp)");
        close();
        return -1;
    }

    _is_connected = true;

    return 0;
}

int
MS5611::probe_address(uint8_t address)
{
	uint8_t cmd = ADDR_RESET_CMD;

	/* select the address we are going to try */
	set_address(address);

	/* send reset command */
	if (OK != transfer(&cmd, 1, nullptr, 0))
		return -EIO;

	/* wait for PROM contents to be in the device (2.8 ms) */
	usleep(3000);

	/* read PROM */
	if (OK != read_prom())
		return -EIO;

	return OK;
}

bool CMySocket::ConnectServer()
{
	Close();
	m_bfirstpack = true;
	m_bZlib = false;
	m_zlibIn.Init();
	m_zlibDe.Init();
	m_sRecvBuf.clear();

	struct sockaddr_in peer;
	if (!set_address(m_szdomian, m_port, &peer))
	{
		g_WriteLog.WriteLog(C_LOG_ERROR, "set_address error, domain:%s, port:%hd", m_szdomian, m_port);
		return FALSE;
	}
	SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
	if (s == INVALID_SOCKET)
	{
		int nerrid = WSAGetLastError();
		g_WriteLog.WriteLog(C_LOG_ERROR, "create sock error, errno=%d, %s", errno, FormatLastError(nerrid));
		return FALSE;
	}

	if (connect(s, (struct sockaddr *)&peer, sizeof(peer)))
	{
		int nerrid = WSAGetLastError();
		g_WriteLog.WriteLog(C_LOG_ERROR, "connect to %s:%hu,errno=%d, %s", m_szdomian, m_port, errno, FormatLastError(nerrid));
		closesocket(s);
		s = INVALID_SOCKET;
		return FALSE;
	}

	setNonblock(s);
	setNoDelay(s, true);


	m_hSocket = s; //赋值后导致recv线程开始执行

	return m_hSocket != INVALID_SOCKET;
}

Walker::ApplyStatus dw2wtp_do_while_statement_walker::operator () (SuifObject *x) {
	SuifEnv *env = get_env();
	DoWhileStatement *do_while_stmt = to<DoWhileStatement>(x);

	Expression *do_while_condition = do_while_stmt->get_condition();
	do_while_stmt->set_condition(0);
	Statement *do_while_body = do_while_stmt->get_body();
	do_while_stmt->set_body(0);

	IfStatement *first_iteration = create_if_statement(env, 
						to<Expression>(deep_suif_clone(do_while_condition)), 
						to<Statement>(deep_suif_clone(do_while_body)));
	WhileStatement *remaining_iterations = create_while_statement(env, do_while_condition, do_while_body);

	StatementList *replacement = create_statement_list(env);
	replacement->append_statement(first_iteration);
	replacement->append_statement(remaining_iterations);

	do_while_stmt->get_parent()->replace(do_while_stmt, replacement);
	set_address(replacement);
    	return Walker::Replaced;
}

static void dissect_vektor_igrp (tvbuff_t *tvb, proto_tree *igrp_vektor_tree, guint8 network)
{
  union {
    guint8 addr_bytes[4];
    guint32 addr_word;
  } addr;
  address ip_addr;

  if (network != 0) {
    /*
     * Interior route; network is the high-order byte, and the three
     * bytes in the vector are the lower 3 bytes.
     */
    addr.addr_bytes[0]=network;
    addr.addr_bytes[1]=tvb_get_guint8(tvb,0);
    addr.addr_bytes[2]=tvb_get_guint8(tvb,1);
    addr.addr_bytes[3]=tvb_get_guint8(tvb,2);
  } else {
    /*
     * System or exterior route; the three bytes in the vector are
     * the three high-order bytes, and the low-order byte is 0.
     */
    addr.addr_bytes[0]=tvb_get_guint8(tvb,0);
    addr.addr_bytes[1]=tvb_get_guint8(tvb,1);
    addr.addr_bytes[2]=tvb_get_guint8(tvb,2);
    addr.addr_bytes[3]=0;
  }

  set_address(&ip_addr, AT_IPv4, 4, &addr);
  igrp_vektor_tree = proto_tree_add_subtree_format(igrp_vektor_tree, tvb, 0 ,14,
                                                   ett_igrp_net, NULL, "Entry for network %s", address_to_str(wmem_packet_scope(), &ip_addr));
  proto_tree_add_ipv4(igrp_vektor_tree, hf_igrp_network, tvb, 0, 3, addr.addr_word);
  proto_tree_add_item(igrp_vektor_tree, hf_igrp_delay, tvb, 3, 3, ENC_BIG_ENDIAN);
  proto_tree_add_item(igrp_vektor_tree, hf_igrp_bandwidth, tvb, 6, 3, ENC_BIG_ENDIAN);
  proto_tree_add_uint_format_value(igrp_vektor_tree, hf_igrp_mtu, tvb, 9, 2, tvb_get_ntohs(tvb,9), "%d  bytes", tvb_get_ntohs(tvb,9));
  proto_tree_add_item(igrp_vektor_tree, hf_igrp_reliability, tvb, 11, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(igrp_vektor_tree, hf_igrp_load, tvb, 12, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(igrp_vektor_tree, hf_igrp_hop_count, tvb, 13, 1, ENC_BIG_ENDIAN);
}