met PIC via triac en met Hall sensor AC motortoeren regelen.

Op 22 oktober 2019 15:02:17 schreef Lambiek:
met interrupt werken.

Zijn daar ook voorbeelden van?

Resultaat:
bovenste lijn is de nuldoorgangdetectie,
onderste de trigger van de triac.

https://lh3.googleusercontent.com/3Bl8KNVKV3hQhy0mr1UaHB_F8nBofqwBVpFiHmoxzEFVLG3-LyV94AGmw8vx1XgE8eork_vdyqHvvWQRMGETWni1XAlF337xvBXNGeUNITwq9LFBn5RqictuAScGg-li8Sxwrj01fE2kBZjbY8WFSUV7BnNwjFcp9q8wjweQDzuyf5LFFIQFqh1_Nh0FaqbuJDRxVCuXJoGr0v1QIU8b1RPrqgWyn-2B4hJdynvr4uSm-WHu6PQTS_ZpSm3opuOwXH03I49AQplwelkq1kAVqir16cABMFbWrqy5XvfQ6w3W3vXBdlyxbSFRrjy6i4dJUKHohEfBPitrT-BZH3w93h_fKIrMlKvCUGWpsuD1Q8lCoGhzMe8rdZECElQoXD6k0Z1-z39eJbuGQMHQ5NC9Ej_xD1NQyKeoC4nmq4ZOUwwz1iZbZJYW3cG8GWM1z5n95Xu5WwyU06U98X_sFt2HEmqoaDK7aVwIRxvSQto_8D2ieVCRgUwu3n1w2_WyRN14dYhrVS9evz4k1qWeD3ZMkbTV0ZpS0QMP8iiEpz4Lc5E5Y5wISBKBJRoM_JCg986_NaEab_1nW2SbFBwZESev45mugtzQ586WWdCqwEq7XM8fj7_4dtTV___rNRiiA5L7cwC6FojrrrJRgR6RVRO90DY9MrBamq4Zg5uDLW-0YzvFgwukwpf4_nwN=w400-h344-no
Uit

https://lh3.googleusercontent.com/k26ctQQTxMKngMz7jatndeVwU4FBQbHQBLKqG5cLN53pJ4DFoFCq4pbk1b5oFOsFMcFPZR-kGMAqV7m1F2f1tlU04RZEUytZF-YSN-TXyPMbDVHKPQ3dLgFPk7fBK_KBsFRFIHT40yWxTsBLYkIaeDqXkTrrxy5Dw6kD0WdIfI-GvjQdR0wHbxiN9MzpEK-kzw6HQEvTS0FT3l9omOFUrRWE5Cnbte63hfxo37sD_02QcfTxFLZVEHjkcSQ-Bc8WNWJYX309ylHEqQADZMtBlPSS330N4GsNb-rGLJWKrWGsnSmOnKuDAa5v0kpbGWouhfpt9CS9K2omAPCqun1dlS7wFYYL5rkfFFZ2aTWZY_I_YLsBHT8-afos7ieCi7Ii7iv29OiPQqXuCjj8Hntkz3iHLbaEJ72Lr0c7TE-6HmpM4CjL-paSFFXbttQgpkijDLzkN5-h8f-HtItYZODYcu7kgcFhrtSC78IlAPBuJlnyCJggjFfeoSbAkX3Jps4i5Rw291g6Nh6Zijh-WrFyiqaCMTmy6a_1cjgCTYraHUgAUHUPqVbdtr69Ki-ye1gkwob66wuK93FuWq4_ryP4eS7LtW8s5Vuw0wQL9P86Wv_SKXk-Ixr17m3jOQpBPhnykBQzU97GJ_qxwe8NglWqvlsYEFa3u2mNlUQNRc9CAnkYdwCDR-o5Vt4Y=w400-h368-no
Half

