int mid_tcp( char * ipaddr,int port,char * mgid,char *inbuf,int inlen,char *outbuf,int * outlen)
{
int clientfd;
/*建立连接*/
clientfd = tcp_client_init(ipaddr ,(int ) port);
if (clientfd < 0)
{
printf("tcp_client_init error!\n");
memcpy(mgid,"0001",4);
return(-1);
}
if (writesock(clientfd,inbuf,inlen) != inlen)
{
printf("writesock error!\n");
memcpy(mgid,"0002",4);
tcp_close(clientfd);
return(-2) ;
}
*outlen = readsock(clientfd,outbuf);
if (*outlen < 0)
{
printf("readsock error! return[%d]\n",*outlen);
memcpy(mgid,"0003",4);
tcp_close(clientfd);
return(-3);
}
/*close tcp connect*/
memcpy(mgid,"0000",4);
tcp_close(clientfd);
return(0);
}
int main() {
set_default_logif_level(LOG_WARN);
int n = 1;
evt_pool *pool = evt_pool_init(n);
net_addr addr;
netaddr_init_v4(&addr, "127.0.0.1", 8887);
ohbuffer_unit_objpool *upool[n];
int i;
for (i = 0; i < n; i++) {
upool[i] = (ohbuffer_unit_objpool*)ohmalloc(sizeof(ohbuffer_unit_objpool));
bufunit_pool_init(upool[i], TCPCLIENT_OBJPOOL_BLOCKSZ, OHBUFFER_UNIT_DEFAULT_SIZE + sizeof(ohbuffer_unit));
}
for (i = 0; i < 1000; i++) {
evt_loop *loop = pool->loops[i%n];
tcp_client *client = (tcp_client*)ohmalloc(sizeof(tcp_client));
tcp_client_init(client, &addr, loop, 0, upool[i%n], OHBUFFER_UNITPOOL_NOLOCK);
tcp_connection_set_on_write(client, write_cb);
tcp_connection_set_on_read(client, read_cb);
tcp_connection_set_on_close(client, close_cb);
tcp_connection_set_on_connect(client, connect_cb);
if (tcp_connect(client) < 0) {
log_error("error");
}
}
evt_timer calll;
evt_timer_init(&calll, calll_cb, SECOND(sec), SECOND(sec));
evt_timer_start(pool->loops[0], &calll);
// tcp_server_start(server);
evt_pool_run(pool);
// int i, n = 4;
// evt_pool *pool = evt_pool_init(n);
// tcp_server_hub *serverh = tcp_server_hub_init(&addr, pool, 0);
// tcp_server_hub_set_on_write(serverh, write_cb);
// tcp_server_hub_set_on_read(serverh, read_cb);
// tcp_server_hub_set_on_close(serverh, close_cb);
// tcp_server_hub_set_on_accept(serverh, accept_cb);
// tcp_server_hub_start(serverh);
// evt_timer calll;
// evt_timer_init(&calll, calll_cb, SECOND(sec), SECOND(sec));
// evt_set_data(&calll, serverh);
// evt_timer_start(pool->loops[0], &calll);
// evt_pool_run(pool);
return 0;
}
ssize_t tcp_send(struct tcp_sock *m, const void *data, int size)
{
ssize_t ret = 0;
switch(m->state) {
case TCP_CLIENT_DISCONNECTED:
/* We rate-limit the amount of connect() calls. */
if (alarm_pending(&tcp_connect_alarm)) {
ret = -1;
break;
}
add_alarm(&tcp_connect_alarm, TCP_CONNECT_TIMEOUT, 0);
ret = connect(m->fd, (struct sockaddr *)&m->addr,
m->sockaddr_len);
if (ret == -1) {
if (errno == EINPROGRESS || errno == EALREADY) {
/* connection in progress or already trying. */
m->state = TCP_CLIENT_DISCONNECTED;
} else if (errno == ECONNREFUSED) {
/* connection refused. */
m->state = TCP_CLIENT_DISCONNECTED;
m->stats.error++;
} else {
/* unexpected error, give up. */
m->state = TCP_CLIENT_DISCONNECTED;
m->stats.error++;
}
break;
} else {
/* we got connected :) */
m->state = TCP_CLIENT_CONNECTED;
}
case TCP_CLIENT_CONNECTED:
ret = sendto(m->fd, data, size, 0,
(struct sockaddr *) &m->addr, m->sockaddr_len);
if (ret == -1) {
if (errno == EPIPE || errno == ECONNRESET) {
close(m->fd);
tcp_client_init(m, m->conf);
m->state = TCP_CLIENT_DISCONNECTED;
m->stats.error++;
} else {
m->stats.error++;
return -1;
}
}
}
if (ret >= 0) {
m->stats.bytes += ret;
m->stats.messages++;
}
return ret;
}
/*
* 函数：wifi_handle_event_cb
* 参数：System_Event_t *evt
* 说明：WiFi事件回调
*/
void ICACHE_FLASH_ATTR
wifi_handle_event_cb(System_Event_t *evt)
{
os_printf("event %x\n", evt->event);
switch (evt->event) {
case EVENT_STAMODE_CONNECTED:
os_printf("connect to ssid %s, channel %d\n",
evt->event_info.connected.ssid,
evt->event_info.connected.channel);
break;
case EVENT_STAMODE_DISCONNECTED:
os_printf("disconnect from ssid %s, reason %d\n",
evt->event_info.disconnected.ssid,
evt->event_info.disconnected.reason);
break;
case EVENT_STAMODE_AUTHMODE_CHANGE:
os_printf("mode: %d -> %d\n",
evt->event_info.auth_change.old_mode,
evt->event_info.auth_change.new_mode);
break;
case EVENT_STAMODE_GOT_IP:
os_printf("ip:" IPSTR ",mask:" IPSTR ",gw:" IPSTR,
IP2STR(&evt->event_info.got_ip.ip),
IP2STR(&evt->event_info.got_ip.mask),
IP2STR(&evt->event_info.got_ip.gw));
os_printf("\n");
// TODO:
// WiFi连接后并获取IP后建立TCP连接
tcp_client_init(HOST, PORT);
break;
case EVENT_SOFTAPMODE_STACONNECTED:
os_printf("station: " MACSTR "join, AID = %d\n",
MAC2STR(evt->event_info.sta_connected.mac),
evt->event_info.sta_connected.aid);
break;
case EVENT_SOFTAPMODE_STADISCONNECTED:
os_printf("station: " MACSTR "leave, AID = %d\n",
MAC2STR(evt->event_info.sta_disconnected.mac),
evt->event_info.sta_disconnected.aid);
break;
default:
break;
}
}
void on_accept(tcp_client *client) {
conn_peer *cpeer = (conn_peer*)ohmalloc(sizeof(conn_peer));
tcp_client *rclient = (tcp_client*)ohmalloc(sizeof(tcp_client));
tcp_client_init(rclient, &serv_addr, client->loop_on, 0, NULL, 0);
tcp_connection_set_on_connect(rclient, on_connect);
tcp_connection_set_on_close(rclient, on_close);
tcp_connection_set_on_read(rclient, on_read);
tcp_connect(rclient);
client->data = (void*)cpeer;
rclient->data = (void*)cpeer;
cpeer->conn[0] = client;
cpeer->conn[1] = rclient;
cpeer->status[0] = ON;
cpeer->status[1] = OFF;
}
struct tcp_sock *tcp_client_create(struct tcp_conf *c)
{
struct tcp_sock *m;
m = calloc(sizeof(struct tcp_sock), 1);
if (m == NULL)
return NULL;
m->conf = c;
if (tcp_client_init(m, c) == -1) {
free(m);
return NULL;
}
init_alarm(&tcp_connect_alarm, NULL, tcp_connect_alarm_cb);
return m;
}
DTrack2::DTrack2(
const std::string& server_host, unsigned short server_port, unsigned short data_port,
int data_bufsize, int data_timeout_us, int server_timeout_us
)
{
int err;
unsigned int ip;
d_udpsock = NULL;
d_tcpsock = NULL;
d_udpbuf = NULL;
set_data_noerror();
set_server_noerror();
cmd_storelasterror(NULL);
d_udptimeout_us = data_timeout_us;
d_tcptimeout_us = server_timeout_us;
// creat UDP socket:
d_udpport = data_port;
err = udp_init(&d_udpsock, &d_udpport);
if(err){
d_udpport = 0;
return;
}
// creat UDP buffer:
d_udpbufsize = data_bufsize;
d_udpbuf = (char *)malloc(data_bufsize);
if(!d_udpbuf){
udp_exit(d_udpsock);
d_udpsock = NULL;
d_udpport = 0;
return;
}
// access DTrack2 server:
if(!server_host.empty()){
ip = ip_name2ip(server_host.c_str());
if(ip == 0){ // resolving of hostname was not possible
free(d_udpbuf);
d_udpbuf = NULL;
udp_exit(d_udpsock);
d_udpsock = NULL;
d_udpport = 0;
return;
}
err = tcp_client_init(&d_tcpsock, ip, (server_port == 0) ? DTRACK2_PROT_TCP_PORT : server_port);
if(err){ // no connection to DTrack2 server
free(d_udpbuf);
d_udpbuf = NULL;
udp_exit(d_udpsock);
d_udpsock = NULL;
d_udpport = 0;
return;
}
}
// reset actual DTrack data:
act_framecounter = 0;
act_timestamp = -1;
act_num_body = act_num_flystick = act_num_meatool = act_num_hand = 0;
act_num_marker = 0;
d_message_origin = "";
d_message_status = "";
d_message_framenr = 0;
d_message_errorid = 0;
d_message_msg = "";
}
INT frontend_init()
{
/* hardware initialization */
INT status;
// have readout stop last to ensure it get data from simulator
cm_set_transition_sequence ( TR_STOP, 501);
//initialize AMC13 RHF
disableLogging();//disable uHal logging
// initalize amc13 settings from ODB
std::cout << "about to do amc13_ODB_init()\n";
if ( amc13_ODB_init() != SUCCESS )
{
return FE_ERR_ODB;
}
std::cout << "finished amc13_ODB_init()\n";
if( ! amc13_settings_odb.simulate_data){
//int serialNo =1;
//int serialNo =33;
//int slot = 13;
//int usingControlHub= 0;
//std::string T2ip = "192.168.1.188";
//std::string T1ip = "192.168.1.189";
//std::string addrTab1="/home/daq/DAQ/amc13/map/AMC13_AddressTable_S6.xml";
//std::string addrTab2="/home/daq/DAQ/amc13/map/AMC13_AddressTable_K7.xml";
int serialNo = amc13_amc13_odb.serialNo;
int slot = amc13_amc13_odb.slot;
int usingControlHub = amc13_amc13_odb.usingControlHub;
std::string T2ip = amc13_amc13_odb.T2ip;
std::string T1ip = amc13_amc13_odb.T1ip;
std::string addrTab1 = amc13_amc13_odb.addrTab1;
std::string addrTab2 = amc13_amc13_odb.addrTab2;
//std::string addrTab2 = "/home/gohn/gm2daq/amc13/map/AMC13_AddressTable_K7.xml";
std::cout <<std::endl<< "AMC13 settings from ODB\n";
std::cout << serialNo<< " "<<slot<<" "<<usingControlHub<<" "<<T2ip<<" "<<T1ip<<std::endl;
std::cout << addrTab1 << std::endl;
std::cout << addrTab2 << std::endl<<std::endl;
Aeo = new AMC13_env(&Auo, serialNo, slot, usingControlHub);
std::cout << "Setting IP addresses ... ";
Aeo->setIPAddresses(T2ip,T1ip);
std::cout << "Setting address tables ... ";
Aeo->setAddressTables(addrTab1,addrTab2);
std::cout << "... new cms::AMC13 ...\n";
amc13 = new cms::AMC13(Aeo);
int riders_enabled = channel_calc();
std::cout << "Channels read " << std::hex<<riders_enabled<<std::endl;
int setup_stat;
if(amc13_amc13_odb.enableSoftwareTrigger) AMC13_FAKE_DATA = TRUE;
else AMC13_FAKE_DATA = FALSE;
// this configures registers in the rider
if(!AMC13_FAKE_DATA ) frontend_init_wfd();
// this configures registers in the amc13
amc13lib.AMC13_rg(amc13);//general reset of both chips
if(AMC13_FAKE_DATA) setup_stat = amc13lib.AMC13_FD_Setup(amc13);
else setup_stat = amc13lib.AMC13_Rider_Setup(amc13,riders_enabled);
printf(" AMC13 Setup commands issued \n");
if (setup_stat==0){
printf("STOP! AMC13 setup failed!\n");
return FE_ERR_HW;
}
}
// initalize TCP settings from ODB
if ( amc13simulator_ODB_get() != SUCCESS )
{
return FE_ERR_ODB;
}
// MIDAS thread lock
pthread_mutex_lock( &mutex_midas );
// create/initialize TCP calo readout (TCP client)
status = tcp_client_init();
if ( status != 0 )
{
cm_msg(MERROR, __FILE__, "TCP initialization failed, err = %i", status);
return FE_ERR_HW;
}
dbprintf("%s(%d): TCP initialization done \n", __func__, __LINE__);
// create/initialize GPU thread
if ( gpu_thread_init() != 0 )
{
cm_msg(MERROR, __FILE__, "Cannot start gpu thread");
return FE_ERR_HW;
}
dbprintf("%s(%d): GPU initialization done \n", __func__, __LINE__);
// create/initialize parallel port communications
#ifdef USE_PARALLEL_PORT
printf("initialize parallel port address 0x%08x\n", pp_addr);
if ( ioperm(pp_addr,1,1) != 0 )
{
cm_msg(MERROR, __FILE__, "Cannot connect to parallel port");
return FE_ERR_HW;
}
#endif
// create/initialize RPC communications
status = frontend_rpc_init();
if ( status != SUCCESS )
{
cm_msg(MERROR, __FILE__, "RPC initialization failed, err = %i", status);
return FE_ERR_HW;
}
dbprintf("%s(%d): RPC initialization done \n", __func__, __LINE__);
return SUCCESS;
}
