Pages

Wednesday, 25 February 2015

GPS Uno Shield


OVERVIEW:
  
To make the GPS module easily to compatible with the existent shield , we use the same pin packaging as XBee wireless module.So you can put the GPS module into the existent shield which compatible with XBee.Arduino Xbee Adapter Development Board allows an Arduino board to communicate wirelessly using  XBEE.




FEATURES OF PRODUCT:

  • 33 tracking/ 99 acquisition-channel GPS receiver.
  • Supports QZSS, SBAS(WAAS, EGNOS, MSAS, GAGAN*) ranging.
  • Ultra-High Sensitivity: -165dBm.
  • High Update Rate: up to 10Hz(: SBAS can only be enabled when update rate is equal or less than to 5Hz.).
  • 12 multi-tone active interference canceller(Some features need special firmware or command programmed by customer please refer to “PMTK Command List”)
  • High accuracy 1-PPS timing support for Timing Applications (±10ns RMS jitter).
  • Mounts directly onto your Arduinos
  • Reset button brought out.
  • High quality PCB FR4 Grade with FPT Certified. 

For More Sample Codes And Schematic: CLICK HERE

LM2576S BUCK DC-DC voltage power supply module Constant 5V

 
PRODUCT IMAGE:



FEATURES OF PRODUCT:

  • LM2576S DC - DC step-down module.
  • The input voltage: 7 V ~ 35 V.
  • The output voltage: 5V
  • The output current: 3 A (Max).
  • Conversion efficiency :92% (the highest).
  • The output ripple : < 30 mv.
  • Switching frequency: 52 kHz .
  • Working temperature: - 45 ~ + 85
For More Sample Codes And Schematic: CLICK HERE

LM2576S BUCK DC-DC voltage power supply module

      
PRODUCT IMAGE:



FEATURES OF PRODUCT:


  • LM2576S DC - DC step-down module.
  • The input voltage: 3.5 V ~ 35 V.
  • The output voltage: 35 V ~ 1.25 V
  • The output current: 3 A (Max).
  • Conversion efficiency :92% (the highest).
  • The output ripple : < 30 mv.
  • Switching frequency: 52 kHz .
  • Working temperature: - 45 ~ + 85
For More Sample Codes and Schematic: CLICK HERE
 

GPS Receiver PA6E-CAM with GPS Antenna

OVERVIEW:

GPS module from GlobalTop: PA6E-CAM, based on MediaTek MT3333 chipset. Possibility of using both systems improves position accuracy and shortens cold start time, especially in difficult satellite signal conditions.
Module is pin-to-pin and functionally compatible to older PA6E module based on MT3329 chipset. Thus it is possible simple migration to this module without changing of printed boards.

 
 



FEATURES OF PRODUCT:

  • 33 tracking/ 99 acquisition-channel GPS receiver.
  • Supports QZSS, SBAS(WAAS, EGNOS, MSAS, GAGAN*) ranging.
  • Ultra-High Sensitivity: -165dBm.
  • High Update Rate: up to 10Hz(: SBAS can only be enabled when update rate is equal or less than to 5Hz.).
  • 12 multi-tone active interference canceller(Some features need special firmware or command programmed by customer please refer to “PMTK Command List”)
  • High accuracy 1-PPS timing support for Timing Applications (±10ns RMS jitter).
  • AGPS Support for Fast TTFF.

APPLICATION:

  • Handheld Device
  • PLB
  • M2M application
  • Asset management
  • Surveillance.

For More Sample Codes and Schematics: CLICK HERE

Tuesday, 17 February 2015

Integrating PHP with Embedded System : Chapter -8


3. With Pic 16F877A

 

PIN CONNECTION

code