https://lh3.googleusercontent.com/klaUPoK_xdO6dfEfOw7t_fdyka_3VgwAeT4gR8WioI2Uai-VhJlnp2ZoCaSDZ6b-yfXkEO0QwDWlGVT8tJO3WZKH0FJrvzP3jN9otVmSBYjLl1g8YuFLcveJQBAeDpAl4SrdCOC4pcy3xUReH6R321p2Ji-JAXiQSrKv6TfbPoUfyfIW1TxXGQ0BOD7sFmO9pQGmmbzLTtLkCRG-pz8CuUhZOJRFYQNMOnIcXFgFiWHnuDVQCFTlVLs6ejUYAs4V3Y8Vw6EjON2iTdLGM2qyzNJxAFJ7DBFKKpLaSuLdIcOSSI3G-BRWNrXGmfgrgOmPmzv9xD_neTp47BGRbxjhfdWctCw1TpEPdBFgMlzyWGuQrsvrMwDIjyF5o3IPEkjdj4gXluAfVn4t1HosGiaFI9fbzkdGV7Z6QQrJNv58pZWMZqn3PH1G3LyElVZZnNuKDR_ByCYefRWfi1M7ESb-CAGHpipPrcGp_5h54-EgXvUIXIdPIynJt2OkTE2A3FtpE-2R6M5ODmBSHmY_nvdMDU3obmeP_3VMCe48D0Y3tJNpZV_yFpmWyo2q88SVF_LpoiXSg0VJEB4zFzKCE6KQsIuA0hzGVeSU33PuFn6ABh_1eZrmcYAcp0aQaCshmEKXZpRhxqzTJPguwxyYRVILyTp10SyerPEc2r1EPx9LM6Rr4QiPhC6qjNzl=w400-h370-no
en Volle uitsturing naar de triac

Lambiek

Special Member

Op 22 oktober 2019 16:51:11 schreef stortbak:
Zijn daar ook voorbeelden van?

Je vind het ook wel verdomd makkelijk als een ander het voor je opzoekt geloof ik.

pic basic code:


On_Hardware_Interrupt
Syntax
On_Hardware_Interrupt Label
Overview
Point to the subroutine that will be called when a hardware interrupt occurs. High priority hardware
interrupt if using an 18F device.
Operators
Label is a valid identifier
Example
' Flash an LED on PORTB.0 at a different rate to the LED on PORTB.1
'
Device = 16F877
Declare Xtal = 4
On_Hardware_Interrupt Goto ISR_Flash
Goto Main ' Jump over the interrupt subroutine
' ---------------------------------------------------
' Timer0 overflow interrupt handler starts here
' Xor PORTB with 1, which will turn on the LED connected to PORTB.0
' with one interrupt and turn it off with the next interrupt
'
ISR_Flash:

Context Save ' Save any variables or SFRs before the interrupt starts
If INTCONbits_T0IF = 1 Then ' Is it TMR0 that caused the interrupt?
PORTB = PORTB ^ 1 ' Yes. So. Xor PORTB.0
INTCONbits_T0IF = 0 ' Clear the TMR0 overflow flag
EndIf
Context Restore ' Restore any variables or SFRs and exit the interrupt
' ---------------------------------------------------
' The main program loop starts here
'
Main:

Low PORTB = 0 ' Make PORTB all outputs and pull it low
'
' Initiate the interrupt
'
OPTION_REG = %00101111 ' Setup Timer0
TMR0 = 0 ' Clear TMR0 initially
INTCONbits_T0IE = 1 ' Enable a Timer0 overflow interrupt
INTCONbits_GIE = 1 ' Enable global interrupts
While ' Create an infinite loop
Clear PORTB.1 ' Extinguish the LED
DelayMs 500 ' Wait a while
Set PORTB.1 ' Illuminate the LED
DelayMs 500 ' Wait a while
Wend

pic basic code:


Typical format of the interrupt handler with standard 14-bit core devices.
The interrupt handler subroutine must always follow a fixed pattern.
• First, the contents of the STATUS, PCLATH, and Working Register (WREG) must be
saved, this is termed context saving, and is performed when the command Context
Save is issued. Variable space is automatically allocated for these registers in the
shared portion of memory located at the top of RAM Bank 0. The Context Save command
also instructs the compiler to save any compiler system variables and device
SFRs (Special Function Registers) used within the interrupt handler. Note that "within
the interrupt handler" means code between Context Save and Context Restore. It will
not track any Goto or Gosub commands.
• Because a standard 14-bit core device has a single interrupt vector, the cause of the interrupt
must be ascertained by checking the appropriate flag. For example INTCON.T0IF
for a Timer0 overflow interrupt, and only perform the relevant code for the relevant interrupt.
This is accomplished by a simple If-EndIf. For example:
ISR_Handler:

