PIC16F628A random output

Een mogelijke oplossing is een array met de nummers 1 t/m 8 (of 0 tm 7) waarvan je de volgorde random maakt door een groot aantal keren random twee posities om te wisselen.

Of alle posities koppelen aan een random-waarde en dan op volgorde van die random-waarde sorteren.

Arco

Special Member

Zoiets (in pseudo-code, assembly was me even te veel werk... ;) ):

pic basic code:



BitMask = 0
For Cnt = 0 to 7                            ;
  Do                                        ;
    bVal = TMR0 And 0xF8                    ;Get timer value 
    If bVal = 0 Then                        ;
      BitToBeSet = %00000001                ;Set bitmask
    Else                                    ;
      BitToBeSet = %00000001 << bVal        ; 
    End If                                  ;
    If BitMask And BitToBeSet = 0 Then      ;Set bit if not done already 
      PortA = BitToBeSet                    ;
      delay_ms(500)                         ;
      BitMask = BitMask Or BitToBeSet       ;Set bit as done 
    End If                                  ;
  Loop Until BitToBeSet <> 0                ;Invalid; next
Next Cnt                                    ;
PortA = %00000000                           ;
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Ik heb ooit een random routine gemaakt gebaseerd op de code die Jal genereert. Echt random wordt het natuurlijk nooit, maar het is in ieder geval niet slecht.
Hiero

Just find out what you like and let it kill you
Arco

Special Member

Aanvullend probleem is dat wat TS wil eigenlijk geen random is... ;)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

De Code van TS daar schort ook het een en ander aan.De stack is maar 8 diep en verscheidene calls hebben geen RET of RETLW. Die loopt dus binnen enkele cycles in de soep/vast aka "stack overflow"...

Re-integratiecoach uitgerangeerde en degoutante electronen
Arco

Special Member

TableOn en TableOff hebben inderdaad geen return, en ze roepen elkaar ook nog aan... Goed voor een zekere en snelle crash... :)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Implementatie van het idee (voor zover ik het begrijp) in C:

c code:


#include <stdint.h>
#include <stdio.h>

static void delay(uint16_t count);
static void update_lfsr(void);

static uint8_t bitmask;

static uint16_t	lfsr;

static uint8_t port;

void main(void) {
	uint8_t bit;
	
	lfsr = 1; // seed
	
	for (bit = 0; bit < 8; bit++) {
		delay(lfsr);
		port |= 1 << bit;
		
		printf("port=%02X after %d delay\n", port, lfsr);
		
		update_lfsr();
	    }
  
    }


static void delay(uint16_t count) {
	volatile uint16_t i;
	for (i = 0; i < count; i++) {
	    (void) i;
	    }
    }


static void update_lfsr(void) {
  /* http://stackoverflow.com/questions/16891655/galois-lfsr-explanation-of-code */
  uint16_t lsb;
 
  lsb = lfsr & 1;     /* Get lsb (i.e., the output bit). */
  lfsr >>= 1;         /* Shift register */
  if (lsb == 1) {     /* Only apply toggle mask if output bit is 1. */
    lfsr ^= 0xB400u;  /* Apply toggle mask, value has 1 at bits corresponding  to taps, 0 elsewhere. */  
    }                 
  }
  

output:

code:


port=01 after 1 delay
port=03 after 46080 delay
port=07 after 23040 delay
port=0F after 11520 delay
port=1F after 5760 delay
port=3F after 2880 delay
port=7F after 1440 delay
port=FF after 720 delay

Met GCC onder ubuntu getest, even aan te passen aan de PIC. Als je de seed waarde van een timer haalt bij opstarten o.i.d. wordt een en ander minder voorspelbaar.

Op 25 juni 2016 19:01:00 schreef Franzki:
Een mogelijke oplossing is een array met de nummers 1 t/m 8 (of 0 tm 7) waarvan je de volgorde random maakt door een groot aantal keren random twee posities om te wisselen.

Dat hoeft niet "een groot aantal keren". Dat hoeft maar 8 keer als er acht elementen zijn.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Bedankt voor jullie ideeën.
Ik ga er eens mee stoeien

Ook leer ik veel van julle, dit zijn mijn eerste stappen in asm en Pic. Dus alle commentaar en ideeën zijn welkom.

