** WELCOME * 2 * AsteriXH **

• Grobdesign

		PSEUDOCODE
		==========
		Inputs: a,b,c,d,e
		Outputs y1 = abcd!e + !a!b!c!de, y2 = ab!cde+abc!de
  y1 =	(	   a
		&& b
		&& c
		&& d
		&& !e )
	||
	(	   !a
		&& !b
		&& !c
		&& !d
		&& e  ) ;

  y2 =	(	    a
		&&  b
		&& !c
		&&  d
		&&  e )
	||
	(	    a
		&&  b
		&&  c
		&& !d
		&&  e  ) ;
		
		fertig!
		-------
		
		des is doch "easy", oder?

• da fehlen aber noch die Input-Signale a..e !

/*		PSEUDOCODE-2 mit Input
		======================
		Inputs: a,b,c,d,e
		Outputs y1 = abcd!e + !a!b!c!de, y2 = ab!cde+abc!de
 */
#include < stdio.h>
float a[]={	0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,
		1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1 };
float b[]={	0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0 };
float c[]={	0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0 };
float d[]={	0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0 };
float e[]={	0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0,0,0 };

int kombinatorischeSchaltung(int t /*time*/){
  y1 =	   (  a[t]  &&  b[t]  &&  c[t]  &&  d[t]  &&  !e[t] )
	|| ( !a[t]  && !b[t]  && !c[t]  && !d[t]  && e[t]  ) ;


  y2 =	   (  a[t]  &&  b[t]  && !c[t]  &&  d[t]  &&  e[t]  )
	|| (  a[t]  &&  b[t]  &&  c[t]  && !d[t]  &&  e[t]  ) ;
}

int main(){
  int t;
  for( t=0; t < 100; t++){
    kombinatorischeSchaltung(t);
    printf("|  %i   %i\n", y1, y2);
  }
}

