Morsecode mit (Attiny22)

[Thomas M. (tommark)]

Hallo zusammen....

habe vor mit dem Atiny 22 durch die eingabe eines Morsecode (SOS)einen 
transistor durchschalten zu lassen. Komme aber mit der adressierung 
nicht klar. So meine Frage ist nun wie bewerkstellige ich dass:

PB0 = Eingang für den Code (SOS);
PB1 = Ausgang für Transistor;
PB4 = Ausgang LED wenn PB1 durchgesteuert ist;

IO-Ports und Datenrichtung bestimmen... wie schreibe ich das?

[Peter (Gast)]

In welcher Sprache will du denn Programmieren, was hast du bist jetzt 
schon geschrieben?

[Thomas M. (tommark)]

gnu gcc...

/*******************************************************/
/************** Morsecode*******************************/
/*******************************************************/

// Chip einbinden

#include <avr/io.h>            // Registernamen definieren
#include <stdint.h>
#include <util/delay.h>

#define _long
#define _short

/**********************Adressen********************************/

DDRB & = ~(1<<PB0);                   // alle ausgang ausser PB0
DDRB = 0xFF;                          //alle als ausgang
PORTB = 0xff;                         /* interne Pull-Ups an allen 
Port-Pins aktivieren */

/*****************hauptprogramm******************************/

int
main (void)
{


  return 0;
}

[Thomas M. (tommark)]

Wie schreibe ich das am besten oder ist das so in ordnung?

[holger (Gast)]

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

[Tim T. (tim_taylor)]

Thomas M. wrote:
> Wie schreibe ich das am besten oder ist das so in ordnung?

Was glaubst du was in dieser Reihenfolge wohl passiert?

> DDRB & = ~(1<<PB0);                   // alle ausgang ausser PB0
> DDRB = 0xFF;                          //alle als ausgang

Drehe es um!

[holger (Gast)]

>Was glaubst du was in dieser Reihenfolge wohl passiert?

>> DDRB & = ~(1<<PB0);                   // alle ausgang ausser PB0
>> DDRB = 0xFF;                          //alle als ausgang

>Drehe es um!

Entscheidend ist auch wo es steht.

[Thomas M. (tommark)]

danke für die schnelle Antwort.

[Thomas M. (tommark)]

wie würde den die main Anweisung aussehen? Ich hab da nicht so den Plan. 
Bin anfänger in µ-controller.

-über beispiele würde ich mich freuen.
-muss ein timer hinzugezogen werden?

[Johann L. (gjlayde)]

Hi, ich verwende in vielen Anwendungen auch Morse-Codes.

Anbei ein Header uim definieren der Codes.

Doe Codierung sieht so aus: Bit7 codiert, ob das Zeichen mit einem 
langen (bit7=9) oder einm kurzen Strich (bit7=1) beginnt.

Bits 6..0 enthalten das eigentliche Zeichen, wobei der erste gesetzte 
Bit dem ersten Ton entspricht.

"A" ist also binär codiert als

A = 1 0000010
            ^ das zweite zeichen (lang)
           ^  das erste zeichen (kurz denn bit7=1)
    ^         erstes gesetztes bit ist "kurz"

und noch "M":

M = 0 0000011
            ^ das zweite zeichen (lang)
           ^  das erste zeichen (lang denn bit7=0)
    ^         erstes gesetztes bit ist "kurz"

Damit lassen sich also 2*127 Zeichen codieren. Eine 0 bedeutet "nichts 
ausgeben", nicht zu verwechseln mit " " oder "0".

EDIT

Da ist schon der erste Fehler.
Der Prototyp für morse muß so aussehen:

#include <inttypes.h>

extern void  morse (uint8_t);

[Johann L. (gjlayde)]

Was jetzt noch fehlt, ist das C-Modul.

Die Funktion zur Ausgabe heisst morse. Um die Zeichenkette "SOS" 
auszugeben musst du die Aufrufreihenfolge.

#include "morse.h"

...
int main ()
{
   ...
   morse (_S_);
   morse (_O_);
   morse (_S_);
   ...
}

machen. Das ist zunächst etwas unkomfortabel, aber platzsparender als 
eine Zeichenkette abzubilden. Nen String rausmorsen kann man dann leicht 
unter Verwendung von morse() implementieren, wann man das gerne hätte. 
Dazu muss man dann 'A' auf A abbilden, 'B' auf B, etc.

