[basic] morse code herkennen *

[Verwijderd]

Ik heb een project voor school waarvoor ik een robot moet bouwen die aan een stapel voorwaardes moet doen, over het algemeen redelijk eenvoudige opdrachten (is eerste jaar elektrotechniek HTS), maar 1tje kom ik niet helemaal uit, en ik vroeg me af of er hier mensen misschien goeie ideeën hebben.
De microcontroller is de BS2p24 van Parallax en de taal is basic.

De robot moet starten op het moment dat deze uit een hele serie morsecodes de letter 'd' hoort. De morsecodes zijn opgebouwd uit uit pulsen van 0.1 seconde. de letter 'd' is dan binair: 011101010. Zelf zit ik er aan te denken om gewoon alle morse-codes op te vangen en op te slaan in een array van bits door dit stukje code:

morse_reader:

'variables
morse_time VAR Byte
morse_time = 7
morse_read VAR Bit(100)

'check loop
PAUSE 50 'zorgt ervoor dat er midden in het signaal (op 0.05s gekeken wordt voor betrouwbaarheid
INDEX_morse VAR Byte
FOR INDEX_morse = 0 TO morse_time
IF IN8 = 1 THEN hoog
IF IN8 = 0 THEN laag
PAUSE 100
NEXT

'Functies van morse:
hoog:
morse_read(INDEX) = 1
laag:
morse_read(INDEX) = 0

Ik weet niet of dit kan werken omdat ik de array op de robot niet kan uitlezen (ben nog aan het uitzoeken hoe dat werkt). Heeft iemand enig idee of dit zou kunnen werken en hoe ik in de ontstane array kan kijken of de bitreeks van de letter 'd' voorkomt?

nb. het kan zijn dat er nog wat kleine programmeer foutjes in zitten die ik nog niet ontdekt heb, ik heb nog niet zoveel ervaring met basic.

[ Voor 3% gewijzigd door Verwijderd op 06-05-2005 16:13 ]

[Spider.007]

Programmeertopics mogen in Programming & Webscripting; ik verplaats je topic dus even

SA > PW

[ Voor 32% gewijzigd door Spider.007 op 06-05-2005 16:12 ]

[Verwijderd]

Spider.007 schreef op vrijdag 06 mei 2005 @ 16:12:
Programmeertopics mogen in Programming & Webscripting; ik verplaats je topic dus even

SA > PW

ok, dankje

[Kuhlie]

Morse werkt helemaal niet met bits...

[NMe]

de letter 'd' is dan binair: 011101010

Staat dat voor "lang kort kort"?

[lemming_nl]

Kuhlie schreef op vrijdag 06 mei 2005 @ 16:14:
Morse werkt helemaal niet met bits...

Volgens mij ook niet. Of jij hebt het niet over morse of je zult alle letters die gebruikt worden defineren. (zodat hij ze kan vergelijken en zien of het een d of een andere letter is)

[ Voor 14% gewijzigd door lemming_nl op 06-05-2005 16:20 ]

[Flapp]

je kan er hele makkelijk bits van maken omdat je maar 2 soorten hebt:
kort = 0
lang = 1
je kan m dus heel makkelijk laten kijken
maar t probleem is het omzetten denk ik , zelf heb ik niet erg veel ervaring met geluid in programmatuur

[Verwijderd]

1e:
Inderdaad morse werkt niet met bits, dus gebruik ik een elektronische schakelijk om het geluid op te vangen en om te zetten naar een serie pulsen en probeer ik dat met dit stukje code om te zetten naar een binaire waarde ...

2e:
Ja dat staat voor lang kort kort, met een "stopbit" en een "startbit" erbij.

Flapietoetoe schreef op vrijdag 06 mei 2005 @ 16:21:
je kan er hele makkelijk bits van maken omdat je maar 2 soorten hebt:
kort = 0
lang = 1
je kan m dus heel makkelijk laten kijken
maar t probleem is het omzetten denk ik , zelf heb ik niet erg veel ervaring met geluid in programmatuur

Je hebt ook nog 'niks', oftwel stilte.

[ Voor 47% gewijzigd door Verwijderd op 06-05-2005 16:23 ]

[Verwijderd]