Context Save ' Save any variables or SFRs used
If INTCONbits_T0IF = 1 Then ' Is it Timer0 that caused the interrupt?
Print "Hello World" ' Yes. So do this code
INTCONbits_T0IF = 0 ' Clear the Timer0 overflow flag
EndIf
Context Restore ' Restore any variables or SFRs used and exit
If more than one interrupt is enabled, multiple If-Endif conditions will be required within the single
interrupt handling subroutine.
• The previously saved STATUS, PCLATH, and Working register (WREG) must be returned
to their original conditions (context restoring) once the interrupt handler has performed
its task. The Context Restore command is used for this. It also returns the program
back to the main body code where the interrupt was called from. In other words it
performs an assembler Retfie instruction.
The above code snippet will cause several compiler system variables and device SFRs to be
saved and restored, thus causing little, or no, disturbance to the main body code.
Typical format of the interrupt handler with enhanced 14-bit core devices.
As with standard 14-bit core interrupts, the interrupt handler subroutine must follow a fixed pattern.
• First, the Context Save command should be issued, as this will save any compiler system
variables and SFRs used. The microcontroller itself will save the contents of the
STATUS, PCLATH, BSR, FSR0L\H, FSR1L\H and WREG registers.
• As with standard 14-bit core devices, enhanced 14-bit core devices have a single interrupt
vector, therefore the same rules apply as outlined above concerning the establishment
of the cause of the interrupt. Not forgetting to clear any interrupt flag that needs
clearing before exiting the interrupt.
Proton Compiler. Development Suite.
305
Rosetta Technologies/Crownhill Associates Limited 2014 - All Rights Reserved Version 3.5 10-03-2014
• The Context Restore command should be issued at the end of the interrupt handler, as
long as its corresponding Context Save command was used previously. This will restore
any compiler system variables and SFRs, then exit the interrupt using the Retfie mnemonic.
Note that the STATUS, PCLATH, BSR, FSR0L\H, FSR1L\H and WREG registers will automatically
be restored by the microcontroller once the interrupt is exited.
As with standard 14-bit core devices, any compiler variable or device SFR that is used by a
command will be saved and restored as long as they reside within the Context Save and Context
Restore commands. This is termed Managed Interrupts.
Note that the Context Save and Context Restore commands are not required unless managed
interrupts are implemented, in which case use the Retfie mnemonic to exit the interrupt
handler. However, you must be certain that the interrupt handler is not disturbing any compiler
system variables or SFRs, or your program will not run correctly.
Typical format of the interrupt handler with 18F devices.
As with both types of 14-bit core devices, the interrupt handler subroutine must also follow a
fixed pattern.
• First, the Context Save command should be issued, as this will save any compiler system
variables and SFRs used. The microcontroller itself will save the contents of the
STATUS, BSR and WREG registers for a high priority interrupt.
• 18F devices have two interrupt vectors for high and low priority interrupts, see
On_Low_Interrupt. However, both of these must follow the rules laid down for 14-bit
core devices, in that the cause of the interrupt must be ascertained before the appropriate
code is performed, and any interrupt flag that needs clearing must be cleared before
exiting the interrupt.
• The Context Restore command should be issued at the end of the interrupt handler, as
long as its corresponding Context Save command was used previously. This will restore
any compiler system variables and SFRs, then exit the interrupt using the Retfie 1 mnemonic.
Note that the STATUS, BSR and WREG registers will automatically be restored by the microcontroller
once the interrupt is exited from a high priority interrupt.
Upon exiting the interrupt, a simple Retfie 1 (Return From Interrupt Fast) mnemonic can be
used, as long as the Context Save command is not issued and it is certain that the interrupt
handling subroutine is not disturbing any compiler system variables or device SFRs.
Note.
On all devices, the code within the interrupt handler should be as quick and efficient as possible
because while it's processing the code, the main program is halted. When inside an interrupt,
care should be taken to ensure that the watchdog timer does not time-out, if it's enabled. Placing
a ClrWdt mnemonic at the beginning of the interrupt handler will usually prevent this from
happening. An alternative approach would be to disable the watchdog timer altogether at programming
time, which is the default of the compiler.

pic basic code:


On_Low_Interrupt
Syntax
On_Low_Interrupt Label
Overview
Point to the subroutine that will be called when a Low Priority Hardware interrupt occurs on an
18F device.
Operators
Label is a valid identifier
Example
' Demonstrate the use of context saving of the compiler's System variables
' Creates low and high priority interrupts incrementing on Timer0 and Timer1
' Within the interrupts a value is displayed and incremented
' In the foreground another value is incremented and transmitted serially
'
Include "Proton18_4.Inc" ' Use the Proton Board with an 18F device
Declare Optimiser_Level = 3 ' Use max optimisation for tight/fast Asm code
' Point to the High Priority interrupt handler to the subroutine
On_Hardware_Interrupt Goto ISR_High
' Point to the Low Priority interrupt handler to the subroutine
On_Low_Interrupt Goto ISR_Low
'
' Create some variables
'
Dim HighCounter as Dword ' Counter for the high interrupt routine
Dim LowCounter as Dword ' Counter for the low interrupt routine
Dim ForeGroundCounter as Dword ' Counter for the Foreground routine
Dim wTimer0 as TMR0L.Word ' Create a 16-bit Word from registers TMR0L/H
Dim wTimer1 as TMR1L.Word ' Create a 16-bit Word from registers TMR1L/H
' ------------------------------------------------------------------
Goto Main ' Jump over any subroutines
'
' ------------------------------------------------------------------
' High Priority Hardware Interrupt Handler
' Interrupt's on a Timer1 Overflow. Display on the LCD and increment a value
'
ISR_High:

'
' Save the compiler's system variables used in the interrupt routine only
' Also save any SFRs used
'
Context Save PORTD, TRISD
If PIR1bits_TMR1IF = 1 Then ' Is it a Timer1 overflow interrupt?
' Yes. So Display the value on the LCD
Print at 1,1,"High Int ", Dec HighCounter
Inc HighCounter ' Increment the value
PIR1bits_TMR1IF = 0 ' Clear the Timer1 Overflow flag
EndIf
'
' Restore compiler's system variables used within the interrupt routine only
' and exit the interrupt
'
Context Restore
Proton Compiler. Development Suite.
307
Rosetta Technologies/Crownhill Associates Limited 2014 - All Rights Reserved Version 3.5 10-03-2014
' ------------------------------------------------------------------
' Low Priority Hardware Interrupt Handler
' Interrupt's on a Timer0 Overflow
' Display on the LCD and increment a value
'
ISR_Low:

' Save the compiler's system variables used in the interrupt routine only
' Also save any SFR's used.
'
Context Save PORTD, TRISD
If INTCON1bits_TMR0IF = 1 Then ' Is it a Timer0 overflow interrupt?
'
' Yes. So Disable Timer 1 High priority interrupt while we use the LCD
'
PIE1bits_TMR1IE = 0 ' Display the value on line 2 of the LCD
Print at 2,1,"Low Int ", Dec LowCounter," "
Inc LowCounter ' Increment the value
PIE1bits_TMR1IE = 1 ' Re-Enable the Timer1 High priority interrupt
INTCON1bits_TMR0IF = 0 ' Clear the Timer0 Overflow flag
EndIf
'
' Restore the compiler's system variables used in the interrupt routine only
' and exit the interrupt
'
Context Restore
'
' ------------------------------------------------------------------
' The Main Program Loop Starts Here
'
Main:

Delayms 100 ' Wait for the LCD to stabilise
INTCON1 = 0 ' Disable Interrupts
Low PORTD ' Set PORTD to Output Low
HighCounter = 0
LowCounter = 0
ForeGroundCounter = 0
Cls ' Clear the LCD
'
' Setup Timer0
'
T0CONbits_T0PS2 = 0 ' \
T0CONbits_T0PS1 = 0 ' Timer0 Prescaler to 1:4
T0CONbits_T0PS0 = 1 ' /
T0CONbits_PSA = 0 ' Assign the prescaler
T0CONbits_T0CS = 0 ' Increment on the internal Clk
T0CONbits_T08Bit = 0 ' Timer0 is configured as a 16-bit counter
wTimer0 = 0 ' Clear Timer0
T0CONbits_TMR0ON = 1 ' Enable Timer0
'
' Setup Timer1
'
T1CONbits_RD16 = 1 ' Enable Timer1 in 16-bit operation
T1CONbits_T1CKPS1 = 0 ' \ Timer1 Prescaler to 1:2
T1CONbits_T1CKPS0 = 0 ' /
T1CONbits_T1OSCEN = 0 ' Disable External Oscillator
T1CONbits_TMR1CS = 0 ' Increment on the internal Clk
wTimer1 = 0 ' Clear Timer1
T1CONbits_TMR1ON = 1 ' Enable Timer1
Proton Compiler. Development Suite.
308
Rosetta Technologies/Crownhill Associates Limited 2014 - All Rights Reserved Version 3.5 10-03-2014
'
' Setup the High and Low priority interrupts
'
INTCON1bits_TMR0IE = 1 ' Enable the Timer0 overflow interrupt
INTCON2bits_TMR0IP = 0 ' Timer0 Overflow Interrupt to Low priority
INTCON1bits_TMR1IE = 1 ' Enable the Timer1 overflow interrupt
IPR1bits_TMR1IP = 1 ' Timer1 Overflow Interrupt to High priority
RCONbits_IPEN = 1 ' Enable priority levels on interrupts
INTCON1bits_GIEL = 1 ' Enable low priority peripheral interrupts
INTCON1bits_GIE = 1 ' Enable all high priority interrupts
'
' Display value in foreground while interrupts do their thing in background
'
While ' Create an infinite loop
' Display the value on serial terminal
Hrsout "ForeGround ", Dec ForeGroundCounter, 13
Inc ForeGroundCounter ' Increment the value
Delayms 200
Wend ' Close the loop. i.e. do it forever
Als je haar maar goed zit, GROETEN LAMBIEK.

