Beispiel #1
0
static void USARTPutString(BYTE *s)
{
    BYTE c;

    while( (c = *s++) )
        USARTPut(c);
}
Beispiel #2
0
void USARTPutROMString(ROM char* str)
{
    BYTE v;

    while( v = *str++ )
        USARTPut(v);
}
Beispiel #3
0
/*********************************************************************
 * Function:        void SMTPSend(void)
 *
 * PreCondition:    SMTP module is already initialized.
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Triggers sending of mail
 *		    This function must be called when the application
 *		    Wants to send a mail.
 * Note:
 ********************************************************************/
void SMTPSend()
{
   if (smSMTP == SM_SMTP_STDBY) {	// check if standby (do not overtrigger)
      lastActivity = TickGet();					// init delay before sending
      cptretry = NRETRY ;							// retry count
      fsend_mail = TRUE ;						// flag for State machine !
      USARTPut(0xAA) ;
   }
}
Beispiel #4
0
static void ProcessIO(void)
{
	char i;
	char temp_buff[10];
	int read_temp;
	float real_temp,temp_count;

    //Get raw data from DS1820  
    convert(temp_buff);

    //Convert raw data to degree C in accorance with datasheet
	read_temp=((temp_buff[1]<<8) | temp_buff[0]) >> 1;
	temp_count=(float)(temp_buff[7] - temp_buff[6])/(float)temp_buff[7];
	real_temp = ((float)read_temp-0.25)+temp_count;

	sprintf(AN1String,"%2.2f",real_temp);

	USARTPutString((BYTE*)AN1String);
	USARTPut(0x0D);
	USARTPut(0x0a);
	

}
Beispiel #5
0
static void DisplayIPValue(IP_ADDR *IPVal, BOOL bToLCD)
{
    char IPDigit[8];

	#if defined(APP_USE_LCD)
    if ( bToLCD )
    {
        /*
         * Erase second line.
         */
        XLCDGoto(1, 0);
   	    XLCDPutROMString(blankLCDLine);
    }
	#endif

    /*
     * Rewrite the second line.
     */
	#if defined(APP_USE_LCD)
    XLCDGoto(1, 0);
	#endif

    itoa(IPVal->v[0], IPDigit);
	#if defined(APP_USE_LCD)
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }
    else
	#endif
    {
        USARTPutString((BYTE*)IPDigit);
        USARTPut('.');
    }

    itoa(IPVal->v[1], IPDigit);
	#if defined(APP_USE_LCD)
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }
    else
	#endif
    {
        USARTPutString((BYTE*)IPDigit);
        USARTPut('.');
    }

    itoa(IPVal->v[2], IPDigit);
	#if defined(APP_USE_LCD)
    if ( bToLCD )
    {
        XLCDPutString(IPDigit);
        XLCDPut('.');
    }
    else
	#endif
    {
        USARTPutString((BYTE*)IPDigit);
        USARTPut('.');
    }

    itoa(IPVal->v[3], IPDigit);
	#if defined(APP_USE_LCD)
    if ( bToLCD )
        XLCDPutString(IPDigit);
    else
	#endif
	{
        USARTPutString((BYTE*)IPDigit);
	}
}
Beispiel #6
0
/*
 * Main entry point.
 */