• Jetzt machst bitte noch ein besseres ASCII-Art-Diagramm statt dem "printf()"

  ...
	/* ASCII-art-DG */
  printf("+--------y1---------+---------y2------------>Ua\n);
  for( t=0; t < 100; t++){
    kombinatorischeSchaltung(t);
    xAxis:    printf("|  ");
    y1trace:  if(y1 < 1){ printf("|      ");
	      }else{      printf("      |");
	      }
    y2trace:  printf("             ");
	      if(y2 < 1){ printf("|      ");
	      }else{      printf("      |");
	      }
  }

1. Offsetspannung
   Wennma die OP-Eingaenge kurzschliesst (nicht politisch gemeint),
   sollte Ua = 0 sein, is aber nit!
   Zwischen Ue+ und Ue- scheint eine kleine Spannungsquelle zu sein,
     mit Udiff = a paar mV
   Zum Messen mussma die Verstaerkung kleiner machen (A₀=100 000 -fach is zviel),
   also bausch an invertierenden mit A=100 oder 1000
   Ue+ an den "Rn"-Eingang und diesen Knoten an eine mittlere Eingangsspannung,
     vielleicht (Vcc+Vee)/2
     dann kriegsch   Udiff*A   aussa
2. Eingangsruhestrom
   bipolare Eingaenge brauchen etwas Basisstrom -
     den kannsch messen,
     indem Du in den einen Eingang an Riesen-Widerstand vorschaltesch
     und dem anderen nit.

• Erzeugt 8-Bit-Sinus-Samples auf 'stdout'

#!/usr/bin/python3
#      +--------sagt einer UNIX-Shell, mit welchem
#               Interpreter das Script zu verarbeiten ist
#
# send sin(t) 8Bit samples to 'stdout' stream
import sys,os,math

def main():
  ##aplay -c1 -traw -fU8 -r22050"
  os.system('amixer set Master 50%')
  z=100
  while(1): #for k in range(1,80,2):
    k=12
    for i in range(0,10000):
      b=bytearray()
      b.append( int(z+z*math.sin(k*i/50.)) )
      os.write(1, b)

main()
#end

• kopiert 'stdin' nach 'stdout' und zeigt ASCII-DG auf '/dev/tty'

/* aDG.c ASCIIartDG filter XH@UdA,UdB
 *
 * compile: 'gcc aDG.c -o aadg'
 * run:     <source> '|' aadg -y [maxYvalue] -s [sampleFactor]'| aplay -c1 -traw -fU8 -r8000'
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

int main(int argc, char *argv[]){
  int opt;
  int ch, xfact=1,yint;
  long lc=0;
  float yscale=1., yval;
  struct timespec ts={0L,0L};

  while ((opt = getopt(argc, argv, "y:s:t:")) != -1) {
    switch (opt) {
    case 'y':
	yscale = atof(optarg);
	break;
    case 's':
	xfact = atoi(optarg);
	break;
    case 't':
	ts.tv_sec = atol(optarg)/1000;
	ts.tv_nsec= (atol(optarg)%1000L)*1000000L;
	break;
    default:
	fprintf(stderr, "\nUsage: %s -y <yscaleMax> -s <sampleFactor> -t millisecs\n", argv[0]);
	break;
    }
  }
  system("amixer set Master 50%");
  system("amixer set PCM 80%");
  system("amixer set Mic 80%");
  system("amixer set 'Mic Boost' 3");
  fprintf(stderr, "yMax:%8.2f, sampleFact: %d dt=%ld.%ld\n",yscale, xfact, ts.tv_sec, ts.tv_nsec);
  for(;;){
    if( EOF == (ch=fgetc(stdin))) break;
    fputc(ch,stdout);
    fprintf(stderr, "%03X ",ch); fflush(stdout);
    if(!((lc++)%xfact)){
      yint= yscale*ch/255.0;
      fprintf(stderr, "!%2$*1$.*1$s%3$i\n", yint,
		"                                                  "
		"                                                  "
		"                                                  "
		, ch);
      if(ts.tv_nsec>0L || ts.tv_sec>0L) nanosleep(&ts,NULL);
    }
  }
  exit(EXIT_SUCCESS);
}

• folgendes Kommando leitet "Mic-In" zum "Sound-Out" und zeichnet Oszillogramm

#!/bin/sh
# pipe "Mic-In" through 'aadg' to "Sound-Out"
#      and as ASCII-Art-DG to /dev/tty:
(arecord | ./aadg -y60 -s3 |aplay) 2> /dev/tty

• Leitet sin()-Byte-Stream zum SoundOut und zeichnet Oszillogram

#!/bin/sh
# pipe a sin()-Byte-Stream through 'aadg' to 'Sound-Out'
#      and as ASCII-Art-DG to /dev/tty:
(./UdB3-snd.py | ./aadg -y60 -s2 | aplay -c1 -r22050 -fU8) 2>| /dev/tty

• XH - 5 May 13:52- FE heisst FINITE ELEMENTE, und zwar isch 'finit' es Gegenteil von 'infinit'/'infinitesimal'
		 --- beim Integral si 'dt' unendlich klein, und bei FE isses nur 'ausreichend klein'

• XH - 5 May 13:52- diese Beispielprogramme sollen Dir augenscheinlich machen,
		mit was fuer Kinderkram Dich Olzium und Co. bescheissen

• XH - 5 May 13:54- unser 'dt = 0.001' fuehrt zur Berechnung nur alle 1ms --- wir kriegen nur alle 1ms einen Wert
		 --- des is wie Abtastung - mit allen Seiteneffekten auch, wie zB Aliasing

• XH - 5 May 13:55- Anstelle eines ADC, der die Samples liefert, programmiersch ez einen "Samples-Generator"

• XH - 5 May 13:55- kannsch mit der Erklaerung was anfangen?

• bitte fertige auch BlockDiagramme an.

	numerische Simulation einer
		RC-Kondensatoraufladung:
	Bitte um schrittweisen Top-Down-Entwurf im PSEUDOCODE
	======================================================
	
	PSeudocode-Schritt1:
  Werte_initialisieren:
  while(C unter 95%)
    Strom_in_R_ausrechnen:
    neue_Spannung_an_C_ausrechnen:
    Zeit_weiterzaehlen:
    Diagramm_anzeigen:
  end;

• oberflächlich
• syntaxfehlerträchtig
• lückenhaft

	
	PSeudocode-Schritt2:
  Werte_initialisieren:
    R=1k;
    C=1uF;
    tau=1./R/C;
    dt = tau/30.;    // "Abtastrate-Samplezeit": 1/30 von 'tau'
    t=0.;
  "while(C unter 95%):"
  while(Uc < 0.95*Vcc)
    Strom_in_R_ausrechnen:
      Ur = Vcc - Uc
      Ir = Ic = Ur/R
    neue_Spannung_an_C_ausrechnen:
      Uc = C* dUc/dt   ==>  dUc = dt * Uc/C
      Uc = Uc + dUc
    Zeit_weiterzaehlen:
      t  = t+dt
    Diagramm_anzeigen:
      printf( ASCII-Diagramm ) aus letztem Termin
  end;

	
	PSeudocode-Schritt3:


	...
	
	(kannsch des ez bitte Du detaillieren)

• ganz simple Rechteck-, Flischflossen- und Rampen- Funktionsgeneratoren
  kriegt man schon mit 1 OP hin:

* Komparator mit Hysterese + RC-GLied von Ua nach E-

*(das ist die 'SPICE-netlist' Simulator-Sprache):

Vplus	Vcc	0	DC 5V
Eop1	Ep  En  Ua 0 G=25000
Rn	Ua  En	?k
Cn	En  0	?nF
R1	Ua  Ep	?k
R2	Ep  0	?k

• Mit dem Ne555 IC reichen 1R und 1C fuer
  Rechteck an Pin3 und
  Fischflossen an Pin2-Pin6
  (das Datenblatt zeigt Beispiele)
• Wird statt R eine Konstantstromquelle nach Pin2-Pin6 geschaltet,
  liegt ein Rampen-Signal an Pin2-Pin6

1. Rechteck --> LED (10..30Hz verstellbar) --> Reaktionsfrequenzgrenze feststellen
2. Rechteck --> Headphone (10..20kHz verstellbar) --> Hörfrequenzbereich feststellen

Kontinuierliche FE-Simulation einer Kondensator-Aufladung (RC-Schaltung)
Prinzip: FE-Simulation der Gleichungen
        Ic = C * dUc / dt
        R=U/I
        Ugesamt = Σ Ui

Pseudo-Code:

/* Simulations-Parameter in SI-Einheiten: */
Vbatt:= 12
R:=     100
C:=     0.1
t_max:= 10
dt:=    0.1

/* Anfangs-Bedingungen: */
t:= 0
Vc:=0

/* Simulationslauf */
while (t < t_max )
 Ir  := ( Vbatt-Vc ) / R
 Ic  := Ir
 dVc := dt * Ic / C
 Vc  := Vc + dVc
 t   := t + dt
end

/* Simulationsergebnis: */
PRINT "Nach ";t;" Sekunden ist Uc auf ";Vc;" angestiegen."
PRINT "Nach ";t;" Sekunden ist Ic auf ";Ic;" abgesunken."

/* RCaufl-UdL1.c Kondensatoraufladung-FE, XH@UdL
 * compile: 'gcc RCaufl-UdL1.c -o RC.bin'
 * run:     './RC.bin'
 */
#include <stdio.h>
int main(int argc, char *argv[]){
  int   zl=0;
  float y, Ir, Ic, Vc, dVc, t,
        /* Simulations-Parameter in SI-Einheiten: */
  Vbatt= 12.0  ,
  R=     100.0 ,
  C=     0.1   ,
  t_max= 10.0  ,
  dt=    0.1   ;

        /* Anfangs-Bedingungen: */
  t= 0.;
  Vc=0.;

        /* Simulationslauf mit Diagrammausgabe (ASCII-Art)*/
  printf("+---------+---------+---------+---------+---------"
        "---------+---------+---------+---------> y\n");
  while (t < t_max ){
    if(! (zl++ % 3)){	/*f.Diagramm: */
      putchar('|');
      for(y=0.; y<Vc; y+=0.1){ putchar(' '); }
      printf("%+4.1fV\n", Vc);
    }
    Ir  = ( Vbatt-Vc ) / R;
    Ic  = Ir;
    dVc = dt * Ic / C;
    Vc  = Vc + dVc;
    t   = t + dt;
  }
  printf("v x\n");
}

+---------+---------+---------+---------+------------------+---------+---------+---------> y
|+0.0V
|    +0.4V
|        +0.7V
|           +1.0V
|              +1.4V
|                 +1.7V
|                    +2.0V
|                       +2.3V
|                          +2.6V
|                             +2.9V
|                                +3.1V
|                                  +3.4V
|                                     +3.6V
|                                       +3.9V
|                                          +4.1V
|                                            +4.4V
|                                              +4.6V
|                                                 +4.8V
|                                                   +5.0V
|                                                     +5.2V
|                                                       +5.4V
|                                                         +5.6V
|                                                           +5.8V
|                                                             +6.0V
|                                                              +6.2V
|                                                                +6.4V
|                                                                  +6.5V
|                                                                   +6.7V
|                                                                     +6.8V
|                                                                      +7.0V
|                                                                        +7.1V
|                                                                         +7.3V
|                                                                           +7.4V
|                                                                            +7.6V
v x

Vplus   Vcc     0       DC 9V
V1      FG      0       DC 0 PULSE ( 0    5  100ns 1us  1us   499us     1ms )
*                                  Vmin Vmax delay tr    tf    pw     periode
Rg      FG      G1      4k7
L1      Vcc     zuR1    1mH
R1      zuR1    D1      40
M1      D1 G1 S1 0      IRF510 W=.64 L=2u 
Vfet    S1      0       DC 0
.control
TRAN    1u  2ms
plot    v(FG)   v(D1)
plot    i(Vfet)
.endc

.model IRF510   NMOS(Level=3 Gamma=0 Delta=0 Eta=0 Theta=0 Kappa=0.2 Vmax=0 Xj=0
+               Tox=100n Uo=600 Phi=.6 Rs=.4508 Kp=20.68u  Vto=3.697
+               Rd=21.08m  Cbd=366.5p Pb=.8 Mj=.5 Fc=.5 Cgso=600.5p
+               Cgdo=62.71p Is=202.9f )
.end

* Leitung Labor4a UcH,UcI,UcM,UcN,

Vin     FG      0       DC 0 PULSE(   0m +1000m 100ns 100ns  100ns 100us  300us  )
*                                   Vmin   Vmax   td    tr    tf   ton  tperiode

Rv      FG      in      330
Vx      in      in1     DC 0
O1      in1 0   out 0   HtlKabel
RL      out     0       136R

.control
 set color0=wheat color1=black color2=navy  color3=darkcyan
    +color4=brown color5=red   color6=purple
 foreach RL  136  100Meg  200  50  1m
  ALTER RL $RL
  TRAN 10ns 60us
 end
 plot   tran1.v(in)   tran2.v(in)   tran3.v(in)   tran4.v(in)   tran5.v(in)
.endc
.model HtlKabel LTRA R=15m L=780n C=42p LEN=1200
.end

Vin     FG      0       DC 0 PULSE(   0m +1000m 1us 100ns  100ns 100us  300us  )
*                                   Vmin  Vmax  td    tr    tf   ton  tperiode
Rv      FG      in      330
Vx      in      in1     DC 0
TLine   in1 0   out 0   Z0=136 TD=7us
RL      out     0       1Meg
.control
 set color0=lightgrey color1=black color2=blue
 TRAN 10ns 100us
 plot   v(in)
.endc
.end