Op 23 oktober 2019 21:44:17 schreef Lambiek:
[...]
Je vind het ook wel verdomd makkelijk als een ander het voor je opzoekt geloof ik.

Het is een gesloten vraag. Het antwoord is dus 'JA' of 'NEE' :+
, maar toch aardig dat je met een voorbeeld komt :)

Bezoek mijn neefjes' site: www.tinuselectronics.nl
Lambiek

Special Member

Als je haar maar goed zit, GROETEN LAMBIEK.

Op 23 oktober 2019 23:07:53 schreef Lambiek:
:)

Lambiek bedankt voor de vele lettertjes.
Natuurlijk is het makkelijk als een ander een enkele zin voor je vertaalt en niet zegt "leer eerst de taal maar, dan kan je die ene regel zelf vertalen".

Het zegt me echter nagenoeg niets, want ik zie niet wat ze uiteindelijk willen, dus niet waarom ze dit schrijven.
Zal dus de schakeling moeten verzinnen, nabouwen en dan kijken wat er waarbij gebeurt.
Pas daarna kan ik beoordelen of het voor mijn project van betekenis kan zijn.
Een hoop werk met een onzekere uitkomst, dus ik rommel nog even op mijn manier verder.

Momenteel druk met uitproberen van de triacregeling.
Dat vordert.
En werkt perfect, zelfs met wat rekenregels er tussen (de juist plaats voor die regels in het program heb ik al ontdekt)
Heb alleen ruzie met tijden en waardes als er ook een "print at" opdracht in het programma staat.

Ik kan al wel een waarde ingeven (gewenste snelheid), die wordt verrekend en als delay aangeboden.
Ook kijkt de pic naar de terugmelding van het toerental en regelt bij of af.
Dat signaal maak ik nu nog met potmeter en een pwm uitgang die ik weer laat inlezen.

Gaat leuk.
Eerst maar eens de pic splitsen in een reken-pic en een triac-pic.
Eens zien tussen welke pootjes ik de zaagsnede kan maken ;)

Lambiek

Special Member

Op 24 oktober 2019 12:58:01 schreef stortbak:
En werkt perfect, zelfs met wat rekenregels er tussen (de juist plaats voor die regels in het program heb ik al ontdekt)
Heb alleen ruzie met tijden en waardes als er ook een "print at" opdracht in het programma staat.

Een print opdracht kost nu eenmaal instructie tijd, daar valt niets aan te veranderen. Wat je kunt doen is alleen een print opdracht geven als er iets veranderd, "dus niet continue een print opdracht geven" dan heb je er in je programma verder geen last van.

Als je haar maar goed zit, GROETEN LAMBIEK.

Op 24 oktober 2019 16:43:25 schreef Lambiek:
[...]
verder geen last van.

klopt, maar ik zie graag wat er gebeurt terwijl ik aan het schrijven ben.

Heb alleen last van iets verschrikkelijks.

Is het een geheime combinatie van letters?
In het programma staat: B = C / D

Wis ik die regel staat alles vast en dat is niet te verhelpen zoals een delay te schrijven waar eerst een print at stond.

Die regel is ooit gebruikt om wat getallen te verrekenen.
het volgende stond er

DIM A AS WORD
DIM B AS FLOAT
DIM C AS WORD
DIM D AS WORD
DIM UITMIN AS WORD
DIMUITMAX AS WORD
DIM INMIN AS WORD
DIM INMAX AS WORD
DIM INLEES AS WORD
DIM UITSTUUR AS WORD

Verderop werd een waarde toegekend aan de variabelen
die heb ik nu maar op 0

uitmin =0
uitmax=0
inmin=0
inmax=0