[Bericht gewijzigd door Henry S. op vrijdag 1 juli 2016 18:58:57 (52%)

Ok: Tip: Na je eerste programma in assembly gedaan te hebben weet je voorlopig genoeg van assembly om voortaan in Basic (PICBASIC) of C verder te gaan.

Je ziet: Je zit hier op een forum en totaal onbekenden tikken voor jou in een paar minuten (Het gebeurt zelden dat zo'n onbekende uren voor jou project gaat zitten ploeteren) een stuk code in C of in Basic in mekaar.

Een vriend van m'n vader rapporteerde in de jaren tachtig dat hij ontzettend blij was toen z'n bedrijf de IBM computer die ze gebruikten upgraden naar 1kB, Hoe blij ik wel niet moest zijn met de 64kB in mijn commodore 64!

Vroeger moest je prutsen om dingen in kleine geheugens te passen. tegenwoordig veel minder. Dus als je gecompileerde-taal-ding 5x groter wordt dan wat je met assembly had gekund is dat niet meer de moeite waard.

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

Ok, bedankt voor de tip.

Ik dacht dat ASM makkelijker zou zijn ivm de instructieset van de 16F628

Wat zou nu beter zijn PICBASIC of C?

mvg

Tja, dat is altijd een heilige oorlog (= eentje waar je niet met discussieren het andere kamp om kan praten).

Basic is iets makkelijker om mee te beginnen, maar dan weer niet zo makkelijk beschikbaar voor andere processoren. C darentegen is voor alle processoren tegenwoordig beschikbaar, dus als je ooit van "PIC" af wilt (of moet omdat een of ander niet met een pic werkt), dan zou C handiger zijn.

Ik zelf zit in het "C-is-beter" kamp. :-)

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/
Arco

Special Member

Na je eerste programma in assembly gedaan te hebben weet je voorlopig genoeg van assembly om voortaan in Basic (PICBASIC) of C verder te gaan.

Assembly is niks mis mee, hoor!... :). (werkt door de simpele instructieset inderdaad vrij eenvoudig, en in heel kleine pics als de 628 is zuinig met geheugen zijn toch wel handig)
Mikrobasic of Picbasic is ook goed in te programmeren als je goed op de programmaopbouw let valt het extra geheugengebruik erg mee.

(vaak is het schrijven van een eigen functie veel korter als de ingebakken library functies. Voorbeeld: uart_init in de library gebruikt 240 bytes, dat kan met eigen routine veeeel korter)
Sommigen zweren bij C, maar ik vind het een draak van een taal. Veel programmeurs maken een onleesbare brij van de code door veel te veel op 1 regel te proppen.

Vaak wordt compatibiliteit als reden voor het gebruik van C gegeven. Da's natuurlijk onzin. Geen enkele code is tussen totaal verschillende hardware bruikbaar zonder wijzigingen.

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Tja, het ligt er een beetje aan wat je ermee wilt doen.

Als je bv voor modelbouw een berg gadgets wilt maken zou ik C gebruiken aangezien je dan per gadget voor weinig (2 a 3$) bv een Arduino Nano kunt gebruiken. Heb je ook geen programmer bij nodig.

Maar als je gewoon met PIC's wilt stoeien, dan is PICBASIC wellicht wat makkelijker en overzichtelijker.

chuckie

Honourable Member

Ik kan bij Pic basic maar 1 nadeel bedenken, en dat is (als je de gekochte versie hebt) dat kl**** dongeltje, wat ik altijd weer kwijt ben...;)

Ervaring is de naam voor de som der fouten die we gemaakt hebben--Oscar Wilde

Lastig hoor

Ik vindt dat asm toch wel leuk.
Wie weet ga ik later over naar c of picbasic.
Ik zal eerst mijn project werkende krijgen

Ben weer hevig aan het stoeien geweest.
Heb nu een versie die pseudo random werkt, alleen de led's gaan weer uit en die moeten juist aan blijven.
Het random ziet er redelijk uit.

Als er iemand zin heeft, tip om de led's die al aan geweest zijn aan te laten....?

pic asm code:

	processor 16f84
	list	f=inhx8m
	include "p16f84.inc"
	__CONFIG        _CP_OFF & _WDT_ON & _HS_OSC


				; general purpose register allocation

				; first common free address as per 

				; p13 of 16f84 spec

beat	equ	0x0c		; frequency beat mask
	
ranl	equ	0x0d		; 24-bit random number
ranm	equ	0x0e
ranh	equ	0x0f


port	equ	PORTB


m_input	equ	b'00000000'	; input mask, which bits are input

	org     0x00		;reset vector
	goto    main		;GOTO 0x0051

	

reinitialise:			; set up ports
	
	clrf	TMR0		; Clear TMR0
	bsf	STATUS,RP0	; select register bank 1 (STATUS=0x3C)
	clrwdt			; Clear watchdog
	movlw	b'11111100'	; assign 1:16 prescaler to WDT
	movwf	OPTION_REG	; move W to OPTION_REG (0xFC)
	bsf	STATUS,RP0	; select register bank 1 (STATUS=0x3C)
	movlw	m_input		; move 0x00 W
	movwf	TRISB		; move W TRISB (0 all outputs)
	bcf	STATUS,RP0	; clear register bank 1 (STATUS=0x1C)
	retlw	0		; return W=0x00

initialise:			; clear the random number seed
	movlw	0xa5		;move 0xA5 to W	(W=0xA5)
	movwf	ranh		;move W to ranh (ranh=0xA5) adres 0x0F
	movwf	ranm		;move W to ranm (ranm=0xA5) adres 0x0E
	movwf	ranl		;move W to ranl (ranl=0xA5) adres 0x0D
	retlw	0		;return W=0x00

alive:				; update the LED drivers
	incf	beat,f		; 0x00C increment the beat write back f
	movf	beat,w		; move 0x00C to beat write in W merge with low bits of random number w=1
	andwf	ranl,w		; AND W with 0x00D ranl write to W (W=1)
	movwf	port		; move W to port (PORTB) sent the result to the port drivers
	retlw	0		; return W=0x01

