PIC Microcontroller MPLAB(C18) voorbeelden

Hallo mensen,

Het viel mij op toen ik met grotere microcontrollers aan de slag ging, dat er zo weinig over te vinden was aan code om uit te proberen. Vandaar dat ik dacht dat het voor beginners misschien makkelijk is ze op weg te helpen, door voorbeeldcode te plaatsen van bepaalde functies van een PIC en uitbreidingen.

dan allereerst de software die nodig is om met name de 18F serie te "branden". bedenk dat je bij de wisp628 versie 1.11 op je "brand pic" moet hebben staan, anders herkent hij ze niet.

handleidingen en info:

structuur:

- plaats bovenaan in de reactie vetgedrukt wat de code doet.
- vermeld welke picburner je gebruikt.
- vermeld ook welke pic je hebt gebruikt en op welke frequentie
- vermeld de connectie, en eventueel zelfs met afbeelding
- Plaats vervolgens in een [ code ] de feitelijke code:

gelieve geen andere talen als C te behandelen svp, en maak er geen chatbox van!
een datasheet bekijken wil ook nogal handig zijn voor je iets vraagt ;)

Dan nog even standaard fuses voor 4 pic's, ik post er meer als ik er meer weet:

PIC18F2620:


#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

PIC28F4550:


#pragma config FOSC = HS
#pragma config PWRT = OFF
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config CCP2MX = OFF
#pragma config LVP = OFF

PIC18F4620:


#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

PIC18F452:


#pragma config OSC = HS, OSCS = OFF
#pragma config PWRT = OFF
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config CCP2MUX = OFF
#pragma config LVP = OFF

------------------------------------------------------
MPLAB PIC Voorbeeld

- bumblebee gebruikt met wisp628 v1.11
- PIC18Fxxxx met freq. X MHz

uitleg:

deze code is een voorbeeld


plaats hier je code
[/code

Blink LED op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

De eenvoudigste code die er bestaat, de blink led :)
de led is verbonden van C1 via een 180 Ohm weerstand naar de ground.


//blinkled.c//
#include <p18f4620.h>
#include <delays.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

void main(void) //Start programma
{
	TRISC=0x00; //Maak alle pinnen van poort C output
	ADCON1=0b00001111; //Zet AD-converters uit
	while(1) //Draai continu continue het volgende stuk code
	{
		PORTCbits.RC1 = 1; //Maak pin C1 hoog
		Delay10KTCYx(100);
		PORTCbits.RC1 = 0; //Maak pin C1 laag
		Delay10KTCYx(100); 
	}
}

EUSART op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

Deze code stuurt terug wat de pic ontvangt via de eusart (ENHANCED UNIVERSAL SYNCHRONOUS RECEIVER TRANSMITTER)
Denk eraan dat je een max232 of 233 gebruikt voor de levelconversie. RC7 is de Rx pin, RC6 is de Tx pin.

(receive gedeelte komt van Dark_Knight)


//usart.c//
#include <p18f4620.h>
#include <delays.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

void init(void);
void send(char data);
char receive(void);
void main(void )
{
	char data = 0x0;
	init();
	while(1)
	{
		send(receive());
	}
}
void init(void)
{
	TRISA = 0x0;
	TRISB = 0x0;
	TRISC = 0b10000000;
	TRISD = 0x0;
	TXSTA = 0b00100100;
	RCSTA = 0b10010000;
	BAUDCON = 0b01011010;
	SPBRG = 129; //baud 9600 @ 20MHz
	INTCONbits.PEIE = 0; // interrups OFF
	INTCONbits.GIE = 0;
	PIE1bits.RCIE = 0;
	RCREG = 0;
	TXREG = 0;
	return;
}
void send(char data)
{
	TXREG = data;
	Delay10KTCYx(30);
	return;
}
char receive(void)
{
	char data;
	while (!PIR1bits.RCIF);
	PIR1bits.RCIF = 0;
	data = RCREG;
	return data;
}

character LCD op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