morse() selbst ist Hardware-unabhängig geschrieben. Es braucht noch 
folgende Makros:

SPEAKER_ON  // Schaltet den Lautsprecher an (zB auf 1000Hz)
SPEAKER_OFF // Schaltet den Lautsprecher aus

und irgendwo muss eine Funktion wait_10ms (uint8_t n) implementiert 
werden, die n*10ms Zeit vertrödelt.

Diese Morse-Implementierung ist also blockierend. Dafür ist sie 
einfacher als eine nicht-blockierende IRQ-getriebene Implementierung.

Johann

[Peter (Gast)]

ich glaube der Threaderstelle, braucht das  gegenstück - er will sein µC 
anmorsen.

[PJ (Gast)]

Du musst Dich in die Lage des µC versetzen, der nur den blinkenden Pin 
sieht.

Und dann musst Du ihm beibringen, wie er die Längen von Biep und Boop 
messen und sich die bisherigen Längen merken kann, um sie zum richtigen 
Zeitpunkt in einer Tabelle nachzuschlagen.

Dafür brauchst Du sicherlich Zeitzählschleifen, Vergleichsfunktionen und 
Bit-Schiebefunktionen.

Der Link von Holger war schon ganz richtig, auf der Seite kann man das 
Wesentliche lernen.
So mal eben auf die Schnelle geht das nicht, wenn man sich mit 
Programmieren noch nicht so gut auskennt.
Das ist halt ein nettes Projekt, an dem Du einiges üben kannst, wenn Du 
es bis zum Erfolg durchziehst.

[Thomas M. (tommark)]

Johann, vielen vielen dank für die sehr guten Vorschläge. Ich versuche 
diese einzubinden.

THX

[Johann L. (gjlayde)]

Peter wrote:
> ich glaube der Threaderstelle, braucht das  gegenstück - er will sein µC
> anmorsen.

hmmm. Ja, so lässt es sich auch lesen.

Dürfte aber ein harter Brocken sein, weil ja die Längen a priori nicht 
feststehen:

Ohne Kontext kann mein ein E nicht von einem T unterscheiden! Ausser 
natürlich man weiß, mit wieviel WPM das Signal reinkommt. Was man aber 
bei Morse-Zeichen eben nicht weiß in Normalfall: Man hört es eben und 
Brain 0.9 erledigt den Rest...

Johann

[Thomas M. (tommark)]

THX @ all, noch irgendwelche Vorschläge? (hier werden Sie geholfen)

PB0 Eingang für ...  _  ...
PB1 Ausgang für Transistor
PB4 Status LED wenn PB1 durchgesteuert

[Peter D. (peda)]

Thomas M. wrote:
> Wie schreibe ich das am besten oder ist das so in ordnung?

Nein, überhaupt nicht.

Du mußt erstmal den PC ausschalten, Papier und Bleistift nehmen und Dir 
nen Programmablaufplan erstellen.
Erst danach kannst Du anfangen, den Quelltext zu schreiben.

Dein Projekt ist allerdings nichts für Anfänger.
Schon die Erkennung der Gebegeschwindigkeit erfordert einiges 
Nachdenken.

Ich würde erstmal ne SW-UART programmieren und mir die Impulslängen 
ausgeben lassen und später dann die erkannten Zeichen.

Und zum Testen nen 2. AVR als Morsezeichengeber erstmal mit konstanter 
Geschwindigkeit und später mit einstellbarem Jitter.

Das ist also auch für nen MC-Profi definitiv kein Wochenendprojekt.


Nen ATtiny22 gibt es nicht (mehr), Du meinst wohl ATtiny25.


Peter

[PJ (Gast)]

Google (mit: AVR Morsedekoder) liefert:

morsedecoder.c // for NerdKits with ATmega168:
http://www.nerdkits.com/videos/morsedecoder/morsedecoder_USB.c

bzw. Beschreibung auf:
http://www.nerdkits.com/videos/morsedecoder/

Das sieht aus wie etwas, was Du gut brauchen könntest.

[Thomas M. (tommark)]

DANKE an alle nochmal, dieses Projekt ist eine herausforderung für mich

[Oliver (Gast)]

>habe vor mit dem Atiny 22 durch die eingabe eines Morsecode (SOS)einen
>transistor durchschalten zu lassen.

