main.c

ARM LPC2148 uart coding...

// Connect P1.24 
#include "LPC214x.H" 
#include "delay.h"	
#include <stdio.h>											// For Used Function printf 

#define  OW_BIT     0x01000000   						// P1.24
#define  RELAY_BIT     0x02000000   						// P1.25
                      
#define OW_GET_IN()   ( IOPIN1 & OW_BIT )
#define OW_OUT_LOW()  ( IOCLR1 = OW_BIT )
#define OW_OUT_HIGH() ( IOSET1 = OW_BIT )

#define OW_DIR_IN()   ( IODIR1 &= ~(OW_BIT) )
#define OW_DIR_OUT()  ( IODIR1|= OW_BIT )


#define RELAY_DIR_OUT()  ( IODIR1|= RELAY_BIT )
#define RELAY_OUT_LOW()  ( IOCLR1 = RELAY_BIT )
#define RELAY_OUT_HIGH() ( IOSET1 = RELAY_BIT )

char TEMBUF[3];

/* pototype  section */
//void delay(unsigned long int);								// Delay Time Function
//void delay_ms(long ms);	

/* pototype  section */
void init_serial0 (void); 									// Initil UART-0
//int sendchar (int ch);  										// Put Char to UART-0
//int getkey  (void);  										// Get Char From Uart-0



void tmreset (void) {                  // Reset TX 
//    unsigned int i;
//	printf("tmreset");
	OW_DIR_OUT(); // pull OW-Pin low for 480us
	OW_OUT_LOW(); // disable internal pull-up (maybe on from parasite)
    delay_us(492);          // minimum 480us 
	OW_OUT_HIGH();
    delay_us(60);          // minimum 60us   ******
}

void tmpre (void) {                    // Wait for Presence RX 
	OW_DIR_IN(); // input
    while (OW_GET_IN());
	//while (~OW_GET_IN());
	delay_us(60);//60 us  
    //while (~OW_GET_IN());delay_us(60);//60 us
    
	printf("sent response ");					   
}

char tmrbit (void) {                    // read one bit 
//    unsigned int i;
    char dat;
	OW_DIR_OUT(); // pull OW-Pin low for 480us
    OW_OUT_LOW(); delay_us(2);//2us
    OW_OUT_HIGH(); delay_us(4);
	OW_DIR_IN();

	if(OW_GET_IN()){
		dat=1;
	}else{
		dat=0;
	}
    delay_us(65);           // Approx 65 uS 
    return (dat);
}

unsigned char tmrbyte (void) {         // read one byte 
    unsigned char i,j,dat;
    dat = 0;
    for (i=1;i<=8;i++) {
        j = tmrbit ();
        dat = (j << 7) | (dat >> 1);
    }
    return (dat);
}

void tmwbyte (unsigned char dat) {               // write one byte 
    unsigned int i;
    unsigned char j;
    char testb;
	OW_DIR_OUT(); // pull OW-Pin low for 480us
    for (j=1;j<=8;j++) {
        testb = dat & 0x01;
        dat = dat >> 1;
        if (testb) {
            OW_OUT_LOW();                           // Write 1 
            delay_us(4);                            // Approx 4 uS 
            OW_OUT_HIGH();
            delay_us(65);             // Approx 65 uS 
        }
        else {
            OW_OUT_LOW();                           // Write 0 
            i = 8; while (i>0) i--;              // Approx 65 uS 
            OW_OUT_HIGH();
            i++; i++;                            // Approx 4 uS 
        }
    }
}

void tmstart (void) {                  // ds1820 start convert 
    tmreset ();
    tmpre ();
    delay_us (100);
    tmwbyte (0xcc);                    // skip rom 
    tmwbyte (0x44);                    // convert 
}

/*
void tmrtemp (void) {                  // read temp 
    unsigned char a,b;
    TEMBUF[0] = 0;
    TEMBUF[1] = 0;
    tmreset ();
    tmpre ();
    delay_us(1000);
    tmwbyte (0xcc);                    // skip rom 
    tmwbyte (0xbe);                    // convert 
    a = tmrbyte ();                    // LSB 
    b = tmrbyte ();                    // MSB 
    if (b==1) return;                  // don't care negative temp 
    TEMBUF[1] = a & 0x01;               // 0=x.0 1=x.5 
    a = a >> 1;                     
    TEMBUF[0] = a + 1;                 // adjust for thailand 
}
*/


