Forum: Mikrocontroller und Digitale Elektronik Midi_Orgel_Schieberegister


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von Fabian F. (fabiii9)


Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo zusammen,

es gab schon einmal einen Thread über dieses Thema.

Karl Heinz (kbuchegg) hatte mir dabei auch sehr geholfen.
Jetzt bin ich gerade dabei, die Planungen umzusetzen.

Ich habe jetzt Platinen-Layouts und Schaltpläne erstellt.

Jetzt brauche ich nur noch den passenden Code dazu.
Kar Heinz hatte mir ja einen gesagt, dass ich mich wieder melden soll, 
wenn ich anfange zu bauen.

Dies war der Code:
#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)

#include <avr/io.h>
#include <util/setbaud.h>

#define NR_SR    2

// Schieberegister MC14021
#define SR_DDR   DDRB
#define SR_PORT  PORTB
#define SR_PIN   PINB
#define SR_PS    PB0
#define SR_C     PB1
#define SR_DATA  PB2

#define SET_BIT(p,b)  p |= (1<<(b))
#define CLR_BIT(p,b)  p &= ~(1<<(b))
#define IS_SET(p,b)   (p & (1<<(b)))

// Midi Kommandos
#define NOTE_ON    145
#define NOTE_OFF   129

#define MIDI_NOTE_C2   12

uint8_t fetchByte()
{
  uint8_t Result = 0;
  for( uint8_t i = 0; i < 8; i++ )
  {
    Result <<= 1;

    if( IS_SET( SR_PIN, SR_DATA ) )
      Result |= 0x01;

    SET_BIT( SR_PORT, SR_C );
    CLR_BIT( SR_PORT, SR_C );
  }

  return Result;
}

void uart_init( void )
{
  UBRRH = UBRRH_VALUE;
  UBRRL = UBRRL_VALUE;
  #if USE_2X                  // U2X-Modus erforderlich
    UCSRA |= (1 << U2X);
  #else                    // U2X-Modus nicht erforderlich
    UCSRA &= ~(1 << U2X);
  #endif
  UCSRB |= (1<<TXEN);              // UART TX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1  
}

void uart_putc( uint8_t c )
{
  while (!(UCSRA & (1<<UDRE)))     // warten bis Senden moeglich
    ;

  UDR = c;
}

void SendNoteOn( uint8_t note )
{
  uart_putc( NOTE_ON );
  uart_putc( note );
  uart_putc( 100);
}

void SendNoteOff( uint8_t note )
{
  uart_putc( NOTE_OFF );
  uart_putc( note );
  uart_putc( 0 );
}

void scanKeys( uint8_t* keys )
{
  SET_BIT( SR_PORT, SR_PS );
  CLR_BIT( SR_PORT, SR_PS );

  for( uint8_t i = 0; i < NR_SR; i++ )
    keys[i] = fetchByte();
}

int main(void)
{
  uint8_t prevKeys[NR_SR];
  uint8_t nowKeys[NR_SR];
  uint8_t changed, pressed;
  uint8_t midiNote;

  SR_DDR |= (1<<SR_PS) | (1<<SR_C);
  uart_init();

  scanKeys( prevKeys );

  while(1)
  {
    scanKeys( nowKeys );

    midiNote = MIDI_NOTE_C2;  // die erste Note im Manual

    for( uint8_t i = 0; i < NR_SR; i++ )
    {
      changed = nowKeys[i] ^ prevKeys[i];
      pressed = nowKeys[i];

      prevKeys[i] = nowKeys[i];

      if( changed != 0x00 )
      {
        for( uint8_t bit = 0; bit < 8; ++bit )
        {
          if( changed & 0x80 )
          {
            if( !(pressed & 0x80) )
              SendNoteOn( midiNote );
            else
              SendNoteOff( midiNote );
          }
          midiNote++;
          changed <<= 1;
          pressed <<= 1;
        }
      }
      else
        midiNote += 8;
    }
  }
}

Das ist der Code für ein Manual.