in het progr:

"
hier stond een formule
"

Wanneer ik overal een ; voor zet en daardoor die regel inactief maak,
blijft het werken zolang B=C/D maar actief blijft.

is dat B= een combinatie die je niet mag gebruiken in de 16f887?

maak ik er dit van, blijft het ook werken: B = C ;/D
B=200 geeft ook een fout. net als B=0-0 ook fout
Zet ik B=C weer terug: alles ok

De kortste versie waarop alles normaal blijft is:
dim b as float (as word pikt hij ook niet)
dim c as word
en
b=c

Ik ken dit soort dingen omdat ik ooit bij een handling robot die met een camera de positie bepaalde van hoe een stuk op een transportband lag en daar zijn grijperstand op aanpaste, om dat stuk op te pakken.
veel interne commando's gebruikten V****** (V van vision)

noemde je echter een programma V28okt2019-1450
dan ging dat ding ook helemaal over de ruk.

leering: geen V gebruiken in een programma naam.

Lambiek

Special Member

Op 28 oktober 2019 15:01:09 schreef stortbak:
klopt, maar ik zie graag wat er gebeurt terwijl ik aan het schrijven ben.

Oké, maar dat kun je naderhand weer verweideren als je programma klaar is.

DIM B AS FLOAT

Dit is ook zoiets wat je moet zien te vermeiden, vreet instructie tijd.

Als je haar maar goed zit, GROETEN LAMBIEK.
Lambiek

Special Member

Als je haar maar goed zit, GROETEN LAMBIEK.

Op 28 oktober 2019 18:47:23 schreef Lambiek:
ook zoiets wat je moet zien te vermeiden, .

Hoe kan je dan nog meer oplossen dat je bij een berekening (een deling van twee variabelen) geen getallen krijgt met een komma?
Zonder dat je gaten in de reeks krijgt door breuken over te slaan of de getallen dusdanig te gaan manipuleren dat er geen breuken kunnen ontstaan.

Zoals Lambiek ook al opmerkte zie ik niet in hoe je zo'n tijdsgebonden programma zonder interrupts kunt maken.

Voor berekeningen heb je toch geen cijfers na de komma nodig gezien zo'n AC motor toch niet zo heel volgzaam is wegens de sterk wisselende slip.
16 bits berekeningen zijn meer dan voldoende en laat de rest vallen.

Verdeel een halve periode in bv. 50 stappen en trigger de triac in die berekende stappen.

Je zult toch eens wat tijd moeten maken om u eens te verdiepen hoe interrupts werken, daar is veel over te vinden, eerst de handleiding van Protonbasic eens nalezen, algemene artikels over interrupts zijn ook goed en moeten niet noodzakelijk in een bepaalde taal geschreven zijn.

Verspil uw tijd niet aan problemen enkel om wat tijd uit te sparen, een controller is razendsnel maar je moet hem onder controle kunnen houden ;)

LDmicro user.

Op 29 oktober 2019 10:12:35 schreef MGP:
Zoals Lambiek ook al opmerkte zie ik niet in hoe je zo'n tijdsgebonden programma zonder interrupts kunt maken.

Voor berekeningen heb je toch geen cijfers na de komma nodig

Op de manier zoals ik het doe heb ik berekeningen nodig.
En al eerder is bewezen dat dat perfect werkt.
Heb een modelstoomketel die zelf waterpeil en druk regelt.
Met slechts 1 keuze knop: uit/1 brander gebruiken/gebruik indien nodig 2 branders.
Brander start op op gas, gaat over op wasbenzine, sluit gas, bij naderen van de maximumdruk regelt de brander af, bij bereiken van de maximumdruk gaat de brander uit.
Tweede brander kan werken in het gebied tussen halve druk en een iets lagere maximumdruk dan brander 1.
Helemaal hufterproof, met vlam ionisatiedetectie, vonkontsteking, waterhoogte meting op basis van lichtbreking, verlegging van gewenste waterpeil afhankelijk van of er wel of geen stoom wordt afgenomen.

Het lijkt er sterk op dat je zelf geen voorstelling hebt wat het allemaal inhoudt.
Een korte uitleg inzake project pelletkachel:
op het display geef je een waarde 350 -- 2700 RPM in
daar maak je een getal van 0---255
dat is nodig om een pwm signaal te maken dat je aanbiedt aan de andere pic.
Die leest de spanning en maakt er een delay tijd van.
Je lijkt nu te beweren dat je dat allemaal zonder berekeningen kan doen: erg knap hoor.
Ik ben benieuwd naar je oplossing.
Wat heb je zelf al met de pic gemaakt?

