Lauflicht mit Latches Übergangproblem

[Nette M. (nette-mann)]

Habe insgesamt 8 Module und 16 Latches. Das ganze ist in Bascom 
programmiert. Jetzt hab ich das Problem, das der Übergang von einem in 
das andere Modul stockt. d.h. es sieht nicht flüssig aus. Hatte jetzt 
mal angefangen mit;

Waitms 80
 Portd.6 = 1                                     'LATCH Allgemein enable
 Portd.7 = 1                                     'LATCH Erste Modul 
enable

 Portb.0 = 1
 Portb.1 = 1
 Portc.5 = 1
 Portc.4 = 1
 Portc.3 = 1
 Portc.2 = 1
 Portc.1 = 0



 Portd.6 = 0
 Portd.7 = 0

Nur das funktioniert zwar, ist allerdings mit riesen Schreibaufwand 
verbunden Von daher, wie kann ich das ganze in BASCOM kompakter 
schreiben? und wie wird es flüssiger? Dachte da an Timer aber das wird 
ein noch viel riesiger Schreibaufwand Da ich bis jetzt  mit GCC noch 
nicht so positive Erfahrung gemacht habe, würde ich gerne bei BASCOM 
bleiben.

[Falk B. (falk)]

@  Nette Mann (nette-mann)

>Nur das funktioniert zwar, ist allerdings mit riesen Schreibaufwand
>verbunden Von daher, wie kann ich das ganze in BASCOM kompakter
>schreiben?

Schon mal was von Schleifen gehört? For next und so?

> und wie wird es flüssiger? Dachte da an Timer aber das wird
>ein noch viel riesiger Schreibaufwand Da ich bis jetzt  mit GCC noch
>nicht so positive Erfahrung gemacht habe, würde ich gerne bei BASCOM
>bleiben.

Dir fehlen vor allem Grundlagen, DIE solltest du dir erstmal 
verschaffen.

MFG
Falk

[Nette M. (nette-mann)]

Schleifen klingt gut. Dann hab ich ja erstmal Lesestoff Vielen Dank. 
Dachte erst an Routinen aber Schleifen klingt besser

[spess53 (Gast)]

Hi

> Portb.0 = 1
> Portb.1 = 1
> Portc.5 = 1
> Portc.4 = 1
> Portc.3 = 1
> Portc.2 = 1
> Portc.1 = 0

Was soll das bewirken?

MfG Spess

[Nette M. (nette-mann)]

Das setzt die ausgänge im ersten Latch das wird dann an das Latch was da 
hinter sitzt übermittelt und daran hängen die LEDs

Portd.7 = 1 wird das Latch was an den LEDs hängt auf High gesetzt und 
die Daten von dem vorderem LATch was auf jedem Modul klebt weitergeben 
und ausgegeben

[Nette M. (nette-mann)]

Beim bearbeiten nimmt er den Anhang nicht

Und je nach dem welches LATCH gerade von den hinteren enabled ist, 
bekommt die Befehle mit &11111110 oder &11111101

Aber mit


Do


Loop until $var = Wert klingt interesssant

[spess53 (Gast)]

Hi

So etwas legt man sinnvollerweise auf einen Port.

MfG Spess

[Jürgen (Gast)]

Hallo Nette Mann,

wenn du nicht gerade mit Latches experimentieren willst (zu Lehrzwecken 
?), würde ich dir empfehlen, google mal Schieberegister.
Oder schau hier in der Artikelsammlung.
Der 74HC595 währe nett, passt also :-)

[Nette M. (nette-mann)]

Bin an die 573A gebunden. Leider... SPI Latches sind mir sympatischer.

Hab allerdings immer noch nicht raus wie ich einmal einen Lauf in eine 
Schleife packen kann

[Nette M. (nette-mann)]

$Regfile = "m8def.dat"
$Crystal = 4000000
Ddrc = &B0011111
Ddrb = &B0000011
Portc = &B00111111
Portb = &B00000011
Dim Led(8) As Byte
Dim Led2(8) As Byte
Dim Zaehler As Byte
Dim Zaehler2 As Byte
 Led(1) = 5 :
 Led(2) = 4 :
 Led(3) = 3 :
 Led(4) = 2 :
 Led(5) = 1 :
 Led(6) = 0 :
 Led(7) = 6 :
 Led(8) = 7:
 Led2(1) = 1:
 Led2(2) = 0:
