Exemple #1
0
static err_t
low_level_output(struct netif *netif, struct pbuf *p)
{
	//struct ethernetif *ethernetif = netif->state;
  /* Interrupts are disabled through this whole thing to support multi-threading
	   transmit calls. Also this function might be called from an ISR. */
	return PacketSend(p);	                // 调用网卡发送函数发送一帧数据
}
Exemple #2
0
void I_NetCmd (void)
{
	if (doomcom.command == CMD_SEND)
	{
		PacketSend ();
	}
	else if (doomcom.command == CMD_GET)
	{
		PacketGet ();
	}
	else
		I_Error ("Bad net cmd: %i\n",doomcom.command);
}
Exemple #3
0
/**************************************************************************//**
 * @brief Request AEM (Advanced Energy Monitoring) voltage from board controller.
 *
 * @note Assumes that BSP_Init() has been called with @ref BSP_INIT_STK_BCUART
  *      bitmask.
 *
 * @return
 *   The voltage. Returns 0.0 on board controller communication
 *   error.
 *****************************************************************************/
float BSP_VoltageGet(void)
{
  STK_Packet pkt;
  float      voltage;

  pkt.type          = STK_PACKETTYPE_VOLTAGE_REQ;
  pkt.payloadLength = 0;

  /* Send Request/Get reply */
  PacketSend(&pkt);
  PacketReceive(&pkt);

  /* Process reply */
  if (pkt.type == STK_PACKETTYPE_VOLTAGE_REPLY)
  {
    memcpy(&voltage, pkt.data, sizeof(float));
    return voltage;
  }
  else
  {
    return (float) 0.0;
  }
}
Exemple #4
0
/**************************************************************************//**
 * @brief Request AEM (Advanced Energy Monitoring) current from board controller.
 *
 * @note Assumes that BSP_Init() has been called with @ref BSP_INIT_STK_BCUART
 *       bitmask.
 *
 * @return
 *   The current expressed in milliamperes. Returns 0.0 on board controller
 *   communication error.
 *****************************************************************************/
float BSP_CurrentGet(void)
{
  STK_Packet pkt;
  float      current;

  pkt.type          = STK_PACKETTYPE_CURRENT_REQ;
  pkt.payloadLength = 0;

  /* Send Request/Get reply */
  PacketSend(&pkt);
  PacketReceive(&pkt);

  /* Process reply */
  if (pkt.type == STK_PACKETTYPE_CURRENT_REPLY)
  {
    memcpy(&current, pkt.data, sizeof(float));
    return current;
  }
  else
  {
    return (float) 0.0;
  }
}
/**
 *  CmdQUpdateAllSends updates the sending of all packets.
 *  Packets that need to be transferred are sent.  Those that don't, don't.
 *  The amount of packets sent depends on the baud rate and the last time
 *  this routine was called.
 *
 *<!-----------------------------------------------------------------------*/