void main(void)
{
    static TICK t = 0;
    BYTE c, i;

    /*
     * Initialize any application specific hardware.
     */
    InitializeBoard();

    /*
     * Initialize all stack related components.
     * Following steps must be performed for all applications using
     * PICmicro TCP/IP Stack.
     */
    TickInit();

    /*
     * Following steps must be performed for all applications using
     * PICmicro TCP/IP Stack.
     */
    MPFSInit();


    /*
     * Initialize Stack and application related NV variables.
     */
    InitAppConfig();


    /*
     * Depending on whether internal program memor is used or external
     * EEPROM is used, keep/remove these block.
     */

    /*
     * Wait a couple of seconds for user input.
	 * - If something is detected, start config.
	 * - If nothing detected, start main program.
     */
	USARTPutROMString(PressKeyForConfig);
	for (i = 60; i > 0; --i)	//Delay for 50mS x 60 = 3 sec
	{
		if ((i % 8) == 0) USARTPut('.');
		if (USARTIsGetReady())
		{
			#if defined(APP_USE_LCD)
	       	XLCDGoto(1, 0);
	       	XLCDPutROMString(SetupMsg);
			#endif
	
	        SetConfig();
			break;
		}
		DelayMs(50);
	}
	USARTPut('\r');
	USARTPut('\n');

    StackInit();

#if defined(STACK_USE_HTTP_SERVER)
    HTTPInit();
#endif

#if defined(STACK_USE_FTP_SERVER) && defined(MPFS_USE_EEPROM)
    FTPInit();
#endif


#if defined(STACK_USE_DHCP) || defined(STACK_USE_IP_GLEANING)
    if ( AppConfig.Flags.bIsDHCPEnabled )
    {
		#if defined(APP_USE_LCD)
        XLCDGoto(1, 0);
   	    XLCDPutROMString(DHCPMsg);
		#endif
    }
    else
    {
        /*
         * Force IP address display update.
         */
        myDHCPBindCount = 1;
#if defined(STACK_USE_DHCP)
        DHCPDisable();
#endif
    }
#endif

    /*
     * Once all items are initialized, go into infinite loop and let
     * stack items execute their tasks.
     * If application needs to perform its own task, it should be
     * done at the end of while loop.
     * Note that this is a "co-operative mult-tasking" mechanism
     * where every task performs its tasks (whether all in one shot
     * or part of it) and returns so that other tasks can do their
     * job.
     * If a task needs very long time to do its job, it must broken
     * down into smaller pieces so that other tasks can have CPU time.
     */
    while(1)
    {
        //Turn off the heater after about 1min to prevent over heating
        if(heater_started ==1)
        {
            if ( TickGetDiff(TickGet(), t) >= 9000 )
            {
                LATB4 = 0;
    			heater_started = 0;
            }   
        }else
		{
		    t = TickGet();
		}
         
        /*
         * This task performs normal stack task including checking
         * for incoming packet, type of packet and calling
         * appropriate stack entity to process it.
         */
        StackTask();

#if defined(STACK_USE_HTTP_SERVER)
        /*
         * This is a TCP application.  It listens to TCP port 80
         * with one or more sockets and responds to remote requests.
         */
        HTTPServer();
#endif

#if defined(STACK_USE_FTP_SERVER) && defined(MPFS_USE_EEPROM)
        FTPServer();
#endif

        /*
         * In future, as new TCP/IP applications are written, it
         * will be added here as new tasks.
         */

         /*
          * Add your application speicifc tasks here.
          */
        ProcessIO();

        /*
         * For DHCP information, display how many times we have renewed the IP
         * configuration since last reset.
         */
        if ( DHCPBindCount != myDHCPBindCount )
        {
            DisplayIPValue(&AppConfig.MyIPAddr, TRUE);
            myDHCPBindCount = DHCPBindCount;

			#if defined(APP_USE_LCD)
            if ( AppConfig.Flags.bIsDHCPEnabled )
            {
                XLCDGoto(1, 14);
   	            if ( myDHCPBindCount < 0x0a )
       	            XLCDPut(myDHCPBindCount + '0');
           	    else
               	    XLCDPut(myDHCPBindCount + 'A');
            }
			#endif
        }

    }
}
Beispiel #7
0
static BOOL DownloadMPFS(void)
{
    enum SM_MPFS
    {
        SM_MPFS_SOH,
        SM_MPFS_BLOCK,
        SM_MPFS_BLOCK_CMP,
        SM_MPFS_DATA,
    } state;

    BYTE c;
    MPFS handle;
    BOOL lbDone;
    BYTE blockLen;
    BYTE lResult;
    BYTE tempData[XMODEM_BLOCK_LEN];
    TICK lastTick;
    TICK currentTick;

    state = SM_MPFS_SOH;
    lbDone = FALSE;

    handle = MPFSFormat();

    /*
     * Notify the host that we are ready to receive...
     */
    lastTick = TickGet();
    do
    {
        /*
         * Update tick here too - just in case interrupt is not used.
         */
        TickUpdate();

        currentTick = TickGet();
        if ( TickGetDiff(currentTick, lastTick) >= (TICK_SECOND/2) )
        {
            lastTick = TickGet();
            USARTPut(XMODEM_NAK);

            /*
             * Blink LED to indicate that we are waiting for
             * host to send the file.
             */
            //LATA2 ^= 1;
        }

    } while( !USARTIsGetReady() );


    while(!lbDone)
    {
        /*
         * Update tick here too - just in case interrupt is not used.
         */
        TickUpdate();

        if ( USARTIsGetReady() )
        {
            /*
             * Toggle LED as we receive the data from host.
             */
            //LATA2 ^= 1;
            c = USARTGet();
        }
        else
        {
            /*
             * Real application should put some timeout to make sure
             * that we do not wait forever.
             */
            continue;
        }

        switch(state)
        {
        default:
            if ( c == XMODEM_SOH )
            {
                state = SM_MPFS_BLOCK;
            }
            else if ( c == XMODEM_EOT )
            {
                /*
                 * Turn off LED when we are done.
                 */
                //LATA2 = 1;

                MPFSClose();
                USARTPut(XMODEM_ACK);
                lbDone = TRUE;
            }
            else
                USARTPut(XMODEM_NAK);

            break;

        case SM_MPFS_BLOCK:
            /*
             * We do not use block information.
             */
            lResult = XMODEM_ACK;
            blockLen = 0;
            state = SM_MPFS_BLOCK_CMP;
            break;

        case SM_MPFS_BLOCK_CMP:
            /*
             * We do not use 1's comp. block value.
             */
            state = SM_MPFS_DATA;
            break;

        case SM_MPFS_DATA:
            /*
             * Buffer block data until it is over.
             */
            tempData[blockLen++] = c;
            if ( blockLen > XMODEM_BLOCK_LEN )
            {
                /*
                 * We have one block data.
                 * Write it to EEPROM.
                 */
                MPFSPutBegin(handle);

                lResult = XMODEM_ACK;
                for ( c = 0; c < XMODEM_BLOCK_LEN; c++ )
                    MPFSPut(tempData[c]);

                handle = MPFSPutEnd();

                USARTPut(lResult);
                state = SM_MPFS_SOH;
            }
            break;

        }

    }


/*
 * This small wait is required if SLIP is in use.
 * If this is not used, PC might misinterpret SLIP
 * module communication and never close file transfer
 * dialog box.
 */
#if defined(STACK_USE_SLIP)
    {
        BYTE i;
        i = 255;
        while( i-- );
    }
#endif
    return TRUE;
}
Beispiel #8
0
void ExecuteMenuChoice(MENU_CMD choice)
{
    char response[MAX_USER_RESPONSE_LEN];
    IP_ADDR tempIPValue;
    IP_ADDR *destIPValue;

    USARTPut('\r');
    USARTPut('\n');
    USARTPutROMString(menuCommandPrompt[choice-'0'-1]);

    switch(choice)
    {
    case MENU_CMD_SERIAL_NUMBER:
        itoa(AppConfig.SerialNumber.Val, response);
        USARTPutString((BYTE*)response);
        USARTPut(')');
        USARTPut(':');
        USARTPut(' ');

        if ( USARTGetString(response, sizeof(response)) )
        {
            AppConfig.SerialNumber.Val = atoi(response);

            AppConfig.MyMACAddr.v[4] = AppConfig.SerialNumber.v[1];
            AppConfig.MyMACAddr.v[5] = AppConfig.SerialNumber.v[0];
        }
        else
            goto HandleInvalidInput;

        break;

    case MENU_CMD_IP_ADDRESS:
        destIPValue = &AppConfig.MyIPAddr;
        goto ReadIPConfig;

    case MENU_CMD_GATEWAY_ADDRESS:
        destIPValue = &AppConfig.MyGateway;
        goto ReadIPConfig;

    case MENU_CMD_SUBNET_MASK:
        destIPValue = &AppConfig.MyMask;

    ReadIPConfig:
        DisplayIPValue(destIPValue, FALSE);
        USARTPut(')');
        USARTPut(':');
        USARTPut(' ');

        USARTGetString(response, sizeof(response));

        if ( !StringToIPAddress(response, &tempIPValue) )
        {
HandleInvalidInput:
            USARTPutROMString(InvalidInputMsg);
            while( !USARTIsGetReady() );
            USARTGet();
        }
        else
        {
            destIPValue->Val = tempIPValue.Val;
        }
        break;


    case MENU_CMD_ENABLE_AUTO_CONFIG:
        AppConfig.Flags.bIsDHCPEnabled = TRUE;
        break;

    case MENU_CMD_DISABLE_AUTO_CONFIG:
        AppConfig.Flags.bIsDHCPEnabled = FALSE;
        break;

    case MENU_CMD_DOWNLOAD_MPFS:
#if defined(MPFS_USE_EEPROM)
        DownloadMPFS();
#endif
        break;

    case MENU_CMD_QUIT:
#if defined(MPFS_USE_EEPROM)
        SaveAppConfig();
#endif
        break;
    }
}
Beispiel #9
0
static BOOL PutFile(void)
{
    BYTE v;


    switch(smFTPCommand)
    {
    case SM_FTP_CMD_IDLE:
        if ( !FTPFlags.Bits.bLoggedIn )
        {
            FTPResponse     = FTP_RESP_LOGIN;
            return TRUE;
        }
        else
        {
            FTPResponse     = FTP_RESP_DATA_OPEN;
            FTPDataSocket   = TCPConnect(&REMOTE_HOST(FTPSocket), FTPDataPort.Val);

			// Make sure that a valid socket was available and returned
			// If not, return with an error
			if(FTPDataSocket != INVALID_SOCKET)
			{
	            smFTPCommand = SM_FTP_CMD_WAIT;
			}
			else
			{
	            FTPResponse = FTP_RESP_DATA_NO_SOCKET;
	            return TRUE;
			}
        }
        break;

    case SM_FTP_CMD_WAIT:
        if ( TCPIsConnected(FTPDataSocket) )
        {
#if defined(FTP_PUT_ENABLED)
            if ( !MPFSIsInUse() )
#endif
            {
#if defined(FTP_PUT_ENABLED)
                FTPFileHandle   = MPFSFormat();
#endif

                smFTPCommand    = SM_FTP_CMD_RECEIVE;
            }
        }
        break;

    case SM_FTP_CMD_RECEIVE:
        if ( TCPIsGetReady(FTPDataSocket) )
        {
            // Reload timeout timer.
            lastActivity    = TickGet();
            MPFSPutBegin(FTPFileHandle);
            while( TCPGet(FTPDataSocket, &v) )
            {
                USARTPut(v);

#if defined(FTP_PUT_ENABLED)
                MPFSPut(v);
#endif
            }
            FTPFileHandle = MPFSPutEnd();
            TCPDiscard(FTPDataSocket);

			// Print hash characters on FTP client display
	        if(TCPIsPutReady(FTPSocket))
	        {
				TCPPut(FTPSocket, '#');
				TCPFlush(FTPSocket);
	        }

        }
        else if ( !TCPIsConnected(FTPDataSocket) )
        {
#if defined(FTP_PUT_ENABLED)
            MPFSPutEnd();
            MPFSClose();
#endif
            TCPDisconnect(FTPDataSocket);
            FTPDataSocket   = INVALID_SOCKET;
            FTPResponse     = FTP_RESP_DATA_CLOSE;
            return TRUE;
        }
    }
    return FALSE;
}
Beispiel #10
0
/*********************************************************************
 * Function:        void FTPServer(void)
 *
 * PreCondition:    FTPInit() must already be called.
 *
 * Input:           None
 *
 * Output:          Opened FTP connections are served.
 *
 * Side Effects:    None
 *
 * Overview:
 *
 * Note:            This function acts as a task (similar to one in
 *                  RTOS).  This function performs its task in
 *                  co-operative manner.  Main application must call
 *                  this function repeatdly to ensure all open
 *                  or new connections are served on time.
 ********************************************************************/