Jetzt brauche ich nur diesen Code für drei Manuale und Pedal und 
Schweller und Taster.

Den Schwellercode habe ich auch schon.
Siehe hier:
#include <avr/io.h>
#include <avr/io.h>
#define F_CPU 1000000              // 1 MHz
#define BAUD 31250                // MIDI-Baudrate (31,25kBit)
#include <util/setbaud.h>
void adc_init (void){

  //interne Referenzspannung
  //ADMUX = 0xC0;

  //AVCC
  //ADMUX = 0x40;

  //AREF
  ADMUX = 0xC0;


  ADCSRA = 0x80; //ADC aktivieren, Rest 0 setzen

  //ADCSRA |= 0x01; //Vorteiler 2
  //ADCSRA |= 0x02; //Vorteiler 4
  //ADCSRA |= 0x03; //Vorteiler 8
  //ADCSRA |= 0x04; //Vorteiler 16
  ADCSRA |= 0x05; //Vorteiler 32
  //ADCSRA |= 0x06; //Vorteiler 64
  //ADCSRA |= 0x07; //Vorteiler 128

  ADCSRA |= (1<<6); //Konvertierung starten

  while(ADCSRA & (1<<6)){}; //Kovertierung beendet

  uint16_t ergebnis = 0;

  ergebnis = ADCL;
  ergebnis += (ADCH<<8);

}

uint16_t adc_read (uint8_t kanal){

  static uint8_t init = 0;

  if(init==0){adc_init(); init++;} //beim ersten Aufruf zunaechst initialisieren

  ADMUX &= (0xE0); //Vorhandenen Wert fuer den Kanal loeschen

  //den Wert fuer den Kanal schreiben, dabei die vorderen 3 Bits vor evtl. fehlern schuetzen

  ADMUX |= (kanal&(0x1F));

  ADCSRA |= (1<<6); //Konvertierung starten



  while(ADCSRA & (1<<6)){}; //Kovertierung beendet

  uint16_t ergebnis = 0;

  ergebnis = ADCL;
  ergebnis += (ADCH<<8);

  return ergebnis; //Ergebnis zurueckgeben

}

int main(void){
  uint16_t schweller;
  uint16_t alterWert;

  uart_init();
  adc_init();

  alterWert = adc_read( 2 ) / 8;
  
  while( 1 )
   {
     schweller = adc_read( 2 ) / 8;
     if( schweller != alterWert )
     {
       alterWert = schweller;

       uart_putc(schweller);
     }
   }
}
  
void uart_init(void){
  UBRRH = UBRRH_VALUE;
  UBRRL = UBRRL_VALUE;
  
  #if USE_2X                  // U2X-Modus erforderlich
  UCSRA |= (1 << U2X);
  #else                    // U2X-Modus nicht erforderlich
  UCSRA &= ~(1 << U2X);
  #endif
  UCSRB |= (1<<TXEN);              // UART TX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1
}

void uart_putc(unsigned char c){
  while (!(UCSRA & (1<<UDRE))){}        // warten bis Senden moeglich
  UDR = c;                  // sende Zeichen
}
  
void Sendmidicontrol(void){
  uart_putc(176);          // Control-Comment
  uart_putc(100);          // Control # (0-127)
  uart_putc(100);          // Control Value (0-127)
}

Es soll insgesamt 3 Schweller geben, 3 Manual, 1 Pedal, 1 
Schieberegisterkette mit Tastern für die Setzersteuerung.

Die Pinbelegung vom Atmega8 isdt aus dem Schaltplan der Masterplatine zu 
entnehmen.
Muss ich die Codes jett einfach nur kopieren ?
Was schlägst du vor Karl Heinz?

Vielen Dank für deine/eure Bemühungen!!!!

Viele Grüße
Fabi

: Bearbeitet durch User
von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Fabian Müller schrieb:

> Was schlägst du vor Karl Heinz?

Gerade erst gesehen.