Ik heb een 'start' en 'stop' bit toegevoegd en ik controleer de ingang elke 100ms, dus als het goed zou ik uit een blokgolf die er zo uit ziet (met 100ms per teken): .---.-.-. de binaire code 011101010 halen, maar ik weet niet zeker of dat gaat lukken met dat stukje code.

[Vaan Banaan]

Kuhlie schreef op vrijdag 06 mei 2005 @ 16:14:
Morse werkt helemaal niet met bits...

Mwa, zoals hij het schijft, klopt het ongeveer wel.
Een 'd' is in morse -.. , waarbij de dah (-) 3 keer zo lang duurt als een dit (.) met tussen elk teken een 'dit' niks. (aan het eind van een letter een 'dah' niks)
Je kunt de letter d dus omschrijven als 111 0 1 0 1
Je kunt dus inderdaad per 0.1 seconde kijken wat de waarde is en daar een soort van binaire waarde van maken. Op het moment dat je 3 keer een 0 tegenkomt, weet je, dat het einde van het teken is bereikt en kun je het vergelijken met de waarde van d.
In jouw voorbeeld zou je dus gewoon een string kunnen nemen van een bepaalde lengte en die vullen met 0-en en 1-en aan de hand van de pulsen.
Morse tekens zijn niet allemaal even lang, dus je kunt geen for next loop gebruiken.
Ik zou het als volgt aanpakken.

• Zolang je geen signaal hebt loop
• Bij het eerste signaal een string vullen met '1'
• Zolang je niet meer dan 1 keer (eigenlijk 3 keer, maar nu heb je even extra tijd) een leeg signaal hebt, string aanvullen met '0' of '1'
• Vergelijken met 11101010
• Indien niet hetzelfde de hele handel herhalen

[ Voor 28% gewijzigd door Vaan Banaan op 06-05-2005 16:43 ]

[Verwijderd]

Vaan_Banaan schreef op vrijdag 06 mei 2005 @ 16:29:
[...]

Mwa, zoals hij het schijft, klopt het ongeveer wel.
Een 'd' is in morse -.. , waarbij de dah (-) 3 keer zo lang duurt als een dit (.) met tussen elk teken een 'dit' niks. (aan het eind van een letter een 'dah' niks)
Je kunt de letter d dus omschrijven als 111 0 1 0 1
Je kunt dus inderdaad per 0.1 seconde kijken wat de waarde is en daar een soort van binaire waarde van maken. Op het moment dat je 3 keer een 0 tegenkomt, weet je, dat het einde van het teken is bereikt en kun je het vergelijken met de waarde van d.
In jouw voorbeeld zou je dus gewoon een string kunnen nemen van een bepaalde lengte en die vullen met 0-en en 1-en aan de hand van de pulsen.

Ik heb op de simpelste manier een array (dat zijn in basic strings) gemaakt met de letter 'd' erin:

'Ducky's morse code:
morse_ducky VAR Bit(9)
'Startbit = 0
morse_ducky(0) = 0
'Morse code letter 'D'
morse_ducky(1) = 1
morse_ducky(2) = 1
morse_ducky(3) = 1
morse_ducky(4) = 0
morse_ducky(5) = 1
morse_ducky(6) = 0
morse_ducky(7) = 1
'Endbit = 0
morse_ducky(8 ) = 0

(nb, naam van de robot is ducky )

De vraag is alleen, hoe kijk ik of deze array voorkomt in de array die ik krijg door het bekijken van de ingang?

[ Voor 10% gewijzigd door Verwijderd op 06-05-2005 16:33 ]

[Megamind]

Maar als hij uit een hele serie geluiden de letter D eruit moet halen neem ik aan dat er wel pauze's zitten tussen de individuele karakters? Anders is de betrouwbaarheid niet zo groot.

[Vaan Banaan]

Megamind schreef op vrijdag 06 mei 2005 @ 16:34:
Maar als hij uit een hele serie geluiden de letter D eruit moet halen neem ik aan dat er wel pauze's zitten tussen de individuele karakters? Anders is de betrouwbaarheid niet zo groot.

Klopt, tussen de dit's en dah's 1 puls pauze, tussen het hele teken 3 pulsen pauze, althans zo zou het moeten zijn.
Even snel gegoogeld
Van http://www.cvil.wustl.edu/~gary/Ham/morse_learn.html