BOOL FTPServer(void)
{
    BYTE v;
    TICK currentTick;

    if ( !TCPIsConnected(FTPSocket) )
    {
        FTPStringLen    = 0;
        FTPCommand      = FTP_CMD_NONE;
        smFTP           = SM_FTP_NOT_CONNECTED;
        FTPFlags.Val    = 0;
        smFTPCommand    = SM_FTP_CMD_IDLE;
        return TRUE;
    }

    if ( TCPIsGetReady(FTPSocket) )
    {
        lastActivity    = TickGet();

        while( TCPGet(FTPSocket, &v ) )
        {
            USARTPut(v);
            FTPString[FTPStringLen++]   = v;
            if ( FTPStringLen == MAX_FTP_CMD_STRING_LEN )
                FTPStringLen            = 0;
        }
        TCPDiscard(FTPSocket);


        if ( v == '\n' )
        {
            FTPString[FTPStringLen]     = '\0';
            FTPStringLen                = 0;
            ParseFTPString();
            FTPCommand                  = ParseFTPCommand(FTP_argv[0]);
        }
    }
    else if ( smFTP != SM_FTP_NOT_CONNECTED )
    {
        currentTick = TickGet();
        currentTick = TickGetDiff(currentTick, lastActivity);
        if ( currentTick >= FTP_TIMEOUT )
        {
            lastActivity                = TickGet();
            FTPCommand                  = FTP_CMD_QUIT;
            smFTP                       = SM_FTP_CONNECTED;
        }
    }

    switch(smFTP)
    {
    case SM_FTP_NOT_CONNECTED:
        FTPResponse = FTP_RESP_BANNER;
        lastActivity = TickGet();
        /* No break - Continue... */

    case SM_FTP_RESPOND:
SM_FTP_RESPOND_Label:
        if(!TCPIsPutReady(FTPSocket))
		{
			return TRUE;
		}
		else
		{
			ROM char* pMsg;
			
			pMsg = FTPResponseString[FTPResponse];
			
			while( (v = *pMsg++) )
			{
			    USARTPut(v);
			    TCPPut(FTPSocket, v);
			}
			TCPFlush(FTPSocket);
			FTPResponse = FTP_RESP_NONE;
			smFTP = SM_FTP_CONNECTED;
		}
        // No break - this will speed up little bit

    case SM_FTP_CONNECTED:
        if ( FTPCommand != FTP_CMD_NONE )
        {
            if ( ExecuteFTPCommand(FTPCommand) )
            {
                if ( FTPResponse != FTP_RESP_NONE )
                    smFTP = SM_FTP_RESPOND;
                else if ( FTPCommand == FTP_CMD_QUIT )
                    smFTP = SM_FTP_NOT_CONNECTED;

                FTPCommand = FTP_CMD_NONE;
                smFTPCommand = SM_FTP_CMD_IDLE;
            }
            else if ( FTPResponse != FTP_RESP_NONE )
            {
                smFTP = SM_FTP_RESPOND;
                goto SM_FTP_RESPOND_Label;
            }
        }
        break;


    }

    return TRUE;
}
Beispiel #11
0
/*********************************************************************
 * Function:        void SMTP Client State machine(void)
 *
 * PreCondition:    FTPInit() must already be called.
 *
 * Input:           None
 *
 * Output:          Ready to send mail.
 *
 * Side Effects:    None
 *
 * Overview:
 *
 * Note:            This function acts as a task (similar to one in
 *                  RTOS).  This function performs its task in
 *                  co-operative manner.  Main application must call
 *                  this function repeatedly to ensure it can send
 *                  mails when requested. (include in the main loop)
 ********************************************************************/