Do
   For Zaehler = 1 To 8 Step 1
      Toggle Portc.led(zaehler)
      Waitms 100
      Toggle Portc.led(zaehler)
   Next Zaehler
      For Zaehler2 = 1 To 2 Step 1
      Toggle Portb.led2(zaehler2)
     Waitms 100
      Toggle Portb.led2(zaehler2)
   Next Zaehler2
Loop
End
schonmal ein anfang

[Nette M. (nette-mann)]

Habe  es jetzt mit Subroutinen auf die Beine gestellt
Auszug;

Main:
A = A + 1
If A = 1 Then Gosub Sub1
Wait 2
If A = 2 Then Gosub Sub2
If A = 2 Then Goto Devnull:



Devnull:
A = 0
Return


Sub1:
 Portd.6 = 1
 Portd.7 = 1
   For Zaehler = 1 To 6 Step 1

   Toggle Portc.led(zaehler)

   Waitms 80

   Toggle Portc.led(zaehler)

   Next Zaehler2

   For Zaehler2 = 1 To 2 Step 1

   Toggle Portb.led2(zaehler2)

   Waitms 80

   Toggle Portb.led2(zaehler2)
   Next Zaehler
 Portd.6 = 0
 Portd.7 = 0
Return
End

Das einzigste was ich jetzt noch gerne wüsste, wäre:

mit Step 1 zählt er immer 1 d.h es geht eine LED aus. Wie schreib ich es 
so, das 2 Leds ausgehen?


0000000X
000000XX
00000XX0
0000XX00
000XX000

etc

[Peter D. (peda)]

Du wirst so kaum nutzbringende Antworten erhalten, da der ganze Thread 
nur ein großes Rätselraten ist.

Du mußt schon nen kompletten Schaltplan posten und vor allem sagen, was 
das überhaupt für ein konkreter MC ist.

Ich sach mal so ins Blaue:
- OC muß beschaltet werden
- IC1 ist überflüssig
- Du kannst nie alle Latches gleichzeitig updaten

Keiner hat Lust, immer die Pins auszuklamüsern, Du mußt den Pins schon 
sinnvolle Namen geben.


Peter

[Matthias L. (Gast)]

>Bin an die 573A gebunden.

Wieso machst du es dann nicht richtig und verschaltest die Latcheingänge 
mit dem \WR-Impuls.

SOmit reicht ein Schreibzugriff auf eine SPeicherzelle.

[NETTE MANN (Gast)]

wr was Inpuls? kenne nur LATCH und OUTPUT ENABLE

[Matthias L. (Gast)]

>wr was Inpuls? kenne nur LATCH und OUTPUT ENABLE

Es ist auch möglich, Signale sinnvoll zu verbinden, welche 
unterschiedliche Namen haben...

Vielleicht solltest du mal die Ratschläge von peda annehmen:

>>Du mußt schon nen kompletten Schaltplan posten und vor allem sagen, was
>>das überhaupt für ein konkreter MC ist.

[Nette M. (nette-mann)]

Es ist ein Atmega 8 der Schaltplan von dem 573 Konstrukt ist wie oben 
abgebildet.

Der Atmega hängt an den Latches der einzelnen Modulen  und am 
allgemeinen LATCH aller Module

Der obere IC ist nur ein VErstärker IC die beiden dickeren sind die 573 
von diesen Module gibt es 8

[Nette M. (nette-mann)]

Mal die Stecker Belegung von dem 34 poligen mit anhängen

erste zweite etc ist auf das LATCH was direkt an dem verstärker IC hängt 
bezogen und LATCH allg. auf den vorderen 573.

[Peter D. (peda)]

Oh oh,
hätte nicht gedacht, daß man ein riesiges 600k-Bild mit so wenig 
Informationen hinkriegt.

Und Text als jpg zu posten, ist gelinde gesagt unhöflich (kommt gleich 
nach der Quelltext als doc-Unsitte).


Peter

[Karl H. (kbuchegg)]

Nette Mann schrieb:

> Das einzigste was ich jetzt noch gerne wüsste, wäre:

Das einzigste was du ganz dringend brauchst, ist ein Bascom Kurs.

   For Zaehler = 1 To 6 Step 1

     ...

   Next Zaehler2


   For Zaehler2 = 1 To 2 Step 1

     ...

   Next Zaehler


