PIC master -> several slaves

Ariff

New Member
Hi,

im quite the newbie when it comes to setting up electronics circuits, but we all gotta start somewhere. I have been succesfully setting up a pic16f628 with rs232 control with a serial port on my pc. I can manage all that, and it works fine. Right now, im wondering how one would start creating the following :

I would like to have a "master" pic and several "slaves". As i read this should be perfectly possible but i dont have a clue on how to begin, or how to set this up. After burning my 3th pic this week, i wisely decided to stop and ask for advise first. The slave pics should have some sort of id code, so i can write software that will recognise the id. I can than select that certain pic and send/receive data from it. When done, i can select another pic id, and send some other data to it. As i go along searching on the internet, it appeared that useing RS485 for this system would be the best choice. I would very kindly ask for a helping hand in here. I'll post my current scheme, if anyone could take a look at it, and help me get it to work, ill be thankfull forever.

kind regards,
Ariff
(sorry for my bad english, it's not my native language)

Last edited:

ljcox

Well-Known Member
Ariff said:
Hi,

im quite the newbie when it comes to setting up electronics circuits, but we all gotta start somewhere. I have been succesfully setting up a pic16f628 with rs232 control with a serial port on my pc. I can manage all that, and it works fine. Right now, im wondering how one would start creating the following :

I would like to have a "master" pic and several "slaves". As i read this should be perfectly possible but i dont have a clue on how to begin, or how to set this up. After burning my 3th pic this week, i wisely decided to stop and ask for advise first. The slave pics should have some sort of id code, so i can write software that will recognise the id. I can than select that certain pic and send/receive data from it. When done, i can select another pic id, and send some other data to it. As i go along searching on the internet, it appeared that useing RS485 for this system would be the best choice. I would very kindly ask for a helping hand in here. I'll post my current scheme, if anyone could take a look at it, and help me get it to work, ill be thankfull forever.

kind regards,
Ariff
(sorry for my bad english, it's not my native language)
Your English is quite good. There is the odd mistake eg. you used "advise" when you meant "advice" Advise is a verb. And "using" does not have an e.

I assume that the PIC shown on your circuit is the master.

Do you need the slaves connected to the computer port? Or does the master do all communication with the computer?

If so, (and assuming that the PICs are all on the one PCB) I would use a one wire data link (ie. one wire for each direction - 2 wires in total) between the master and the slaves. And I would be inclined to use RS232 between the master and the slaves.

I think that your idea of sending "some sort of id code" from the master to the slaves so the appropriate slave can become active is good.

I suggest that when the slave detects its "address" it could respond with a suitable message. Then the master could communicate with the slave. When finished, it would then send a "finished" code to indicate to all slaves that the communication with the addressed slave is finished and to return to the "await address" data.

Incidentally, your LEDs are pointing the wrong way and they each need a series resistor. About 330 Ohm should suffice.

Last edited:

Pommie

Well-Known Member
Have a good read up on the 9 bit data mode with address detect enable of the RS22 module of most pics. In this mode the pic will only receive data with the 9th bit set. In this mode, a master pic can communicate with 256 slaves.

It is all explained very well in the 16f88 data sheet in section 11.2.3

Mike.

AlarmMan

New Member
Hi Ariff,

The Parallax.com site has a tutorial on using the RS485 protocol with the Basic Stamp which is a PIC. There are also numerous articles written on the subject of what you are wanting to do on www.picbasic.co.uk. Mister E on this site has posted a program and schematic on setting up a Master and Slave system that might be of interest to you. It uses a dip switch to program the "CODE" for the slaves.

I recently completed building two 160-Zone Annunciator Panels with 20 PIC's giving information to the master using 1 wire for serial communications and 1 wire for a "busy" indicator. I received assistance from several sources on the correct manner to setup the PICs so there is no interference from one another.

Look at the sites above and let me know if this is what you want to do.

You didn't specify a programming language that you are using so I hope this will help you out.

Alarmman

Nigel Goodwin

Super Moderator
You also really need to clarify what you're wanting to do, RS485 is certainly one possible method, but may be more complicated than you really need?.

There was a nice website featuring 'PICNET' which was a serial or USB system for connecting multiple PIC's in a simple 'network' round a house - but the site seems to have disappeared?.

Ariff

New Member
Hi all,

what a warm welcome on these boards ! Thats great, i might stay around here for a while. I am sorry that i didn't make my intentions quite clear as i should have. I'll explain a bit. I have been experimenting with RGB leds lately. I created some sort of prototype RGB spot. This was PWM controlled using a PIC16f628, serial connection to pc. I wrote a program in VB so i could control the colour fades, strobe modes, delay modes, and so on. Since my original idea was to build several "circuits" of rgb spots in my house and i want every circuit to be controlled by my pc, i figured some sort of "pic network" should be the solution. Now, i have written the asm file for my single pic to rgb spot prototype thingy, but thats how far my knowledge goes. The vb software sends out colour patterns to the pic. The pic itself stores this "pattern" into eeprom memory, and loops the pattern infinitly, untill a new pattern arrives, or the software tells it to shut down. Im practically 100% sure im close to the solution, but i cannot get it to work like i want. I have been testing 2 pic's which i loaded with an adapted version of my first asm code. There's so much information on this subject to be found on the net, that i cannot filter anymore what is relevant for me. I have used a stripped down version of the above scheme for my prototype, and this works fine. Tested it for about 3 months and no single error to be found in the asm nor in the vb programming. Since im not used to work with several pic's at once, i kindly asked for help here. (after posting on other forums too, with a lot of laughter and flame reply's, and urls who didnt give me that crucial information i need so badly) I hope ive been a bit more clear about my intentions. Maybe a few questions are answered now.

If i want to control the pic's using serial connection with a pc, do i need to setup a master pic ? or can the pc serve as a master who controls everything. I suppose if the pc is down, the pic's can continue running there eeprom pattern. Or do they have to send some sort of alive message every now and than ?

Which type of "network" setup would i need. (lets say i will have about 10 different circuits running through the house, each controlling about 10-15 spots) I have read about I2C, CAN bus and RS485... Not a clue really what there specs are, and what i would use best to be honest.

I know its a lot of questions, but i hope someone would be kind enough to give me just that little push in the right direction. When everything is ready, i will put everything (source, scheme's, asm,...) online for your pleasure

Kind regards,
Ariff

rockin_rick

New Member
If you're running 10-15 nodes around the house, IMO, I'd go with RS485 in a single master, multi slave arrangement. I2C is for shorter distances (originally intended for PCB level comms, but can go a few feet slowly...), RS232 is not multidrop and probably won't be quite long enough, CAN I'm not sure....

RS485 is relatively easy. Connect a RS-485 driver to the USART. Have the master talk to the CPU and the RS 485 network. Slaves will talk to the RS-485 network and run the LEDs. Run twisted pair wire in a daisy chain fashion, not star. Terminate each end of the cable with a 100 ohm resistor (that's the 'normal' value). A common misconception is that you only need 2 wires between nodes, but you need to also include a common ground. RS-485 is a hardware protocol, not software, so you can do your communications however you want. For the network protocol, have the master initiate all messages, slaves can only respond. This will eliminate the need to design in collision detection. The message packet can be something like:

Byte 1: start byte (whatever you want)
Byte 2: sender ID
Byte 4: this entire packet length
Byte 5: data
Byte 6: (more data...)
.
.
.
Byte x: last data byte OR checksum

Assign each node a seperate ID. When the master sends a message, all slaves listen, but only the addressed slave will respond/reply.

Good luck,
Rick

Last edited:

rockin_rick

New Member
Just another quick thought... Your schematic showed network biasing resistors to hold the network in a known state - only use 1 set of these on the network, not at every node.

I don't know what MAX346 are? Perhaps you should use MAX483 or MAX485...

Rick

Last edited:

Ariff

New Member
Hi, after a long time of trial/error i think i made a working scheme. Problem is i can not test it to see if it works or not hehe. Well to be honest im a bit lost trying to write a simple testprogram for the pic16f628a. Im trying to make it send some char's over rs485 to the serial port. I just wanted to read those using hyperterminal or something likewise. Anyone who can kick me in the right direction ? thanks already !!

Ariff

richb

New Member
I'm looking to construct somthing very similar to Ariff, but am totally confused by RS485. There is just too much information out there.

Does anyone know of some good tutorials to get started, so I can build up a demo circuit of a master and client nodes and try and learn. I had a look on Parallax.com but couldn't find anything of use.

Any links or information would be of great help.

Thanks

Ariff

New Member
its me again

i managed to get myself up and running this afternoon. I currently have the following setup working :

pc master -> rs485 -> pic1 (id : 8) / pic2 (id : 15)

I have hardcoded the id numbers in the pic16f628a. Now i wrote a vb program in which i can select a certain id number, and send/receive data from it. This works fine for 1 pic, but if i select the other one, it looks like the bus is being held open by the first pic or something in that genre. I think my asm code for the pic's itself is not right, if someone would have time to take a look at it, it would be very much appreciated.

Code:
        LIST P=16F628A
include <P16F628A.INC>
__CONFIG _CP_OFF & _WDT_OFF & _PWRTE_ON & _RC_OSC_NOCLKOUT & _LVP_OFF & _INTOSC_OSC_NOCLKOUT & _BODEN_OFF

ERRORLEVEL -302

CBLOCK 0x20
EE_tlr
EE_data
cntmsec
pwm_tlr
r1
g1
b1
r2
g2
b2
r3
g3
b3
step
lptlr1a
lptlr2a
lptlr2b
fdtlr2
fdtlr3
fdmax
function
pointer
tijd
tijdtlr
delay
time_on
time_off
byte
char
chartlr
dataout
datain
ENDC

CBLOCK 0x70
W_temp
STATUS_temp
buf_tlr
buf_tmp
buf_data
buf_0
buf_1
buf_2
buf_3
buf_4
buf_5
idcode
ENDC

#define clr_C	bcf	STATUS, C
#define	BANK0	bcf	STATUS,RP0	; RAM PAGE 0
#define	BANK1	bsf	STATUS,RP0	; RAM PAGE 1

#define	ledon	byte,0

#define	RTS		PORTB,0

#define	stage1	PORTA,0
#define	stage3	PORTA,1
#define	stage5	PORTA,2
#define	stageok	PORTA,3

#define	stageint	PORTB,7

#define	red		PORTB,4
#define	blue	PORTB,5
#define	green	PORTB,6

org		0x0000
goto	start

org	0x0004

; -------------------------
; INTERRUPT SERVICE ROUTINE
; -------------------------
isr		movwf 	W_temp 			;SAVE CONTEXT
swapf 	STATUS,w 		;SAVE CONTEXT
movwf 	STATUS_temp 	;SAVE CONTEXT
BANK0

btfsc	stageint		;test led
goto	intledoff		;led is on
bsf		stageint		;led is off
goto	intledexit
intledoff
bcf		stageint
intledexit

handleuart
movf	RCREG, w
movwf	buf_data
;buf_tmp = buf_tlr*8
clr_C
rlf		buf_tlr, w
movwf	buf_tmp
rlf		buf_tmp, f
rlf  	buf_tmp, w
;buf_tlr = 0
movlw   'r'                     ; move literal 'value' into register W
subwf   buf_data,  W            ; subtract the contents of register1 from
W1
btfss   STATUS, Z               ; check the Z bit in the status register
goto    char_nok
movf	buf_data, w
movwf	buf_0
bsf		stage1
goto	endhandleuart
;buf_tlr = 1
;		nop
movlw   's'                     ; move literal 'value' into register W
subwf   buf_data,  W            ; subtract the contents of register1 from
W2
btfss   STATUS, Z               ; check the Z bit in the status register
goto    char_nok
movf	buf_data, w
movwf	buf_1
goto	endhandleuart
;buf_tlr = 2
nop
movlw   '4'                     ; move literal 'value' into register W
subwf   buf_data,  W            ; subtract the contents of register1 from
W3
btfss   STATUS, Z               ; check the Z bit in the status register
goto    char_nok
movf	buf_data, w
movwf	buf_2
bsf		stage3
goto	endhandleuart
;buf_tlr = 3
;		nop
movlw   '8'                     ; move literal 'value' into register W
subwf   buf_data,  W            ; subtract the contents of register1 from
W4
btfss   STATUS, Z               ; check the Z bit in the status register
goto    char_nok
movf	buf_data, w
movwf	buf_3
goto	endhandleuart
;buf_tlr = 4
nop
movlw   '5'                     ; move literal 'value' into register W
subwf   buf_data,  W            ; subtract the contents of register1 from
W5
btfss   STATUS, Z               ; check the Z bit in the status register
goto    char_nok
movf	buf_data, w
movwf	buf_4
bsf		stage5
goto	endhandleuart
;buf_tlr = 5
movf	buf_data, w
andlw	b'00011111'				; filter 5 LSB bits
subwf	idcode, W
btfss   STATUS, Z
goto    char_nok
movf	buf_data, w
movwf	buf_5
bsf		stageok
call	msec25
movf	idcode, w
btfsc	buf_5,5
iorlw	b'00100000'
call	send
clrf	buf_tlr
goto	isr_end

endhandleuart
incf	buf_tlr,f
goto	isr_end
char_nok
clrf	buf_tlr
bcf		buf_5,5			;wissen activate bit
bcf		stage1
bcf		stage3
bcf		stage5
bcf		stageok
isr_end	swapf 	STATUS_temp,W 	;
movwf 	STATUS 			;RESTORE CONTEXT
swapf 	W_temp,F 		;
swapf 	W_temp,W 		;
btfss	buf_5,5			;IF activated THEN
retfie					;RETURN with ISR on
bcf		INTCON,PEIE		;disable Peripheral interrupt
return

r_init	movlw	D'7' 		;
movwf	CMCON		; Comparators off, all pins digital I/O
movlw	b'00000000'	; set up portA
movwf	PORTA
movlw	b'00000100'	; RB2(TX)=1 others are 0
movwf	PORTB
BANK1
movlw	b'11110000'
movwf	TRISA		; RA1 en RA2 output, others input
movlw	b'00000010'	; RB1(RX)=input, others output
movwf	TRISB
bsf		PIE1,RCIE   ;enable Usart Receive interrupt
BANK0
bsf		INTCON,PEIE	;enable Peripheral interrupt
bsf		INTCON,GIE	;enable Global interrupt
return

; ------------------------------------
; Reset registers
; ------------------------------------

r_set	clrf	r1
clrf	g1
clrf	b1
clrf	r2
clrf	g2
clrf	b2
clrf	r3
clrf	g3
clrf	b3
clrf	EE_tlr
clrf	pwm_tlr
clrf	pointer
MOVVR	D'50', time_on
MOVVR	D'50', time_off
clrf	buf_tlr
bcf		RTS
MOVVR	D'8', idcode
return

; ------------------------------------
; SET BAUD RATE TO COMMUNICATE WITH PC
; ------------------------------------
; Boot Baud Rate = 9600, No Parity, 1 Stop Bit

r_RS232_init
BANK1
movlw	0x19		  ; 0x19=9600 bps (0x0C=19200 bps)
movwf	SPBRG
movlw	b'00100100'       ; brgh = high
movwf	TXSTA             ; enable Async Transmission, set brgh
BANK0
movlw	b'10010000'       ; enable Async Reception
movwf	RCSTA

; ------------------------------------
; ------------------------------------
movf	RCREG,W
movf	RCREG,W
movf	RCREG,W            ; flush receive buffer
return

; ------
; Start
; ------

start	call	r_init
call	r_RS232_init
call	r_set

; ---------
; MAIN LOOP
; ---------

main
call	lees_function
clr_C				; clear carry uit STATUS
rlf		function, w	; functie * 2 (schuif 1 bit naar links)
clrf	pointer		;function = 0
goto	main
call	show_long	;function = 1
goto	main
call	show_short	;function = 2
goto	main
goto	main
goto	main
call	flash		;function = 5
goto	main
call	set_time	;function = 6
goto	main
nop					;function = 7
goto	main

;Lezen van informatie uit de EEPROM

lees_function
movf	pointer, w	; lees eeprom met pointer
andlw	0x07		; maximaal 7
movwf	function	; functie
incf	pointer, f
MOVRR	r1, r2		; backup rood
movf	pointer, w
movwf	r1			; nieuwe rood
incf	pointer, f
MOVRR	g1, g2		; backup groen
movf	pointer, w
movwf	g1			; nieuwe groen
incf	pointer, f
MOVRR	b1, b2		; backup blauw
movf	pointer, w
movwf	b1			; nieuwe blauw
incf	pointer, f
movf	pointer, w
movwf	tijd		; nieuwe tijdseenheid
incf	pointer, f
return

; Laat de kleuren zien
show_long
MOVVR	D'20', delay
goto	show
show_short
MOVVR	D'1', delay
goto	show		; deze instructie is overbodig

show	MOVRR	tijd, tijdtlr	; tijd x delay x 5ms
lp01	MOVRR	delay, lptlr1a	;
lp01a	call	rgb_1a	 	; 5ms
decfsz	lptlr1a, f
goto	lp01a
decfsz	tijdtlr, f
goto	lp01
return

; knipperen van de kleuren
flash	MOVRR	tijd, tijdtlr
MOVRR	r1 ,r2
MOVRR	g1 ,g2
MOVRR	b1 ,b2
clrf	lptlr2b
bsf	ledon
lp02	MOVVR	D'10', lptlr2a	;10x
lp02a	btfss	ledon
goto	lp02_off
goto	lp02_on		; deze instructie is overbodig

lp02_on
IRNEQRT	lptlr2b, time_on, lp02_out
clrf	lptlr2b
clrf	r1
clrf	g1
clrf	b1
bcf	ledon
goto	lp02_out

lp02_off
IRNEQRT	lptlr2b, time_off, lp02_out
clrf	lptlr2b
MOVRR	r2 ,r1
MOVRR	g2 ,g1
MOVRR	b2 ,b1
bsf	ledon
goto	lp02_out	; deze instructie is overbodig

lp02_out
incf	lptlr2b, f
call	rgb_1a	 	; 5ms
call	rgb_1a	 	; 5ms
decfsz	lptlr2a, f
goto	lp02a
decfsz	tijdtlr, f
goto	lp02
return

;Van de ene kleur naar de andere kleur
; kleur fade in 32 stappen van 32 met 32 kleurstappen
movlw	D'32'
movwf	fdmax
movlw	D'8'
movwf	step

; kleur fade in 16 stappen van 16 met 16 kleurstappen
movlw	D'16'
movwf	fdmax
movlw	D'16'		; deze instructie is overbodig in w staat al D'16'
movwf	step
goto	fade		; deze instructie is overbodig

; fade_fast is 4x sneller als fade_slow maar heeft 2x zo grote kleurstappen
fade	call	rgb_bck		; backup rgb_new + rgb_old
movf	fdmax, w
movwf	fdtlr2		; For fdtlr2 = fdmax to 0
fade2	movf	tijd, w		; tijdtlr = tijd
movwf	tijdtlr
movwf	fdtlr3			; For fdtlr3 = fdmax to 0
call	rgb_new				; nieuw kleuren laden
fade3	movf	fdtlr2, w			; fdtlr2 --> w
subwf	fdtlr3, w			; fdtlr3 - w
btfsc	STATUS, Z			; If fdtlr2 - fdtlr3 = 0 Then
call	rgb_old				; oude kleuren laden
call	rgb_2a				; uitsturen kleuren
decfsz	fdtlr3, f
decfsz	tijdtlr, f		; extra herhalingslus
decfsz	fdtlr2, f
call	rgb_new		; restore rgb_new
return

rgb_bck	movf	r2,w		; backup van de kleuren
movwf	r3
movf	g2,w
movwf	g3
movf	b2,w
movwf	b3
movf	r1,w
movwf	r2
movf	g1,w
movwf	g2
movf	b1,w
movwf	b2
return

rgb_new	movf	r2,w		; zet nieuwe kleuren in uitsturing
movwf	r1
movf	g2,w
movwf	g1
movf	b2,w
movwf	b1
return

rgb_old	movf	r3,w		; zet oude kleuren in uitsturing
movwf	r1
movf	g3,w
movwf	g1
movf	b3,w
movwf	b1
return

; knippertijden instellen
set_time
MOVRR	r1, time_on
MOVRR	g1, time_off
return

; Hier gebeurt het echt.
; De LED's worden gestuurd.
; 256x256x256 = 16777216 kleuren (24 bits)

; wijziging
; kijk of er data in de buffer staat
rgb_1a	btfsc	PIR1,RCIF	; check for received data
call	program
clrf	pwm_tlr
rgb_1b	decf	pwm_tlr, f
btfsc	STATUS, Z
goto	rgb_1c
movf	pwm_tlr, w
subwf	r1, w
btfsc	STATUS, Z
bsf	red
movf	pwm_tlr, w
subwf	g1, w
btfsc	STATUS, Z
bsf	green
movf	pwm_tlr, w
subwf	b1, w
btfsc	STATUS, Z
bsf	blue
nop
nop
goto	rgb_1b
rgb_1c	bcf	red
bcf	green
bcf	blue
return

; Hier gebeurt het ook echter lagere resolutie.
; De LED's worden gestuurd.
; 16x16x16 =  4096 kleuren (12 bits)
; 32x32x32 = 32768 kleuren (15 bits)

; wijziging
; kijk of er data in de buffer staat
rgb_2a	btfsc	PIR1,RCIF	; check for received data
call	program
clrf	pwm_tlr
rgb_2b	movf	step, w
subwf	pwm_tlr, f
btfsc	STATUS, Z
goto	rgb_2c
; If pwm_tlr <= r1 then set red
movf    pwm_tlr, w
subwf   r1, w
btfsc   STATUS, C
bsf     red
; If pwm_tlr <= g1 then set green
movf    pwm_tlr, w
subwf   g1, w
btfsc   STATUS, C
bsf     green
; If pwm_tlr <= b1 then set blue
movf    pwm_tlr, w
subwf   b1, w
btfsc   STATUS, C
bsf     blue
goto	rgb_2b
rgb_2c	bcf	red
bcf	green
bcf	blue
return

;**************************************************
;* Programmeren en uitlezen van de interne EEPROM *
;**************************************************
; Wat wordt het ?
; W = Write
; D = Deactivate Slave en Exit
; Overig = Echo en Exit

program	clrf	EE_tlr
call	receive		; wacht op data
call	msec25
call	send		; verstuur data
return

; Het antwoord op de 'grote' W is een 'kleine' w.
; Dit start de programmeer cyclus
progw	movlw	'w'
call	send		; verstuur data
progw2	call	receive		; wacht op data
movwf	EE_data
call	msec25
movf	EE_data, w
call	send		; verstuur data
movf	EE_tlr, w
call	writEE		; data opslaan
movlw	D'10'		; verwerkingstijd PIC 10 millisec
call	nmsec
incf	EE_tlr, f
IRLEQVT	EE_tlr, D'128', progw2
return

; Het antwoord op de 'grote' R is een 'kleine' r.
; Dit start de uitlees cyclus
progr	movlw	'r'
call	send		; verstuur data
progr2	movf	EE_tlr, w
call	send		; verstuur data
movlw	D'10'		; wachttijd 10 msec
call	nmsec
incf	EE_tlr,f
IRLEQVT	EE_tlr, D'128', progr2
return

progd	movlw	'd'
call	send		; verstuur data
bcf		stage1
bcf		stage3
bcf		stage5
bcf		stageok
bsf		INTCON,PEIE	;enable Peripheral interrupt
bsf		INTCON,GIE	;enable Global interrupt
return

;******************************************************
;* Ontvang een karakter via RS232 en plaats deze in w *
;******************************************************
; RS232 ontvangen (bron = internet)

receive btfss PIR1,RCIF         ; controleer op ontvangen data
movf RCREG,W            ; opslaan van ontvangen data in w
return

;****************************************
;* Verzend een karakter uit w via RS232 *
;****************************************
; RS232 verzenden (bron = internet)

send    movwf	dataout
bsf		RTS				; Slave neemt bus over
movlw	D'1'			; wacht 1 msec
call 	nmsec
movf	dataout, w
movwf	TXREG           ; verzend data in W
BANK1
send1	btfss 	TXSTA,TRMT      ; verzenden gereed indien hoog
goto 	send1
BANK0
movlw	D'1'			; wacht 1 msec
call 	nmsec
bcf		RTS				; Slave geeft bus vrij
return

;*********************
;* Wachtlus Routines *
;*********************
; Hele fijne wachtroutines (bron = internet)
; Zijn alleen van toepassing bij 4Mhz
msec25	movlw	D'25'
nmsec	movwf	cntmsec		; delay for N (in W) millisec
mseclp	movlw	D'248'		; 1 usec for load
call	usec		; this instruction is 995 usec
nop					; 1 usec
decfsz	cntmsec,f	; 1 usec, (2 if skip taken)
goto	mseclp		; 2 usec, loop = 995+5 = 1 msec
return

usec	addlw	D'255'		; substract 1 from 'W'
btfss	STATUS,Z	; skip when you reach zero
goto	usec		; more loops
return

;***********************************
;* Lezen en schrijven in EE-Memory *
;***********************************
; Maak gebruik van het interne geheugen!
; Deze informatie blijft bewaard.
; Ook bij spanningsverlies.
; bron = internet en datascheet

bsf		EECON1, RD 	; EE Read
movf	EEDATA,w	; Byte naar w
BANK0
return

writEE	BANK1
BANK0
movf	EE_data, w
BANK1
movwf	EEDATA		; Te schrijven byte,
bsf		EECON1, WREN; Enable write
bcf		INTCON, GIE	; Disable INTs
btfsc	INTCON, GIE	; AN576
goto	\$-2
movlw	H'55' 		;
movwf	EECON2		; Write 55h
movlw	H'AA'		;
movwf	EECON2 		; Write AAh
bsf		EECON1, WR 	; Set WR bit begin write
bsf		INTCON, GIE	; Enable INTs.
BANK0
return

;************************
;* begin waarden EEPROM *
;************************
; Hier begint de EEPROM sectie
org	0x2100
de 0x01, 0xff, 0x00, 0x00, 0x1e
de 0x01, 0x00, 0xff, 0x00, 0x1e
de 0x01, 0x00, 0x00, 0xff, 0x1e
de 0x01, 0xff, 0xff, 0x00, 0x1e
de 0x01, 0xff, 0x00, 0xff, 0x1e
de 0x01, 0x00, 0xff, 0xff, 0x1e
de 0x01, 0xff, 0xff, 0xff, 0x1e
de 0x06, 0x32, 0x32, 0x00, 0x01
de 0x05, 0xff, 0x00, 0x00, 0x32
de 0x06, 0x19, 0x19, 0x00, 0x01
de 0x05, 0x00, 0xff, 0x00, 0x32
de 0x06, 0x0C, 0x0C, 0x00, 0x01
de 0x05, 0x00, 0x00, 0xff, 0x32
de 0x06, 0x06, 0x06, 0x00, 0x01
de 0x05, 0xff, 0xff, 0xff, 0x32
de 0x03, 0xff, 0x00, 0x00, 0x05
de 0x03, 0x7f, 0x7f, 0x00, 0x05
de 0x03, 0x00, 0xff, 0x00, 0x05
de 0x03, 0x00, 0x7f, 0x7f, 0x05
de 0x03, 0x00, 0x00, 0xff, 0x05
de 0x03, 0x7f, 0x00, 0x7f, 0x05
de 0x03, 0xff, 0x00, 0x00, 0x05
de 0x03, 0x00, 0x00, 0x00, 0x05
de 0x00, 0x00, 0x00, 0x00, 0x05
de 0x00, 0x00, 0x00, 0x00, 0x00
de 0x00, 0x00, 0x00
; Hier eindigt de EEPROM sectie
org	0x2000
;verplicht
END
greetings !
Ariff