Wenn man diese Anforderung wörtlich nimmt, steht da nichts vom gesamten 
Morsealphabet. Es soll nur SOS erkannt werden. Eine Lösung wäre, den 
Ausgang zu setzen, wenn von den letzten neun Impulsen die mittleren drei 
erkennbar länger waren, als die anderen 6, und zwischen den 9 Impulsen 
keine allzulange Pause war.

Oliver

[Karl H. (kbuchegg)]

Oliver wrote:

> Wenn man diese Anforderung wörtlich nimmt, steht da nichts vom gesamten
> Morsealphabet. Es soll nur SOS erkannt werden. Eine Lösung wäre, den
> Ausgang zu setzen, wenn von den letzten neun Impulsen die mittleren drei
> erkennbar länger waren, als die anderen 6, und zwischen den 9 Impulsen
> keine allzulange Pause war.

Das sieht mir nach einer halbwegs vernünftigen Strategie aus. Das ganze 
so aufzuziehen, dass tatsächlich die einzelnen Buchstaben erkannt 
werden, hmmm, ich denke ich bin kein schlechter Entwickler ... aber 
damit hätt ich auch so meine Probleme.

[Thomas M. (tommark)]

Oliver hat es verstanden...

>Wenn man diese Anforderung wörtlich nimmt, steht da nichts vom gesamten
 Morsealphabet. Es soll nur SOS erkannt werden. Eine Lösung wäre, den
 Ausgang zu setzen, wenn von den letzten neun Impulsen die mittleren 
drei
 erkennbar länger waren, als die anderen 6, und zwischen den 9 Impulsen
 keine allzulange Pause war.

[Thomas M. (tommark)]

Wie lässt sich das einbinden in die main- Anweisung? wie würde der Code 
aussehen?

[Peter D. (peda)]

Thomas M. wrote:
> Wie lässt sich das einbinden in die main- Anweisung?

Was willst Du denn einbinden, Du hast doch noch garnichts.

Hast Du überhaupt schonmal programmiert?
Dann solltest Du eigentlich wissen, daß man so nicht programmieren kann 
(zumindest nicht effektiv).

> wie würde der Code
> aussehen?

Weiß ich nicht, da ich diese Aufgabe bisher noch nicht bearbeitet habe.


Du hast ein paar Ideen geliefert bekommen, mach daraus nen Ablaufplan.
Erst dann weißt Du, was Du wie einbinden mußt.


Peter

[Oliver (Gast)]

>Wie lässt sich das einbinden in die main- Anweisung?

while(1)
  if (isSOS())
    TransistorAn();

Jetzt musst du dir nur noch überlegen, wann der Transistor wieder 
ausgeschaltet werden soll :-)

Oliver

[Karl H. (kbuchegg)]

Thomas M. wrote:
> Wie lässt sich das einbinden in die main- Anweisung? wie würde der Code
> aussehen?

Ich denke, diese Aufgabe ist noch deutlich zu schwer für dich. Du 
solltest mit einfacheren Dingen anfangen.

> IO-Ports und Datenrichtung bestimmen... wie schreibe ich das?

Wer solche Fragen stellt, hat noch mindestens 2 Monate lernen vor sich, 
ehe er sich über die gewählte Aufgabenstellung drübertrauen kann.

Wenn ich so zwischen den Zeilen lese, dann denke ich, du solltest erst 
mal auf einem PC anfangen, deine ersten C-Programme zu schreiben. Dort 
ist das deutlich einfacher. Alleine die Möglichkeit sich mittels printf 
unkompliziert Zwischenwerte ausgeben zu lassen, ist für einen Anfänger 
Gold wert.

[Thomas M. (tommark)]

Danke nochmal @ all...

[Peter D. (peda)]

Oliver wrote:
>

> while(1)
>   if (isSOS())
>     TransistorAn();
>

Stimmt, hast recht, Programmieren ist ja ganz einfach.
Da muß nur noch die Zeile:

#include <diverse_secret_black_boxes/isSOS.h>

mit rein und schon läuft das Programm.


Peter

[PJ (Gast)]

Du kannst die Länge eines Impulses mit einer Zählschleife messen, die so 
lange zählt, wie der Impuls auf "An" ist.