Over de interrupts schreef ik eerder dat het me niets zegt, dat ik dan dat hele verhaal moet gaan namaken om te kunnen zien wat er gebeurt.
Daarna kan ik dingen veranderen om te ontdekken wat er en waarom er dan iets gebeurt.
Pas dan kan ik beoordelen of het wel of niet toepasbaar is.

Dan is naar een oplossing toewerken, zien wat er gebeurt en dat veranderen tot het naar behoren werkt simpeler.
Ik heb het simulatieprogramma dat nodig was om de triac-pic te sturen in het hoofdprogramma weten te zetten en dat zonder de B=C/D regel en het werkt..........

Nu dus 1 hoofdpic en straks 2 picjes die alleen de nuldoorgang bekijken en een gewenst toerental aangeboden krijgen waar ze zelf een wachttijd van maken om samen met een tachosignaal een uitsturing te maken. Die picjes hebben twee berekeningen met floats.

Want ik heb nog steeds niets aangeboden gekregen op mijn eerste vraag triacsturing MET TACHO. 8)7

Wat heb je zelf al met de pic gemaakt?

Waarschijnlijk meer als dat jij ooit nog gaat maken... ;)

Programma zonder interrupts is inderdaad niet handig, en op zijn minst een 'pain in the ass' om te onderhouden...
Ik zie ook niet waarom je 2 extra pics nodig zou hebben om de nuldoorgang vast te stellen???

(met 1 pic kun je alles doen, en die staat dan nog 90% van de tijd niets te doen...)
Ik vind het na 4 pagina's topic weinig duidelijker geworden als aan het begin...

Floats e.d. kun je vermijden door de komma eruit te shiften (je houdt dan hele getallen over)

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Op 29 oktober 2019 12:05:25 schreef Arco:
[...]
Floats e.d. kun je vermijden door de komma eruit te shiften (je houdt dan hele getallen over)

Als ik daarop zoek, krijg ik geen resultaat in de proton handleiding. :'( hoe dan?

met 1 pic kun je alles doen, en die staat dan nog 90% van de tijd niets te doen

Leg eens uit hoe ik na een nuldoorgang een tijdvertraging moet geven om de fase-aansnijding van een triac te maken en dat dan in 1 pic met twee triacs met verschillende aansnijpunten.
Daar heb ik al eerder om gevraagd, ik ben blij wanneer je nu gaat zeggen hoe, want blijkbaar heb je die vraag over het hoofd gezien.

Hardware timers met output set on compare match, of interrupt on compare match.

Berekeningen zonder floats doe je met fixed-point math. In dit geval zou ik CPU cycles gebruiken als eenheid voor tijd, dat maakt het leven met timers simpel.

Je bent continue mensen die je, ondanks je eigen gedrag, nog steeds helpen voor idioot aan het uitmaken ("Wat heb je zelf al met de pic gemaakt?" bijvoorbeeld), terwijl jij hier het groentje bent dat er de ballen van begrijpt, terwijl veel van ons professionals zijn.

Een manager is iemand die denkt dat negen vrouwen in één maand een kind kunnen maken

Nuldoorgang detector geeft een puls op een I/O pin met interrupt functie.
In de interrupt functie laad je 2 hardware timers (een voor elke triac) met de gewenste waarde. Zodra een timer "afgaat" geeft dit weer een interrupt waarmee je de triac kan sturen.

De truc is om de "wacht tijd" met hardware timers en interrupts te doen zodat je processor tijd heeft voor andere zaken.

It's the rule that you live by and die for It's the one thing you can't deny Even though you don't know what the price is. It is justified.

Niet goed gelezen? ik heb niet gezegd dat je niet kunt programmeren en ook niet dat je geen berekeningen moet maken, wel dat 16bits berekeningen meer dan voldoende zijn, daar hoeven absoluut geen float-berekeningen bij.

Maar ik heb wel ervaring als het op triac's en motoren aankomt en ook veel programmeerervaring (no picbasic) en weet heel goed waarover ik spreek.
Je zou er ook veel van opsteken moest je de interrupt logica leren, dan kun je pas goed programmeren en verbindingen maken met de buitenwereld.
Dat het u niks zegt is maar een ingesteldheid en daar kun je wat aan doen.

Wat ik al gemaakt hebt kan ik hier niet allemaal opnoemen, de lijst is veel te lang en ik schat gemiddeld 1 programma/week.

