Lauflicht mit Latches Übergangproblem

@  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

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

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

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

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

$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

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

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

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

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.

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

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 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.

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:

1

#include "sbit.h"

2

//----------------------------------------------------------------------------

3

// Hardware Assignments:

4

5

#define F_CPU   1e6                     // 1MHz

6

#include <util\delay.h>

7

8

#define D0      SBIT( PORTD, 0 )        // name data pins

9

#define D0_DDR  SBIT( DDRD,  0 )

10

#define D1      SBIT( PORTD, 1 )

11

#define D1_DDR  SBIT( DDRD,  1 )

12

#define D2      SBIT( PORTD, 2 )

13

#define D2_DDR  SBIT( DDRD,  2 )

14

#define D3      SBIT( PORTD, 3 )

15

#define D3_DDR  SBIT( DDRD,  3 )

16

#define D4      SBIT( PORTD, 4 )

17

#define D4_DDR  SBIT( DDRD,  4 )

18

#define D5      SBIT( PORTD, 5 )

19

#define D5_DDR  SBIT( DDRD,  5 )

20

#define D6      SBIT( PORTD, 6 )

21

#define D6_DDR  SBIT( DDRD,  6 )

22

#define D7      SBIT( PORTD, 7 )

23

#define D7_DDR  SBIT( DDRD,  7 )

24

25

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

26

#define PL_DDR  SBIT( DDRC,  0 )

27

28

#define L0      SBIT( PORTC, 1 )        // name latch pins

29

#define L0_DDR  SBIT( DDRC,  1 )

30

#define L1      SBIT( PORTC, 2 )

31

#define L1_DDR  SBIT( DDRC,  2 )

32

#define L2      SBIT( PORTC, 3 )

33

#define L2_DDR  SBIT( DDRC,  3 )

34

#define L3      SBIT( PORTC, 4 )

35

#define L3_DDR  SBIT( DDRC,  4 )

36

#define L4      SBIT( PORTC, 5 )

37

#define L4_DDR  SBIT( DDRC,  5 )

38

#define L5      SBIT( PORTB, 0 )

39

#define L5_DDR  SBIT( DDRB,  0 )

40

#define L6      SBIT( PORTB, 1 )

41

#define L6_DDR  SBIT( DDRB,  1 )

42

#define L7      SBIT( PORTB, 2 )

43

#define L7_DDR  SBIT( DDRB,  2 )

44

45

//---------------------------------------------------------------------------

46

// Program Code:

47

/******************* write the byte val to the latch num *****************/

48

49

void latch_data( uint8_t val, uint8_t num )

50

{

51

  D0 = 0; if( val & 1<<0 ) D0 = 1;      // set data pins

52

  D1 = 0; if( val & 1<<1 ) D1 = 1;

53

  D2 = 0; if( val & 1<<2 ) D2 = 1;

54

  D3 = 0; if( val & 1<<3 ) D3 = 1;

55

  D4 = 0; if( val & 1<<4 ) D4 = 1;

56

  D5 = 0; if( val & 1<<5 ) D5 = 1;

57

  D6 = 0; if( val & 1<<6 ) D6 = 1;

58

  D7 = 0; if( val & 1<<7 ) D7 = 1;

59

60

  switch( num ){                        // set selected latch

61

    case 0: L0 = 1; break;

62

    case 1: L1 = 1; break;

63

    case 2: L2 = 1; break;

64

    case 3: L3 = 1; break;

65

    case 4: L4 = 1; break;

66

    case 5: L5 = 1; break;

67

    case 6: L6 = 1; break;

68

    case 7: L7 = 1; break;

69

  }

70

  L0 = 0;

71

  L1 = 0;

72

  L2 = 0;

73

  L3 = 0;

74

  L4 = 0;

75

  L5 = 0;

76

  L6 = 0;

77

  L7 = 0;

78

}

79

80

81

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

82

83

void latch_init( void )

84

{

85

  D0_DDR = 1;

86

  D1_DDR = 1;

87

  D2_DDR = 1;

88

  D3_DDR = 1;

89

  D4_DDR = 1;

90

  D5_DDR = 1;

91

  D6_DDR = 1;

92

  D7_DDR = 1;

93

94

  PL = 1;                               // transparent forever

95

  PL_DDR = 1;

96

97

  L0_DDR = 1;

98

  L1_DDR = 1;

99

  L2_DDR = 1;

100

  L3_DDR = 1;

101

  L4_DDR = 1;

102

  L5_DDR = 1;

103

  L6_DDR = 1;

104

  L7_DDR = 1;

105

106

  for( uint8_t i = 0; i < 8; i++ )

107

    latch_data( 0, i );                 // clear all latches

108

}

109

110

111

int main( void )

112

{

113

  latch_init();

114

115

  for(;;){

116

    for( uint8_t i = 0; i < 8; i++ ){                   // for 8 latches

117

      for( uint8_t mask = 0x80; mask; mask >>= 1 ){     // for 8 bits

118

        latch_data( mask, i );                          // next LED on

119

        _delay_ms( 500 );

120

        latch_data( 0, i );                             // LED off

121

      }

122

    }

123

  }

124

}

Peter

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.

Erst vielen Dank an  Peter Dannegger

Dein Code hat mir weitergeholfen!