Autor: katrin

Activity calls next Activity

Aufbau Haupt- und Nebenhandlungen

Zwei Aktivitäten werden  über eine Intent-Verknüpfung  miteinander verbunden. Welche Aktionsklasse als nächstes aufgerufen werden soll, definiert man bei der Intent-Implementation. Diese geschieht bei der Funktionsdefinition der XXOnClickXX()-Funktion.

// Die Main Activity

public class ChooseFlower extends Activity(..){  


   protected void onCreate(){       // per default da
     // details see below  
     ... 
   } 

   // wird aufgerufen, wenn Taste gedrückt wurde
   public void onClickFindFlower(View view){ // selber aufgebaute Funktion 
       ... 
   } 
}
public class TopLevelActivity extends AppCompatActivity {
    
    protected void onCreate(Bundle savedInstanceState) {
       // details below

       // definiert Listener mit onItemClick() Methode
    };
        
    // Add listener to list view
    ListView listView = (ListView) findViewById(R.id.list_options);
    listView.setOnClickListener(itemClickListener);   
}

Funktin onCreate()

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_top_level);

        // Listener (needed after as argument) 
        // in which the desired action is implemented for the click 

        AdapterView.OnItemClickListener itemClickListener = 
                        new AdapterView.OnItemClickListener(){

            // define own function: what happens after click
            public void onItemClick(AdapterView<?> listView, View v, int position, long id){

                // handel position of list elements
                if(position == 0){  // first element in List
                    Intent intent = new Intent(TopLevelActivity.this, DrinkCategoryActivity.class);
                    startActivity(intent);
                }
            }
        };

 

Intent der etwas sendet
Bsp. Bein Klicken wird ein Email versendet

public void onSendMessage(view View){
      ...
      Intent intent = new Intent(Intent.ACTION_SEND);
      intent.putExtra(Intent.EXTRA_TEXT, messageTExt);  // Text übergeben
      starActivity(intent);
}

 

..

Funktionsnamen

Methode set: Setter
Inhalt:         Wechselt den Zustand der Variable
Struktur:    void <name>(<argument>);
Bsp:              stream.set( string );

Methode get: Getter
Inhalt:         Liest einen Wert aus
Struktur:   <type> <name>();
Bsp:              command = getToken();

Klasse Definition

class Token_stream {
    public:
        void set(string line);
        Token get();
        void put_back(Token t);
    private:
        istringstream calculation;
        bool full = false;
        Token buffer;
};

Eine Klasse beinhaltet Klassenvariablen und Klassen-Funktionen.

Instanzierung

Token_stream current_token_stream;

current_token_stream ist eine Instanz dieser Klasse. Alle Funktionen (die gebraucht werden um die Instanz zu verarbeiten) brauchen zuerst den Instanznamen.

current_token_stream.set(calculation_line);

 

Klassen-Funktionen
Jede Funktion einer Klasse muss nach der Klassendefinition definiert werden. Die Funktion braucht vor ihrem Namen die Klasse, zu der sie gehört.

void Token_stream::put_back(Token t) {
    
    // check if token is already in buffer
    if (token_buffer_full) {
        throw std::overflow_error("buffer contains already a Token");
    }
    
    // set token in buffer
    token_buffer = t;

    token_buffer_full = true;
}

Funktionen einer Klasse, müssen nicht forward deklariert werden. Sie sind durch die Definition der Klasse bereits bekannt.

Klassen-Variablen
Es gibt meist wenige Klassenvariblen. Denn diese sind „global“ innerhalb der Klasse. Alle Funktionen können auf diese Zugreifen.

class Token_stream {
    ...
    private:
        istringstream calculation;
        bool full = false;
        Token token_buffer;
};

Typisch ist, dass sie im private-Teil der Klasse stehen.

Lokale Variablen
In jeder Klassen-Funktion werden zur Verarbeitung auch lokale Variablen gebraucht.

Token Token_stream::get() {

    char c;
    Token t;

    calculation >> c;

    if (isdigit(c)) {
        t.kind = 'n';
        t.value = c;
    } else if (c == '\0') {
        t.kind = 'q';
    } 

    return t;
}

 

I2C

Hier ein Zusammenfassung aus der Spezifikation:
– Hat 2 Kabel: Serial Data (sda), Serial Clock (scl)
– Die Datenleitung ist im Ruhezustand auf ‚1‘ (pull up Widerstände notwendig)
– Start geht vom Datenkanal aus (siehe unten)

Serielle Datenübermittlung
I2C_data_transferMit jedem Takt wird 1 Bit der Daten übermittelt.
Das Bit wird bei ‚1‘ im CLK ¨übernommen. Der Datenwechsel ist bei ‚0‘.
bit-transfer

Start und Stop
Die Datenleitung steuert Start und Stop. Sie geht auf ‚0, wenn der CLK auf ‚1‘ ist. Normalerweise gibt es keinen Wechsel, wenn CLK auf ‚1‘ ist.

acknowledge

 

Empfangen der Bits
Mit jedem CLK wird 1 Bit empfangen.
Der Slave empfängt die Bits und legt sie in ein Register.

 

Lock In

Schwingkreise können sich gegenseitig beeinflussen. So können sie sich z. B. ungewollt synchronisieren, was die Genauigkeit beschränken kann.

Frequenzdifferenz
Koppeln sich die zwei Systemen unterhalb der Lock-In-Schwelle, so schwingen danach beide mit derselben Frequenz.

 

CUDA paralleles Programmieren

N-mal Funktion parallel ausführen

__global__ void add( int *a, int *b, int *c){
.      *c = *a + *b;
}

// Funktion add() wird 1-mal ausgeführt
add<<< 1, 1 >>>( dev_a, dev_b, dev_c );

// Funktion add() wird N-mal ausgeführt
add<<< N, 1 >>>( dev_a, dev_b, dev_c );

Die Variablen werden dadurch zu Arrays.
a -> a[N]      ,       b -> b[N],        c -> c[N]


Zugreifen auf die parallelen Prozesse
Jeder parallele Prozess läuft im Kernel in einem anderen Block. Jeder Block hat seine Id  blockIdx.x  .
a[1], b[1], c[1] laufen im Block 1.

c[0] = a[0] + b[0]
__global__ void add( int *a, int *b, int *c ) {
.      c[blockIdx.x] = a[blockIdx.x] + b[blockIdx.x];
}

.