void SMTPClient(void)
{
    BYTE v;
//    TICK currentTick;

    // check if state machine is stuck somewhere and reset the SM after a while if needed :
    if ((smSMTP != SM_SMTP_STDBY) && (TickGetDiff(TickGet(), lastActivity) > (15 * TICK_SECOND))) {
        if (TCPIsConnected(SMTPSocket))
           TCPDisconnect(SMTPSocket) ;
        if(cptretry--) {						// if not all retries done...
           lastActivity = TickGet();			// re-init delay
           smSMTP = SM_SMTP_STDBY ;   			// force standby state
        } else {
           fsend_mail = FALSE ;					// give up !
           smSMTP = SM_SMTP_STDBY ;   			// -> standby
        }
    }

    // work each state :
    switch(smSMTP)
    {
    case SM_SMTP_STDBY:		// standby: idle, waiting for connection request
        if (fsend_mail) {
           if (TickGetDiff(TickGet(), lastActivity) > (10 * TICK_SECOND)) {
      USARTPut(0xBB) ;

              lastActivity = TickGet();
              ARPResolve(&nodedist.IPAddr) ;	// resolve IP adress
              smSMTP = SM_SMTP_ARP ;   			// -> wait ARP answer
           }
        }
        break ;

    case SM_SMTP_ARP:		// wait ARP to be resolved
        if ( ARPIsResolved(&nodedist.IPAddr, &nodedist.MACAddr)) {
           SMTPSocket = TCPConnect(&nodedist, SMTP_PORT) ;
           if (SMTPSocket == INVALID_SOCKET) {
              fsend_mail = FALSE ;	       		// avorte
           } else {
              smSMTP = SM_SMTP_CONNECT ;   		// -> attente ACK
           }
        }
        break ;

    case SM_SMTP_CONNECT:		// standby: attente ack connexion
        if (TCPIsConnected(SMTPSocket)) {
           smSMTP = SM_SMTP_WELCOME ;   		// -> attente WELCOME

        }
        break ;

    case SM_SMTP_WELCOME:		// attente welcome du serveur
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket, &v)) {
              if (v == '2') {		// commence par un 2 ? (220..)
                 TCPDiscard(SMTPSocket) ;
                 ExecuteSMTPCommand(SMTP_CMD_HELO) ;
                 smSMTP = SM_SMTP_HELO ;   		// -> attente reponse au HELO
              }else {
              smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;

    case SM_SMTP_HELO:			// attente HELO du serveur
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket,&v)) {
              if (v == '2') {					// commence par un 2 ? (220..)
                 TCPDiscard(SMTPSocket) ;
                 ExecuteSMTPCommand(SMTP_CMD_FROM) ;
                 smSMTP = SM_SMTP_FROM ;   		// -> attente reponse au FROM
              }else {
                 smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;

    case SM_SMTP_FROM:			// attente HELO du serveur
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket,&v)) {
              if (v == '2') {		// commence par un 2 ? (220..)
                 TCPDiscard(SMTPSocket) ;
                 ExecuteSMTPCommand(SMTP_CMD_TO) ;
                 smSMTP = SM_SMTP_TO ;   		// -> attente reponse au TO
              }else {
                 smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;

    case SM_SMTP_TO:			// attente HELO du serveur
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket,&v)) {
              if (v == '2') {					// commence par un 2 ? (220..)
                 TCPDiscard(SMTPSocket) ;
                 ExecuteSMTPCommand(SMTP_CMD_DATA) ;
                 smSMTP = SM_SMTP_DATA1 ;  		// -> attente reponse au DATA
              }else {
                 smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;

    case SM_SMTP_DATA1:			// when OK send message headers
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket,&v)) {
              if (v == '3') {		// commence par un 3 ? (220..)
                 TCPDiscard(SMTPSocket) ;
                 ExecuteSMTPCommand(SMTP_CMD_DATA_HEADERS) ;	// send headers
//                 ExecuteSMTPCommand(SMTP_CMD_DATA_MESSAGE) ; // message
//                 ExecuteSMTPCommand(SMTP_CMD_DATA_END) ;     // termine

                 smSMTP = SM_SMTP_DATA2;   		// -> send body
              }else {
                 smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;

    case SM_SMTP_DATA2:			// wait to send message body
        if (TCPIsPutReady(SMTPSocket)) {				// wait for TX buffer free
           ExecuteSMTPCommand(SMTP_CMD_DATA_MESSAGE) ;	// message
           smSMTP = SM_SMTP_DATA3 ;   		// -> attente reponse au TO
        } else {
//           USARTPut(0xCC) ;		vérifié qu'il y avait bien besoin d'une attente ici

        }
        break ;

    case SM_SMTP_DATA3:			// wait to send the final "."
        if (TCPIsPutReady(SMTPSocket)) {				// wait for TX buffer free
           ExecuteSMTPCommand(SMTP_CMD_DATA_END) ; 		// termine
           smSMTP = SM_SMTP_QUIT ;						// -> end
        }  else {
//            USARTPut(0xDD) ;		vérifié qu'il y avait bien besoin d'une attente ici

        }
        break ;

    case SM_SMTP_QUIT:		// wait last message before leaving...
        if (TCPIsGetReady(SMTPSocket)) {
           if (TCPGet(SMTPSocket,&v)) {
              if (v == '2') {		// commence par un 2 ? (220..)

                 TCPDiscard(SMTPSocket) ;
                 smSMTP = SM_SMTP_DONE ;   		// -> deconnecte
              }else {
                 smSMTP = SM_SMTP_DONE ;   		// -> disconnect
              }
           }
        }
        break ;


    case SM_SMTP_DONE:			// disconnect Socket :
        if (TCPIsConnected(SMTPSocket) && (TCPIsPutReady(SMTPSocket))) { // wait for TX buff free
           TCPDisconnect(SMTPSocket) ;
        }
        fsend_mail = FALSE ;		// done !
        smSMTP = SM_SMTP_STDBY ;   // -> standby
        break ;
    }
}
Beispiel #12
0
/*********************************************************************
 * Function:        void DHCPTask(void)
 *
 * PreCondition:    DHCPInit() is already called AND
 *                  IPGetHeader() is called with
 *                  IPFrameType == IP_PROT_UDP
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Fetches pending UDP packet from MAC receive buffer
 *                  and dispatches it appropriate UDP socket.
 *                  If not UDP socket is matched, UDP packet is
 *                  silently discarded.
 *
 * Note:            Caller must make sure that MAC receive buffer
 *                  access pointer is set to begining of UDP packet.
 *                  Required steps before calling this function is:
 *
 *                  If ( MACIsRxReady() )
 *                  {
 *                      MACGetHeader()
 *                      If MACFrameType == IP
 *                          IPGetHeader()
 *                          if ( IPFrameType == IP_PROT_UDP )
 *                              Call DHCPTask()
 *                  ...
 ********************************************************************/