T_void CmdQUpdateAllSends(T_void)
{
    T_byte8 currentCmd;
    T_cmdQPacketStruct *p_packet = NULL;
    T_cmdQPacketStruct *p_next = NULL;
    T_byte8 packetLength;
    T_word32 time;
    T_sword16 status;
    T_word16 bytesused;
    T_word32 maxOutput;
    E_Boolean onceFlag = FALSE;
    E_Boolean sentAny;

    DebugRoutine("CmdQUpdateAllSends") ;

    /* Get the current time. */
    time = TickerGet();

    bytesused = 0;
    maxOutput = 100;
    currentCmd = 0;
    if (bytesused < maxOutput) {
        do {
            sentAny = FALSE;
            p_next = 0;
            p_packet = G_activeCmdQList[currentCmd].first;
            do {
                /* Try sending the command at currentCmd. */
                /* See if there is anything that needs to be sent. */
                if ((p_packet != NULL)
                        && (bytesused < maxOutput)) {
                    DebugCheck(currentCmd < PACKET_COMMAND_UNKNOWN);
                    p_next = p_packet->next;
#ifndef NDEBUG
                    if (strcmp(p_packet->tag, "CmQ") != 0) {
                        printf("Bad packet %p\n", p_packet);
                        DebugCheck(FALSE);
                    }
#endif

                    /* See if it is time to send it. */
                    /** (It's always time to send an ACK.) **/
                    if ((currentCmd == PACKET_COMMAND_ACK)
                            || (p_packet->timeToRetry < time)) {
                        /* Yes, it is time to send it. */
                        packetLength = p_packet->packet.header.packetLength;
                        /* Add the count to the output. */
                        bytesused += packetLength + sizeof(T_packetHeader);

                        /* Make sure this didn't go over the threshold. */
                        if (bytesused >= maxOutput)
                            break;

                        /* Let's send that packet to the given destination. */
                        DirectTalkSetDestination(&p_packet->destination);
                        status =
                                PacketSend(
                                        (T_packetEitherShortOrLong *)(&p_packet->packet));
                        sentAny = TRUE;

#ifdef COMPILE_OPTION_CREATE_PACKET_DATA_FILE
                        fprintf(G_packetFile, "S(%d) cmd=%2d, id=%ld, time=%ld\n", CmdQGetActivePortNum (), p_packet->packet.data[0], p_packet->packet.header.id, SyncTimeGet()); fflush(G_packetFile);
#endif
                        /* Was the packet actually sent? */
                        if (status == 0) {
                            /* Packet was sent correctly (as far as we know). */
                            /* Is this a lossy or lossless command queue? */
                            if ((G_CmdQTypeCommand[currentCmd]
                                    == PACKET_COMMAND_TYPE_LOSSY)
                                    || (DirectTalkIsBroadcastAddress(
                                            &p_packet->destination))) {
                                /* Lossy.  Means we can go ahead and */
                                /* discard this packet. */
                                ICmdQDiscardPacket(currentCmd, p_packet);
                            } else {
                                /* Lossless.  Means we must wait for an ACK */
                                /* packet to confirm that we were sent. */
                                /* Until then, we can't discard the packet. */
                                /* But we might have to resend latter. */
                                /* Set up the retry time. */
                                p_packet->timeToRetry = time
                                        + p_packet->retryTime;
                            }
                        } else {
                            /* Packet was NOT sent correctly. */
                            /** -- IFF the packet is lossless... **/
                            /* We'll have to retry later.  Change the time, */
                            /* but don't remove it from the linked list. */
                            if (G_CmdQTypeCommand[currentCmd]
                                    == PACKET_COMMAND_TYPE_LOSSLESS) {
                                p_packet->timeToRetry = time
                                        + p_packet->retryTime;
                            } else {
                                /* Waste it!  We can't wait around */
                                ICmdQDiscardPacket(currentCmd, p_packet);
                            }
                        }
                    } else {
                        /* Don't loop if it is not time to send. */
                        break;
                    }

                    /** Now, if we aren't checking the ACK queue, we need **/
                    /** to break after the first send.  If we are, we **/
                    /** want to dump everything in the queue. **/
                    if (currentCmd != PACKET_COMMAND_ACK)
                        break;
                }

                // Move to the next packet (if any)
                p_packet = p_next;

                while (!p_packet) {
                    /* Update to the next command. */
                    currentCmd++;
                    if (currentCmd < PACKET_COMMAND_MAX) {
                        // Get the beginning of the list
                        p_packet = G_activeCmdQList[currentCmd].first;
                        if (p_packet)
                            p_next = p_packet->next;
                        else
                            p_next = 0;
                    } else {
                        break;
                    }
                }
            } while (currentCmd < PACKET_COMMAND_MAX);
            // Loop back to the start looking for more to send
            currentCmd = 0;
        } while ((bytesused < maxOutput) && (sentAny == TRUE));
    }

    DebugEnd() ;
}
Exemple #6
0
/*****************************************************************************
 * Entry point
 *****************************************************************************/