/*
 * Project Name:
     httpserver_example (Ethernet Library http server demo for ENC28J60 mcu)
 * Copyright:
     (c) Mikroelektronika, 2005-2010.
 * Revision History:
     2007/12/10:
       - initial release; Author: Bruno Gavand.
     2010/12/20:
       - modified for PRO compilers (FJ);
     2012/10/19:
     Modifier pour usage personnel

* description  :
 *      this code shows how to use the Spi_Ethernet mini library :
 *              the board will reply to ARP & ICMP echo requests
 *              the board will reply to HTTP requests on port 80, GET method with pathnames :
 *                      /               will return the HTML main page
 *                      /s              will return board status as text string
 *                      /t0 ... /t7     will toggle PD0 to PD7 bit and return HTML main page
 *                      all other requests return also HTML main page
 * Test configuration:
     MCU:                 PIC16F877A
                          http://ww1.microchip.com/downloads/en/DeviceDoc/41291D.pdf

     Dev.Board:           PIC-Ready1
                          http://www.mikroe.com/products/view/177/pic-ready-prototype-board/
                          http://www.mikroe.com/products/view/305/pic-ready1-board/

     Oscillator:          External Clock 8.0000 MHz
     Ext. Modules:        ac:Serial_Ethernet_board
                          http://www.mikroe.com/eng/products/view/14/serial-ethernet-board/

     SW:                  mikroC PRO for PIC

                          http://www.mikroe.com/en/compilers/mikroc/pro/pic/
 * NOTES:
     - Connect Serial Ethernet Board on PortC (Board and MCU Specific)
     - Since the ENC28J60 doesn't support auto-negotiation, full-duplex mode is
       not compatible with most switches/routers.  If a dedicated network is used
       where the duplex of the remote node can be manually configured, you may
       change this configuration.  Otherwise, half duplex should always be used.
     - External power supply should be used due to Serial Ethernet Board power consumption.
 */
/*
Pour voir l'états des variables tapper : 192.168.0.170/s

Pour faire une commande d'interrupteur faire :
192.168.0.170/dXo ouvre(OFF)
192.168.0.170/dXf ferme(ON)

avec X pour valeur : 0 a 7
*/
// duplex config flags
#define Spi_Ethernet_HALFDUPLEX     0x00  // half duplex
#define Spi_Ethernet_FULLDUPLEX     0x01  // full duplex

// mE ehternet NIC pinout
sfr sbit SPI_Ethernet_Rst at RC0_bit;
sfr sbit SPI_Ethernet_CS  at RC1_bit;
sfr sbit SPI_Ethernet_Rst_Direction at TRISC0_bit;
sfr sbit SPI_Ethernet_CS_Direction  at TRISC1_bit;
// end ethernet NIC definitions

typedef struct
{
  unsigned canCloseTCP: 1;  // flag which closes TCP socket (not relevant to UDP)
  unsigned isBroadcast: 1;  // flag which denotes that the IP package has been received via subnet broadcast address (not used for PIC16 family)
} TEthPktFlags;

/************************************************************
 * ROM constant strings
 */
const unsigned char httpHeader[] = "HTTP/1.1 200 OK\nContent-type: " ;  // HTTP header
const unsigned char httpMimeTypeHTML[] = "text/html\n\n" ;              // HTML MIME type
const unsigned char httpMimeTypeScript[] = "text/plain\n\n" ;           // TEXT MIME type
unsigned char httpMethod[] = "GET /";
/*
 * web page, splited into 2 parts :
 * when coming short of ROM, fragmented data is handled more efficiently by linker
 *
 * this HTML page calls the boards to get its status, and builds itself with javascript
 */
 //*************************************************************************
 // Change the IP address of the page to be refreshed

const char *indexPageHEAD = "<meta http-equiv='refresh' content='10;url=http://192.168.1.15/'>\
<HTML><HEAD></HEAD><BODY>\
<h1>RESEARCH DESIGN LAB,<p></h1>\
<p><a href=\"http://olivier.fournet.free.fr/e.html\">NOTICE</a><p>\
<p><a href=/>Reload</a><p>\
<script src=/s></script>";

const char *indexPageBODY =  "<table><tr><td valign=top><table border=1 style='font-size:20px; font-family: terminal;'>\
<tr><th colspan=2>ADC</th></tr>\
<tr><td>AN2</td><td><script>document.write(AN2);</script></td></tr>\

<tr><td>AN3</td><td><script>document.write(AN3);</script></td></tr>\
</table></td><td><table border=1 style='font-size:20px; font-family: terminal;'>\
<tr><th colspan=2>PORTB (IN) : <script>document.write(PORTB);</script></th></tr>\
<script>\
var str,i;\
str='';\
for(i=0;i<8;i++)\
{\
str+='<tr><td bgcolor=#cccccc>BUTTON #'+i+'</td>';\
if(PORTB&(1<<i))\
{str+='<td bgcolor=green>ON';}\
else\
{str+='<td bgcolor=red>OFF';}\
str+='</td></tr>';}\
document.write(str);\
</script>";

