|
DataMuseum.dkPresents historical artifacts from the history of: CP/M |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about CP/M Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 54400 (0xd480)
Types: RcTekst
Names: »LÆRER.WP«
└─⟦be08f6879⟧ Bits:30003899/Brug_pæren_lærer-tekst.imd Brug pæren Rev. 1.0 (Piccolo)
└─⟦this⟧ »LÆRER.WP«
╱04002d4e0a00060000000002084e31400000000000000000000000000000000000000000000000000c16202a343e48525c66707a848e98ff04╱
════════════════════════════════════════════════════════════════════════
↓
┆14┆┆b3┆┆b0┆"BRUG PÆREN" LÆRERTEKST Side ┆0b┆↲
╱04002d4e0a00060000000002194131400000000000000000000000000000000000000000000000001d27313b454f59636d77818b959fa9ff04╱
╱04002d4e0a00060000000002084e31400000000000000000000000000000000000000000000000000c16202a343e48525c66707a848e98ff04╱
↓
↲
↲
↲
┆b0┆┆b0┆MAPPEN:↲
_________________________________________↲
↲
↲
LÆRERTEKSTEN:↲
... programmeringsprincip for lyspanelet↲
... funktionsprincip for lyspanelet↲
... lærer-vejledning til↲
undervisningsmaterialet↲
... program-dokumentation for↲
diskettens programmer↲
↲
↲
ELEVTEKSTEN:↲
... teori↲
... opgaver (een løsning)↲
... problemer (flere løsninger)↲
... tabeller↲
... arbejdsark (hjælp til løsninger)↲
↲
↲
TEKNISK TILLÆG:↲
... datablad for lyspanel↲
... tilslutning af lyspanel til ↓
┆1f┆┆1f┆┆1f┆┆1f┆forskellige↲
microdatamatfabrikater↲
↲
_________________________________________↲
↲
↲
┆b0┆DISKETTEN:↲
_________________________________________↲
↲
↲
Disketten indeholder programmer ↲
┆1f┆┆1f┆┆1f┆┆1f┆skrevet i COMAL80 til:↲
... elevbrug ved opgaveløsning↲
... lærerbrug ved fremstilling af opgaver↲
┆1f┆┆1f┆┆1f┆på printer.↲
... løsningseksempler til alle ↲
┆1f┆┆1f┆┆1f┆opgaver/problemer i elevteksten↲
↲
_________________________________________↲
↲
↲
┆b0┆LYSPANELET:↲
_________________________________________↲
↲
↲
Lyspanelet består af en boks med en ↓
vandret række med 8 lamper, samt 4 ↓
lyskurve: To med 3 lamper (rød-gul-grøn) ↓
og to med 2 lamper (rød-grøn). ↓
Lamperne kan styres fra micro┄datamaten ↓
ved hjælp af simple programmer, her ↓
COMAL80-programmer, via en parallelport ↓
med 8-10 bit. ↲
↲
_________________________________________↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆FORORD:↲
_________________________________________↲
↲
↲
Datamaskiner anvendes til at løse mange ↓
forskellige problemer i samfundet. Man ↓
kan sige, at der er tale om mindst 3 ↓
principielt forskellige an┄ven┄del┄ses┄↓
områder:↲
↲
↲
┆b0┆(1) ADMINISTRATION↲
┆b0┆(2) AUTOMATISERING↲
┆b0┆(3) KOMMUNIKATION↲
↲
↲
Emnet "AUTOMATISERING" kan deles i 3 ↓
del┄emner:↲
↲
┆b0┆(A) STYRING┆f0┆ (data ud af micro'en)↲
┆b0┆(B) MÅLING ┆f0┆ (data ind i micro'en)↲
┆b0┆(C) REGULERING ┆f0┆ (data begge veje)↲
↲
↲
Hvis delemnet ┆b0┆"STYRING"┆f0┆ skal behandles i ↓
┆19┆┄┆81┆┄undervisningen på en konkret og virkelig┄↓
┆19┆┄┆81┆┄hedsnær måde, kræver det naturligvis at ↓
┆19┆┄┆81┆┄eleverne har mulighed for selv at arbejde ↓
┆19┆┄┆81┆┄med styring af et system udenfor selve ↓
┆19┆┄┆81┆┄datamaskinen. Det kræver desuden inter┄↓
┆19┆┄┆81┆┄face┄udstyr til sammenkobling af det ↓
┆19┆┄┆81┆┄eksterne udstyr og microdatamaten.↲
↲
↲
Til "BRUG PÆREN" hører et lyspanel med ↓
små pærer på frontpladen, der kan styres ↓
med f.eks. COMAL80-programmer. Lyspanelet ↓
indeholder desuden interface til pærerne ↓
så det direkte kan tilsluttes en micro┄↓
datamat.↲
↲
↲
Undervisningsmaterialet "BRUG PÆREN" skal ↓
derfor ses som en mulighed for, på en ↓
simpel og konkret måde, at behandle emnet ↓
┆b0┆"STYRING"┆f0┆ i den elementære datalære┄↓
┆19┆┄┆81┆┄undervis┄ning.↲
↲
↲
Uden assistance fra kolleger, i form af ↓
afprøvning, ideer og kritik, var "BRUG ↓
PÆREN" ikke blevet lavet. ↲
↲
↲
Tak for hjælpen !↲
↲
↲
↲
CHRISTIAN WANG↲
ODENSE 1983↲
1. UDGAVE↲
════════════════════════════════════════════════════════════════════════
↓
╱04002d4e0a000600000000021449314000000000000000000000000000000000000000000000000018222c36404a545e68727c86909aa4ff04╱
╱04002d4e0a00060000000002194131400000000000000000000000000000000000000000000000001d27313b454f59636d77818b959fa9ff04╱
↓
↲
↲
↲
┆b0┆PRINCIPPET BAG PROGRAMMERINGEN AF LYSPANELET: ↲
_____________________________________________________↲
↲
Enhver microdatamat er udstyret med stik for ↓
tilkobling af forskelligt udstyr:↲
TASTATUR, PRINTER, SKÆRM, DISKSTATION, MODEM, m.m..↲
↲
Stikkene er forbundet til "IN/OUT"-kredsløb i data┄↓
maten. Disse "IN/OUT"-kredse sørger for trans┄mission ↓
af data ind og ud af datamaten.↲
↲
Der findes to typer "IN/OUT"-kredse. En type beregnet ↓
til ┆b0┆seriel┆f0┆ transmission, og en til ┆b0┆parallel┆f0┆ ↓
┆19┆┄┆82┆┄transmission. Begge typer er udstyret med kontrol┄↓
┆19┆┄┆82┆┄linier, der kan synkronisere datamatens databehandling ↓
┆19┆┄┆82┆┄med ind- og udgående datastrømme, såkaldt "handshake" ↓
┆19┆┄┆82┆┄signaler.↲
↲
"IN/OUT"-kredsene kan programmeres med to forskellige ↓
formål :↲
↲
(1) ┆b0┆KONTROL┆f0┆ af kredsenes funktioner, og↲
↲
(2) Transmission af ┆b0┆DATA┆f0┆ gennem kredsene.↲
↲
I forbindelse med undervisningsmaterialet ↲
"BRUG PÆREN" og det tilhørende LYSPANEL, benyttes ↓
┆b0┆PARALLELPORTEN til transmission af data ud af micro'en┆f0┆ ↓
┆19┆┄┆81┆┄til lyspanelet:↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
Hvis vi går ud fra, at LYSPANELET er tilsluttet en↲
┆b0┆8 BITS PARALLELPORT┆f0┆, så betyder det, at de 8 lamper på ↓
┆19┆┄┆81┆┄lyspanelet er forbundet med microdatamaten med hver ↓
┆19┆┄┆81┆┄sin ledning samt en stelforbindelse. Disse 8 ledninger ↓
┆19┆┄┆81┆┄kan programmeres til at have en elektrisk spænding på ↓
┆19┆┄┆81┆┄h.h.v. 0 Volt og ca. +4 Volt. Der er kun disse to ↓
┆19┆┄┆81┆┄muligheder: ┆b0┆LAV┆f0┆ og ┆b0┆HØJ┆f0┆ spænding, svarende til tallene ↓
┆19┆┄┆83┆┄"0" og "1" i det binære talsystem, totalsystemet.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
Ønsker man at tænde og slukke for lamperne på ↓
lyspanelet, skal man forestille sig hver lampe ↓
svarende til et ciffer i et binært tal. Hvis vi for ↓
eksempel sender det decimale tal 174 til parallel┄↓
porten, vil lamperne lyse svarende til 174 omsat til ↓
et 8-cifret binært tal: ┆b0┆10101110┆f0┆ ,hvor cifret ↓
┆19┆┄┆81┆┄længst til højre er BIT(0), og cifret længst til ↓
┆19┆┄┆81┆┄venstre er BIT(7).↲
↲
Hvis man ønsker at tænde for en enkelt lampe ad ↓
gangen, skal disse tal benyttes:↲
↲
↲
↲
BIT: BINÆR: DECIMAL:↲
------- --------------- --------------↲
↲
BIT(0): 0 0 0 0 0 0 0 1 = 1 ( = 2^0 )↲
BIT(1): 0 0 0 0 0 0 1 0 = 2 ( = 2^1 )↲
BIT(2): 0 0 0 0 0 1 0 0 = 4 ( = 2^2 )↲
BIT(3): 0 0 0 0 1 0 0 0 = 8 ( = 2^3 )↲
BIT(4): 0 0 0 1 0 0 0 0 = 16 ( = 2^4 )↲
BIT(5): 0 0 1 0 0 0 0 0 = 32 ( = 2^5 )↲
BIT(6): 0 1 0 0 0 0 0 0 = 64 ( = 2^6 )↲
BIT(7): 1 0 0 0 0 0 0 0 = 128 ( = 2^7 )↲
↲
↲
↲
Alle bits sættes "HØJE" ved at sende det decimale tal ↓
255 (=128+64+32+16+8+4+2+1 ) til parallelporten !↲
↲
↲
Med hensyn til programmering af lyspanelet i COMAL80 ↓
henvises til afsnittet med programdokumentationen i ↓
lærervejledningen.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PRINCIPPET BAG LYSPANELETS VIRKEMÅDE:↲
_____________________________________________________↲
↲
↲
Som nævnt leverer micro'en udgangsspændinger på enten ↓
0 volt (LAV spænding), eller ca. +4 volt (HØJ ↓
spænding). Strømstyrken på det "høje" signal fra ↓
parallelporten er imidlertid alt for lille til at ↓
tænde for en pære direkte. Signalet bruges derfor kun ↓
til at tænde for en afbryder, et elektronisk relæ, der ↓
åbner for en elektrisk strøm der er stærk nok til ↓
at få pæren til at lyse.↲
↲
------------------------------------------------------↲
↲
Når BIT(0) sættes LAV, forbinder relæet "L1" med ↓
"+12 volt". Det betyder, at der er en elektrisk ↓
spænding på +12 volt på ┆b0┆begge┆f0┆ sider af pæren, altså ↓
┆19┆┄┆81┆┄ingen spændings-┆b0┆forskel┆f0┆, og den lyser derfor ikke: ↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
┆b0┆ BIT(0) LAV = BIT(0)-PÆREN SLUKKET !!↲
↲
------------------------------------------------------↲
↲
Når BIT(0) sættes HØJ, forbinder relæet "L1" med↓
"0 volt". Det betyder, at der er en spænding på 0 volt ↓
på den ene side af pæren, og en spænding på +6 volt på ↓
den anden side, og pæren lyser derfor:↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
↲
┆b0┆ BIT(0) HØJ = BIT(0)-PÆREN TÆNDT !! ↲
↲
------------------------------------------------------↲
↲
Alle lamper på lyspanelet tænder og slukker efter ↓
dette princip.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆LÆRER-VEJLEDNING TIL UNDERVISNINGSMATERIALET:↲
_____________________________________________________↲
↲
↲
┆b0┆Formålet med "BRUG PÆREN" :↲
↲
┆b0┆(1)┆f0┆: At give eleverne viden om og færdigheder i ↓
┆19┆┄┆81┆┄anvendelse af datamaskinen til styring af en ydre ↓
┆19┆┄┆81┆┄enhed.↲
↲
┆b0┆(2)┆f0┆: At give eleverne færdigheder i at løse simple ↓
┆19┆┄┆81┆┄konkrete problemer af algoritmisk art ved hjælp af en ↓
┆19┆┄┆81┆┄microdatamat.↲
↲
┆b0┆(3)┆f0┆: At give eleverne viden om datamaskinens ↓
┆19┆┄┆81┆┄principielle opbygning og virkemåde.↲
↲
↲
┆b0┆Indhold: ↲
↲
.... BINÆRE OG DECIMALE TAL↲
.... ASCII-VÆRDIER↲
.... SKRIFT-TEGN↲
.... FUNKTIONS-TEGN (FUNKTIONS-TASTER)↲
.... TRANSMISSION AF DATA↲
.... STYRING AF LYSPANELET ("TÆND"/"SLUK")↲
.... "PAUSE"↲
.... "BLINKLYS"↲
.... "REAKTIONSTID"↲
.... "FYR"↲
.... "MORSE"↲
.... "LØBELYS"↲
.... "TÆLLE"↲
.... PORTE↲
.... INTERFACE↲
.... "TRAFIKLYS"↲
↲
↲
┆b0┆Nødvendigt udstyr til undervisningen:↲
↲
Mindst ┆b0┆EN┆f0┆ microdatamat med en parallelport med mindst ↓
┆19┆┄┆81┆┄8 bit, og helst 10 bit.↲
↲
Micro'en/micro'erne bør være udstyret med en diskette┄↓
station, og en printer.↲
↲
↲
┆b0┆Undervisningens organisering:↲
↲
Hver elev skal have et eksemplar af elevteksten.↲
↲
Elev-arbejdsarkene bør forefindes i klassen i ↓
et tilstrækkeligt antal, til at eleverne frit kan ↓
benytte dem når de har lyst.↲
↲
Eleverne bør arbejde sammen to og to, eller i lidt ↓
større grupper. ↲
↲
Hver gruppe bør have sin egen diskette.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
Eleverne bør ikke sidde og programmere ved data┄ma┄↓
skinerne. Programmeringsarbejdet bør foregå i grupper ↓
"pr. håndkraft", bl.a. ved hjælp af ar┄bejds┄arkene, der ↓
er udformet som en hjælp til opstilling af en struk┄↓
tur/algoritme for løsningen af de stillede opga┄↓
ver/problemer. Der bør foreligge en kladde til de ↓
forskellige programmer før indtastningen foretages.↲
↲
Ligeledes bør fejlfindingen kun i særlige tilfælde ↓
tillades ved datamaskinerne. Normalt bør fejlfinding ↓
foregå i grupperne "pr. håndkraft".↲
↲
Det er derfor en fordel hvis eleverne nemt kan lave ↓
printerudskrifter af programmerne.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆Bemærkninger til elevteksten:↲
↲
Opgave 1:↲
Programmet "tal" giver eleverne lejlighed til at se ↓
hvordan decimale tal kan bruges til at styre ↓
lyspanelets lamper. Lyspanelets vælger skal stå på ↓
"BITS" !↲
↲
Opgave 2, 3, 4, og 5:↲
Disse opgaver skal gennemarbejdes selvstændigt af ↓
eleverne. De skal eksperimentere sig frem til ↓
løsningerne. Det væsentlige ved arbejdet er de ↓
diskussioner der opstår mellem eleverne. Ikke ↓
mindst i forbindelse med opgave 5.↲
↲
Opgave 6:↲
Denne opgave kan udvides med arbejdsark nr. 1 hvis det ↓
ønskes.↲
↲
Opgave 7:↲
Denne opgave er identisk med de opgaver der kan ↓
udskrives på printeren ved hjælp af programmet ↓
"BINDECopg". Programmet er selvinstruerende, og er ↓
meget simpelt at bruge.↲
↲
Opgave 8:↲
Programmet "taster" giver eleverne lejlighed til at se ↓
hvordan der er knyttet et tal til alle tegn, både ↓
skrift-tegnene og funktions-tegnene.↲
↲
Opgave 9:↲
Side 9 og 10 er opbygget så man kan se at mange af ↓
tasterne på tastaturet har 2 eller 3 funktioner. Hvis ↓
der arbejdes med et udvidet tastatur, kan de specielle ↓
taster evt. undersøges ved hjælp af arbejdsark nr. 3, ↓
der i øvrigt kan bruges hvis der skal undersøges flere ↓
taster end der er mulighed for på side 9 og 10.↲
↲
Side 12 og 13:↲
Tabellerne på disse to sider kan skrives ud på ↓
printeren ved hjælp af programmerne "SKRIFTtegn" og ↓
"FUNKTtegn".↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆Bemærkninger til elev-arbejdsarkene:↲
↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆┆b0┆PROBLEM "TÆND":↲
↲
↲
┆b0┆0010 // "tænd"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 PRINT FILE 1: CHR$(255);↲
┆b0┆0040 CLOSE FILE 1↲
┆b0┆0050 END ↲
↲
┆b0┆0020:┆f0┆ Datastrøm nummer 1 åbnes til port 17 for skriv┄↓
┆19┆┄┆81┆┄ning (WRITE). D.v.s. at data til lyspanelet bliver ↓
┆19┆┄┆81┆┄sendt til port 17 via datastrøm nr. 1.↲
↲
┆b0┆0030:┆f0┆ CHR$(255) sendes via strøm nr.1 til port 17. ↓
┆19┆┄┆81┆┄Sætningen SKAL afsluttes med ";", da der ellers vil ↓
┆19┆┄┆81┆┄blive sendt en karakter-"vognretur", d.v.s. chr$(13) ↓
┆19┆┄┆81┆┄umiddelbart efter. CHR$(255), binært 11111111, bliver ↓
┆19┆┄┆81┆┄sendt ud af porten, så alle 8 bit går HØJ, og alle 8 ↓
┆19┆┄┆81┆┄lamper tændes.↲
↲
┆b0┆0040:┆f0┆ Datastrøm nr.1 lukkes. Hvis dette ikke bliver ↓
┆19┆┄┆81┆┄gjort, vil der opstå kørselsfejl næste gang programmet ↓
┆19┆┄┆81┆┄startes: Når sætning 20 prøver at åbne datastrømmen, ↓
┆19┆┄┆81┆┄der vil være åben i forvejen, og der vil komme en ↓
┆19┆┄┆81┆┄fejlmeddelelse. I dette tilfælde lukkes datastrømmen ↓
┆19┆┄┆81┆┄med komandoen ┆b0┆CLOSE┆f0┆.↲
↲
↲
------------------------------------------------------↲
↲
↲
┆b0┆PROBLEM "SLUK":↲
↲
↲
↲
0010 // "sluk"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
0030 PRINT FILE 1: CHR$(┆b0┆0┆f0┆);↲
0040 CLOSE FILE 1↲
0050 END ↲
↲
┆b0┆0030:┆f0┆ Her sendes CHR$(0), binært 00000000, til ↓
┆19┆┄┆81┆┄lyspanelet, og alle bits går LAV, hvorfor alle lamper ↓
┆19┆┄┆81┆┄slukkes.↲
↲
┆b0┆NB:┆f0┆ Problemet med den åbne datastrøm kan løses på en ↓
nem måde, selvom metoden kan karakteriseres som "en ↓
dårlig vane" i programmeringsmæssig henseende. Hvis ↓
alle programmer indledes med en CLOSE-sætning, vil ↓
programmerne starte med at lukke alle datastrømme der ↓
måtte stå åbne i forvejen. Derefter kan OPEN-↓
sætningerne udføres uden problemer!↲
↲
Det må være op til den enkelte lærer at vurdere om det ↓
er OK at lære eleverne dette "fif". Pædagogisk set må ↓
det være i orden. Programmeringsmæssigt er metoden som ↓
sagt lidt "ulden".↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "PAUSE":↲
↲
↲
Den simpleste måde at lave en pause på er en REPEAT/ ↓
UNTIL-løkke med en tæller til at fastlægge pausens ↓
længde. Så må eleverne tage tid med et stopur og køre ↓
programmet nogle gange for at finde ud af hvor mange ↓
gennemløb der skal til pr. tidsenhed:↲
↲
┆b0┆0010 // "pause-a"↲
┆b0┆0020 n:=0↲
┆b0┆0030 REPEAT ↲
┆b0┆0040 n:=n+1↲
┆b0┆0050 UNTIL n=1000↲
┆b0┆0060 END ↲
↲
↲
"pause-aTID" er et lærerprogram der benytter micro'ens ↓
interne ur til måling af antallet af gennemløb.↲
↲
------------------------------------------------------↲
↲
"pause-b" og "pause-bTID" svarer til de to ovennævnte ↓
programmer. Her er blot anvendt en FOR/NEXT-løkke:↲
↲
┆b0┆0010 // "pause-b"↲
┆b0┆0020 FOR n:=1 TO 1000 DO↲
┆b0┆0030 NEXT n↲
┆b0┆0040 END ↲
↲
------------------------------------------------------↲
↲
Den bedste metode at lave en pause på, er naturligvis ↓
at benytte micro'ens interne ur, der kan aflæses fra ↓
et program ved at tildele en talvariabel urets ↓
aktuelle klokkeslet. "pause-c" udfører en pause på 1 ↓
sekund:↲
↲
┆b0┆0010 // "pause-c"↲
┆b0┆0020 start:=SYS(3)/50↲
┆b0┆0030 REPEAT ↲
┆b0┆0040 slut:=SYS(3)/50↲
┆b0┆0050 UNTIL slut-start>=1↲
┆b0┆0060 END ↲
↲
┆b0┆0020:┆f0┆ Talvariablen START tildeles en værdi svarende ↓
┆19┆┄┆81┆┄til det aktuelle sekund-tal. START anvendes til at ↓
┆19┆┄┆81┆┄gemme klokkeslettet ved pausens start. ┆b0┆SYS(3)┆f0┆ er en ↓
┆19┆┄┆82┆┄funktion der har funktionsværdien svarende til antal┄↓
┆19┆┄┆82┆┄let af lysnettets vekselstrøm-perioder siden micro'en ↓
┆19┆┄┆82┆┄blev tændt. Vekselstrømmen er på 50 perioder pr. se┄↓
┆19┆┄┆82┆┄kund. Hvis ┆b0┆START┆f0┆ skal tildeles en værdi svarende til ↓
┆19┆┄┆83┆┄antallet af ┆b0┆hele┆f0┆ sekunder, skal SYS(3) divideres med ↓
┆19┆┄┆84┆┄50!↲
↲
┆b0┆0040:┆f0┆ Talvariablen SLUT tildeles det aktuelle ↓
┆19┆┄┆81┆┄sekund-tal. ↲
┆19┆┄┆81┆┄↲
┆b0┆0030-0050:┆f0┆ I denne løkke gentages aflæsningen af uret ↓
┆19┆┄┆81┆┄med talvariablen SLUT indtil forskellen mellem SLUT og ↓
┆19┆┄┆81┆┄START er 1, altså 1 sekund.↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "pause-cTID1" kan pauselængden varieres.↲
↲
I "pause-cTID2" er pausen skrevt som en procedure der ↓
kaldes sådan: ┆b0┆EXEC pause(3.5)┆f0┆, hvilket svarer til en ↓
┆19┆┄┆81┆┄pause på 3,5 sekunder.↲
↲
------------------------------------------------------↲
↲
"PROC-pause" indeholder ┆b0┆kun┆f0┆ proceduren fra↲
"pause-cTID2":↲
↲
┆b0┆1000 PROC pause(sekunder)↲
┆b0┆1010 start:=SYS(3)/50↲
┆b0┆1020 REPEAT ↲
┆b0┆1030 slut:=SYS(3)/50↲
┆b0┆1040 UNTIL slut-start>=sekunder↲
┆b0┆1050 ENDPROC pause↲
↲
Denne procedure er gemt på disketten som en↲
LIST-fil. Den kan derfor hentes frem og ┆b0┆blandes┆f0┆ ind i ↓
┆19┆┄┆81┆┄de kommende programmer med ENTER komandoen. Så behøver ↓
┆19┆┄┆81┆┄man ikke at skrive proceduren forfra når den skal ↓
┆19┆┄┆81┆┄bruges.↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "BLINK":↲
↲
↲
Algoritmen for blink er simpel: Først skal lampen ↓
tændes - så skal der udføres en pause - så skal lampen ↓
slukkes - så skal der udføres en pause - så skal der ↓
begyndes forfra :↲
↲
┆b0┆0010 // "blink-a1"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(8); .... TÆND↲
┆b0┆0050 FOR vent:=1 TO 500 DO .... PAUSE↲
┆b0┆0060 NEXT vent↲
┆b0┆0070 PRINT FILE 1: CHR$(0); .... SLUK↲
┆b0┆0080 FOR vent:=1 TO 500 DO .... PAUSE↲
┆b0┆0090 NEXT vent↲
┆b0┆0100 UNTIL FALSE .... FORFRA↲
┆b0┆0110 CLOSE FILE 1↲
┆b0┆0120 END ↲
↲
┆b0┆0040:┆f0┆ Decimalt 8, binært 00001000, sendes til ↓
┆19┆┄┆81┆┄lyspanelet så BIT3-lampen, og kun denne, lyser.↲
er blevet tændt. ↲
↲
┆b0┆0050-0060:┆f0┆ Pause med FOR/NEXT-løkke.↲
↲
┆b0┆0070:┆f0┆ Decimalt 0, binært 00000000, sendes til ↓
┆19┆┄┆81┆┄lyspanelet så alle 8 lamper slukkes.↲
↲
┆b0┆0080-0090:┆f0┆ Pause med FOR/NEXT-løkke.↲
↲
┆b0┆0030-00100:┆f0┆ Løkke der gentager det enkelte blink. ↓
┆19┆┄┆81┆┄Løkken kan kun standes ved at trykke på ESCAPE, ↓
┆19┆┄┆81┆┄hvorfor linierne 0110 og 0120 aldrig bliver udført.↲
↲
------------------------------------------------------↲
↲
Her er FOR/NEXT-pausen udskiftet med proceduren↲
┆b0┆pause┆f0┆:↲
↲
0010 // "blink-a2"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
0030 REPEAT ↲
0040 PRINT FILE 1: CHR$(8);↲
┆b0┆0050 EXEC pause(0.5)↲
0060 PRINT FILE 1: CHR$(0);↲
┆b0┆0070 EXEC pause(0.5)↲
0080 UNTIL FALSE↲
0090 CLOSE FILE 1↲
0100 END ↲
0110 //↲
┆b0┆0120 PROC pause(sekunder)↲
┆b0┆0130 start:=SYS(3)/50↲
┆b0┆0140 REPEAT ↲
┆b0┆0150 slut:=SYS(3)/50↲
┆b0┆0160 UNTIL slut-start>=sekunder↲
┆b0┆0170 ENDPROC pause↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "blink-b1" og "blink-b2" blinker alle 8 lamper fordi ↓
det decimale tal ┆b0┆255┆f0┆ sendes til lyspanelet i stedet ↓
┆19┆┄┆81┆┄for ┆b0┆8┆f0┆:↲
↲
0010 // "blink-b2"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
0030 REPEAT ↲
0040 PRINT FILE 1: CHR$(┆b0┆255┆f0┆);↲
0050 EXEC pause(0.5)↲
0060 PRINT FILE 1: CHR$(0);↲
0070 EXEC pause(0.5)↲
0080 UNTIL FALSE↲
0090 CLOSE FILE 1↲
0100 END ↲
0110 //↲
0120 PROC pause(sekunder)↲
0130 start:=SYS(3)/50↲
0140 REPEAT ↲
0150 slut:=SYS(3)/50↲
0160 UNTIL slut-start>=sekunder↲
0170 ENDPROC pause↲
↲
------------------------------------------------------↲
↲
Problemet med at ┆b0┆CLOSE FILE 1┆f0┆-sætningen aldrig ↓
┆19┆┄┆81┆┄udføres, fordi programmet standses inde i ↓
┆19┆┄┆81┆┄REPEAT/UNTIL-løkken med ESCAPE-tasten, kan løses med ↓
┆19┆┄┆81┆┄at programmet standses med en anden tast end ESCAPE, ↓
┆19┆┄┆81┆┄for eksempel MELLEMRUM-tasten, den er nem at ramme, ↓
┆19┆┄┆81┆┄eller S-tasten for STOP.↲
↲
I "blink-c1" og "blink-c2" er problemet løst ved at ↓
der i bunden af REPEAT/UNTIL-løkken undersøges om der ↓
er blevet trykket på den valgte tast eller ej: ↲
↲
0010 // "blink-c2"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
0030 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0040 REPEAT ↲
0050 PRINT FILE 1: CHR$(255);↲
0060 EXEC pause(0.5)↲
0070 PRINT FILE 1: CHR$(0);↲
0080 EXEC pause(0.5)↲
0090 UNTIL ┆b0┆ORD(KEY$)=32┆f0┆↲
0100 CLOSE FILE 1↲
0110 END ↲
0120 //↲
0130 PROC pause(sekunder)↲
0140 start:=SYS(3)/50↲
0150 REPEAT ↲
0160 slut:=SYS(3)/50↲
0170 UNTIL slut-start>=sekunder↲
0180 ENDPROC pause↲
↲
┆b0┆0090:┆f0┆ Valget mellem disse to muligheder er nærmet↲
en smagssag:↲
↲
┆b0┆A: 0090 UNTIL KEY$=" " ↲
┆b0┆B: 0090 UNTIL ORD(KEY$)=32 ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
NB:┆f0┆ Fra dette sted i teksten udelades listningen af ↓
┆19┆┄┆81┆┄proceduren "pause(sekunder)". Den forudsættes at være ↓
┆19┆┄┆81┆┄i alle de programmer hvor procedurekaldet↲
┆19┆┄┆81┆┄EXEC pause(X) forekommer !↲
↲
------------------------------------------------------↲
↲
I "blink-d1" er den konstante pauselængde udskiftet med ↓
variablen PAUSELÆNGDE, der tildeles en værdi i ↲
INPUT-sætningen:↲
↲
↲
0010 // "blink-d1"↲
0020 ant:=20↲
0030 PRINT CHR$(12)↲
0040 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0050 INPUT "SKRIV PAUSELÆNGDEN I SEKUNDER: ": ↲
┆19┆┄┆81┆┄┆b0┆ pauselængde↲
0060 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0070 REPEAT ↲
0080 PRINT FILE 1: CHR$(255);↲
0090 EXEC pause(┆b0┆pauselængde┆f0┆)↲
0100 PRINT FILE 1: CHR$(0);↲
0110 EXEC pause(┆b0┆pauselængde┆f0┆)↲
0120 UNTIL ORD(KEY$)=32↲
0130 CLOSE FILE 1↲
0140 END ↲
↲
------------------------------------------------------↲
↲
Variationen i blinkhastigheden kan også defineres som ↓
en ændring af blinkfrekvensen, altså antal brink pr. ↓
sekund. I "blink-d2" tildeles BLINKFREKVENSEN en værdi ↓
i INPUT-sætningen, hvorefter pauselængden fastsættes i ↓
linie 0050, så lysperioden og mørkeperioden er lige ↓
lange for de enkelte blink:↲
↲
0010 // "blink-d2"↲
0020 PRINT CHR$(12)↲
0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 INPUT "SKRIV ANTAL BLINK PR. SEKUND: ": ↲
┆19┆┄┆81┆┄┆b0┆ blinkfrekvens↲
┆b0┆0050 pauselængde:=1/(blinkfrekvens*2)↲
0060 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0070 REPEAT ↲
0080 PRINT FILE 1: CHR$(255);↲
0090 EXEC pause(┆b0┆pauselængde┆f0┆)↲
0100 PRINT FILE 1: CHR$(0);↲
0110 EXEC pause(┆b0┆pauselængde┆f0┆)↲
0120 UNTIL ORD(KEY$)=32↲
0130 CLOSE FILE 1↲
0140 END ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "blink-e" fastlægges lysperioden og mørkeperioden i ↓
to tildelingssætninger:↲
↲
0010 // "blink-e"↲
0020 PRINT CHR$(12)↲
0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 lysperiode:=1↲
┆b0┆0050 mørkeperiode:=0.5↲
0060 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0070 REPEAT ↲
0080 PRINT FILE 1: CHR$(255);↲
0090 EXEC pause(┆b0┆lysperiode┆f0┆)↲
0100 PRINT FILE 1: CHR$(0);↲
0110 EXEC pause(┆b0┆mørkeperiode┆f0┆)↲
0120 UNTIL ORD(KEY$)=32↲
0130 CLOSE FILE 1↲
0140 END ↲
↲
------------------------------------------------------↲
↲
I "blink-f" kan lysperioden og mørkeperioden varieres:↲
↲
0010 // "blink-f"↲
0020 PRINT CHR$(12)↲
0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 INPUT "SKRIV LYSPERIODEN I SEKUNDER: ": ↲
┆19┆┄┆81┆┄┆b0┆ lysperiode↲
┆b0┆0050 INPUT "SKRIV MØRKEPERIODEN I SEKUNDER: ": ↲
┆b0┆ mørkeperiode↲
0060 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0070 REPEAT ↲
0080 PRINT FILE 1: CHR$(255);↲
0090 EXEC pause(┆b0┆lysperiode┆f0┆)↲
0100 PRINT FILE 1: CHR$(0);↲
0110 EXEC pause(┆b0┆mørkeperiode┆f0┆)↲
0120 UNTIL ORD(KEY$)=32↲
0130 CLOSE FILE 1↲
0140 END ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "REAKTION":↲
↲
↲
Lamperne skal tændes et tilfældigt antal sekunder ↓
efter at programmet er startet, hvorefter lamperne ↓
skal slukkes når en tast bliver trykket ned:↲
↲
┆b0┆0010 // "reaktion-a"↲
┆b0┆0020 RANDOMIZE↲
┆b0┆0030 PRINT CHR$(12)↲
┆b0┆0040 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0050 EXEC pause(RND(3,7))↲
┆b0┆0060 PRINT FILE 1: CHR$(255);↲
┆b0┆0070 REPEAT ↲
┆b0┆0080 UNTIL ORD(KEY$)<>0↲
┆b0┆0090 PRINT FILE 1: CHR$(0);↲
┆b0┆0100 CLOSE ↲
┆b0┆0110 END ↲
↲
┆b0┆0050┆f0┆: Her udføres en pause på mellem 3 og 7 sekunder, ↓
┆19┆┄┆81┆┄tilfældigt udtaget. ↲
↲
┆b0┆0060┆f0┆: Alle 8 lamper tændes.↲
↲
┆b0┆0070-0080┆f0┆: Her ventes der til en eller anden tast ↓
┆19┆┄┆81┆┄bliver trykket ned.↲
↲
┆b0┆0090┆f0┆: Alle lamper slukkes.↲
↲
------------------------------------------------------↲
↲
Nu skal der tages tid på hvor længe det varer fra ↓
lamperne bliver tændt, til der trykkes på en tast:↲
↲
0010 // "reaktion-b"↲
0020 RANDOMIZE↲
0030 PRINT CHR$(12)↲
0040 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0050 DIM videre$ OF 10↲
┆b0┆0060 INPUT "TRYK <RETURN> NÅR DU ER KLAR !!": videre$↲
0070 EXEC pause(RND(3,7))↲
0080 PRINT FILE 1: CHR$(255);↲
┆b0┆0090 start:=SYS(3)/50↲
0100 REPEAT ↲
0110 UNTIL ORD(KEY$)<>0↲
┆b0┆0120 slut:=SYS(3)/50↲
0130 PRINT FILE 1: CHR$(0);↲
┆b0┆0140 reaktionstid:=slut-start↲
┆b0┆0150 PRINT "REAKTIONSTID: ";reaktionstid;" sek."↲
0160 CLOSE ↲
0170 END ↲
↲
┆b0┆0060┆f0┆: Her skal der trykkes på RETURN-tasten før ↓
┆19┆┄┆81┆┄reaktionsmålingen foretages. ┆b0┆videre$┆f0┆ er en dummy-↓
┆19┆┄┆82┆┄variabel der kun bruges til at standse program┄af┄vik┄↓
┆19┆┄┆82┆┄lingen indtil der trykkes på RETURN-tasten.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆0090 og 0120┆f0┆: Micro'ens interne ur aflæses i starten ↓
┆19┆┄┆81┆┄(┆b0┆start┆f0┆) og i slutningen (┆b0┆slut┆f0┆) af reaktionsperioden.↲
↲
┆b0┆0140┆f0┆: Reaktionstiden beregnes.↲
↲
┆b0┆0150┆f0┆: Reaktionstiden skrives på skærmen.↲
↲
------------------------------------------------------↲
↲
I "reaktion-c" er data-transmissionen til lyspanelet ↓
erstattet med CHR$(7), der får microen til at give et ↓
dyt eller et beep:↲
↲
0010 // "reaktion-c"↲
0020 PRINT CHR$(12)↲
0030 RANDOMIZE ↲
0040 DIM videre$ OF 10↲
0050 INPUT "TRYK <RETURN> NÅR DU ER KLAR !!": videre$↲
0060 EXEC pause(RND(3,7))↲
┆b0┆0070 PRINT CHR$(7)↲
0080 start:=SYS(3)/50↲
0090 REPEAT ↲
0100 UNTIL ORD(KEY$)<>0↲
0110 slut:=SYS(3)/50↲
0120 reaktionstid:=slut-start↲
0130 PRINT "REAKTIONSTID: ";reaktionstid;" sek."↲
0140 END ↲
↲
-----------------------------------------------------↲
↲
↲
Normalt er man hurtigere til at reagere på et lyd-↓
signal, end på et lys-signal. Men det er der jo ↓
mulighed for at undersøge med de to ovenstående ↓
programmer.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "FYR":↲
↲
↲
Her er beskrevet "fyr-d" som en mulig løsning på ↓
problemet i elevteksten:↲
↲
┆b0┆0010 // "fyr-d"↲
┆b0┆0020 CLOSE ↲
┆b0┆0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 PRINT FILE 1: CHR$(0);↲
┆b0┆0050 REPEAT ↲
┆b0┆0060 EXEC lys(4)↲
┆b0┆0070 EXEC mørke(2)↲
┆b0┆0080 EXEC isofaseblink(5,2)↲
┆b0┆0090 EXEC hurtigblink(20)↲
┆b0┆0100 EXEC gruppeblink(5,3)↲
┆b0┆0110 UNTIL ORD(KEY$)=32↲
┆b0┆0120 PRINT FILE 1: CHR$(0);↲
┆b0┆0130 CLOSE FILE 1↲
┆b0┆0140 END ↲
↲
┆b0┆0040┆f0┆: Her slukkes alle lamper der måtte være tændt før ↓
┆19┆┄┆81┆┄programmet blev startet.↲
↲
┆b0┆0060-0100┆f0┆: Her er selve fyrets karakteristik som ↓
┆19┆┄┆81┆┄procedurekald. ↲
↲
------------------------------------------------------↲
↲
┆b0┆EXEC lys(4)┆f0┆ tænder fyret i 4 sekunder:↲
↲
┆b0┆0160 PROC lys(sek)↲
┆b0┆0170 PRINT FILE 1: CHR$(255);↲
┆b0┆0180 EXEC pause(sek)↲
┆b0┆0190 PRINT FILE 1: CHR$(0);↲
┆b0┆0200 ENDPROC lys↲
↲
------------------------------------------------------↲
↲
┆b0┆EXEC mørke(2)┆f0┆ slukker fyret i 2 sekunder: ↲
↲
┆b0┆0220 PROC mørke(sek)↲
┆b0┆0230 PRINT FILE 1: CHR$(0);↲
┆b0┆0240 EXEC pause(sek)↲
┆b0┆0250 ENDPROC mørke↲
↲
------------------------------------------------------↲
↲
┆b0┆EXEC isofaseblink(5,2)┆f0┆ får fyret til at give 5 blink, ↓
┆19┆┄┆81┆┄hvor ┆b0┆hvert┆f0┆ blink består af en lysperiode og en ↓
┆19┆┄┆82┆┄mørkeperiode der er lige lange (=isofase), tilsammen 2 ↓
┆19┆┄┆82┆┄sekunder. ┆b0┆blinktid┆f0┆ er altså lysperioden + mørke┄↓
┆19┆┄┆83┆┄perioden:↲
↲
┆b0┆0270 PROC isofaseblink(antalblink,blinktid)↲
┆b0┆0280 FOR blink:=1 TO antalblink DO↲
┆b0┆0290 EXEC lys(blinktid/2)↲
┆b0┆0300 EXEC mørke(blinktid/2)↲
┆b0┆0310 NEXT blink↲
┆b0┆0320 ENDPROC isofaseblink↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆EXEC hurtigblink(20)┆f0┆ får fyret til at give 20 hurtige ↓
┆19┆┄┆81┆┄blink, d.v.s. 60 blink pr. minut. Lysperioden er lige ↓
┆19┆┄┆81┆┄så lang som mørkeperioden:↲
↲
┆b0┆0340 PROC hurtigblink(antalblink)↲
┆b0┆0350 FOR blink:=1 TO antalblink DO↲
┆b0┆0360 EXEC lys(0.5)↲
┆b0┆0370 EXEC mørke(0.5)↲
┆b0┆0380 NEXT blink↲
┆b0┆0390 ENDPROC hurtigblink↲
↲
------------------------------------------------------↲
↲
┆b0┆EXEC gruppeblink(5,3)┆f0┆ får fyret til at give 5 blink┄↓
┆19┆┄┆81┆┄grupper a' 3 blink. Lysperioden og mørkeperioden er ↓
┆19┆┄┆81┆┄begge på et halvt sekund, og pausen mellem grupperne ↓
┆19┆┄┆81┆┄er på 3 sekunder:↲
↲
┆b0┆0410 PROC gruppeblink(antalgrupper,antalgpblink)↲
┆b0┆0420 FOR gruppe:=1 TO antalgrupper DO↲
┆b0┆0430 FOR gpblink:=1 TO antalgpblink DO↲
┆b0┆0440 EXEC lys(0.5)↲
┆b0┆0450 EXEC mørke(0.5)↲
┆b0┆0460 NEXT gpblink↲
┆b0┆0470 EXEC pause(3)↲
┆b0┆0480 NEXT gruppe↲
┆b0┆0490 ENDPROC gruppeblink↲
↲
┆b0┆0430-460┆f0┆: Den enkelte blink-gruppe.↲
↲
┆b0┆0420-480┆f0┆: Antallet af blink-grupper.↲
↲
┆b0┆0470┆f0┆: Pausen mellem blink-grupperne.↲
↲
------------------------------------------------------↲
↲
Og her ┆b0┆PROC pause(X)┆f0┆:↲
↲
┆b0┆0510 PROC pause(sekunder)↲
┆b0┆0520 start:=SYS(3)/50↲
┆b0┆0530 REPEAT ↲
┆b0┆0540 slut:=SYS(3)/50↲
┆b0┆0550 UNTIL slut-start>=sekunder↲
┆b0┆0560 ENDPROC pause↲
↲
------------------------------------------------------↲
↲
↲
Programmet kan naturligvis udbygges efter ønske. I ↓
elevteksten er der eksempler på andre fyr-karakteri┆1e┆↲
stikker.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "MORSE":↲
↲
↲
"SOS" ( ...---... ) kan laves efter "GØG-OG-GOKKE-↓
METODEN", altså med en "PRINT FILE"-sætning til hver ↓
prik/streg samt et procedurekald mellem alle ↓
prikker/streger. "morse-a" er lavet efter dette ↓
princip, som naturligvis er en besværlig løsning. ↓
Men det virker:↲
↲
┆b0┆0010 // "morse-a"↲
┆b0┆0020 CLOSE ↲
┆b0┆0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 REPEAT ↲
↲
Her kommer de tre prikker:↲
┆b0┆0060 PRINT FILE 1: CHR$(255);↲
┆b0┆0070 EXEC pause(0.2)↲
┆b0┆0080 PRINT FILE 1: CHR$(0);↲
┆b0┆0090 EXEC pause(0.2)↲
┆b0┆0100 PRINT FILE 1: CHR$(255);↲
┆b0┆0110 EXEC pause(0.2)↲
┆b0┆0120 PRINT FILE 1: CHR$(0);↲
┆b0┆0130 EXEC pause(0.2)↲
┆b0┆0140 PRINT FILE 1: CHR$(255);↲
┆b0┆0150 EXEC pause(0.2)↲
┆b0┆0160 PRINT FILE 1: CHR$(0);↲
┆b0┆0170 EXEC pause(0.2)↲
┆b0┆0190 EXEC pause(1)↲
↲
Her kommer de tre streger:↲
┆b0┆0210 PRINT FILE 1: CHR$(255);↲
┆b0┆0220 EXEC pause(0.5)↲
┆b0┆0230 PRINT FILE 1: CHR$(0);↲
┆b0┆0240 EXEC pause(0.2)↲
┆b0┆0250 PRINT FILE 1: CHR$(255);↲
┆b0┆0260 EXEC pause(0.5)↲
┆b0┆0270 PRINT FILE 1: CHR$(0);↲
┆b0┆0280 EXEC pause(0.2)↲
┆b0┆0290 PRINT FILE 1: CHR$(255);↲
┆b0┆0300 EXEC pause(0.5)↲
┆b0┆0310 PRINT FILE 1: CHR$(0);↲
┆b0┆0320 EXEC pause(0.2)↲
┆b0┆0340 EXEC pause(1)↲
↲
Og her er så tre prikker igen:↲
┆b0┆0360 PRINT FILE 1: CHR$(255);↲
┆b0┆0370 EXEC pause(0.2)↲
┆b0┆.↲
o.s.v.↲
↲
Og til sidst afslutningen på programmet:↲
┆b0┆0510 UNTIL ORD(KEY$)=32↲
┆b0┆0520 PRINT FILE 1: CHR$(0);↲
┆b0┆0530 CLOSE ↲
┆b0┆0540 END ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
"morse-b" er en løsning på det samme problem. Her er ↓
der lavet en procedure til hhv. en prik og en streg:↲
↲
↲
┆b0┆0010 // "morse-b"↲
┆b0┆0020 CLOSE ↲
┆b0┆0030 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 PRINT FILE 1: CHR$(0);↲
┆b0┆0050 REPEAT ↲
┆b0┆0070 EXEC prik(3)↲
┆b0┆0080 EXEC mellemrum(1)↲
┆b0┆0090 EXEC streg(3)↲
┆b0┆0100 EXEC mellemrum(1)↲
┆b0┆0110 EXEC prik(3)↲
┆b0┆0120 EXEC mellemrum(7)↲
┆b0┆0140 UNTIL ORD(KEY$)=32↲
┆b0┆0150 PRINT FILE 1: CHR$(0);↲
┆b0┆0160 CLOSE ↲
┆b0┆0170 END ↲
↲
┆b0┆0190 PROC mellemrum(antal)↲
┆b0┆0200 FOR n:=1 TO antal DO EXEC pause(0.2)↲
┆b0┆0210 ENDPROC mellemrum↲
↲
┆b0┆0230 PROC prik(antal)↲
┆b0┆0240 FOR priknr:=1 TO antal DO↲
┆b0┆0250 PRINT FILE 1: CHR$(255);↲
┆b0┆0260 EXEC pause(0.2)↲
┆b0┆0270 PRINT FILE 1: CHR$(0);↲
┆b0┆0280 EXEC pause(0.2)↲
┆b0┆0290 NEXT priknr↲
┆b0┆0300 ENDPROC prik↲
┆b0┆↲
┆b0┆0320 PROC streg(antal)↲
┆b0┆0330 FOR stregnr:=1 TO antal DO↲
┆b0┆0340 PRINT FILE 1: CHR$(255);↲
┆b0┆0350 EXEC pause(0.5)↲
┆b0┆0360 PRINT FILE 1: CHR$(0);↲
┆b0┆0370 EXEC pause(0.2)↲
┆b0┆0380 NEXT stregnr↲
┆b0┆0390 ENDPROC streg↲
↲
↲
┆b0┆0070-0120┆f0┆: Her "kaldes" prikkerne og stregerne hver ↓
┆19┆┄┆81┆┄for sig. ┆b0┆EXEC mellemrum(1)┆f0┆ svarer til mellemrum mellem ↓
┆19┆┄┆82┆┄prikkerne og stregerne i og mellem bogstaverne, og ↓
┆19┆┄┆82┆┄┆b0┆EXEC mellemrum(7)┆f0┆ svarer til mellemrum mellem ordene. ↲
↲
┆b0┆0190-0210┆f0┆: Et mellemrum svarer blot til en pause på ↓
┆19┆┄┆81┆┄0.2 sekunder.↲
↲
┆b0┆0230-0300┆f0┆: En prik består af en lysperiode på 0.2 ↓
┆19┆┄┆81┆┄sekunder og en mørkeperiode på 0.2 sekunder.↲
↲
┆b0┆032-0390┆f0┆: En streg består af en lysperiode på 0.5 ↓
┆19┆┄┆81┆┄sekunder og en mørkeperiode på 0.2 sekunder.↲
↲
Lys- og mørkeperioderne bør selvfølgelig fastlægges ↓
efter elevernes egne ønsker.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "morse-c" er muligheden for at variere morse-↓
hastigheden tilføjet. Her er "normalhastigheden" sat ↓
til 100%. Hvis hastigheden skal halveres, skal der ↓
således indtastes ┆b0┆50┆f0┆ for 50%, og ┆b0┆200┆f0┆ for at fordoble ↓
┆19┆┄┆82┆┄hastigheden, d.v.s. 200%:↲
↲
Her er selve programmets struktur afspejlet i ↓
procedurekaldene:↲
↲
┆b0┆0010 // "morse-c"↲
┆b0┆0020 EXEC åbne_port↲
┆b0┆0030 EXEC ind_hastighed↲
┆b0┆0040 EXEC blink↲
┆b0┆0050 EXEC lukke_port↲
┆b0┆0060 END ↲
↲
------------------------------------------------------↲
↲
Her åbnes port 17, og lamperne slukkes:↲
↲
┆b0┆0080 PROC åbne_port↲
┆b0┆0090 CLOSE ↲
┆b0┆0100 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0110 PRINT FILE 1: CHR$(0);↲
┆b0┆0120 ENDPROC åbne_port↲
↲
------------------------------------------------------↲
↲
Her indtastes blink-hastigheden:↲
↲
┆b0┆0140 PROC ind_hastighed↲
┆b0┆0150 PRINT CHR$(12)↲
┆b0┆0160 INPUT "SKRIV HASTIGHED (normal=100%): ": ↲
┆19┆┄┆81┆┄┆b0┆ hastighed↲
┆b0┆0170 mellemrumlængde:=0.2/hastighed x 100↲
┆b0┆0180 priklængde:=0.2/hastighed x 100↲
┆b0┆0190 streglængde:=0.5/hastighed x 100↲
┆b0┆0200 ENDPROC ind_hastighed↲
↲
------------------------------------------------------↲
↲
Og her udføres selve blink-sekvensen ligesom i↲
"morse-b":↲
↲
┆b0┆0220 PROC blink↲
┆b0┆0230 REPEAT ↲
┆b0┆0240 EXEC prik(3)↲
┆b0┆0250 EXEC mellemrum(1)↲
┆b0┆0260 EXEC streg(3)↲
┆b0┆0270 EXEC mellemrum(1)↲
┆b0┆0280 EXEC prik(3)↲
┆b0┆0290 EXEC mellemrum(7)↲
┆b0┆0300 UNTIL ORD(KEY$)=32↲
┆b0┆0310 ENDPROC blink↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
Til sidst slukkes lamperne og datastrømmen lukkes:↲
↲
┆b0┆0330 PROC lukke_port↲
┆b0┆0340 PRINT FILE 1: CHR$(0);↲
┆b0┆0350 CLOSE ↲
┆b0┆0360 ENDPROC lukke_port↲
↲
------------------------------------------------------↲
↲
↲
↲
Procedurerne ┆b0┆prik┆f0┆, ┆b0┆streg┆f0┆ og ┆b0┆pause┆f0┆ er som i programmet ↓
┆19┆┄┆83┆┄"morse-b".↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
"morse-d" blinker navnet ┆b0┆OLE┆f0┆ (/---/.-.././). Her blot proceduren ↓
┆19┆┄┆81┆┄┆b0┆blink┆f0┆:↲
↲
┆b0┆0240 PROC blink↲
┆b0┆0250 REPEAT ↲
┆b0┆0260 // ---------------↲
┆b0┆0270 EXEC streg(3) .... O ↲
┆b0┆0280 EXEC mellemrum(5)↲
┆b0┆0290 // ---------------↲
┆b0┆0300 EXEC prik(1) .... L ↲
┆b0┆0310 EXEC streg(1)↲
┆b0┆0320 EXEC prik(2)↲
┆b0┆0330 EXEC mellemrum(5)↲
┆b0┆0340 // ---------------↲
┆b0┆0350 EXEC prik(1) .... E↲
┆b0┆0360 EXEC mellemrum(5)↲
┆b0┆0370 // ---------------↲
┆b0┆0380 EXEC mellemrum(5)↲
┆b0┆0390 // ---------------↲
┆b0┆0400 UNTIL ORD(KEY$)=32↲
┆b0┆0410 ENDPROC blink↲
↲
------------------------------------------------------↲
↲
↲
Det skal nævnes, at morseprogrammerne er svære, ↓
┆19┆┄┆81┆┄og det vil ikke være forkert at springe dem over hvis ↓
┆19┆┄┆82┆┄elevernes forudsætninger eller interesse ikke slår ↓
┆19┆┄┆83┆┄til.↲
↲
"morse-e", på næste side, er for eksempel i overkanten ↓
af hvad eleverne må forventes at kunne klare.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
"morse-e" er et løsningsforslag til et "generelt" ↓
morseprogram, hvor der blot skal indtastes en tekst på ↓
skærmen og trykkes <RETURN>. Det er absolut i ↓
overkanten hvad sværhedsgraden angår. ↲
↲
╱04002d4e0a00060000000002074d31400000000000000000000000000000000000000000000000000b151f29333d47515b656f79838d97ff04╱
╱04002d4e0a000600000000021449314000000000000000000000000000000000000000000000000018222c36404a545e68727c86909aa4ff04╱
↓
┆b0┆0010 // "morse-e"↲
┆b0┆0020 dec:=255↲
┆b0┆0030 CLOSE ↲
┆b0┆0040 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0050 DIM morsetegn$(96) OF 10,tekst$ OF 80↲
┆b0┆0060 FOR tegn:=97 TO 122 DO READ morsetegn$(tegn-96)↲
↲
┆b0┆0070 DATA ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---"↲
┆b0┆0080 DATA "-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-"↲
┆b0┆0090 DATA "..-","...-",".--","-..-","-.--","--.."↲
↲
┆b0┆0110 INPUT "SKRIV TEKST: ": tekst$↲
┆b0┆0120 PRINT ↲
┆b0┆0130 INPUT "SKRIV HASTIGHED (100=normal): ": hastighed↲
↲
┆b0┆0140 FOR tegnnr:=1 TO LEN(tekst$) DO↲
┆b0┆0150 morsetegnnr:=ORD(tekst$(tegnnr:tegnnr))-96↲
┆b0┆0160 FOR signal:=1 TO LEN(morsetegn$(morsetegnnr)) DO↲
┆b0┆0170 IF morsetegn$(morsetegnnr,signal:signal)="." THEN EXEC prik↲
┆b0┆0180 IF morsetegn$(morsetegnnr,signal:signal)="-" THEN EXEC streg↲
┆b0┆0190 NEXT signal↲
┆b0┆0200 EXEC pause(1/hastighed x 100)↲
┆b0┆0210 NEXT tegnnr↲
↲
┆b0┆0230 PROC prik↲
┆b0┆0240 PRINT FILE 1: CHR$(255)↲
┆b0┆0250 EXEC pause(0.25/hastighed x 100)↲
┆b0┆0260 PRINT FILE 1: CHR$(0);↲
┆b0┆0270 EXEC pause(0.2/hastighed x 100)↲
┆b0┆0280 ENDPROC prik↲
↲
┆b0┆0300 PROC streg↲
┆b0┆0310 PRINT FILE 1: CHR$(255);↲
┆b0┆0320 EXEC pause(0.6/hastighed x 100)↲
┆b0┆0330 PRINT FILE 1: CHR$(0);↲
┆b0┆0340 EXEC pause(0.2/hastighed x 100)↲
┆b0┆0340 ENDPROC streg↲
╱04002d4e0a00060000000002144a314000000000000000000000000000000000000000000000000018222c36404a545e68727c86909aa4ff04╱
╱04002d4e0a00060000000002074d31400000000000000000000000000000000000000000000000000b151f29333d47515b656f79838d97ff04╱
↓
↲
┆b0┆0060-0090┆f0┆: Her tildeles tekstvariablen ┆b0┆morsetegn$┆f0┆ de ↓
┆19┆┄┆82┆┄enkelte morsetegns udseende læst fra DATA-sætningerne.↲
↲
┆b0┆0110┆f0┆: Her tildeles ┆b0┆tekst$┆f0┆ den ønskede tekst.↲
↲
┆b0┆0160-0190┆f0┆: Her udføres de enkelte morsesignaler, altså ↓
┆19┆┄┆81┆┄de enkelte prikker og streger.↲
↲
┆b0┆0140-0210┆f0┆: Her udføres de enkelte bogstaver, der består ↓
┆19┆┄┆81┆┄af et eller flere morsesignaler (=prikker og streger).↲
↲
┆b0┆0200┆f0┆: Her udføres mellemrummmene mellem de enkelte ↓
┆19┆┄┆81┆┄bogstaver.↲
↲
Som det kan ses, kræver denne opgave, at eleverne er ↓
fortrolige med variable med index, samt del-strenge. Så ↓
opgaven er god hvis der er et par skrappe elever der ↓
mangler lidt udfordring.↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "LØBELYS":↲
↲
↲
I "løb-a1" er anvendt "GØG-OG-GOKKE-METODEN", idet ↓
hvert gennemløb består at 8 "PRINT FILE"-sætninger. ↓
Lyset løber kun ┆b0┆en┆f0┆ gang fra venstre mod højre:↲
↲
┆b0┆0010 // "løb-a1"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 PRINT FILE 1: CHR$(1);↲
┆b0┆0040 EXEC pause(0.3)↲
┆b0┆0050 PRINT FILE 1: CHR$(2);↲
┆b0┆0060 EXEC pause(0.3)↲
┆b0┆0070 PRINT FILE 1: CHR$(4);↲
┆b0┆0080 EXEC pause(0.3)↲
┆b0┆0090 PRINT FILE 1: CHR$(8);↲
┆b0┆0100 EXEC pause(0.3)↲
┆b0┆0110 PRINT FILE 1: CHR$(16);↲
┆b0┆0120 EXEC pause(0.3)↲
┆b0┆0130 PRINT FILE 1: CHR$(32);↲
┆b0┆0140 EXEC pause(0.3)↲
┆b0┆0150 PRINT FILE 1: CHR$(64);↲
┆b0┆0160 EXEC pause(0.3)↲
┆b0┆0170 PRINT FILE 1: CHR$(128);↲
┆b0┆0180 EXEC pause(0.3)↲
┆b0┆0190 CLOSE FILE 1↲
┆b0┆0200 END ↲
↲
------------------------------------------------------↲
↲
Problemet bør løses på en mere elegant måde, nemlig med en ↓
FOR/NEXT-løkke, hvor et gennemløb kan udtrykkes ↓
simpelt rent matematisk: 2 opløftet til en potens ↓
svarende til bit-nummeret, altså 2 i nulte (=1), 2 i ↓
første (=2), 2 i anden (=4), 2 i tredie (=8), ... ↓
o.s.v..↲
↲
I "løb-a2" er det gjort sådan:↲
↲
┆b0┆0010 // "løb-a2"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 FOR n:=0 TO 7 DO↲
┆b0┆0040 PRINT FILE 1: CHR$(2^n);↲
┆b0┆0050 EXEC pause(0.3)↲
┆b0┆0060 NEXT n↲
┆b0┆0070 CLOSE FILE 1↲
┆b0┆0080 END ↲
↲
------------------------------------------------------↲
↲
I "løb-b" er FOR/NEXT-løkken lagt ind i en "REPEAT-↓
UNTIL"-løkke, for at få gennemløbet gentaget indtil ↓
der trykkes på mellemrum-tasten:↲
↲
┆b0┆0040 REPEAT ↲
0050 FOR bit:=0 TO 7 DO↲
0060 PRINT FILE 1: CHR$(2^bit);↲
0070 EXEC pause(0.3)↲
0080 NEXT bit↲
┆b0┆0090 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "løb-c" er tilføjet muligheden for at variere ↓
blinkfrekvensen:↲
↲
0010 // "løb-c"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 PRINT "SKRIV LYSPERIODEN"↲
┆b0┆0040 PRINT "I SEKUNDER"↲
┆b0┆0050 INPUT "FOR HVER PÆRE: ": lysperiode↲
0060 PRINT ↲
0070 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
0080 REPEAT ↲
0090 FOR bit:=0 TO 7 DO↲
0100 PRINT FILE 1: CHR$(2^bit);↲
0110 EXEC pause(┆b0┆lysperiode┆f0┆)↲
0120 NEXT bit↲
0130 UNTIL ORD(KEY$)=32↲
0140 PRINT FILE 1: CHR$(0);↲
0150 CLOSE FILE 1↲
0160 END ↲
↲
------------------------------------------------------↲
↲
I "løb-d" gennemløbes FOR/NEXT-løkken med et ↓
negativt STEP, svarende til at BIT-7 pæren begynder og ↓
BIT-0 pæren slutter hvert gennemløb:↲
↲
┆b0┆0090 FOR bit:=7 TO 0 STEP -1 DO↲
┆b0┆0100 PRINT FILE 1: CHR$(2^bit);↲
┆b0┆0110 EXEC pause(lysperiode)↲
┆b0┆0120 NEXT bit↲
↲
------------------------------------------------------↲
↲
I "løb-e1" er det talvariablen ┆b0┆ DECTAL┆f0┆ der sendes til ↓
┆19┆┄┆81┆┄lyspanelet. ┆b0┆DECTAL┆f0┆ forøges i FOR/NEXT-løkken med et ↓
┆19┆┄┆82┆┄tal svarende til hver lampes decimale tal, således at ↓
┆19┆┄┆82┆┄┆b0┆DECTAL┆f0┆ opsummerers. Bemærk at BIT-0 pæren forbliver ↓
┆19┆┄┆83┆┄tændt under programmets afvikling:↲
↲
┆b0┆0080 REPEAT ↲
┆b0┆0090 dectal:=0↲
┆b0┆0100 FOR bit:=0 TO 7 DO↲
┆b0┆0110 dectal:=dectal+2^bit↲
┆b0┆0120 PRINT FILE 1: CHR$(dectal);↲
┆b0┆0130 EXEC pause(lysperiode)↲
┆b0┆0140 NEXT bit↲
┆b0┆0150 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "løb-e2" indledes FOR/NEXT-løkken med at 0 sendes ↓
til lyuspanelet så alle pærer slukkes, og der udføres ↓
en pause før pærerne begynder at lyse op. På denne ↓
måde slukkes også BIT-0 pæren i hver gennemløb:↲
↲
0080 REPEAT ↲
┆b0┆0090 PRINT FILE 1: CHR$(0);↲
┆b0┆0100 EXEC pause(lysperiode)↲
0110 dectal:=0↲
0120 FOR bit:=0 TO 7 DO↲
0130 dectal:=dectal+2^bit↲
0140 PRINT FILE 1: CHR$(dectal);↲
0150 EXEC pause(lysperiode)↲
0160 NEXT bit↲
0170 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
↲
"løb-e3" virker som "løb-e2". Her er den største 2-↓
talspotens blot 8 i stedet for 7. 2 opløftet til 8 er ↓
256, hvilket svarer til 100000000 binært. Der skal ↓
altså 9 bit til, hvor lyspanelet kun viser de 8 ↓
laveste bit. Igen lamper lyser derfor hvis 2 opløftet ↓
til 8. potens ( =256 ) sendes til lyspanelet:↲
↲
┆b0┆0090 FOR bit:=0 TO 8 DO↲
┆b0┆0100 PRINT FILE 1: CHR$(2^bit-1);↲
┆b0┆0110 EXEC pause(lysperiode)↲
┆b0┆0120 NEXT bit↲
↲
------------------------------------------------------↲
↲
Hvis man ønsker at lyset skal løbe fra højre mod ↓
venstre er "løb-e4" måske en nærliggende løsning - ↓
men den duer ┆b0┆IKKE┆f0┆ !! Her er det nemlig en slukket pære ↓
┆19┆┄┆81┆┄der "løber", og ikke en tændt:↲
↲
┆b0┆0090 FOR bit:=8 TO 0 STEP -1 DO↲
┆b0┆0100 PRINT FILE 1: CHR$(2^bit-1);↲
┆b0┆0110 EXEC pause(lysperiode)↲
┆b0┆0120 NEXT bit↲
↲
------------------------------------------------------↲
↲
"løb-e5" er en korrekt løsning, hvis lyset skal løbe ↓
fra højre mod venstre samtidig med at lysene skal ↓
"opsummeres":↲
↲
┆b0┆0090 FOR bit:=8 TO 0 STEP -1 DO↲
┆b0┆0100 PRINT FILE 1: CHR$(255-2^bit+1);↲
┆b0┆0110 EXEC pause(lysperiode)↲
┆b0┆0120 NEXT bit↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "løb-f" er det to FOR/NEXT-løkker der hver for sig ↓
får lyset til at løbe hhv. mod højre og mod venstre:↲
↲
0070 REPEAT ↲
┆b0┆0080 FOR bit:=0 TO 7 DO↲
┆b0┆0090 PRINT FILE 1: CHR$(2^bit);↲
┆b0┆0100 EXEC pause(lysperiode)↲
┆b0┆0110 NEXT bit↲
0120 PRINT FILE 1: CHR$(0);↲
0130 EXEC pause(lysperiode)↲
┆b0┆0140 FOR bit:=7 TO 0 STEP -1 DO↲
┆b0┆0150 PRINT FILE 1: CHR$(2^bit);↲
┆b0┆0160 EXEC pause(lysperiode)↲
┆b0┆0170 NEXT bit↲
0180 PRINT FILE 1: CHR$(0);↲
0190 EXEC pause(lysperiode)↲
0200 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
↲
"løb-g1", "løb-g2" og "løb-g3" er forslag til løsning ↓
af problemet med at man fra tastaturet skal kunne få ↓
lyset til at løbe hhv. mod højre og mod venstre.↲
↲
Her "løb-g2":↲
↲
┆b0┆0010 // "løb-g2"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 DIM tast$ OF 1↲
┆b0┆0040 PRINT "STOP: TRYK PÅ MELLEMRUM-TASTEN !!"↲
┆b0┆0050 PRINT "SKRIV LYSPERIODEN"↲
┆b0┆0060 PRINT "I SEKUNDER"↲
┆b0┆0070 INPUT "FOR HVER PÆRE: ": lysperiode↲
↲
------------------------------------------------------↲
↲
Her er selve afviklingen af løbelyset. Det er proce┄↓
duren ┆b0┆løbelys┆f0┆ (se næste side) der får lyset til at ↓
┆19┆┄┆81┆┄løbe:↲
↲
┆b0┆0090 REPEAT ↲
↲
┆b0┆0100 tast$:=KEY$↲
↲
┆b0┆0110 IF tast$="v" OR tast$="V" OR tast$=CHR$(8) ↲
┆19┆┄┆81┆┄┆b0┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆THEN EXEC løbelys(0,7,+1)↲
↲
┆b0┆0120 IF tast$="h" OR tast$="H" OR tast$=CHR$(24) ↲
┆19┆┄┆81┆┄┆b0┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆THEN EXEC løbelys(7,0,-1)↲
↲
┆b0┆0130 IF tast$="s" OR tast$="S" OR tast$=" " ↲
┆19┆┄┆81┆┄┆b0┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆┆1f┆THEN EXEC stands↲
↲
┆b0┆0140 UNTIL FALSE↲
↲
┆b0┆0150 END↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆EXEC løbelys(0,7,+1)┆f0┆ får lyset til at løbe fra BIT 0, ↓
┆19┆┄┆81┆┄d.v.s. venstre, mod BIT 7, altså højre. Modsvarende ↓
┆19┆┄┆81┆┄får ┆b0┆EXEC løbelys(7,0,-1)┆f0┆ lyset til at løbe den anden ↓
┆19┆┄┆82┆┄vej:↲
↲
┆b0┆0160 PROC løbelys(startværdi,slutværdi,stepværdi)↲
↲
┆b0┆0170 FOR bit:=startværdi TO slutværdi↲
┆19┆┄┆81┆┄┆b0┆ STEP stepværdi DO↲
↲
┆b0┆0180 PRINT FILE 1: CHR$(2^bit);↲
↲
┆b0┆0190 EXEC pause(lysperiode)↲
↲
┆b0┆0200 NEXT bit↲
↲
┆b0┆0210 PRINT FILE 1: CHR$(0);↲
↲
┆b0┆0220 EXEC pause(lysperiode)↲
↲
┆b0┆0230 ENDPROC løbelys↲
↲
------------------------------------------------------↲
↲
Hvis der trykkes på MELLEMRUM- eller S-tasten så ↓
udføres proceduren ┆b0┆stands┆f0┆, hvor lyset slukkes og ↓
┆19┆┄┆81┆┄datastrømmen lukkes:↲
↲
┆b0┆0320 PROC stands↲
┆b0┆0330 PRINT FILE 1: CHR$(0);↲
┆b0┆0340 CLOSE FILE 1↲
┆b0┆0350 ENDPROC stands↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "TÆLLE":↲
↲
↲
"tælle-a" er et lille program der tæller binært. Der ↓
kan naturligvis kun tælles fra 0 til 255, da der kun ↓
er 8 bit/lamper på lyspanelet:↲
↲
┆b0┆0010 // "tælle-a"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0040 FOR tal:=0 TO 255 DO↲
┆b0┆0050 PRINT FILE 1: CHR$(tal);↲
┆b0┆0060 EXEC pause(1/3)↲
┆b0┆0070 NEXT tal↲
┆b0┆0080 PRINT FILE 1: CHR$(0);↲
┆b0┆0090 CLOSE FILE 1↲
┆b0┆0100 END ↲
↲
------------------------------------------------------↲
↲
I "tælle-b" kan tællehastigheden varieres, idet ↓
brugeren selv bestemmer hvor lang tid hvert pause skal ↓
være.↲
↲
↲
0010 // "tælle-b"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 INPUT "PAUSETID: ": tid↲
0040 FOR tal:=0 TO 255 DO↲
0050 PRINT FILE 1: CHR$(tal);↲
0060 EXEC pause(┆b0┆tid┆f0┆)↲
0070 NEXT tal↲
0080 PRINT FILE 1: CHR$(0);↲
0090 CLOSE FILE 1↲
0100 END ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "BLINK-0/7":↲
↲
Dette program får BIT-0 og BIT-7 pærerne til at blinke ↓
på skift. Strukturen er den sammen som i et simpelt ↓
blink-program↲
↲
┆b0┆0010 // "blink-7/0"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(1);↲
┆b0┆0050 EXEC pause(0.5)↲
┆b0┆0060 PRINT FILE 1: CHR$(128);↲
┆b0┆0070 EXEC pause(0.5)↲
┆b0┆0080 UNTIL ORD(KEY$)=32↲
┆b0┆0090 PRINT FILE 1: CHR$(0);↲
┆b0┆0100 CLOSE FILE 1↲
┆b0┆0110 END ↲
↲
┆b0┆0040┆f0┆: Her lyser kun BIT-0 pæren.↲
↲
┆b0┆0060┆f0┆: Her lyser kun BIT-7 pæren↲
↲
------------------------------------------------------↲
↲
↲
┆b0┆PROBLEM "BLINK-A/B":↲
↲
↲
Her kommer så det første program der styrer de to ↓
ekstra bit. Port 17, som er en papallelport, består kun ↓
af 8 bit, og vi kan derfor ikke bruge den til de to ↓
ekstra bit. Nu skal ┆b0┆PORT 10┆f0┆ bruges. Det er ganske vist ↓
┆19┆┄┆81┆┄en seriel port, ligesom den printeren er tilsluttet, ↓
┆19┆┄┆81┆┄men den indeholder to bits der normalt bruges til ↓
┆19┆┄┆81┆┄kontrol-formål. De kan programmeres ligesom de 8 bit i ↓
┆19┆┄┆81┆┄port 17. Det forudsætter blot, at vi sender de decimale ↓
┆19┆┄┆81┆┄tal ┆b0┆24┆f0┆ og ┆b0┆5┆f0┆ i nævnte rækkefølge ┆b0┆umiddelbart før┆f0┆ det tal ↓
┆19┆┄┆84┆┄der sætter BIT-A og/eller BIT-B høje. ┆b0┆24┆f0┆ og ┆b0┆5┆f0┆ er ↓
┆19┆┄┆86┆┄karakterer der programmerer port 10, ┆b0┆0/2/128/130┆f0┆ er ↓
┆19┆┄┆87┆┄data der transmitteres ┆b0┆ud┆f0┆ af port 10!↲
↲
Der er disse 4 muligheder for programmering af BIT-A ↓
og BIT-B:↲
↲
↲
DECIMAL TAL: BIT-A: BIT-B:↲
------------ ------ ------↲
↲
0 LAV LAV↲
2 HØJ LAV↲
128 LAV HØJ↲
2+128=130 HØJ HØJ↲
↲
------------ ------ ------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
"blink-A/B" får BIT-A og BIT-B pærerne til at blinke på ↓
skift:↲
↲
0010 // "blink-A/B"↲
0020 OPEN FILE 1,"/┆b0┆10┆f0┆/PORT", WRITE ↲
0030 REPEAT ↲
0040 PRINT FILE 1: ┆b0┆CHR$(24);CHR$(5);CHR$(2);┆f0┆↲
0050 EXEC pause(0.5)↲
0060 PRINT FILE 1: ┆b0┆CHR$(24);CHR$(5);CHR$(128);┆f0┆↲
0070 EXEC pause(0.5)↲
0080 UNTIL ORD(KEY$)=32↲
0090 PRINT FILE 1: ┆b0┆CHR$(24);CHR$(5);CHR$(0)┆f0┆;↲
0100 CLOSE FILE 1↲
0110 END ↲
↲
┆b0┆0020┆f0┆: Her åbnes port ┆b0┆10┆f0┆ for skrivning (WRITE).↲
↲
┆b0┆0040┆f0┆: Her bruges ┆b0┆24┆f0┆ og ┆b0┆5┆f0┆ til at "fortælle" port 10 at ↓
┆19┆┄┆83┆┄vi gerne vil programmere BIT-A og BIT-B, og derefter ↓
┆19┆┄┆83┆┄sender vi tallet ┆b0┆2┆f0┆, der sætter BIT-A høj, så BIT-A ↓
┆19┆┄┆84┆┄pæren lyser, og ┆b0┆kun┆f0┆ BIT-A pæren.↲
↲
┆b0┆0060┆f0┆: Her sendes 24 og 5 ligesom i linie 0040, og ↓
┆19┆┄┆81┆┄derefter sendes 128, der sætter BIT-B, og kun BIT-B, ↓
┆19┆┄┆81┆┄høj.↲
↲
┆b0┆0090┆f0┆: Her sendes 24 og 5, samt 0. Nullet sætter både ↓
┆19┆┄┆81┆┄BIT-A og BIT-B lave, så ingen af disse to pærer lyser.↲
↲
Den eneste forskel på at programmere de 8 bit fra port ↓
17, og de 2 bit fra port 10, er altså at port 17 kan ↓
programmeres direkte med det decimale tal der sætter de ↓
enkelte bits, hvorimod de decimale tal 24 og 5 skal ↓
sendes forud for ┆b0┆hver eneste┆f0┆ ændring af status på de to ↓
┆19┆┄┆81┆┄bit vi kalder for BIT-A og BIT-B.↲
↲
------------------------------------------------------↲
↲
↲
┆b0┆"tænd10"┆f0┆ og ┆b0┆sluk10"┆f0┆ er to små programmer der hhv. ↓
┆19┆┄┆82┆┄tænder og slukker BIT-A ┆b0┆og┆f0┆ BIT-B. De refererer ┆b0┆ikke┆f0┆ til ↓
┆19┆┄┆84┆┄elevteksten, men er rare at have på disketten. Så kan ↓
┆19┆┄┆84┆┄man blot skrive komandoen ┆b0┆run "tænd10"┆f0┆ eller ┆b0┆"run ↓
┆19┆┄┆86┆┄"sluk10"┆f0┆ hvis man ønsker at tænde eller slukke de to ↓
┆19┆┄┆86┆┄lamper.↲
↲
0010 // "tænd10"↲
0020 OPEN FILE 1,"/10/PORT", WRITE ↲
0030 PRINT FILE 1: CHR$(24);CHR$(5);CHR$(┆b0┆130┆f0┆);↲
0040 CLOSE FILE 1↲
0050 END ↲
↲
↲
0010 // "sluk10"↲
0020 OPEN FILE 1,"/10/PORT", WRITE ↲
0030 PRINT FILE 1: CHR$(24);CHR$(5);CHR$(┆b0┆0┆f0┆);↲
0040 CLOSE FILE 1↲
0050 END ↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆PROBLEM "TRAFIK":↲
↲
↲
Nu skal lyskurvene på lyspanelet bruges, og omskifteren ↓
skal derfor stå på "TRAFIK".↲
↲
I "trafik-a1" og "trafik-a2" er det ┆b0┆kun┆f0┆ to-lysene der ↓
┆19┆┄┆81┆┄skal programmeres. Det vil sige at både port 17 og port ↓
┆19┆┄┆81┆┄10 skal bruges i det samme program. Derfor skal der ↓
┆19┆┄┆81┆┄åbnes til begge porte. Den eneste forskel på↲
"trafik-a1" og "trafik-a2" er at det er lyskurv nr. 1 ↓
på lyspanelet der bruges i det ene program, og lyskurv nr. 2 der ↓
bruges i det andet:↲
↲
↲
┆b0┆0010 // "trafik-a1"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 OPEN FILE 2,"/10/PORT", WRITE ↲
┆b0┆0040 REPEAT ↲
┆b0┆0050 PRINT FILE 1: CHR$(16); ↲
┆b0┆0060 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(0); ↲
┆b0┆0070 EXEC pause(6)↲
┆b0┆0080 PRINT FILE 1: CHR$(0); ↲
┆b0┆0090 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(128); ↲
┆b0┆0100 EXEC pause(4)↲
┆b0┆0110 UNTIL ORD(KEY$)=32↲
┆b0┆0120 CLOSE ↲
┆b0┆0130 END ↲
↲
↲
┆b0┆0020┆f0┆: Datastrøm nummer 1 til port 17 åbnes.↲
┆b0┆0030┆f0┆: Datastrøm nummer 2 til port 10 åbnes.↲
↲
┆b0┆0050┆f0┆: TÆND RØD(1), og få brøkdele af et sekund efter:↲
┆b0┆0060┆f0┆: SLUK GRØN(1)↲
↲
┆b0┆0070┆f0┆: Pause på 6 sekunder. Der er altså RØDT i 6 ↓
┆19┆┄┆81┆┄sekunder.↲
↲
┆b0┆0080┆f0┆: SLUK RØD(1), og få brøkdele af et sekund efter:↲
┆b0┆0090┆f0┆: TÆND GRØN(1)↲
↲
┆b0┆0100┆f0┆: Pause på 4 sekunder. Der er altså GRØNT i 4 ↓
┆19┆┄┆81┆┄sekunder.↲
↲
┆b0┆0120┆f0┆: Datastrømmene lukkes.↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
┆b0┆0010 // "trafik-a2"↲
┆b0┆0020 OPEN FILE 1,"/17/PORT", WRITE ↲
┆b0┆0030 OPEN FILE 2,"/10/PORT", WRITE ↲
┆b0┆0040 REPEAT ↲
┆b0┆0050 PRINT FILE 1: CHR$(8); ↲
┆b0┆0060 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(0); ↲
┆b0┆0070 EXEC pause(6)↲
┆b0┆0080 PRINT FILE 1: CHR$(0); ↲
┆b0┆0090 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(2); ↲
┆b0┆0100 EXEC pause(4)↲
┆b0┆0110 UNTIL ORD(KEY$)=32↲
┆b0┆0120 CLOSE ↲
┆b0┆0130 END ↲
↲
┆b0┆0050┆f0┆: TÆND RØD(4)↲
┆b0┆0060┆f0┆: SLUK GRØN(4)↲
↲
┆b0┆0080┆f0┆: SLUK RØD(4)↲
┆b0┆0090┆f0┆: TÆND GRØN(4)↲
↲
------------------------------------------------------↲
↲
↲
"trafik-b" styrer de to 2-lys, og er således en ↓
kombination af de to foregående programmer:↲
↲
↲
┆b0┆0040 REPEAT ↲
┆b0┆0050 PRINT FILE 1: CHR$(8); ↲
┆b0┆0060 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(128); ↲
┆b0┆0070 EXEC pause(6)↲
┆b0┆0080 PRINT FILE 1: CHR$(16);↲
┆b0┆0090 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(2); ↲
┆b0┆0100 EXEC pause(4)↲
┆b0┆0120 UNTIL ORD(KEY$)=32↲
↲
┆b0┆0050┆f0┆: TÆND RØD(1) + SLUK RØD(4) ↲
┆b0┆0060┆f0┆: SLUK GRØN(1) + TÆND GRØN(4)↲
↲
┆b0┆0080┆f0┆: SLUK RØD(1) + TÆND RØD(4)↲
┆b0┆0090┆f0┆: TÆND GRØN(1) + SLUK GRØN(4)↲
↲
Den "grønne bølge" på lyskurv nr. 1 er på 4 sekunder. ↓
Den "grønne bølge" på lyskurv nr. 2 er på 6 sekunder.↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
"trafik-c1" og "trafik-c2" styrer hhv. lyskurv nr. 2 og ↓
lyskurv nr.3, altså ┆b0┆et┆f0┆ 3-lys:↲
↲
↲
┆b0┆"trafik-c1":↲
↲
0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(128); RØD(2)↲
0050 EXEC pause(6)↲
┆b0┆0060 PRINT FILE 1: CHR$(192); RØD(2) + GUL(2)↲
0070 EXEC pause(2)↲
┆b0┆0080 PRINT FILE 1: CHR$(32); GRØN(2)↲
0090 EXEC pause(4)↲
┆b0┆0100 PRINT FILE 1: CHR$(64); GUL(2)↲
0110 EXEC pause(1)↲
0120 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
↲
↲
┆b0┆"trafik-c2":↲
↲
0010 // "trafik-c2"↲
0020 OPEN FILE 1,"/17/PORT", WRITE ↲
0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(1); RØD(3)↲
0050 EXEC pause(6)↲
┆b0┆0060 PRINT FILE 1: CHR$(3); RØD(3) + GUL(3)↲
0070 EXEC pause(2)↲
┆b0┆0080 PRINT FILE 1: CHR$(4); GRØN(3)↲
0090 EXEC pause(4)↲
┆b0┆0100 PRINT FILE 1: CHR$(2); GUL(3)↲
0110 EXEC pause(1)↲
0120 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
↲
↲
"trafik-d" er en kombination af de to foregående ↓
programmer. Her styres altså begge 3-lys:↲
↲
↲
0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(33); RØD(3)+GRØN(2)↲
0050 EXEC pause(6)↲
┆b0┆0060 PRINT FILE 1: CHR$(67); RØD(3)+GUL(3)+GRØN(2)↲
┆19┆┄┆81┆┄0070 EXEC pause(2)↲
┆b0┆0080 PRINT FILE 1: CHR$(132); GRØN(3)+RØD(2)↲
0090 EXEC pause(4)↲
┆b0┆0100 PRINT FILE 1: CHR$(194); GUL(3)+RØD(2)+GUL(2)↲
0110 EXEC pause(1)↲
0120 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "trafik-e" er det igen de to 3-lys der styres. Her er ↓
sekvensen blot lavet så der er ┆b0┆rødt i begge trafik┄↓
┆19┆┄┆81┆┄retninger┆f0┆ i 1 sekund mellem skiftene:↲
↲
↲
0030 REPEAT ↲
┆b0┆0040 PRINT FILE 1: CHR$(33); RØD(3)+GRØN(2)↲
0050 EXEC pause(6)↲
┆b0┆0060 PRINT FILE 1: CHR$(65); RØD(3)+GUL(2)↲
0070 EXEC pause(3)↲
┆b0┆0080 PRINT FILE 1: CHR$(129); RØD(3)+RØD(2)↲
0090 EXEC pause(2)↲
┆b0┆0100 PRINT FILE 1: CHR$(131); RØD(3)+GUL(3)+RØD(2)↲
┆19┆┄┆81┆┄0110 EXEC pause(1)↲
┆b0┆0120 PRINT FILE 1: CHR$(132); RØD(2)+GRØN(3)↲
0130 EXEC pause(10)↲
┆b0┆0140 PRINT FILE 1: CHR$(130): RØD(2)+GUL(3)↲
0150 EXEC pause(3)↲
┆b0┆0160 PRINT FILE 1: CHR$(129); RØD(2)+RØD(3)↲
0170 EXEC pause(2)↲
┆b0┆0180 PRINT FILE 1: CHR$(193); RØD(2)+GUL(2)+RØD(3)↲
┆19┆┄┆81┆┄0190 EXEC pause(1)↲
0200 UNTIL ORD(KEY$)=32↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
I "trafik-f" styres ┆b0┆alle 4 lyskurve┆f0┆ på en gang:↲
↲
↲
0040 REPEAT ↲
┆b0┆0050 PRINT CHR$(7);↲
┆b0┆0060 PRINT FILE 1: CHR$(148);↲
┆b0┆0070 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(2);↲
0080 EXEC pause(10)↲
┆b0┆0090 PRINT FILE 1: CHR$(156);↲
┆b0┆0100 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(0);↲
0110 EXEC pause(3)↲
┆b0┆0120 PRINT FILE 1: CHR$(154);↲
0130 EXEC pause(3)↲
┆b0┆0140 PRINT FILE 1: CHR$(217);↲
0150 EXEC pause(2)↲
┆b0┆0160 PRINT FILE 1: CHR$(41);↲
┆b0┆0170 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(128);↲
0180 EXEC pause(10)↲
┆b0┆0190 PRINT FILE 1: CHR$(57);↲
┆b0┆0200 PRINT FILE 2: CHR$(24);CHR$(5);CHR$(0);↲
0210 EXEC pause(3)↲
┆b0┆0220 PRINT FILE 1: CHR$(89);↲
0230 EXEC pause(3)↲
┆b0┆0240 PRINT FILE 1: CHR$(155);↲
0250 EXEC pause(2)↲
0260 UNTIL ORD(KEY$)=32↲
↲
↲
For at vise hvordan arbejdsarkene til lyskurvopgaverne ↓
kan bruges, vises på næste side hvordan en algoritme ↓
til "trafik-f" kan tagnes svarende direkte til ↓
programmet. Det er naturligvis de decimale tal, samt ↓
portene, der skal koncentreres om !↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
↲
Endelig er der på næste side en listning af et ↓
"generelt" lyskurv program ┆b0┆"TRAFIK"┆f0┆, hvor alle lamper ↓
┆19┆┄┆81┆┄tændes og slukkes en efter en ved hjælp af EXEC-↓
┆19┆┄┆81┆┄sætninger. Det er proce┄durerne ┆b0┆tænd(lampe)┆f0┆ og ↓
┆19┆┄┆82┆┄┆b0┆sluk(lampe)┆f0┆ der kaldes.↲
↲
Programmet kan f.eks. bruges af de elever der har svært ↓
ved at programmere lyskurvene med deres ┆b0┆egne┆f0┆ COMAL80-↓
┆19┆┄┆81┆┄programmer. Fortæl dem at de blot skal bruge ↓
┆19┆┄┆81┆┄arbejdsarkene og derefter indsætte EXEC-sætningerne i ↓
┆19┆┄┆81┆┄toppen af programmet!↲
↲
┆b0┆"TRAFIK-1"┆f0┆ og ┆b0┆"TRAFIK-2"┆f0┆ er identiske med "TRAFIK".↲
↲
"TRAFIK-1" indeholder EXEC-sætninger svarende til at ↓
RØD(1) blinker:↲
↲
┆b0┆0010 // "TRAFIK-1"↲
┆b0┆0020 PROC blink↲
┆b0┆0030 EXEC tænd(rød1)↲
┆b0┆0040 EXEC pause(1)↲
┆b0┆0050 EXEC sluk(rød1)↲
┆b0┆0060 EXEC pause(1)↲
┆b0┆0070 ENDPROC blink↲
↲
------------------------------------------------------↲
↲
"TRAFIK-2" styrer et enkelt 3-lys:↲
↲
┆b0┆0010 // "TRAFIK-2"↲
┆b0┆0020 PROC blink↲
┆b0┆0030 EXEC tænd(rød2)↲
┆b0┆0040 EXEC pause(6)↲
┆b0┆0050 EXEC tænd(gul2)↲
┆b0┆0060 EXEC pause(2)↲
┆b0┆0070 EXEC sluk(rød2)↲
┆b0┆0080 EXEC sluk(gul2)↲
┆b0┆0090 EXEC tænd(grøn2)↲
┆b0┆0100 EXEC pause(6)↲
┆b0┆0110 EXEC sluk(grøn2)↲
┆b0┆0120 EXEC tænd(gul2)↲
┆b0┆0130 EXEC pause(3)↲
┆b0┆0140 EXEC sluk(gul2)↲
┆b0┆0150 ENDPROC blink↲
↲
------------------------------------------------------↲
════════════════════════════════════════════════════════════════════════
↓
↲
↲
┆b0┆"TRAFIK":↲
════════════════════════════════════════════════════════════════════════
↓
↲
┆1a┆┆1a┆ 1: CHR$(33); //RØD(3)+GRØN(2)↲
0050 EXEC pause(6)↲
┆b0┆0060 PRI FILE 1: CHR$(65); RØD(3)+GUL(2)↲
0