Wenn der Impuls wieder weg ist, speicherst Du das in einem Array ("eine 
Liste von Werten"). Das Array hat dann 9 Felder, und bei jedem Speichern 
der beendeten Zeit schiebst Du alle bisherigen Werte eine Position 
weiter.

Sobald der neue Wert dann in dem Array ist, musst Du eine Funktion die 
Werte prüfen lassen, ob sie dem SOS-Kriterium entsprechen. Also die drei 
mittleren Array-Werte ca. 3 mal so groß wie die 3 ersten und die 3 
letzten. Wenn das der Fall ist - Transistor schalten.

Wie genau Du dieses "ca." festlegst, bleibt Dir überlassen, damit kannst 
Du die Unterscheidungsgenauigkeit gegenüber schlecht gemorsten Codes 
festlegen.

Wann Du den Transistor wieder ausschaltest und wovon das abhängen soll 
(Zeit? Ein anderer Code? Bestätigung des SOS-Alarms über eine Taste? 
Kein neues SOS nach soundsoviel Zeit?), hast Du noch nicht geschrieben.

Dieses Verfahren ist ein vereinfachtes Verfahren, weil die 
Zeichenzwischenräume nicht ausgewertet werden. Man kann den SOS-Code 
wahrscheinlich auch mit anderen Zeichen geben, die zusammengenommen 
dasselbe . - Muster geben, aber eben aus anderen Zeichen bestehen. Aber 
das kannst Du später noch einbauen, wenn die vereinfachte Version 
erstmal funktioniert.

Willst Du mit der Klingel automatisch die Tür öffnen? Oder ist das für 
irgendeine Art von Spiel oder Joke? Oder was tatsächlich sehr Ernstes?

[Oliver (Gast)]

>Das Array hat dann 9 Felder,

Wenn da eine mechanische Morsetaste dranhängt, hat das Array gefühlte 
287 Felder...

Oliver

[Thomas M. (tommark)]

Willst Du mit der Klingel automatisch die Tür öffnen? Oder ist das für
irgendeine Art von Spiel oder Joke? Oder was tatsächlich sehr Ernstes?

Möchte an meinem Roller einen Bremshebelcode einbauen (CDI)dass dieser 
von 45- auf 25 KM/h drosselt. Mit ..._  ...(SOS) soll der Transistor 
durchschalten welcher einen Kondensator ansteuert und drosselt 
(Phasenverschiebung des zündens). Das ist der Plan...

[Thomas M. (tommark)]

kennt sich da jemand mit aus? Habe was in Bascom gefunden. siehe 
anhang...
kennt sich jemand damit aus, wie ich .bas in eine .hex compiliere?

[Oliver (Gast)]

>kennt sich jemand damit aus, wie ich .bas in eine .hex compiliere?

Tante google

>Das ist der Plan...

den die grünen (oder jetzt blauen) Jungs und Mädels von der Rennleitung 
auch kennen.

Oliver

[Thomas M. (tommark)]

@ Oliver, mir ist das schon bewust... aber könnte mir jemand nen link 
schicken, wo ich eine .bas in hex. compiliere. Bei Tante google finde 
ich nix! Hab es schon aufgegeben.

THX Thomas

[PJ (Gast)]

Das hört sich ja nun an wie ein Projekt, mit dem Du dich in Teufels 
Küche katapultieren könntest.

Wenn Du damit einen schweren Personenschaden verursachen solltest, den 
Deine Haftpflicht nicht deckt, dann hast Du damit ja wohl Dein Leben 
ruiniert.

Das kann es ja wohl nicht wert sein, oder?

[Thomas M. (tommark)]

Wo du recht hasst, hasst du recht, so habe ich das noch nicht gesehen. 
Immerhin sind DZB nicht umsonnst da... Hasste recht, Danke. Da muss ein 
anderes Projekt her. Bye

[Oliver (Gast)]

>... aber könnte mir jemand nen link
>schicken, wo ich eine .bas in hex. compiliere. Bei Tante google finde
>ich nix! Hab es schon aufgegeben.

Wenn du schon daran scheiterst, ist das wohl eine kluge Entscheidung.

Oliver

[Kai Bruhns (Gast)]

http://loetstelle.net/projekte/tinycode/tinycode.php

Ich denke das kommt dem nahe.
ist zwar asm aber en das auf dem 22 übertragbar ist...