const char *indexPageBODY2 =  "</table></td><td>\
<table border=1 style='font-size:20px; font-family: terminal;'>\
<tr><th colspan=3>PORTD (OUT) : <script>document.write(PORTD);</script></th></tr>\
<script>\
var str,i;\
str='';\
for(i=0;i<8;i++)\
{\
str+='<tr><td bgcolor=#cccccc>LED #'+i+'</td>';\
if(PORTD&(1<<i))\
{\
str+='<td bgcolor=yellow>ON';\
}\
else\
{\
str+='<td bgcolor=#999999>OFF';\
}\
str+='</td></tr>';}\
document.write(str);\
</script>\
</table></td></tr></table>\
<p>This is HTTP request #<script>document.write(REQ)</script><p>\
</BODY></HTML>";

//*************************************************************************


/***********************************
 * RAM variables
 */
unsigned char   myMacAddr[6] = {0x54, 0x55, 0x58, 0x10, 0x00, 0x24};   // my MAC address
unsigned char   myIpAddr[4]  = {192, 168, 1, 15};                     // my IP address
unsigned char   getRequest[15];                                        // HTTP request buffer
unsigned char   get_Request, digit_getRequest, etat_interrupteur;
unsigned char   dyna[30];                                              // buffer for dynamic response
unsigned long   httpCounter = 0;                                       // counter of HTTP requests

/*******************************************
 * functions
 */

/*
 * put the constant string pointed to by s to the ENC transmit buffer.
 */
/*unsigned int    putConstString(const char *s)
        {
        unsigned int ctr = 0 ;

        while(*s)
                {
                Spi_Ethernet_putByte(*s++) ;
                ctr++ ;
                }
        return(ctr) ;
        }*/
/*
 * it will be much faster to use library Spi_Ethernet_putConstString routine
 * instead of putConstString routine above. However, the code will be a little
 * bit bigger. User should choose between size and speed and pick the implementation that
 * suites him best. If you choose to go with the putConstString definition above
 * the #define line below should be commented out.
 *
 */
#define putConstString  SPI_Ethernet_putConstString

/*
 * put the string pointed to by s to the ENC transmit buffer
 */
/*unsigned int    putString(char *s)
        {
        unsigned int ctr = 0 ;

        while(*s)
                {
                Spi_Ethernet_putByte(*s++) ;

                ctr++ ;
                }
        return(ctr) ;
        }*/
/*
 * it will be much faster to use library Spi_Ethernet_putString routine
 * instead of putString routine above. However, the code will be a little
 * bit bigger. User should choose between size and speed and pick the implementation that
 * suites him best. If you choose to go with the putString definition above
 * the #define line below should be commented out.
 *
 */
#define putString  SPI_Ethernet_putString

/*
 * this function is called by the library
 * the user accesses to the HTTP request by successive calls to Spi_Ethernet_getByte()
 * the user puts data in the transmit buffer by successive calls to Spi_Ethernet_putByte()
 * the function must return the length in bytes of the HTTP reply, or 0 if nothing to transmit
 *
 * if you don't need to reply to HTTP requests,
 * just define this function with a return(0) as single statement
 *
 */
