main.cpp

00001 /*
00002  * FreeModbus Libary: BARE Demo Application
00003  * Copyright (C) 2006 Christian Walter <wolti@sil.at>
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00018  *
00019  * File: $Id: demo.c,v 1.1 2006/08/22 21:35:13 wolti Exp $
00020  */
00021 
00022 /* ----------------------- System includes --------------------------------*/
00023 
00024 /* ----------------------- Modbus includes ----------------------------------*/
00025 #include "mbed.h"
00026 #include "EthernetInterface.h"
00027 #include "mb.h"
00028 #include "mbport.h"
00029 
00030 /* ----------------------- Defines ------------------------------------------*/
00031 #define REG_INPUT_START 1
00032 #define REG_INPUT_NREGS 20
00033 #define SLAVE_ID 0x00
00034 
00035 /* ----------------------- Static variables ---------------------------------*/
00036 static USHORT   usRegInputStart = REG_INPUT_START;
00037 static USHORT   usRegInputBuf[REG_INPUT_NREGS];
00038 
00039 /* ----------------------- Start implementation -----------------------------*/
00040 
00041 Ticker flipper; 
00042 Serial le_pc(SERIAL_TX, SERIAL_RX);
00043 Serial RS485(D1, D0);
00044 DigitalIn mybutton(USER_BUTTON);
00045 DigitalOut myled(LED1);
00046 DigitalOut myled2(LED2);
00047 DigitalOut myled3(LED3);
00048 
00049 int i=0;
00050 int timer=0;
00051 char new_adr[13]="#adrADR000\r";
00052 
00053 void flip1()
00054 {
00055     le_pc.printf("\n\ri=%i\n\r",i);
00056     RS485.puts("#???ADR\r");
00057     le_pc.puts("#???ADR\r");
00058     if(i!=0) i=0;
00059     timer++;
00060     myled3=!myled3;
00061 }
00062 
00063 void flip2()
00064 {
00065     le_pc.printf("\n\ri=%i\n\r",i);
00066     RS485.printf("%s",&new_adr[0]);
00067     le_pc.printf("%s",&new_adr[0]);
00068     if(i!=0) i=0;
00069     timer++;
00070     myled=!myled;
00071 }
00072  
00073 void flip3()
00074 {
00075     RS485.puts("#000STA\r"); 
00076     le_pc.printf("i=%i\n\r",i);
00077     if(i!=0) i=0;
00078     myled2=!myled2;
00079 }  
00080 
00081 
00082 int
00083 main( void )
00084 {
00085     uint32_t var;
00086     unsigned short var_bon;
00087     
00088     char buffer[150];
00089     RS485.baud(9600);
00090     RS485.format(8,SerialBase::None,1);
00091     printf("START OF THE TESTS\n");
00092     eMBErrorCode    eStatus; 
00093     EthernetInterface eth;
00094     //eth.set_network("169.254.178.1","255.255.0.0","169.254.178.3");
00095     eth.set_network("10.64.123.43","255.255.252.0","10.64.123.254");
00096     eth.connect();
00097     printf("IP address is '%s'\n", eth.get_ip_address());
00098     printf("MAC address is '%s'\n", eth.get_mac_address());
00099     flipper.attach(&flip1, 0.5);
00100     
00101     while( timer<3 )
00102     {
00103         while(RS485.readable())
00104         {
00105             buffer[i++]=RS485.getc();
00106         }
00107         if(i>=7)
00108         {
00109             i=0;
00110             buffer[7]='\0';
00111             le_pc.printf("%s",buffer);
00112         }
00113     }
00114     flipper.detach();
00115     
00116     new_adr[1]=buffer[1];
00117     new_adr[2]=buffer[2];
00118     new_adr[3]=buffer[3];
00119     timer=0;
00120     
00121     flipper.attach(&flip2, 0.5);
00122     
00123     while( timer<3 )
00124     {
00125         while(RS485.readable())
00126         {
00127             buffer[i++]=RS485.getc();
00128         }
00129         if(i>=7)
00130         {
00131             i=0;
00132             buffer[7]='\0';
00133             le_pc.printf("%s",buffer);
00134         }
00135     }
00136     flipper.detach();
00137     
00138     i=0;   
00139     
00140     /* inicializacion del Stack de Modbus */
00141     eMBTCPInit(502);
00142     
00143     /* Enable the Modbus Protocol Stack. */
00144     eStatus = eMBEnable(  );
00145     myled2=1;      
00146 
00147     flipper.attach(&flip3, 2.0);
00148     
00149     myled=1;
00150     
00151     while(1)
00152     {
00153         while(RS485.readable())
00154         {
00155             buffer[i++]=RS485.getc();
00156         }
00157         if(i>=56)
00158         {
00159             i=0;
00160             if( buffer[54]>=48 && buffer[54]<=58) buffer[55]='\0';
00161             else if( buffer[53]>=48 && buffer[53]<=58 )buffer[54]='\0';
00162             else buffer[53]='\0';
00163             le_pc.printf("%s",buffer);
00164             
00165             //Adresse Pompe
00166             usRegInputBuf[1] = (buffer[1]-48)*100 + (buffer[2]-48)*10 + (buffer[3]-48);
00167             
00168             //Infos diverses
00169             usRegInputBuf[2] = buffer[7]-48; // 1 -> Pompe en marche / 0 -> Arretee
00170             usRegInputBuf[3] = buffer[8]-48; // 1 -> Vitesse Standby / 0 -> Vitesse nominale
00171             usRegInputBuf[4] = buffer[9]-48; // 1 -> Mode Standby / 0 -> Autre
00172             
00173             usRegInputBuf[5] = buffer[12]-48; // 1 -> Transistor de puissance non commandes / 0 ->sinon
00174             usRegInputBuf[6] = buffer[13]-48; // 1 -> Temperature moteur elevee
00175             usRegInputBuf[7] = buffer[14]-48; // 1 -> Courant moteur important
00176             
00177             //Vitesse en tr/min en consigne
00178             var = (buffer[26]-48)*10000 + (buffer[27]-48)*1000 + (buffer[28]-48)*100 + (buffer[29]-48)*10 + (buffer[30]-48) ;
00179             var_bon = var>>16;
00180             usRegInputBuf[8] = var_bon;
00181             usRegInputBuf[9] = (unsigned short) var;
00182             
00183             //Puissance Pompe
00184             usRegInputBuf[10] = (buffer[32]-48)*1000 + (buffer[33]-48)*100 + (buffer[34]-48)*10 + (buffer[35]-48) ;
00185             
00186             //Temperature Pompe
00187             usRegInputBuf[11] = (buffer[41]-48)*100 + (buffer[42]-48)*10 + buffer[43]-48 ;
00188             
00189             //Temps de fonctionnement Pompe
00190             if( buffer[53]=='\0')
00191             {
00192                 usRegInputBuf[12] = 0;
00193                 usRegInputBuf[13] = (buffer[49]-48)*1000 + (buffer[50]-48)*100 + (buffer[51]-48)*10 + buffer[52]-48 ;;    
00194             }
00195             else if( buffer[54]=='\0' ){
00196                 var = (buffer[49]-48)*10000 + (buffer[50]-48)*1000 + (buffer[51]-48)*100 + (buffer[52]-48)*10 + (buffer[53]-48);
00197                 var_bon = var>>16;
00198                 usRegInputBuf[12] = var_bon;
00199                 usRegInputBuf[13] = (unsigned short) var;
00200             }
00201             else{
00202                 var = (buffer[49]-48)*100000 + (buffer[50]-48)*10000 + (buffer[51]-48)*1000 + (buffer[52]-48)*100 + (buffer[53]-48)*10 + (buffer[54]-48)*1;
00203                 var_bon = var>>16;
00204                 usRegInputBuf[12] = var_bon;
00205                 usRegInputBuf[13] = (unsigned short) var;
00206             }
00207         }
00208         
00209         /* Here we simply count the number of poll cycles. */
00210         ( void )eMBPoll(  );
00211         //usRegInputBuf[0]++;
00212     }
00213 }
00214 
00215 eMBErrorCode
00216 eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
00217 {
00218     eMBErrorCode    eStatus = MB_ENOERR ;
00219     int             iRegIndex;
00220 
00221     if( ( usAddress >= REG_INPUT_START )
00222         && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
00223     {
00224         iRegIndex = ( int )( usAddress - usRegInputStart );
00225         while( usNRegs > 0 )
00226         {
00227             *pucRegBuffer++ =
00228                 ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
00229             *pucRegBuffer++ =
00230                 ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
00231             iRegIndex++;
00232             usNRegs--;
00233         }
00234     }
00235     else
00236     {
00237         eStatus = MB_ENOREG ;
00238     }
00239 
00240     return eStatus;
00241 }
00242 
00243 eMBErrorCode
00244 eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
00245 {
00246     eMBErrorCode    eStatus = MB_ENOERR ;
00247     int             iRegIndex;
00248 
00249     if (eMode == MB_REG_READ )
00250     {
00251         if( ( usAddress >= REG_INPUT_START )
00252             && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
00253         {
00254             iRegIndex = ( int )( usAddress - usRegInputStart );
00255             while( usNRegs > 0 )
00256             {
00257                 *pucRegBuffer++ =
00258                     ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
00259                 *pucRegBuffer++ =
00260                     ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
00261                 iRegIndex++;
00262                 usNRegs--;
00263             }
00264         }
00265     }
00266 
00267     if (eMode == MB_REG_WRITE )
00268     {
00269         if( ( usAddress >= REG_INPUT_START )
00270             && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
00271         {
00272             iRegIndex = ( int )( usAddress - usRegInputStart );
00273             while( usNRegs > 0 )
00274             {
00275                 usRegInputBuf[iRegIndex] =  ((unsigned int) *pucRegBuffer << 8) | ((unsigned int) *(pucRegBuffer+1));
00276                 pucRegBuffer+=2;
00277                 iRegIndex++;
00278                 usNRegs--;
00279             }
00280         }
00281     }
00282 
00283     return eStatus;
00284 }
00285 
00286 
00287 eMBErrorCode
00288 eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
00289                eMBRegisterMode eMode )
00290 {
00291     return MB_ENOREG ;
00292 }
00293 
00294 eMBErrorCode
00295 eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
00296 {
00297     return MB_ENOREG ;
00298 }
00299