Dits and dahs: Dots and dashes are visual cues and you should avoid them. Think in terms of dits (the short sound) and dahs (the long sound). You may see all but the final dit abbreviated as di. For example, the letter "H" is four dits and would probably be described as di-di-di-dit.

The duration of a dah is three times longer than the duration of a dit. The silent space between the dits and dahs in a letter is the same duration as a dit. The silent space between letters is the same duration as a dah.

[Microkid]

Dit kan veel eenvoudiger. Je moet gewoon de inkomende pulsen vergelijken met de 'd' (011101010). Je kijkt gewoon of de laatste puls een 0 is. Zo ja, dan ga je een loop in, en kijkt of het volgende een 1 is. Zo ja, dan kijk je of het volgende weer een 1 is, daarna een 1, 0, 1, 0, 1 en 0. Dan heb je een 'd' te pakken. Zodra ergens in de loop een andere puls dan verwacht binnen komt (bijv. 0110) dan spring je uit de lus en begin je opnieuw. Kort gezegd: je test alle bts van de 'd' en zodra er een foute bit binnen komt, begin je opnieuw.

[Vaan Banaan]

En dat is dus de instnker want een 'B' is 111010101 (-...) en een 'X' is 11101010111 (-..-), dus begint het programma te lopen bij een verkeerde letter

[ Voor 38% gewijzigd door Vaan Banaan op 06-05-2005 16:51 ]

[Megamind]

Microkid schreef op vrijdag 06 mei 2005 @ 16:42:
Dit kan veel eenvoudiger. Je moet gewoon de inkomende pulsen vergelijken met de 'd' (011101010). Je kijkt gewoon of de laatste puls een 0 is. Zo ja, dan ga je een loop in, en kijkt of het volgende een 1 is. Zo ja, dan kijk je of het volgende weer een 1 is, daarna een 1, 0, 1, 0, 1 en 0. Dan heb je een 'd' te pakken. Zodra ergens in de loop een andere puls dan verwacht binnen komt (bijv. 0110) dan spring je uit de lus en begin je opnieuw. Kort gezegd: je test alle bts van de 'd' en zodra er een foute bit binnen komt, begin je opnieuw.

Dat is niet zo veilig, je zal toch eerst weer moeten wachten tot er een silent van 3 dahs is geweest anders begin je midden in een letter te tellen.

Je kan toch ook gewoon de inkomende string opslaan in een string en vergelijken met '011101010'

[Microkid]

Vaan_Banaan schreef op vrijdag 06 mei 2005 @ 16:47:
En dat is dus de instnker want een 'B' is 111010101 (-...), dus begint het programma lopen bij een verkeerde letter

Nee, want je hebt de eerste 0 niet gehad
Alleen als de bits in deze volgorde 011101010 binnenkomen heb je een 'd'. Anders niet.

Dat is niet zo veilig, je zal toch eerst weer moeten wachten tot er een silent van 3 dahs is geweest anders begin je midden in een letter te tellen.

Hangt er van af. Als het echte morse is zouden alle letters uniek moeten zijn en zou je niet door halverwege in een letter te vallen toch een juiste code binnen krijgen. Maar wellicht kan TS daar wat over ophelderen?

[ Voor 35% gewijzigd door Microkid op 06-05-2005 16:52 ]

[Soultaker]

Volgens mij is dat herkennen van die pulsen zo echt vragen om problemen, als de golf een heel klein beetje van de specificatie zit. Anders dan je in je commentaar stelt, doe je namelijk helemaal niets om te garanderen dat je in het 'midden' van een tijdseenheid samplet. Sterker nog: met die pauzes zo gekozen zul je langzaam maar zeker gegarandeerd asynchroon gaan sampelen omdat de code tussen de pauzes ook tijd kost om uit te voeren (om over de rest van de processen op het systeem maar te zwijgen).

Ik zou dus zeggen: zorg dat je veel vaker samplet (desnoods zo vaak mogelijk) en beslis dan of je pulsen lang of kort zijn. Daarna is het vrij makkelijk er een string van te maken en die om te zetten naar een letter.

[Vaan Banaan]

Ok, dan stuur ik nu het volgende: 'AB', wat je kunt omschrijven als: 10111000111010101000, dat
gaat dan toch fout?
@Microkid: morse zijn geen tekens met gelijke lengte.