Schau doch mal, die du hier die Laufvariablen in Bezug auf die Fors 
ineinander geschachtelt hast! Die Schleife beginnt mit dem For und endet 
beim Next. Und klarerweise muss das immer dieselbe Laufvariable sein! 
Wenn BASCOM das zulässt, ist das für mich definitiv ein Grund, den 
Gedanken auch mal mit BASCOM ein bischen zu spielen wieder fallen zu 
lassen. Solche Fehler passieren schon einmal beim experimentieren. Aber 
sowas MUSS ein Compiler finden.

Hast du schon mal was von Arrays gehört? Von Data-Feldern?
Der ganze Ansatz mit Einzelbit-Manipulation, den du da treibst, ist doch 
für die Tonne.
Besorg dir Literatur oder zumindest ein BASCOM Tutorial. Wie willst du 
denn programmieren, wenn du dein Werkzeug nicht kennst?

[nette mann (Gast)]

Array wird in der FOR Schleife angewandt!

Problem ist halt das das LED Spiel Portd und port B beansprucht.

LED(1) = 1
.....
LED(6) = 1

For Zaehler = 1 To 6 Step 1

Toggle PortD.LED(Zaehler)

...


Das ist halt das Probelm das ich 6 Pins an PortD habe und 2 an B und das 
kann ich nicht in eine For Schleife packen.

Und sowas wie:
"Wie willst du
denn programmieren, wenn du dein Werkzeug nicht kennst?"

ist Dünnschiss. Ich kenne nur nicht ALLE Befehle und habe zu vor nur mit 
ADC SPI LCD und nen paar Relais gebastelt. Entschuldigung das man 
gefragt hat. Vom theoretischen Aufbau ist mir das Lauflicht bewusst. 
Kann es ja auch wie im ersten Beitrag zu lesen umsetzen. Nur diese 
Variante ist Dünnschiss weils zich Seiten Code ergibt. Wenn mir keiner 
dazu nen hilfreichen Tipp geben kann, wie z.B. Nimm 1 ne For Schleife 
für die Latches und bind 2 For Schleifen ein für die 7 LEDs, dann sagt 
es gleich. Nur hier rum mäkeln und sagen haste noch nie was von Arrays 
gehört obwohl welche programmiert sind oder mich als voll Null 
darzustellen was ich nicht bin, dann sagt es gleich. Entweder ihr postet 
was hilfreichen oder ihr lasst es gleich. Nur dann seit auch noch so 
fair und sagt das ihr es selber nicht könnt. Wenn ihr es z.B. in C 
könnt, danbn könnte man als nützlichen Beitrag den in etwa Aufbau 
beschreiben.

[nette mann (Gast)]

Nachtrag:

Ich kenne nur nicht ALLE Befehle und habe zu vor nur mit
ADC SPI LCD und nen paar Relais gebastelt.

Da fehlt noch der UART

[Micha (Gast)]

Vielleicht solltest du aber wirklich mal den kompletten Schaltplan 
posten und kein Bild auf dem man nichts erkennen kann und auch keine 
Steckerbelegung mit der man nichts anfangen kann.

Und nein: auch der "Schaltplan" von 
Beitrag "Re: Lauflicht mit Latches Übergangproblem" hilft nicht weiter 
und ist obendrein auch noch etwas unsinnig...

Außerdem empfehle ich dir dringend ein Basic-Tutorial durchzuarbeiten!

[Karl H. (kbuchegg)]

nette mann schrieb:

> Das ist halt das Probelm das ich 6 Pins an PortD habe und 2 an B und das
> kann ich nicht in eine For Schleife packen.

Sagt wer?
Alles was du brauchst ist eine Funktion die dir einen 8-Bit Wert 
entsprechend an die Ports verteilt. In der Schleife kannst du dann ganz 
normal hochzählen und die Spezialfunktion verteilt die Bits auf die 
richtigen Pins.

Jetzt siehst du wenigstens, dass man bei der Vergabe der Portpins 
aufpasst und Dinge die zusammengehören nicht unnötig auseinanderreisst. 
Das muss dann später alles in Software wieder ausgebügelt werden. 
Entweder man kann das oder man kann es nicht. Im letzten Fall sollte man 
dann etwas vorsichtiger sein und etwas mehr planen, wenn man die 
Hardware baut.