unsigned int  SPI_Ethernet_UserTCP(unsigned char *remoteHost, unsigned int remotePort,
                               unsigned int localPort, unsigned int reqLength, TEthPktFlags *flags)
{
  unsigned int    len = 0 ;                   // my reply length
  unsigned int    i ;                         // general purpose integer

  // should we close tcp socket after response is sent?
  // library closes tcp socket by default if canClose flag is not reset here
  // flags->canClose = 0; // 0 - do not close socket
                          // otherwise - close socket

  if(localPort != 80)
  {                        // I listen only to web request on port 80
    return(0) ;
  }

  // get 10 first bytes only of the request, the rest does not matter here
  for(i = 0 ; i < 10 ; i++)
  {
    getRequest[i] = SPI_Ethernet_getByte() ;
  }

  getRequest[i] = 0 ;

  if(memcmp(getRequest, httpMethod, 5))
  {      // only GET method is supported here
    return(0) ;
  }

  httpCounter++ ;   // one more request done

  get_Request = getRequest[5];  // s , d

  if(get_Request == 's')  // utiliser pour <script src=/s></script>
  {
    // if request path name starts with s, store dynamic data in transmit buffer
    // the text string replied by this request can be interpreted as javascript statements
    // by browsers
    len = putConstString(httpHeader);     // HTTP header
    len += putConstString(httpMimeTypeScript); // with text MIME type

    // add AN2 value to reply
    IntToStr(ADC_Read(2), dyna);
    len += putConstString("var AN2=");
    len += putString(dyna);
    len += putConstString(";");

    // add AN3 value to reply
    IntToStr(ADC_Read(3), dyna);
    len += putConstString("var AN3=");
    len += putString(dyna);
    len += putConstString(";");

    // add PORTB value (buttons) to reply
    len += putConstString("var PORTB=");
    IntToStr(PORTB, dyna);
    len += putString(dyna);
    len += putConstString(";");

    // add PORTD value (LEDs) to reply
    len += putConstString("var PORTD=");
    IntToStr(PORTD, dyna);
    len += putString(dyna);
    len += putConstString(";");

    // add HTTP requests counter to reply
    IntToStr(httpCounter, dyna);
    len += putConstString("var REQ=");
    len += putString(dyna);
    len += putConstString(";");
  }
  else
  {
   //
   if(get_Request == 'd') // Commande PORTD
   {
    if( isdigit(getRequest[6]) )
    {
     digit_getRequest  = getRequest[6] - '0'; // numéro de port 0 à 7

     if( getRequest[7] == 'o' )  // Contact Ouvert (OFF)
      etat_interrupteur = 0;

     if( getRequest[7] == 'f' )  // Contact Fermer (ON)
      etat_interrupteur = 1;

     switch(digit_getRequest)
     {
       case 0: PORTD.B0 = etat_interrupteur; break;
       case 1: PORTD.B1 = etat_interrupteur; break;
       case 2: PORTD.B2 = etat_interrupteur; break;
       case 3: PORTD.B3 = etat_interrupteur; break;
       case 4: PORTD.B4 = etat_interrupteur; break;
       case 5: PORTD.B5 = etat_interrupteur; break;
       case 6: PORTD.B6 = etat_interrupteur; break;
       case 7: PORTD.B7 = etat_interrupteur; break;
     }
    }
   }
   //
  }

  if(len == 0)
  {           // what do to by default
    len =  putConstString(httpHeader);       // HTTP header
    len += putConstString(httpMimeTypeHTML); // with HTML MIME type
    len += putConstString(indexPageHEAD);    // HTML page first part
    len += putConstString(indexPageBODY);    // HTML page second part
    len += putConstString(indexPageBODY2);   // HTML page second part
  }

  return(len) ;                               // return to the library with the number of bytes to transmit
}

/*
 * this function is called by the library
 * the user accesses to the UDP request by successive calls to Spi_Ethernet_getByte()
 * the user puts data in the transmit buffer by successive calls to Spi_Ethernet_putByte()
 * the function must return the length in bytes of the UDP reply, or 0 if nothing to transmit
 *
 * if you don't need to reply to UDP requests,
 * just define this function with a return(0) as single statement
 *
 */
unsigned int  SPI_Ethernet_UserUDP(unsigned char *remoteHost, unsigned int remotePort,
                                   unsigned int destPort, unsigned int reqLength, TEthPktFlags *flags)
{
   return 0;              // back to the library with the length of the UDP reply
}

/*
 * main entry
 */
void main()
{
  //ANSEL = 0x0C ;          // AN2 and AN3 convertors will be used
  //C1ON_bit = 0;           // Disable comparators
  //C2ON_bit = 0;
  PORTA = 0 ;
  TRISA = 0xff ;          // set PORTA as input for ADC

  //ANSELH = 0;             // Configure other AN pins as digital I/O
  PORTB = 0 ;
  TRISB = 0xff ;          // set PORTB as input for buttons

  PORTD = 0 ;
  TRISD = 0 ;             // set PORTD as output

  /*
   * starts ENC28J60 with :
   * reset bit on RC0
   * CS bit on RC1
   * my MAC & IP address
   * full duplex
   */
  SPI1_Init();
  SPI_Ethernet_Init(myMacAddr, myIpAddr, Spi_Ethernet_FULLDUPLEX) ;

  while(1)
  {                            // do forever
    /*
     * if necessary, test the return value to get error code
     */
    SPI_Ethernet_doPacket() ;   // process incoming Ethernet packets

    /*
     * add your stuff here if needed
     * Spi_Ethernet_doPacket() must be called as often as possible
     * otherwise packets could be lost
     */
  }
}