Vorschlag:
zunächjst mal kümmern wir uns um die Manuals.
Dazu braucht es 3 Schieberegisterketten, für jedes Manual eines.
Die 3 Schieberegisterketten werden mit den Steuerleitungen parallel 
gehängt und gemeinsam ausgelesen, dann dauert das für alle 3 nicht 
wesentlich länger als nur für eines alleine.

Ich würde auch vorschlagen, die Setzer-Taster im Grunde wie ein Manual 
zu behandeln. D.h. da sind nicht 3 SR-Ketten, sondern deren 4. Auch wenn 
die 4.te hardwaremässig nicht voll ausgeführt ist. Macht aber nix. 
Programmintern tun wir einfach so, mit dem Bewusstsein, dass einge der 
'Tasten' Phantasiewerte aufweisen.

Vorschlag für den Anschluss


   +-------+
           |
      PB0  o---------------------+------> PS der Taster-SR Kette
           |                     |
      PB1  o------------------+--)------>  C der Taster-SR Kette
           |                  |  |
      PB2  o------------------)--)------> DATA der Taster SR-Kette
           |                  |  |
      PB3  o---------------+  |  |
           |               |  |  |
      PB4  o-------------+ |  |  +------> PS Manual 1        -+
           |             | |  |  |                            |
      PB5  o-----------+ | |  +--)------>  C Manual 1       SR-Kette
           |           | | |  |  |                            |
           |           | | +--)--)------> Data Manual 1      -+
           |           | |    |  |
           |           | |    |  |
   +-------+           | |    |  |
                       | |    |  +------> PS Manual 2        -+
                       | |    |  |                            |
                       | |    +--)------>  C Manual 2       SR-Kette
                       | |    |  |                            |
                       | +----)--)------> Data Manual 2      -+
                       |      |  |
                       |      |  |
                       |      |  |
                       |      |  +------> PS Manual 3        -+
                       |      |                               |
                       |      +--------->  C Manual 3       SR-Kette
                       |                                      |
                       +----------------> Data Manual 3      -+

Ist das bei dir hardwaremässig so möglich?
(Ich hoffe, du hast da deine Masterplatine noch nicht gebaut)