void tmrtemp (void) {                  // read temp
    unsigned char a,b;
    TEMBUF[0] = 0;
    TEMBUF[1] = 0;
    tmreset ();
    tmpre ();
	printf("a");
    delay_ms(1);
	printf("2");
    tmwbyte (0xcc);                    // skip rom
    tmwbyte (0xbe);                    // convert
	printf("3");
    a = tmrbyte ();                    // LSB
    b = tmrbyte ();                    // MSB
	printf("4");
    if (b==1) return;                  // don't care negative temp   
	printf("5");                
    TEMBUF[0] = a + 2;   
	printf("%s%d","temp",TEMBUF);
	              
} 


int main(void)
{	  	
	int TrueTemp; 
	init_delay();
  	delay_us(1000);
  	init_serial0();		   									// Initilial UART0 = 9600,N,8,1
  	printf("Temperature\n"); 	// Call printf Function
	RELAY_DIR_OUT();
 
  while(1)													// Loop Continue
  {   		
    tmstart ();                    // ds1820 start convert
    delay_us(100);//delay_us(1000);
	tmrtemp ();
	
	/*printf("%X.%X\n",TEMBUF[0],TEMBUF[1]);
	 TrueTemp = (TEMBUF[1]*10);
	 if(TEMBUF[1]==0){

	 }else{
		TrueTemp = TrueTemp + 5;
	 }
	
	  	printf("%d%s",TrueTemp,"decimal\n");
	// =60.0 C
	*/
	 TrueTemp = (TEMBUF[0]/2);
	 printf("%s%d%s","tem is",TrueTemp,"\n");
	 if(TrueTemp>600) 
	 {
	   RELAY_OUT_LOW();	   //on relay by active low

	 }else {
		RELAY_OUT_HIGH();   //off relay by active high
	 }
		
	delay_s(1);										// Display Delay 1sec
  }  
}	  

/******************************/
/* Initial UART0 = 9600,N,8,1 */
/* VPB(pclk) = 60.00 MHz      */
/******************************/
void init_serial0 (void)  
{
  PINSEL0 &= 0xFFFFFFF0;									// Reset P0.0,P0.1 Pin Config
  PINSEL0 |= 0x00000001;									// Select P0.0 = TxD(UART0)
  PINSEL0 |= 0x00000004;									// Select P0.1 = RxD(UART0)

  U0LCR &= 0xFC;											// Reset Word Select(1:0)
  U0LCR |= 0x03;											// Data Bit = 8 Bit
  U0LCR &= 0xFB;											// Stop Bit = 1 Bit
  U0LCR &= 0xF7;											// Parity = Disable
  U0LCR &= 0xBF;											// Disable Break Control
  U0LCR |= 0x80;											// Enable Programming of Divisor Latches

  // U0DLM:U0DLL = 30.00 MHz / [16 x Baud]
  //             = 30.00 MHz / [16 x 9600]
  //             = 195.3 = 196 = C4
 
  /*** Use CLK = 30.00 MHz ***/
  U0DLM = 0x00;
  U0DLL = 0xC4;

  U0LCR &= 0x7F;											// Disable Programming of Divisor Latches

  U0FCR |= 0x01;											// FIF0 Enable
  U0FCR |= 0x02;											// RX FIFO Reset
  U0FCR |= 0x04;											// TX FIFO Reset
  U0FCR &= 0x3F;                      
}

/****************************/
/* Write Character To UART0 */
/****************************/
int sendchar (int ch)  
{                  
  if (ch == '\n')  
  {
    while (!(U0LSR & 0x20));  								// Wait TXD Buffer Empty
    U0THR = 0x0D;                          					// Write CR
  }
  while (!(U0LSR & 0x20));									// Wait TXD Buffer Empty
  return (U0THR = ch);										// Write Character
}

/*****************************/
/* Read Character From UART0 */
/*****************************/
int getkey  (void)  
{                    
  while (!(U0LSR & 0x01));									// Wait RXD Receive Data Ready
  return (U0RBR);											// Get Receice Data & Return
}