void DHCPTask(void)
{
    NODE_INFO DHCPServerNode;
    static TICK lastTryTick;
    BYTE DHCPRecvReturnValue;

    switch(smDHCPState)
    {
    case SM_DHCP_INIT:
        DHCPServerNode.MACAddr.v[0] = 0xff;
        DHCPServerNode.MACAddr.v[1] = 0xff;
        DHCPServerNode.MACAddr.v[2] = 0xff;
        DHCPServerNode.MACAddr.v[3] = 0xff;
        DHCPServerNode.MACAddr.v[4] = 0xff;
        DHCPServerNode.MACAddr.v[5] = 0xff;
        DHCPServerNode.IPAddr.Val = 0xffffffff;
        tempIPAddress.Val = 0x0;
        DHCPSocket = UDPOpen(DHCP_CLIENT_PORT,
                             &DHCPServerNode,
                             DHCP_SERVER_PORT);
        lastTryTick = TickGet();
        smDHCPState = SM_DHCP_RESET_WAIT;
        /* No break */

    case SM_DHCP_RESET_WAIT:
        if ( TickGetDiff(TickGet(), lastTryTick) >= (TICK_SECOND/(TICK)5) )
            smDHCPState = SM_DHCP_BROADCAST;
        break;

    case SM_DHCP_BROADCAST:
        /*
         * If we have already obtained some IP address, renew it.
         */
        if ( tempIPAddress.Val != 0x00000 )
        {
            smDHCPState = SM_DHCP_REQUEST;
        }
        else if ( UDPIsPutReady(DHCPSocket) )
        {
            /*
             * To minimize code requirement, user must make sure that
             * above call will be successful by making at least one
             * UDP socket available.
             * Usually this will be the case, given that DHCP will be
             * the first one to use UDP socket.
             *
             * Also, we will not check for transmitter readiness,
             * we assume it to be ready.
             */

            _DHCPSend(DHCP_DISCOVER_MESSAGE);

            // DEBUG
            USARTPut('\n');
            USARTPut('\r');
            USARTPut('D');

            lastTryTick = TickGet();
            smDHCPState = SM_DHCP_DISCOVER;
        }

        break;


    case SM_DHCP_DISCOVER:
        if ( TickGetDiff(TickGet(), lastTryTick) >= DHCP_TIMEOUT )
        {
            smDHCPState = SM_DHCP_BROADCAST;
            //return;
        }

        if ( UDPIsGetReady(DHCPSocket) )
        {
            // DEBUG
            USARTPut('R');

            if ( _DHCPReceive() == DHCP_OFFER_MESSAGE )
            {
                // DEBUG
                USARTPut('O');

                smDHCPState = SM_DHCP_REQUEST;
            }
            else
                break;
        }
        else
            break;



    case SM_DHCP_REQUEST:
        if ( UDPIsPutReady(DHCPSocket) )
        {
            _DHCPSend(DHCP_REQUEST_MESSAGE);

            lastTryTick = TickGet();
            smDHCPState = SM_DHCP_BIND;
        }
        break;

    case SM_DHCP_BIND:
        if ( UDPIsGetReady(DHCPSocket) )
        {
            DHCPRecvReturnValue = _DHCPReceive();
            if ( DHCPRecvReturnValue == DHCP_NAK_MESSAGE )
            {
               // (RSS) NAK recieved.  DHCP server didn't like our DHCP Request format
                USARTPut('n');
                smDHCPState = SM_DHCP_REQUEST;   // Request again
            }
            else if ( DHCPRecvReturnValue == DHCP_ACK_MESSAGE )
            {
                // DEBUG
                USARTPut('B');

                /*
                 * Once DCHP is successful, release the UDP socket
                 * This will ensure that UDP layer discards any further
                 * DHCP related packets.
                 */
                UDPClose(DHCPSocket);
                DHCPSocket = INVALID_UDP_SOCKET;

                lastTryTick = TickGet();
                smDHCPState = SM_DHCP_BOUND;

                MY_IP_BYTE1     = tempIPAddress.v[0];
                MY_IP_BYTE2     = tempIPAddress.v[1];
                MY_IP_BYTE3     = tempIPAddress.v[2];
                MY_IP_BYTE4     = tempIPAddress.v[3];

                MY_MASK_BYTE1   = tempMask.v[0];
                MY_MASK_BYTE2   = tempMask.v[1];
                MY_MASK_BYTE3   = tempMask.v[2];
                MY_MASK_BYTE4   = tempMask.v[3];

                MY_GATE_BYTE1   = tempGateway.v[0];
                MY_GATE_BYTE2   = tempGateway.v[1];
                MY_GATE_BYTE3   = tempGateway.v[2];
                MY_GATE_BYTE4   = tempGateway.v[3];

                DHCPState.bits.bIsBound = TRUE;

                DHCPBindCount++;

                return;
            }
        }
        else if ( TickGetDiff(TickGet(), lastTryTick) >= DHCP_TIMEOUT )
        {
            USARTPut('t');
            smDHCPState = SM_DHCP_BROADCAST;
        }
        break;

    case SM_DHCP_BOUND:
        /*
         * Keep track of how long we use this IP configuration.
         * When lease period expires, renew the configuration.
         */
        if ( TickGetDiff(TickGet(), lastTryTick) >= TICK_SECOND )
        {
            DHCPLeaseTime.Val -= 1;
            if ( DHCPLeaseTime.Val == 0 )
                smDHCPState = SM_DHCP_INIT;
            lastTryTick = TickGet();
        }
    }

}