Die Manualplatine:
Würde ich nicht so machen.
Ich würde mir ein kleines Platinenmodul machen, auf dem EIN (maximal 2) 
Schieberegister sitzt. Ernsthaft.
Jedes dieser Module hat eine Stiftleiste als "Eingang" und eine 
Stiftleiste als "Ausgang". Jedes Modul holt sich die PS und die 
C-Leitung vom Eingang und schleift sie auf seinen Ausgang durch. Die 
Data-Leitung von der Ausgangsstiftleiste geht auf den Kaskadiereingang 
des Schieberegisters und der Datenausgang vom Schieberegister geht auf 
auf die Eingangsstiftleiste. Dazu natürlich noch Vcc und GND (wobei es 
nicht schadet, ,mehrere GND bzw. Vcc Leitungen auf dem Kabel zu haben, 
so dass zwischen jeder Signale-führenden Leitung jeweils eine Vcc bzw. 
GND Leitung liegt. 2-reihige Stiftleisten sind ideal dafür.

Die Module werden in der benötigten Anzahl pro Schieregisterkette 
mittels kurzer Flachbandkabel aneinander gesteckt, wobei die Module dann 
möglichst dicht an die Manual-Tasten kommen, für die sie zuständig sind.

d.h. die Module werden so aneinander gereiht

           +----------------+         +----------------+         +----------------+
   PS -----o----+-----------o---------o----+-----------o---------o----+-----------o-->
    C -----o---+|-----------o---------o---+|-----------o---------o---+|-----------o-->
 Data -----o--+||       +---o---------o--+||       +---o------------+||       +---o-->
           |  |||       |   |         |  |||       |   |         |  |||       |   |
           |  Schieregister |         |  Schieregister |         |  Schieregister |
           |                |         |                |         |                |
           +|-|-|-|-|-|-|-|-+         +|-|-|-|-|-|-|-|-+         +|-|-|-|-|-|-|-|-+
            | | | | | | | |            | | | | | | | |            | | | | | | | |
            v v v v v v v v            v v v v v v v v            v v v v v v v v
               8 oder 16                  8 oder 16
                Tasten                      Tasten

Jedes Rechteck ist ein Modul - eine Platine. Alle Platinen sind gleich 
und man kann 'beliebig' viele hintereinander schalten, je nachdem 
wieviele Eingänge in dieser Kette benötigt werden.
Dadurch, dass die Platinen auf die Art klein sind, kann man die auch 
problemlos fertigen. Und dadurch, dass die Verbindungen zwischen den 
Modulen problemlos ein paar Zentimeter lang sein können 
(Flachbandkabel), können die Platinen jeweils in unmittelbarer nähe der 
8 Tasten sitzen, für die sie zuständig sind. (oder 16 Tasten, wenn 
jeweils 2 Schieberegister auf einem Modul sitzen)

Pro Manual brauchst du also 8 derartige Model (oder 4, bei 2 SR pro 
Modul). Für alle 3 Manuals daher 24 Module (oder 12). Für die Taster pro 
8 Taster jeweils 1 weiteres Momdul (oder pro 16 Taster), wobei ich mir 
die Frage stelle, ob die Pedale im Prinzip ja auch einfach nichts 
anderes als Schalter sind und daher mit den Tastern mitgehen.
Willst du irgendwann man mehr Schalter und Taster, dann hängst du 
einfach ein weiteres Modul an diese Kette an, was durch die 
'standardisierten' Anschlüsse auch problemlos geht.

So würde ich das aufbauen, wenn ich den Platz in der vorgegebenen Orgel 
habe, entlang der Manuals jeweils kleine Platinen anbringen zu können.

: Bearbeitet durch Moderator
von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Zu deinen Platinen.

Da haben wir wieder mal zum 3 millionsten mal den immer gleichen Fehler:
JEDES IC benötigt seinen Blockkondensator. Zwischen Vcc und GND gehört 
(möglichst dicht an das IC herangerückt) ein 100nF keramischer 
Kondensator.

Ohne diese Kondensatoren kann es funktionieren, muss aber nicht. Gerade 
bei derartigen Sachen, würde ich aber nicht auf 'kann' setzen, sondern 
auf Nummer sicher gehen. Blockkondensator hin und zumindest der Teil ist 
in Punkte 'Erhöhung der Zuverlässigkeit' erst mal abgehakt.
Die Blockkondensatoren stellen sicher, dass kleine Spannungseinbrüche, 
die durch kurzzeitig hohen Stromverbrauch eines IC entstehen, abgeblockt 
und am Ort des Entstehens ausgeglichen werden. Nicht ganz unwichtig, 
wenn im µC Arbeit verrichtet wird bzw. wenn ca. 30 Schieberegister 
gleichzeitig schalten. Da entstehen ganz schnell Stromspitzen, die das 
Netzteil mit Sicherheit nicht schnell genug ausregeln kann.

: Bearbeitet durch Moderator
von Fabian F. (fabiii9)


Bewertung
0 lesenswert
nicht lesenswert
Hallo,

viele Dank für deine Antwort.

Habe mich jetzt doch gegen den Selbstbau entschieden.
Es wird mir zu kompliziert.
Werde Platinen von WIRA oder Konsorten kaufen.

Gruß
Fabi

von Hobbyorganist (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ich finde das Thema interessant, ich baue auch an einer Orgel und würde 
gerne den Zweck dieses Schieberegisters verstehen.

von Karl H. (kbuchegg) (Moderator)


Bewertung
0 lesenswert
nicht lesenswert
Ein derartiger µC hat zuwenig Pins, als das man die Tasten der Manuals 
direkt anhängen könnte.
Die Schieberegister beheben das, indem sie sich zu einem bestimmten 
Zeitpunkt den aktuell Zustand jeder Taste merken und der µC dann die 
jeweiligen Zustände im Gänsemarsch an lediglich 3 Pins einlesen kann.

: Bearbeitet durch Moderator
von Hi-Tech-Progger S. (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Falls das jemand liest und sich dafür interessiert:

Die Firma Döpfer hat ein fertiges System für bis zu 64 INs und OUTs und 
auf UCAPPS gibt es Projekte mit bis zu 128 IOs.

von Kamerad Butzelmann (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Nur so zur Information.

In der Zeitschrift "c't Magazin" 2005 Heft14,15,17,22 war mal eine 
Selbstbau Musik-Workstation "Klangcomputer ||" beschrieben. Sehr 
interessant aber aufwändig.

von Organist (Gast)


Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Karl H. schrieb:
> Die Schieberegister beheben das, indem sie sich zu einem bestimmten
> Zeitpunkt den aktuell Zustand jeder Taste merken und der µC dann die
> jeweiligen Zustände im Gänsemarsch an lediglich 3 Pins einlesen kann.

Ich benutze diese hier in Handverdrahtung. Sind 1,50 das Stück.

Kennt jemand was Besseres? Z.b. eine komplette Kaskade für gleich 32 
Kanäle?

von schlumpf (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Naggige 595er hab ich schon fuer 3 ct/Stck per 30er Stange gesehn.

Das waeren aber wohl auch die flaschen.

Du brauchst Parallel-In Serial-Out.
Die 595er sind Serial-In und Parallel-Out!

von Organist (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Ja, richtig. Zum Ansteuern nach diesem Schema benötige ich aber beide 
Funktionen:

Beitrag "Re: 4x4 Matrix Tastatur am FPGA"

von Schlumpf (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Matrixtastaturen bei Musikinstrumenten sind Kaese.

Ausser Billigheimern macht sowas niemand ohne Not.

von Lothar M. (lkmiller) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Organist schrieb:
> Ja, richtig. Zum Ansteuern nach diesem Schema benötige ich aber beide
> Funktionen:
Dass dieses "Schema" für deine Zwecke völlig untauglich ist, wurde in 
dem verlinkten Thread schon ausgiebig diskutiert. Es bringt nichts, wenn 
du noch ein paar weitere Threads damit beglückst.

Aber wenn du es UNBEDINGT so machen WILLST, dann mache es genau so. 
Fang einfach mal damit an und mach ein Funktionsmodell zum Lernen. So, 
wie du zur Zeit herumhampelst und dich in der Theorie und halbgaren 
Spekulationen verlierst, dauert das Jahre und wird nichts.

Schlumpf schrieb:
> Matrixtastaturen bei Musikinstrumenten sind Kaese.
Ganz meine Worte. Auf jeden Fall bei Einzelstücken. Wenn man 1 Million 
davon macht, dann sieht das evtl. anders aus...

: Bearbeitet durch Moderator
von Schlumpf (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Spaetestens wenn er denn mal wirklich 61 oder 73 oder womoeglich
sogar 88 Tasten an/in einer Matrix verknueppern muss, wird ihmchen
schon die Einsicht kommen.
Statt 8 oder 16 Leitungen (+GND) per Tastaturabschnitt, fuer eine
Tastatur ohne oder mit Anschlagdynamik, hat er dann mit einem wilden
Draht/Platinenverhau zu kaempfen.

Mein Beileid hat er dann nicht.

von Lothar M. (lkmiller) (Moderator) Benutzerseite


Bewertung
1 lesenswert
nicht lesenswert
Zum Glück hat ein Orgel keine Anschlagdynamik, aber da müssen noch viele 
andere Schaltkontakte (Register, Koppel,...) abgefragt werden. Und wehe, 
wenn man mal hinterher noch was erweitern will.
Mit vielen Schieberegistern hintereinander ist das kein Problem: die 
verteilten Schalter/Taster/Kontakte müssen nicht großartig verdrahtet 
werden, weil sie einfach auf dem kürzesten Weg zum (durchaus räumlich 
gesehen) nächsten Schieberegister verdrahtet werden. Und wenn die Mimik 
zu wenige Eingänge hat, weil noch was erweitert werden soll, dann hängt 
man einfach noch ein paar Schieberegister dahinter.

Es ist ja nicht so, dass ich sowas nicht schon ein paar Mal gemacht 
hätte und ins Blaue hinein fabulieren würde...

von Schlumpf (Gast)


Bewertung
0 lesenswert
nicht lesenswert
> Mit vielen Schieberegistern hintereinander ist das kein Problem
Ja.

> räumlich gesehen
Genau deswegen.

Eine Matrix wuerde auch keine IOs an einem Controller/FPGA einsparen
sondern nur zusaetzliche belegen.

von Organist (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Schlumpf schrieb:
> Eine Matrix wuerde auch keine IOs an einem Controller/FPGA einsparen
> sondern nur zusaetzliche belegen.

Wieso denn das bitte?

Schlumpf schrieb:
> fuer eine
> Tastatur ohne oder mit Anschlagdynamik, hat er dann mit einem wilden
> Draht/Platinenverhau zu kaempfen.

Es geht auch nicht um die Tasten des Manuals, sondern nur um Schalter, 
die per Hand bedient werden und Funktionen steuern.

von Schlumpf (Gast)


Bewertung
0 lesenswert
nicht lesenswert
Fuer die Abfrage von Tasten (gegen GND) mit einem Parallel-Seriellen-SR
braucht man nur Takt und Daten.

Macht genau 2 IOs.

Um die Tasten in einer Matrix abzufragen braucht man noch Ausgaenge.

Die muessen ja auch angesteuert werden.


> Wieso denn das bitte?

[Hier stand ein unfreundlicher Satz.]


> Es geht auch nicht um die Tasten des Manuals, sondern nur um Schalter,
> die per Hand bedient werden und Funktionen steuern.

Was da dran haengt ist den Schieberegistern weitgehend egal.

von Organist (Gast)


Bewertung
1 lesenswert
nicht lesenswert
Schlumpf schrieb:
>> Wieso denn das bitte?
>
> [Hier stand ein unfreundlicher Satz.]

Wenn du eine sachliche Rückfrage nicht beantworten möchtest, dann lass 
es eben. Am Besten hälst Du Dich aus solchen Foren fern, wenn Du nicht 
kommunizieren kannst, oder willst.

Und noch dies:

Schlumpf schrieb:
> Matrixtastaturen bei Musikinstrumenten sind Kaese.
>
> Ausser Billigheimern macht sowas niemand ohne Not.

Nur so am Rande:
http://www.doepfer.de/DIY/Matrix_61.gif

von Lothar M. (lkmiller) (Moderator) Benutzerseite


Bewertung
0 lesenswert
nicht lesenswert
Organist schrieb:
> Nur so am Rande:
> http://www.doepfer.de/DIY/Matrix_61.gif
Na bitte, da hast du deinen Schaltplan. Du siehst da auch, wie die 
Dioden dort reinkommen.

Mach es genau so. An den Matrixleitungen kommen da dann auch keine 
Schieberegister, sondern direkt Portpins.

> Am Besten hälst Du Dich aus solchen Foren fern, wenn Du nicht
> kommunizieren kannst, oder willst.
Statt die Zeit für solche Ratschläge zu vergeuden solltest du einfach 
mal anfangen...

von Rolf S. (audiorolf)


Bewertung
1 lesenswert
nicht lesenswert
Hobbyorganist schrieb:
> Ich finde das Thema interessant, ich baue auch an einer Orgel und würde
> gerne den Zweck dieses Schieberegisters verstehen.

Die Bauzeit scheint sich in die Länge zu ziehen! (2014)

Vielleicht hilft doch ein Blick auf MIDIBOX. Die haben eine Menge 
fertiger Projekte mit WIKI. Für mich steht das hier an:

http://midibox.org/forums/gallery/image/3455-seq-productsheet-twojpg/

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.