Wozu soll eigentlich das Zwischenlatch gut sein? Das braucht kein 
Mensch. Portpins halten ihren Zustand solange, bis man was Neues drauf 
schreibt. Dort hast du also bereits dein 'Zwischenlatch', es ist im µC 
eingebaut.

Ganz abgesehen davon, dass der ganze Ansatz mit Latches schon fragwürdig 
ist.

> "Wie willst du
> denn programmieren, wenn du dein Werkzeug nicht kennst?"
>
> ist Dünnschiss.

Na wenn du das sagst.

> Ich kenne nur nicht ALLE Befehle und habe zu vor nur mit
> ADC SPI LCD und nen paar Relais gebastelt.

Ich rede nicht von vorgefertigten Funktionsgruppen, denen man nur noch 
ein paar Werte einstellen muss und dann arbeiten sie ganz von alleine. 
Ich rede von Befehlen, mit denen man Programmlogik ausdrücken kann. 
Möglichkeiten Daten abzulegen und wiederzufinden, einzelne Bits 
extrahieren und mit ihnen was machen, etc.
Programmieren ist mehr als nur einen Ausgabepin auf 0 oder 1 zu setzen.

[Route_66 (Gast)]

Programmieren können heißt nicht ALLE Befehle kennen. Programmieren 
heißt zu lösende Aufgaben zu erkennen, sinnvoll zu teilen, in 
Algorithmen zerlegen und dann möglichst effizient umzusetzen.
Das ist wie Krimis schreiben. Die Story ausdenken, die Personen 
erfinden, alles an einen passenden Ort und in die passende Zeit packen, 
und dann noch spannend ablaufen lassen - das ist programmieren. Alle 
Befehle kennen ist dann damit vergleichbar ob ich im Krimi 100 mal Haus 
schreibe oder auch mal Gebäude, Villa, Kate, Bungalow, Hütte usw.

[Peter D. (peda)]

Es gilt "divide et impera", d.h. teile Dein Programm in kleine 
Unterfunktionen auf, dann wirst Du es auch beherrschen.
Kryptischer Spaghetticode ist out.
Eine wichtige Unterfunktion ist, gebe ein Byte auf ein Latch aus.

Und wenn die Pins nicht sortiert sind, ist das kein Beinbruch, man 
braucht dann nur etwas Schreibarbeit für die Namensgebung und Zuordnung.

Hier mal ein Beispiel in C (ich kann kein Bascom). Die Pinbelegung habe 
ich willkürlich gewählt. Ist aber einfach zu ändern.
Die Mainroutine macht als Beispiel ein Lauflicht:

#include "sbit.h"
//----------------------------------------------------------------------------
// Hardware Assignments:

#define F_CPU   1e6                     // 1MHz
#include <util\delay.h>

#define D0      SBIT( PORTD, 0 )        // name data pins
#define D0_DDR  SBIT( DDRD,  0 )
#define D1      SBIT( PORTD, 1 )
#define D1_DDR  SBIT( DDRD,  1 )
#define D2      SBIT( PORTD, 2 )
#define D2_DDR  SBIT( DDRD,  2 )
#define D3      SBIT( PORTD, 3 )
#define D3_DDR  SBIT( DDRD,  3 )
#define D4      SBIT( PORTD, 4 )
#define D4_DDR  SBIT( DDRD,  4 )
#define D5      SBIT( PORTD, 5 )
#define D5_DDR  SBIT( DDRD,  5 )
#define D6      SBIT( PORTD, 6 )
#define D6_DDR  SBIT( DDRD,  6 )
#define D7      SBIT( PORTD, 7 )
#define D7_DDR  SBIT( DDRD,  7 )

#define PL      SBIT( PORTC, 0 )        // unnecessary !
#define PL_DDR  SBIT( DDRC,  0 )

#define L0      SBIT( PORTC, 1 )        // name latch pins
#define L0_DDR  SBIT( DDRC,  1 )
#define L1      SBIT( PORTC, 2 )
#define L1_DDR  SBIT( DDRC,  2 )
#define L2      SBIT( PORTC, 3 )
#define L2_DDR  SBIT( DDRC,  3 )
#define L3      SBIT( PORTC, 4 )
#define L3_DDR  SBIT( DDRC,  4 )
#define L4      SBIT( PORTC, 5 )
#define L4_DDR  SBIT( DDRC,  5 )
#define L5      SBIT( PORTB, 0 )
#define L5_DDR  SBIT( DDRB,  0 )
#define L6      SBIT( PORTB, 1 )
#define L6_DDR  SBIT( DDRB,  1 )
#define L7      SBIT( PORTB, 2 )
#define L7_DDR  SBIT( DDRB,  2 )