Deze code stuurt characters naar het LCD. de code bevat speciale functies zoals space, backspace, second_line, inttochar, cursor aan/uit (0 of 1 geven) en lookup tabel voor characters. De functie puttekst plaatst tekst op het LCD

//////////////Connections to PIC/////////
// RD0 = Enable
// RD1 = RS
// RD2 = R/W
// PORTB is connected to datalines LCD


//lcd.c//
#include <p18f4620.h>
#include <delays.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

/////declare LCD functions////
void init (void);
void puttext(void);
void second_line(void);
char inttochar(int in);
void space(int u);
void backspace(int u);
void init_display(void);
void delay(void);
void clear_display(void);
void cursor(int u);
void searchchar (char input);
//////////////////////////////

void main(void) //Main program
{
	init();
	init_display();
	clear_display();
	puttext();
	while(1)
	{		
		Delay100TCYx(25); //lekker niks doen	
	}
}
////////////////////////////////LCD screen functions////////////////////////////////////////////
void init(void)
{
	//PIC-things
	TRISB = 0;
	TRISC = 0b10010000;					// make C0 & C6 inputs
	TRISD = 0;	
	
	// make sure everything's OFF
	PORTA = 0x0;
	PORTB = 0x0;
	PORTC = 0x0;
	PORTD = 0x0;	
}
////////////////////////////////////////////////////////////////////////////////////////////////
void puttext(void)
{
	searchchar('H');
	searchchar('e');
	searchchar('l');
	searchchar('l');
	searchchar('o');
	second_line();
	searchchar('C');
	searchchar('r');	
	searchchar('u');
	searchchar('e');
        searchchar('l');
        space(1);
        searchchar('w');
	searchchar('o');	
	searchchar('r');
	searchchar('l');
        searchchar('d');
}
////////////////////////////////////////////////////////////////////////////////////////////////
void second_line(void)
{
	PORTDbits.RD0 = 1;
	PORTDbits.RD1 = 0;
	PORTB = 0b11000000;
	PORTDbits.RD0 = 0;
	delay();
}
////////////////////////////////////////////////////////////////////////////////////////////////
char inttochar(int in)
{
	char out;
	if(in == 0) out = '0'; 
	if(in == 1) out = '1';
	if(in == 2) out = '2'; 
	if(in == 3) out = '3';
	if(in == 4) out = '4'; 
	if(in == 5) out = '5';
	if(in == 6) out = '6'; 
	if(in == 7) out = '7';
	if(in == 8) out = '8'; 
	if(in == 9) out = '9';
	return out;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void space(int u)
{
	int i;	
	for(i=0;i<u;i++)
	{
		PORTDbits.RD2 = 0;
		PORTDbits.RD1 = 0;
		PORTDbits.RD0 = 1;
		PORTB = 0b00010100;
		PORTDbits.RD0 = 0;
		Delay1KTCYx(1);
	}
}
////////////////////////////////////////////////////////////////////////////////////////////////
void backspace(int u)
{
	int i;	
	for(i=0;i<u;i++)
	{
		PORTDbits.RD2 = 0;
		PORTDbits.RD1 = 0;
		PORTDbits.RD0 = 1;
		PORTB = 0b00010000;
		PORTDbits.RD0 = 0;
		Delay1KTCYx(1);
	}	
}
////////////////////////////////////////////////////////////////////////////////////////////////
void init_display(void)
{
	delay();					//give display time to wake up	
	PORTDbits.RD1 = 0;
	PORTDbits.RD2 = 0;
	// ----------------------------------------------------------------
	// Function set
		PORTDbits.RD0 = 1;
		PORTB = 0b00111000;
		PORTDbits.RD0 = 0;
		delay();
	// Turn on screen 
		cursor(0);	
	// Entry mode set
		PORTDbits.RD0 = 1;
		PORTB = 0b00000110;
		PORTDbits.RD0 = 0;
		delay();
	// Cursor home
		PORTDbits.RD0 = 1;
		PORTB = 0b00000010;
		PORTDbits.RD0 = 0;
		delay();
	return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void write_to_screen(char bytes)
{
	PORTDbits.RD1 = 1;
	PORTDbits.RD0 = 1;
	PORTB = bytes;
	PORTDbits.RD0 = 0;
	delay();
	return;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void clear_display(void)
{		
		//int i;	
		PORTDbits.RD2 = 0;
		PORTDbits.RD1 = 0;
		// write text to LCD
		PORTDbits.RD0 = 1;
		PORTB = 0b00000001;
		PORTDbits.RD0 = 0;
		delay();
}
////////////////////////////////////////////////////////////////////////////////////////////////
void delay(void)
{
// wait 3.00 ms @ 20MHz
	unsigned int i;
	unsigned int t;

	for(i = 0 ; i < 10000 ; i++)
		t=t+1;
	return;	
}
////////////////////////////////////////////////////////////////////////////////////////////////
void cursor(int u)
{
	PORTDbits.RD1 = 0;
	PORTDbits.RD2 = 0;
	// Turn on/off cursor
	PORTDbits.RD0 = 1;
	if(u)PORTB = 0b00001111;
	else PORTB = 0b00001100;
	PORTDbits.RD0 = 0;
	delay();
}
////////////////////////////////////////////////////////////////////////////////////////////////
void searchchar (char input)
{
	if(input == '!') write_to_screen(0b00100001); 	
	if(input == '"') write_to_screen(0b00100010); 
	if(input == '#') write_to_screen(0b00100011); 
	if(input == '$') write_to_screen(0b00100100); 
	if(input == '%') write_to_screen(0b00100101); 
	if(input == '&') write_to_screen(0b00100110); 
 
	if(input == '(') write_to_screen(0b00101000);
	if(input == ')') write_to_screen(0b00101001);
	if(input == '*') write_to_screen(0b00101010);
	if(input == '+') write_to_screen(0b00101011);
	if(input == ',') write_to_screen(0b00101100);
	if(input == '-') write_to_screen(0b00101101);
	if(input == '.') write_to_screen(0b00101110);
	if(input == '/') write_to_screen(0b00101111);
	
	if(input == '0') write_to_screen(0b00110000);	
	if(input == '1') write_to_screen(0b00110001);
	if(input == '2') write_to_screen(0b00110010);
	if(input == '3') write_to_screen(0b00110011);
	if(input == '4') write_to_screen(0b00110100);
	if(input == '5') write_to_screen(0b00110101);
	if(input == '6') write_to_screen(0b00110110);
	if(input == '7') write_to_screen(0b00110111);
	if(input == '8') write_to_screen(0b00111000);
	if(input == '9') write_to_screen(0b00111001);
	if(input == ':') write_to_screen(0b00111010);
	if(input == ';') write_to_screen(0b00111011);
	if(input == '<') write_to_screen(0b00111100);
	if(input == '=') write_to_screen(0b00111101);
	if(input == '>') write_to_screen(0b00111110);
	if(input == '?') write_to_screen(0b00111111);
	
		
	if(input == 'A') write_to_screen(0b01000001);
	if(input == 'B') write_to_screen(0b01000010);
	if(input == 'C') write_to_screen(0b01000011);
	if(input == 'D') write_to_screen(0b01000100);
	if(input == 'E') write_to_screen(0b01000101);
	if(input == 'F') write_to_screen(0b01000110);
	if(input == 'G') write_to_screen(0b01000111);
	if(input == 'H') write_to_screen(0b01001000);
	if(input == 'I') write_to_screen(0b01001001);
	if(input == 'J') write_to_screen(0b01001010);
	if(input == 'K') write_to_screen(0b01001011);
	if(input == 'L') write_to_screen(0b01001100);
	if(input == 'M') write_to_screen(0b01001101);
	if(input == 'N') write_to_screen(0b01001110);
	if(input == 'O') write_to_screen(0b01001111);

	if(input == 'P') write_to_screen(0b01010000);	
	if(input == 'Q') write_to_screen(0b01010001);
	if(input == 'R') write_to_screen(0b01010010);
	if(input == 'S') write_to_screen(0b01010011);
	if(input == 'T') write_to_screen(0b01010100);
	if(input == 'U') write_to_screen(0b01010101);
	if(input == 'V') write_to_screen(0b01010110);
	if(input == 'W') write_to_screen(0b01010111);
	if(input == 'X') write_to_screen(0b01011000);
	if(input == 'Y') write_to_screen(0b01011001);
	if(input == 'Z') write_to_screen(0b01011010);
	if(input == '[') write_to_screen(0b01011011);

	if(input == ']') write_to_screen(0b01011101);
	if(input == '^') write_to_screen(0b01011110);
	if(input == '_') write_to_screen(0b01011111);
	
	if(input == '`') write_to_screen(0b01100000);	
	if(input == 'a') write_to_screen(0b01100001);
	if(input == 'b') write_to_screen(0b01100010);
	if(input == 'c') write_to_screen(0b01100011);
	if(input == 'd') write_to_screen(0b01100100);
	if(input == 'e') write_to_screen(0b01100101);
	if(input == 'f') write_to_screen(0b01100110);
	if(input == 'g') write_to_screen(0b01100111);
	if(input == 'h') write_to_screen(0b01101000);
	if(input == 'i') write_to_screen(0b01101001);
	if(input == 'j') write_to_screen(0b01101010);
	if(input == 'k') write_to_screen(0b01101011);
	if(input == 'l') write_to_screen(0b01101100);
	if(input == 'm') write_to_screen(0b01101101);
	if(input == 'n') write_to_screen(0b01101110);
	if(input == 'o') write_to_screen(0b01101111);

	if(input == 'p') write_to_screen(0b01110000);	
	if(input == 'q') write_to_screen(0b01110001);
	if(input == 'r') write_to_screen(0b01110010);
	if(input == 's') write_to_screen(0b01110011);
	if(input == 't') write_to_screen(0b01110100);
	if(input == 'u') write_to_screen(0b01110101);
	if(input == 'v') write_to_screen(0b01110110);
	if(input == 'w') write_to_screen(0b01110111);
	if(input == 'x') write_to_screen(0b01111000);
	if(input == 'y') write_to_screen(0b01111001);
	if(input == 'z') write_to_screen(0b01111010);
	if(input == '{') write_to_screen(0b01111011);
	if(input == '|') write_to_screen(0b01111100);
	if(input == '}') write_to_screen(0b01111101);
	
	if(input == '@') write_to_screen(0b11011111); 

	//type new lines here to add more characters
 
}
////////////////////////////////////////////////////////////////////////////////////////////////

ADC op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

deze code kan gebruikt worden om de analoog digitaal converter in de microcontroller te gebruiken. Het signaal is aangesloten op AN0, en de adc meet tussen 0 en 5 volt. als je dit wilt veranderen in Vref, moet je bit 4 en 5 van ADCON1 wijzigen in een 1. Denk ook aan je TRIS settings! resultn bevat het resultaat van de conversie.


//adconv.c//
#include <p18f4620.h>
#include <delays.h>
#include <adc.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

void main(void )
{
	int result, result2,resultn, resultt;
	TRISA = 0b00111111;
	ADCON0 = 0b00000001; //Channel 0, not started, ADC ON
	ADCON1 = 0b00000111; //Portconfig: AN0 analog, other i/o digital, Vref- = Vss, Vref+ = Vdd
	ADCON2 = 0b10111010; //Result left justified, aq time = 20 Tad, conversion clock = Fosc/32
	
	while(1)
	{
		Delay10TCYx(5); //Delay for 50TCY
		
		while( BusyADC() ); // Wait for ADC conversion
		ADCON0bits.GO = 1; //Start conversion
		while(ADCON0bits.GO == 1); //Wait for completion
		result = ADRESL; //Read result, 8 MSBs
		result2 = ADRESH;
		resultt = (result2 << 8);
		resultn = (result + resultt)>> 2;
                //doe hier iets met je resultaat//
		Delay10KTCYx(0); //korte pauze
	}
}

3x4 matrixtoetsenbord op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

Deze code leest een 3x4 matrix folietoetsenbord uit. De integer perm werd gebruikt voor een tijd in te stellen. het is een trigger dat je bij minuten geen 60 bijvoorbeeld kunt intoetsen.


//usart.c//
#include <p18f4620.h>
#include <delays.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

int getnumber(int perm);

void main (void)
{
       int getnumber(1); //voor alle getallen
       int getnumber(1); //voor 0-5
       int getnumber(0); //voor * en #
}

int getnumber(int perm)
{
	// RD7 = (1,4,7,*) 
	// RD6 = (2,5,8,0)
	// RD5 = (3,6,9,#)
	// RD4 = (*,0,#)
	// RC7 = (7,8,9)
	// RC6 = (4,5,6)
	// RC5 = (1,2,3)
	int result = 13;  //valt buiten waardes, 0 is een waarde
	int flag = 1;

	TRISC = 0b11100000;	
	TRISD = 0b00010000;	
	PORTC = 0x00;
	while(flag)
	{
		//check first column
		PORTD = 0b10000000;
		Delay1KTCYx(3);  //give time to configure 
		if((PORTCbits.RC5 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 1; 
			//timearray[y] = 1;
			//searchchar('1');
			flag = 0;
		} 
		if((PORTCbits.RC6 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 4; 
			//timearray[y] = 4;
			//searchchar('4');
			flag = 0;
		}
		if((PORTCbits.RC7 == 1) && (perm == 1))
		{ 
			result = 7; 
			//timearray[y] = 7;
			//searchchar('7');	
			flag = 0;
		}
		if((PORTDbits.RD4 == 1) && (perm == 0))
		{ 
			result = 10;	
			//searchchar('*');		 
			flag = 0;
		}
		
		//check second column
		PORTD = 0b01000000;
		Delay1KTCYx(3);  //give time to configure
		if((PORTCbits.RC5 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 2;
			//searchchar('2');		
			flag = 0;
		} 
		if((PORTCbits.RC6 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 5;
			//searchchar('5');		
			flag = 0;
		}
		if((PORTCbits.RC7 == 1) && (perm == 1))
		{ 
			result = 8;
			//searchchar('8');		
			flag = 0;
		}
		if((PORTDbits.RD4 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 0;
			//searchchar('0');		
			flag = 0;
		}
		
		//check third column
		PORTD = 0b00100000;
		Delay1KTCYx(3);  //give time to configure
		if((PORTCbits.RC5 == 1) && ((perm == 1) || (perm == 2)))
		{ 
			result = 3;
			//searchchar('3');		
			flag = 0;
		} 
		if((PORTCbits.RC6 == 1) && (perm == 1))
		{ 
			result = 6;
			//searchchar('6');		
			flag = 0;
		}
		if((PORTCbits.RC7 == 1) && (perm == 1))
		{ 
			result = 9; 
			//searchchar('9');		
			flag = 0;
		}
		if((PORTDbits.RD4 == 1) && (perm == 0))
		{ 
			result = 11; 
			//searchchar('#');		
			flag = 0;
		}
	}
	Delay10KTCYx(100);
	flag = 1;
	return result;	///uiteindelijke resultaat ingedrukte toets
}

DS18S20 op PIC microcontroller

- bumblebee gebruikt met wisp628 v1.11
- PIC 18F4620 met freq. 20 MHz

uitleg:

Deze code leest de temperatuur uit van de digitale sensor via de onewire(maxim). De data bus is pin D3. speciale functies als splitbyte(in onewire_s), splitint(voor temperatuur op LCd zetten), catnate bits (in onewire_r). De code is geschreven voor slechts 1 device. voor meerdere devices moeten converttemp en readscratchpad en wellicht main gewijzigd worden. De onewirecommunicatie blijft echter gelijk :)


//ds18s20.c//
#include <p18f4620.h>
#include <delays.h>

///fuses instellen// 
#pragma config OSC = HS
#pragma config PWRT = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

void init(void);
void converttemp(void);
void readscratchpad(void);
int presence(void);
void onewire_s(int sendbyte);
int onewire_r(void);
int exp(int a,int b);
void splitint(int in)
//////////////////////////////
void main(void )
{
	while(1)
	{		
		converttemp();
		readscratchpad();	
	}
}
////////////////////////////////////////////////////////////////////////////////////////////////
void init(void)
{
	//PIC-things
	TRISB = 0;
	TRISC = 0b10010000;	// make C0 & C6 inputs
	TRISD = 0;	
	
	// make sure everything's OFF
	PORTA = 0x0;
	PORTB = 0x0;
	PORTC = 0x0;
	PORTD = 0x0;
}
/////////////////////////////////////////DS1820 functions///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
void converttemp(void)
{
  int i,realtemp=0,calctemp=0,famcode=0,CRC=0;
  int sensor_id[6];
  int byte[9],flag = 0;	
  if(presence()==1)		//check if sensor is present before continue
  {
	onewire_s(0xCC);	//send "skip ROM" command
	onewire_s(0x44);	//send "Convert T" command
	Delay10KTCYx(255);
	Delay10KTCYx(255);
  }
}
////////////////////////////////////////////////////////////////////////////////////////////////
int presence(void) //returns 1 if DS1820 is on bus, also called reset
{
	int pr = 0;
	TRISD = 0x00; 		//make bus output
	PORTDbits.RD3 = 0; 	//make bus low
	Delay100TCYx(25); 	//wait 500us
	PORTDbits.RD3 = 1; 	//make bus high
	TRISD = 0b00001000;	//make bus input
	Delay10TCYx(31);	//wait 62us for sensor to respond
	if(PORTDbits.RD3 == 0)	//if sensor pulls down
	{
		Delay10TCYx(30); 	//wait 60us
		if(PORTDbits.RD3 == 0)
		{
			pr =1;	//if bus = still low, DS1820 it present
		}
		else pr=0;
	}
	Delay100TCYx(19); 	//wait 380us to end presence mode
	return pr;		//return presence bit
	 	
}
////////////////////////////////////////////////////////////////////////////////////////////////
void readscratchpad(void)
{
  int i,realtemp=0,calctemp=0;
  int bytes[9];
  if(presence()==1)		//check if sensor is present before continue
  {
	onewire_s(0xCC);	//send "skip ROM" command
	onewire_s(0xBE);	//send "read scratchpad" command		
	for(i=0;i<10;i++)
	{
		bytes[i] = onewire_r();
	}
	splitint(bytes[0]*5);
	//searchchar(';');
	//splitint(bytes[1]);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////
void onewire_s(int sendbyte)
{
  //portD3 is used for one-wire
  //send LSB first
  //Write timeslot has duration at least 60 us, with at least 1us recovery
  //The master(PIC) has to pull down  and release within 15us for a logic 0, and a minimum of 60us for logic 1 
  int c;
  ///////////////procedure splitbyte//////////////////////
  int biti,i;
  int bits[8];
  int rest=sendbyte;
  for(i=0;i<8;i++)		//split 8 times
  {
        biti = exp(2,7-i);	//calculate current exponent
        if( rest >= biti )	//if byte> calculated exponent
        {
                bits[i] = 1;	//current bit of byte is 1			
                rest = rest - biti;	//change rest value
        }
        else
        {
                bits[i] = 0;	//else current bit = 0
        }
        
  }
  //////////////////////////////////////////////////////
  for(c=7;c>=0;c--)
  {			
	  if(bits[c] == 0)		//if bit = 0, write "0" to DS1820
	  {
	 	TRISD = 0x00;		//make bus output
		PORTDbits.RD3 = 0;	//begin sending "0"
  		Delay100TCYx(5); 	//wait for 100us
  		PORTDbits.RD3 = 1;	//pull back up
	 	Delay10TCYx(1); 	//recovery time 2us		
	  }
      if(bits[c] == 1)			//if bit = 1, write "1" to DS1820							
	  {	
		TRISD = 0x00;		//make bus output
		PORTDbits.RD3 = 0;	//begin sending "1"
  		Delay10TCYx(5); 	//wait for 10us
  		PORTDbits.RD3 = 1;	//pull back up
	 	Delay10TCYx(26); 	//recovery time 2us + time slot = 52us
	  }
   }
}
////////////////////////////////////////////////////////////////////////////////////////////////
int onewire_r(void)
{
  //portD3 is used for one-wire
  //receive LSB first
  //Read timeslot has duration at least 60 us, with at least 1us recovery
  //The master(PIC) must send "read-timeslot command" directly after sending Convert T(0x44)
  int b,i,biti,byte,bitscatn=0; 
  int bits[8]; 
  
  for(i=7;i>=0;i--)			//collect 8 bits
  {											
					//initiate read timeslot  	
	TRISD = 0x00;			//make bus output
	PORTDbits.RD3 = 0;		//initiate read time slot
	Delay10TCYx(1); 		//pull down for 2us					
	TRISD = 0b00001000;		//make bus input (listen)
	Delay10TCYx(4);			//wait 8us
	if(PORTDbits.RD3 == 0)		//bus still low?
	{
		bits[i] = 0;		//if so, current bit =0
	}
	if(PORTDbits.RD3 == 1)		//bus became high?
	{
		bits[i] = 1;		//if so, current bit =1
	}								
	Delay10TCYx(25);		//wait 50us to get next bit
  }
  ///Concatenate bits///bits[0] = MSB
  for(b=0;b<8;b++)
  {
		biti = exp(2,7-b);
		bitscatn = bitscatn +bits[b]*biti;
  } 
  /////////result = bitscatn//////////
  return bitscatn;
}
////////////////////////////////////////////////////////////////////////////////////////////////
int exp(int a,int b)					
{
      int exp = 1,c;					
      if(b == 0) {exp = 1; return exp;}	//if exponent =0, then answer is always 1, return value
      if(a == 0) {exp = 0; return exp;}	//if a = 0, answer = 0, return value
      else
      {
	      for(c = 0;c<b;c++)		
	      {
	              exp =  exp * a;	//multiplicate
	      }
      return exp;			//return value
      }
}
////////////////////////////////End of DS1820 functions/////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
void splitint(int in)
{	
      int outa=0;	//duizendtal
      int outb=0;	//hondertal
      int outc=0;	//tiental
      int outd=0;   //eenheid
      int ref, temp;

      // ----- duizendtal -----

      ref=1000;
      temp=1;

      while(ref!=0)
      {
              if(ref<=in)
              {
                      outa=temp;
                      break;
              }
              ref-=1000;
              temp--;
      }
      // ----- hondertal -----

      in-=(1000*outa);
      ref=900;
      temp=9;

      while(ref!=0)
      {
              if(ref<=in)
              {
                      outb=temp;
                      break;
              }
              ref-=100;
              temp--;
      }
      // ----- tiental -----

      in-=(100*outb);
      ref=90;
      temp=9;

      while(ref!=0)
      {
              if(ref<=in)
              {
                      outc=temp;
                      break;
              }
              ref-=10;
              temp--;
      }
      // ----- eenheid -----

      in-=(10*outc);
      ref=9;
      temp=9;

      while(ref!=0)
      {
              if(ref<=in)
              {
                      outd=temp;
                      break;
              }
              ref--;
              temp--;
      }
      //doe iets leuks met (outa, outb, outc, outd);
}

ZIet er goed uit.

Heb je ook een voorbeeld van de sw usart voor de pic 18?

Volgens mij is een link zinvoller dan al die lappen code: http://www.microchipc.com

hej,

die single wire usart heb ik (nog) niet. Als iemand zich geroepen voelt :)....

ik denk dat de link een aanvulling geeft jowi, niet iedereen hier kan evengoed engels, en er staat niet uitgelegd bij de code wat het doet, zodat je de stappen niet snapt. voor elke toepassing moet je toch weer net je eigen invulling inbrengen. dus in zoverre ben ik het niet met je eens, maar de link is zeker zinvol ;)

Gr. Rik

Wellicht off-topic, maar ik krijg ook nog steeds een enorme scroll-bar bij code met te veel kolommen. We hebben nog niet allemaal een 1900 pix breed scherm helaas...