Het laatste programma voor iemand van CO staat hier.

Een deeltje voor CO gemaakt kun je hier zien.

Nog eentje https://www.circuitsonline.net/forum/view/136451/last#highli...trapsensor

Gepost dinsdag 11 juli 2017 15:42:05 |Quoten
Hallo MGP,
Lang geleden beloofd (en gemaakt)en nu eindelijk op YOUTUBE, de filmpjes van de fiets met en zonder trapvolger. Het geluid hard zetten dan hoor je het wiel draaien (met wat bijgeluiden). Doe even copy / paste van de files op de computer en de filmpjes doen het. O ik zie dat het gelijk linkjes worden dus dat hoeft niet.

met : https://www.youtube.com/watch?v=0uUKDxKebGs
zonder : https://www.youtube.com/watch?v=sLt7_B5MeWc

Nu ongeveer 400km mee gefietst en het gaat goed.

Want ik heb nog steeds niets aangeboden gekregen op mijn eerste vraag triacsturing MET TACHO.

Verwacht je dat echt? |:( dan moet ge dringend uw forumverwachtingen herzien!

LDmicro user.

Als ik daarop zoek, krijg ik geen resultaat in de proton handleiding. :'( hoe dan?

Dat heeft ook niks met picbasic te maken, maar met programmeertechnieken in het algemeen.

Leg eens uit hoe ik na een nuldoorgang een tijdvertraging moet geven om de fase-aansnijding van een triac te maken en dat dan in 1 pic met twee triacs met verschillende aansnijpunten.

Zoals gezegd: timer met interrupts.
Ik doe nuldoorgansdetectie, fase aansnijding met 24 kanalen en nog veel meer met 1 pic (en nog heeft die niet echt veel te doen)

MikroE heeft veel eBooks over de 'basic basics'... ;)
https://www.mikroe.com/ebooks/pic-microcontrollers-programmi...troduction

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

Op 29 oktober 2019 13:21:02 schreef SparkyGSX:
terwijl jij hier het groentje bent dat er de ballen van begrijpt, terwijl veel van ons professionals zijn.

1 daar schaam ik me niet voor, ik ben goed in heel veel andere dingen.
2 blijkbaar is het te moeilijk om even wat programmaregels uit hun mauw te schudden, met moeilijke termen strooien is het enige dat ik hier zie.
Alleen heeft het groentje daar niets aan.

Je kunt wel hulp krijgen, maar het is wel prettig als je zelf ook enige inspanning levert.
En niet gaat zitten wachten tot er een kant-en-klaar programma wordt afgeleverd...
Wat heb je al tot nu toe?

[Bericht gewijzigd door Arco op 29 oktober 2019 13:50:12 (14%)]

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

2 blijkbaar is het te moeilijk om even wat programmaregels uit hun mauw te schudden

Bij deze, het is voor AVR want ik doe geen PIC, het principe blijft hetzelfde.

https://playground.arduino.cc/Main/ACPhaseControl/

It's the rule that you live by and die for It's the one thing you can't deny Even though you don't know what the price is. It is justified.

Op 29 oktober 2019 13:52:59 schreef Roland van Leusden:
, het is voor AVR want ik doe geen PIC,

Dank voor de moeite, maar de nuldetectie en de triac doen het al volgens schema van Lambiek.
Bovendien zie ik bij die arduino ook geen tacho. :'(

Ik zal wel kijken of ik wat kan brouwen uit die arduino-timertaal, want die spreek ik niet.

Op 29 oktober 2019 13:49:18 schreef Arco:

Wat heb je al tot nu toe?

Een motor waarvan ik de toeren kan instellen aan de hand van een potmeter.
Een andere potmeter doet nu dienst als tacho.

draai ik de tacho te hoog = te snel regelt de pic iets af, draai ik de tachopot omlaag= langzamer geeft de pic weer de ingestelde waarde.

Het werkt dus, alleen zonder timers en interrupten.
En straks met 1 pic per triac en een hoofdpic met display en knopjes voor in de kachel.

Ik heb dus niet zitten wachten totdat ik hier zie dat er alleen maar weer gepraat wordt.

De sollwert potmeter vervang ik door een getal uit de hoofdpic, dat staat voor de gewenste snelheid en de tachopot wordt een pulsgever die via een frequentie naar voltomzetter een signaal aan de triacpic geeft.

Het werkt dus, alleen zonder timers en interrupten.

Post die code dan...

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com