//---------------------------------------------------------------------------
// Program Code:
/******************* write the byte val to the latch num *****************/

void latch_data( uint8_t val, uint8_t num )
{
  D0 = 0; if( val & 1<<0 ) D0 = 1;      // set data pins
  D1 = 0; if( val & 1<<1 ) D1 = 1;
  D2 = 0; if( val & 1<<2 ) D2 = 1;
  D3 = 0; if( val & 1<<3 ) D3 = 1;
  D4 = 0; if( val & 1<<4 ) D4 = 1;
  D5 = 0; if( val & 1<<5 ) D5 = 1;
  D6 = 0; if( val & 1<<6 ) D6 = 1;
  D7 = 0; if( val & 1<<7 ) D7 = 1;

  switch( num ){                        // set selected latch
    case 0: L0 = 1; break;
    case 1: L1 = 1; break;
    case 2: L2 = 1; break;
    case 3: L3 = 1; break;
    case 4: L4 = 1; break;
    case 5: L5 = 1; break;
    case 6: L6 = 1; break;
    case 7: L7 = 1; break;
  }
  L0 = 0;
  L1 = 0;
  L2 = 0;
  L3 = 0;
  L4 = 0;
  L5 = 0;
  L6 = 0;
  L7 = 0;
}


/************************* init latches after reset *******************/

void latch_init( void )
{
  D0_DDR = 1;
  D1_DDR = 1;
  D2_DDR = 1;
  D3_DDR = 1;
  D4_DDR = 1;
  D5_DDR = 1;
  D6_DDR = 1;
  D7_DDR = 1;

  PL = 1;                               // transparent forever
  PL_DDR = 1;

  L0_DDR = 1;
  L1_DDR = 1;
  L2_DDR = 1;
  L3_DDR = 1;
  L4_DDR = 1;
  L5_DDR = 1;
  L6_DDR = 1;
  L7_DDR = 1;

  for( uint8_t i = 0; i < 8; i++ )
    latch_data( 0, i );                 // clear all latches
}


int main( void )
{
  latch_init();

  for(;;){
    for( uint8_t i = 0; i < 8; i++ ){                   // for 8 latches
      for( uint8_t mask = 0x80; mask; mask >>= 1 ){     // for 8 bits
        latch_data( mask, i );                          // next LED on
        _delay_ms( 500 );
        latch_data( 0, i );                             // LED off
      }
    }
  }
}

Peter

[Karl H. (kbuchegg)]

Route_66 schrieb:

> Das ist wie Krimis schreiben.

Wenn du Krimis schreiben willst, solltest du zumindest den Grossteil der 
Buchstaben des Alphabets kennen.
Nur mit der Kenntnis von A E I O U und vielleicht noch H, kann man keine 
Krimis schreiben.

> Alle Befehle kennen ist dann damit vergleichbar

Von 'alle' habe ich auch gar nicht gesprochen. Aber zumindest die 
wichtigsten. Um in deinem Beispiel zu bleiben. Wenn mein Wortschatz nur 
aus 'der', 'die', 'das' besteht und dazu noch 'Essen', 'Stuhl', 'Messer' 
und 'Licht', dann wird der Krimi wohl nichts werden.
Und da hilft mir auch kein Schimpfen in einem Forum, da hilft nur das 
Wörterbuch studieren (=Hilfe) und mir einen Überblick zu verschaffen, 
welche Wörter es noch gibt und was sie bedeuten. So viele sind es ja in 
einer Programmiersprache nicht.

[Route_66 (Gast)]

Ganz genau kbucheg!
Und zu den Programmiersprachen:

>ein Beispiel in C (ich kann kein Bascom).

Das ist wie Krimis schreiben in Englisch (ich kann kein Arabisch)...

Die Sprache ist unwichtig, wenn mann nicht wie ein Programmierer denken 
kann.

[nette mann (Gast)]

Alles hilfreich. dann werde ich mal drübernachdenken und mich wieder 
melden. Vom Aufbau ist es mir klar. Nur an der umsetzung haperte es

[Nette M. (nette-mann)]

Erst vielen Dank an  Peter Dannegger

Dein Code hat mir weitergeholfen!