random:				; find next random number
	movf	ranl,w		; move ranl in W check total value zero
	iorwf	ranh,w		; InclusiveOR W with f=ranh. If d=0 result in W If d=1 result in f
	btfsc	STATUS,Z	; bit test STATUS,Z skip if '0'
	comf	ranh,f		; invert some bits if so
	movlw	0x80		; move 0x80 to W
	btfsc	ranh,6		; bit test f=ranh bit 6 skip if '0'
	xorwf	ranh,f		; Exclusive OR W with f if d=0 result in W. If d =1 result in f
	btfsc	ranh,4		; bit test f=ranh bit 4 skip if '0'
	xorwf	ranh,f
	btfsc	ranl,3		; bit test f=ranl bit 3 skip if '0'
	xorwf	ranh,f
	bcf	STATUS,C	; clear the carry flag
	btfsc	ranh,7		; bit test f=ranh bit 7 skip if '0'      if the high bit is set ...
	bsf	STATUS,C	; ... set also the carry flag
	rlf	ranl,f		;rotate left f=ranl write back to f
	rlf	ranm,f		;rotate left f=ranm write back to f
	rlf	ranh,f		;rotate left f=ranh write back to f
	retlw	0		;return W=0x00

main:
	btfsc	STATUS,NOT_TO	; if this is a reset or power-up ...
	call	initialise	; CALL 0x0035... clear random number seed
	call	reinitialise	; CALL 0x002B set port drivers and WDT prescaler

main_1:
	call	alive			; CALL 0x003A update LED outputs
	call	random			; CALL 0x003F find next random number
	goto	main_1			; GOTO 0x0054

	end
Arco

Special Member

pic asm code:

alive:				; update the LED drivers
	movwf	port		; move W to port (PORTB) sent the result to the port drivers

vervangen door:

pic asm code:

alive:				; update the LED drivers
	iorwf	port,f		; move W to port (PORTB) sent the result to the port drivers
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Hoi Arco,

Dat is snel, bedankt

Mvg

Ik ben begonnen met assembler en ben daar wel blij om. Je snapt veel beter wat je aan het uitvreten bent.
Daarna PicBasic en ook mePascal.

@rew: in de jaren 80 een IBM upgraden naar 1 kB? Ik geloof er maar heel weinig van. Zelfs op een Sinclair ZX81 kon je 16 kB extra hangen. En de eerste IBM PC's hadden volgens mij al 384 kB aan boord.

Just find out what you like and let it kill you

Ik zie het zo:

ASM: -> Figuurzaag. Uitermate geschikt voor de precisie stukjes.

C/Picbasic etc.: -> Handzaag, voor het normale werk. Kan in principe alles mee gedaan worden, uitgezonderd erg precisiewerk.

Libraries: -> Decoupeerzaag uit de losse pols. Niet zo netjes als met de handzaag, maar grote stappen is snel thuis.

En om principieel alles met ASM te doen is hetzelfde als met een figuurzaag een balk doorzagen: Ja het kan, maar je verbeterd er echt de wereld niet mee, het dient feitelijk zelfs geen enkel doel, je maakt het alleen jezelf lastiger dan nodig.

Ok, duidelijk

Als ik naar PIC Basic zou willen wat heb ik dan nodig aan software?

mvg

Arco

Special Member

Picbasic... :) (meer heb je niet nodig. Is in de demoversie wel erg beperkt tot 50 regels. Mikrobasic kun je in de demoversie 4k aan code compileren)

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

Je kunt ook voor de Amicus 18 kiezen, dat is een wat grotere processor, wordt volledig ondersteund en zonder beperkingen.
Verder zijn er ook enkele 16 bits PIC's die gratis volledig worden ondersteund in PicBasic.

Just find out what you like and let it kill you

Nadeel van Basic is dat elke Basic compiler een erg sterk dialect heeft, overstappen naar een andere compiler of code omschrijven voor een andere compiler kan daardoor erg lastig zijn.
C heeft hier minder last van (wel enigszins afhankelijk van eventuele libraries die je gebruikt), maar heeft wel een steilere leercurve.
De meeste Basic compilers zijn niet gratis (tenzij je een sterk verouderde versie met beperkte hoeveelheid code pakt), terwijl er wel veel gratis (maar ook betaalde...) C compilers zijn.

Zelf spreek ik C, en dan met name voor AVR, en heb bij mijn vorige werkgever in wat mikroBASIC (http://www.mikroe.com/) code voor PIC zitten pielen. Het klinkt misschien tegenstrijdig, maar Basic was makkelijk maar omslachtig. In C kon ik veel makkelijker krachtigere code schrijven.

Mijn advies zou dan ook zijn om voor C te kiezen, maar dat is volgens mij inmiddels wel duidelijk ;)

Zo goed als het vroeger was, is het nooit geweest.

Ok, bedankt voor alle info

Denk dat ik toch eerst naar PIC Basic ga en dan ooit naar C.

mvg