int main( int i_argc, char **pp_argv )
{
    int i, c;
    int i_priority = -1;
    int i_ttl = 0;
    struct pollfd *pfd = NULL;
    int i_fd;
    bool b_tcp;

#define ADD_INPUT                                                           \
    p_inputs = realloc( p_inputs, ++i_nb_inputs * sizeof(input_t) );        \
    p_inputs[i_nb_inputs - 1].i_fd = i_fd;                                  \
    p_inputs[i_nb_inputs - 1].b_tcp = b_tcp;                                \
    p_inputs[i_nb_inputs - 1].p_block = NULL;                               \
    pfd = realloc( pfd, i_nb_inputs * sizeof(struct pollfd) );              \
    pfd[i_nb_inputs - 1].fd = i_fd;                                         \
    pfd[i_nb_inputs - 1].events = POLLIN | POLLERR | POLLRDHUP | POLLHUP;

    while ( (c = getopt( i_argc, pp_argv, "i:t:b:g:j:r:n:x:X:Um:R:h" )) != -1 )
    {
        switch ( c )
        {
        case 'i':
            i_priority = strtol( optarg, NULL, 0 );
            break;

        case 't':
            i_ttl = strtol( optarg, NULL, 0 );
            break;

        case 'b':
            i_buffer_length = strtoll( optarg, NULL, 0 ) * 27000;
            break;

        case 'g':
            i_cr_max_gap = strtoll( optarg, NULL, 0 ) * 27000;
            break;

        case 'j':
            i_cr_max_jitter = strtoll( optarg, NULL, 0 ) * 27000;
            break;

        case 'r':
            i_cr_average = strtol( optarg, NULL, 0 );
            break;

        case 'n':
            i_max_retx_burst = strtoul( optarg, NULL, 0 );
            break;

        case 'x':
            i_retx_delay = strtoll( optarg, NULL, 0 ) * 27000;
            break;

        case 'X':
            i_retx_fd = i_fd = OpenSocket( optarg, 0, 0, 0, NULL, &b_tcp, NULL );
            if ( i_fd == -1 )
            {
                msg_Err( NULL, "unable to set up retx with %s\n", optarg );
                exit(EXIT_FAILURE);
            }

            ADD_INPUT
            break;

        case 'U':
            b_udp = 1;
            break;

        case 'm':
            i_asked_payload_size = strtol( optarg, NULL, 0 );
            break;

        case 'R':
            i_rtp_header_size = strtol( optarg, NULL, 0 );
            break;

        case 'h':
        default:
            usage();
            break;
        }
    }
    if ( optind >= i_argc - 1 )
        usage();

    while ( optind < i_argc - 1 )
    {
        i_fd = OpenSocket( pp_argv[optind], 0, DEFAULT_PORT, 0, NULL,
                           &b_tcp, NULL );
        if ( i_fd == -1 )
        {
            msg_Err( NULL, "unable to open input %s\n", pp_argv[optind] );
            exit(EXIT_FAILURE);
        }
        optind++;

        ADD_INPUT
    }
    msg_Dbg( NULL, "%d inputs", i_nb_inputs );

    i_nb_retx = (i_buffer_length - MIN_RETX_DELAY) / i_retx_delay;
    pp_retx = malloc( i_nb_retx * sizeof(block_t *) );
    for ( i = 0; i < i_nb_retx; i++ )
        pp_retx[i] = NULL;
    if ( i_retx_fd && i_nb_retx )
        msg_Dbg( NULL, "%d retx passes", i_nb_retx );

    i_output_fd = OpenSocket( pp_argv[optind], i_ttl, 0, DEFAULT_PORT, NULL,
                              NULL, NULL );
    if ( i_output_fd == -1 )
    {
        msg_Err( NULL, "unable to open output %s\n", pp_argv[optind] );
        exit(EXIT_FAILURE);
    }
    clock_Init();

    if ( i_priority > 0 )
    {
        struct sched_param param;
        int i_error;

        memset( &param, 0, sizeof(struct sched_param) );
        param.sched_priority = i_priority;
        if ( (i_error = pthread_setschedparam( pthread_self(), SCHED_RR,
                                               &param )) )
        {
            msg_Warn( NULL, "couldn't set thread priority: %s",
                      strerror(i_error) );
        }
    }

    for ( ; ; )
    {
        int i_timeout = -1;
        uint64_t i_current_date;

        while ( p_first != NULL
                 && p_first->i_date <= (i_current_date = wall_Date()) + 26999 )
            PacketSend();

        i_current_date = wall_Date();
        RetxCheck( i_current_date );
        i_current_date = wall_Date();

        if ( p_first != NULL )
            i_timeout = (p_first->i_date - i_current_date) / 27000;

        if ( poll( pfd, i_nb_inputs, i_timeout ) < 0 )
        {
            int saved_errno = errno;
            msg_Warn( NULL, "couldn't poll(): %s", strerror(errno) );
            if ( saved_errno == EINTR ) continue;
            exit(EXIT_FAILURE);
        }
        i_current_date = wall_Date();

        for ( i = 0; i < i_nb_inputs; i++ )
        {
            input_t *p_input = &p_inputs[i];

            if ( pfd[i].revents & POLLIN )
            {
                ssize_t i_size = i_asked_payload_size + i_rtp_header_size;
                uint8_t *p_buffer;

                if ( p_input->p_block == NULL )
                {
                    p_input->p_block = malloc( sizeof(block_t) + i_size );
                    p_buffer = p_input->p_block->p_data =
                        (uint8_t *)p_input->p_block + sizeof(block_t);
                    p_input->p_block->i_size = 0;
                }
                else
                {
                    p_buffer = p_input->p_block->p_data +
                               p_input->p_block->i_size;
                    i_size -= p_input->p_block->i_size;
                }

                i_size = read( p_input->i_fd, p_buffer, i_size );
                if ( i_size < 0 && errno != EAGAIN && errno != EINTR &&
                     errno != ECONNREFUSED )
                {
                    msg_Err( NULL, "unrecoverable read error, dying (%s)",
                             strerror(errno) );
                    exit(EXIT_FAILURE);
                }
                if ( i_size <= 0 ) continue;

                p_input->p_block->i_size += i_size;

                if ( p_input->b_tcp &&
                     p_input->p_block->i_size !=
                         i_asked_payload_size + i_rtp_header_size )
                    continue;

                if ( i_retx_fd == -1 || i )
                    PacketRecv( p_input->p_block, i_current_date );
                else
                    PacketRecv( p_input->p_block, 0 );

                p_input->p_block = NULL;
            }
            else if ( pfd[i].revents & (POLLERR | POLLRDHUP | POLLHUP) )
            {
                msg_Err( NULL, "poll error on input %d" );
                exit(EXIT_FAILURE);
            }

        }
    }

    return EXIT_SUCCESS;
}