[ Voor 25% gewijzigd door Vaan Banaan op 06-05-2005 16:55 ]

[Microkid]

Vaan_Banaan schreef op vrijdag 06 mei 2005 @ 16:53:
Ok, dan stuur ik nu het volgende: 'AB', wat je kunt omschrijven als: 10111000111010101000, dat
gaat dan toch fout?
@Microkid: morse zijn geen tekens met gelijke lengte.

* Microkid goes back to the drawingboard

je zou moeten beginnen te tellen na een pauze. Dan is bovenstaand probleem opgelost. Dus eerst pauze, dan een 0, een 1, 1, 1, 0, 1, 0, 1, 0

[ Voor 66% gewijzigd door Microkid op 06-05-2005 17:02 ]

[Verwijderd]

Je moet toch gewoon een schuifregister programmeren

Dus je zet een bitje in een array , leest de array parallel uit, en maakt dan de keuze of de waarden in de array in het goede patroon staan. Zo ja, voilà je hebt je 'd' ontvangen, zo nee schuif er weer 1 bitje in

Bijv:
Startwaarde:

Array[0-7] : 00000000

Bitje er in:

Array[0-7] : 10000000

Is het patroon "011101010" ? Nee dus

Weer een bitje erin:

Array[0-7]: 01000000

enzovoort tot je het goede patroon heb gehad

edit: moet je wel met pauzes werken, want een totale stroom bitjes levert idd een probleem op

[ Voor 29% gewijzigd door Verwijderd op 06-05-2005 17:09 ]

[Sjaaky]

Je moet eerst detecteren of een signaal lang of kort is, zoals je het nu omschrijft bevat een lang signaal 3 pulsen van 0.1 sec. Dat kan natuurlijk, maar echt morse is het niet. Verder weet ik niet of je zomaar 50 msec kunt wachten om in het midden van een pulse uit te komen, dat gaat namelijk alleen als de systemen gesynchroniseerd zijn. Ook 'verloopt' je tijd langzaam omdat elke loop 100msec + de tijd die je nodig hebt voor het uitvoeren van je instructies duurt.

De manier om een 'd' te herkennen uit een lange stream van pulsen is met een state machine. Hier zul je ongetwijfeld wel iets van op school hebben gehad. Je wilt de stream 011101010 matchen uit een input stream. Hiervoor bouw je een state machine, dat werkt ongeveer als volgt.
State 1() Bij pulse 0 ga naar State 2, bij pulse 1 blijf in State 1
State 2(0) Bij pulse 0 blijf in State 2, bij een 1 naar State 3
State 3(01) 0 -> State 2; 1 -> State 4
State 4(011) 0 -> State 2; 1 -> State 5
State 5(0111) 0 -> State 6; 1 -> State 1
State 6(01110) 0 -> State 2; 1 -> State 7
State 7(011101) 0 -> State 8; 1 -> State 4
.
.
.
State n: Klaar, 'd' gematched!

Nu moet jij de rest van de states nog even aanvullen. Let op dat waar je naar welke volgende state je springt als je niet de verwachte pulse binnenkrijgt. Je kan dan namelijk eigenlijk al opnieuw een beginstuk hebben gematcht (zie state 7 jump naar state 4).

---
Ik neem aan de problemen die in posts hierboven vernoemd staan niet relevant zijn mbt tot de opdracht. Een beetje slimme leraar zorgt wel dat dit eenduidig in de opdracht staat.

[ Voor 10% gewijzigd door Sjaaky op 06-05-2005 17:13 ]

[Verwijderd]

Sjaaky schreef op vrijdag 06 mei 2005 @ 17:05:
De manier om een 'd' te herkennen uit een lange stream van pulsen is met een state machine. Hier zul je ongetwijfeld wel iets van op school hebben gehad. Je wilt de stream 011101010 matchen uit een input stream. Hiervoor bouw je een state machine, dat werkt ongeveer als volgt.
State 1() Bij pulse 0 ga naar State 2, bij pulse 1 blijf in State 1
State 2(0) Bij pulse 0 blijf in State 2, bij een 1 naar State 3
State 3(01) 0 -> State 2; 1 -> State 4
State 4(011) 0 -> State 2; 1 -> State 5
State 5(0111) 0 -> State 6; 1 -> State 1
State 6(01110) 0 -> State 2; 1 -> State 7
State 7(011101) 0 -> State 8; 1 -> State 4
.
.
.
State n: Klaar, 'd' gematched!

Mijn idee Alleen kun je in Basic geen states maken, hoogstens met while-loops

[ Voor 6% gewijzigd door Verwijderd op 06-05-2005 17:08 ]

[Microkid]

Sjaaky schreef op vrijdag 06 mei 2005 @ 17:05:
De manier om een 'd' te herkennen uit een lange stream van pulsen is met een state machine. Hier zul je ongetwijfeld wel iets van op school hebben gehad. Je wilt de stream 011101010 matchen uit een input stream. Hiervoor bouw je een state machine, dat werkt ongeveer als volgt.
State 1() Bij pulse 0 ga naar State 2, bij pulse 1 blijf in State 1
State 2(0) Bij pulse 0 blijf in State 2, bij een 1 naar State 3
State 3(01) 0 -> State 2; 1 -> State 4
State 4(011) 0 -> State 2; 1 -> State 5
State 5(0111) 0 -> State 6; 1 -> State 1
State 6(01110) 0 -> State 2; 1 -> State 7
State 7(011101) 0 -> State 8; 1 -> State 4
.
.
.
State n: Klaar, 'd' gematched!

Nee, zie het geintje van Vaan_Banaan

[Sjaaky]

Het geintje van Vaan_Banaan gaat niet op als je de drie pauze 0'en meeneemt.
10111000111010101000 dit is namelijk geen 'd',
een 'd' is dan namelijk 011101010000.

[Verwijderd]

Heeft dat ding geen bitwise shift en 'and' ?

[Vaan Banaan]

Soultaker heeft zeker een punt.
Ik heb vroagah al eens geprobeerd een seinsleutel aan een C64 te hangen zodat ik de 'morse piepjes' als letters op het scherm kon zetten. Het eerste wat de zendamateur zei, die naast me zat, was: "Je krijgt die synchronisatie nooit voor elkaar" En inderdaad, dat lukte nooit voor 100%
In dit geval (blokpuls) is de frequentie vastgesteld op 10ms en kan het synchroniseren plaatsvinden door 2x een meting op de frequentie van een puls.
Bij korte afwisselende pulsen (0->1 of 1->0) kun je meten of je nog goed zit. Zolang 2 metingen hetzelfde zijn, loopt je synchronisatie goed.

code:

tijd-> 0.025     0.125   0.175
         Ŝ  0.075 Ŝ 0.150  Ŝ
         Ŝ    Ŝ   Ŝ    Ŝ   Ŝ
        ________  Ŝ    Ŝ  ____
puls   Ŝ        Ŝ Ŝ    Ŝ Ŝ
    ___Ŝ        Ŝ________Ŝ

Op het moment dat je x1101xxxx of xx0010xxx meet, zit iets niet goed. Je meet maar één keer een afwijkende waarde, dus je moet de pause verkleinen met een aantal milliseconden
In het geval je xx001110xxx of xx110001xxx meet weet je dat je interval te klein is. Je hebt nu 3 keer dezelfde waarde van een puls gelezen, dus moet je pauze groter.
Dan kan je ook nog drempel waardes voor je pauze instellen (bijv tussen 0,03 - 0.07 seconde) en als de pauze daarbuiten valt, is het geen morse teken of iets dergelijks.
Maar dat is hufterproof programmeren en ik verwacht niet, dat dat binnen deze opdracht valt.

[Verwijderd]

Bedankt allemaal voor jullie hulp, ik heb in ieder geval weer wat te proberen volgende week, de opdracht is echter niet erg eenduidig moet ik zeggen, deze luidt namelijk letterlijk:

Tijdens de demonstratie van de robot zal de file alle_start_codes.wav worden afgespeeld. Wanneer het voor de robot bestemde signaal klinkt, moet alleen die robot gaan werken. De robot mag dus niet reageren op omgevingsgeluid of op een signaal bestemd voor een andere robot.

alle_start_codes.wav is in 'blokgolf':
.-.---...---.-.-...-.---.-...---.---...-.---.-...-.-.-...-.-.---.
(de tweede code is de letter d, na de eerste rust (de 1e drie puntjes)

Het signaal is exact 3 kHz, dus omgevingsgeluid is makkelijk weg te filteren (parallel resonantie icm elektret microfoontje en schmidt-trigger). Alleen andere morsecodes en het samplen is dus van belang. Het bestand alle_start_codes.wav is een bestand van ongeveer 7 seconde lang, met 6 morsecodes van ongeveer 1 seconde per code (de rust tijd tussen de signalen is inderdaad 0.3s). Ik zat eigenlijk een beetje te hopen dat met 'maar' 7 seconde de synchronosatie niet zo'n ramp zou zijn wanneer je de loop pas start op het eerste pulsje, dat zal blijken uit het testen volgende week.

Een ander probleem is de beperking van de taal basic en het geheugen van de robot, wanneer ik zeer vaak ga samplen houdt de microprocessor het niet meer bij en kan het geheugen problemen op gaan leveren. Hier staat de data van de betreffende controller: BS2p24-IC
Dit 1 van de 8 opdrachten die op de robot gebouwd moet worden, dus ik probeer zo zuinig mogelijk met code te zijn.

[ Voor 22% gewijzigd door Verwijderd op 06-05-2005 23:19 ]

[Vaan Banaan]

dat is nu juist de kunst van het programmeren, zovveel mogelijk code hergebruiken. Helaas kan ik je niet verder helpen met deze opdracht, en zeker niet als de andere opdrachten totaal anders zijn en ook nog in 8kB moeten passen. Ik heb nog aandachtig gekeken op http://www.parallax.com/detail.asp?product_id=BS2P24-IC, maar ik ben helaas al te lang van school om deze stof nog uit mijn mouw te kunnen schudden. Maar volgens mij moet je inmiddels genoeg stof hebben om deze opdracht tot goed einde een te brengen.

[kzin]

Ik heb destijds ook een morse-decoder gschreven op de Acorn Atom (6502). Mijn aanpak was:
(ik ga er even van uit dat er een schakeling voor hangt die de toontjes omzet in 0/1)
Allereerst moet je de snelheid bepalen. Meet wanneer de ingang veranderd (dus 0 -> 1 of omgekeerd). Ga net zolang door tot je twee waarden hebt die een factor 2 uit elkaar liggen. Je punt/streep grens leg je halverwege. Dus niet exact: een streep is 3 x een punt, want dat werkt niet altijd bij mensen die met de hand seinen.

Bij het eigenlijke decoderen blijf je constant deze grens aanpassen. Je gaat dus niet ergens 'midden in' kijken, maar triggert op overgangen. Je kunt nu in principe 4 zaken tegenkomen:
1. Een 'actief' teken met een lengte onder de grens -> een punt dus [actief = 1]
2. Een 'passief' teken met een lengte onder de grens -> een ruimte binnen een teken
3. actief, maar nu boven de grens -> een streep
4. passief, maar nu boven de grens -> Einde van het karakter

Je moet dus (1) en (3) tijdelijk opslaan, zij het als bits, danwel als twee ASCII karakters.
(2) hoef je niet op te slaan, want die wordt alleen gebruikt als scheiding
(4) hoef je niet op te slaan, want op dat moment moet je decoderen.

Voorbeeld (Ik ga er van uit dat je een punt opslaat als een 'P' en een streep als een 'S')
Morse: -.. ..- .... sla ik op als: PSS <decode> SSP <decode> PPPP <decode>

Decoderen is het opzoeken van je string in een tabel

Houdt rekening met lange tekens, b.v. de 0: -----, of een komma --..--

Tenslotte nog: De eerste tekens. Je kent de punt/streep lengte nog niet, maar als je alle lengtes opslaat kun je ze alsnog decoderen zodra je weet wat een punt en een streep is.

success

[ Voor 4% gewijzigd door kzin op 07-05-2005 14:27 ]

[Verwijderd]

Ik denk dat ik met al deze informatie de opdracht wel tot een goed einde kan brengen, enorm bedankt voor jullie hulp allemaal. Wanneer het gelukt is zal ik de succesvolle oplossing hier wel even neerzetten, wie weet komt dit nog ooit iemand van pas.