Hulp gevraagd met alarm rtc.

Deze code heb ik een klein beetje aangepast dat als het alarm af gaat(tekst Serial.println ) dat een led gaat branden, maar deze moet ook weer uit gaan na 1 seconde. Dat aan gaan lukt wel, alleen dat uit gaan niet. Deze alarm repeat zich zelf weer na 1 min, dus ik wil dat de led elke 1 min aan gaat en na 1 seconde weer uit.

Wie kan hier mij mee helpen?

hier onder code( als het goed is, heb ik het nu bij gevoegd zoals het hoort :slight_smile:

// during an alarm the INT pin of the RTC is pulled low
//
// this is handy for minimizing power consumption for sensor-like devices, 
// since they can be started up by this pin on given time intervals.


#include <Wire.h>
#include "ds3231.h"

#define BUFF_MAX 256


int in1 = 4;  // IN1-IN4= input is of your motorstepper driver (L298N MODULE)
int in2 = 5;
int in3 = 6;
int in4 = 7;



uint8_t sleep_period = 1;       // the sleep interval in minutes between 2 consecutive alarms

// how often to refresh the info on stdout (ms)
unsigned long prev = 5000, interval = 5000;

void set_next_alarm(void)
{
    struct ts t;
    unsigned char wakeup_min;

    DS3231_get(&t);

    // calculate the minute when the next alarm will be triggered
    wakeup_min = (t.min / sleep_period + 1) * sleep_period;
    if (wakeup_min > 59) {
        wakeup_min -= 60;
    }

    // flags define what calendar component to be checked against the current time in order
    // to trigger the alarm
    // A2M2 (minutes) (0 to enable, 1 to disable)
    // A2M3 (hour)    (0 to enable, 1 to disable) 
    // A2M4 (day)     (0 to enable, 1 to disable)
    // DY/DT          (dayofweek == 1/dayofmonth == 0)
    uint8_t flags[4] = { 0, 1, 1, 1 };

    // set Alarm2. only the minute is set since we ignore the hour and day component
    DS3231_set_a2(wakeup_min, 0, 0, flags);

    // activate Alarm2
    DS3231_set_creg(DS3231_INTCN | DS3231_A2IE);
}

void setup()
{
 pinMode(in1, OUTPUT);
 pinMode(in2, OUTPUT);
 pinMode(in3, OUTPUT);
 pinMode(in4, OUTPUT);

  
    Serial.begin(9600);
    Wire.begin();
    DS3231_init(DS3231_INTCN);
    DS3231_clear_a2f();
    set_next_alarm();
}

void loop()
{
    char buff[BUFF_MAX];
    unsigned long now = millis();
    struct ts t;

    // once a while show what is going on
    if ((now - prev > interval) && (Serial.available() <= 0)) {
        DS3231_get(&t);

        // display current time
        snprintf(buff, BUFF_MAX, "%d.%02d.%02d %02d:%02d:%02d", t.year,
             t.mon, t.mday, t.hour, t.min, t.sec);
        Serial.println(buff);

        // display a2 debug info
        DS3231_get_a2(&buff[0], 59);
        Serial.println(buff);

        if (DS3231_triggered_a2()) {
            Serial.println(" -> alarm2 has been triggered");
            set_next_alarm();
            digitalWrite(in1, HIGH);                                  // Dit heb ik zelf aan toegevoegd!!!
            // clear a2 alarm flag and let INT go into hi-z
            DS3231_clear_a2f(); 

        //digitalWrite(in1, LOW);                                     //Dit heb ik ingevult om het laag te krijgen. 
              
        }
        prev = now;
    }

    
}

Gelukt, door natuurlijk delay(1000) toevoegen en daarna digitalWrite(in1, low);

Maar nu het volgende wil ik niet dat het alarm om de 1 min langs komt maar wil in dat het om de bv 10 seconde langs komt.

Ik heb weer de code aangepast min in sec te maken, maar dat lukt nog niet!! weet iemand dit wel!!!

// during an alarm the INT pin of the RTC is pulled low
//
// this is handy for minimizing power consumption for sensor-like devices, 
// since they can be started up by this pin on given time intervals.


#include <Wire.h>
#include "ds3231.h"

#define BUFF_MAX 256


int in1 = 4;  // IN1-IN4= input is of your motorstepper driver (L298N MODULE)
int in2 = 5;
int in3 = 6;
int in4 = 7;



uint8_t sleep_period =10;  // the sleep interval in minutes between 2 consecutive alarms

// how often to refresh the info on stdout (ms)
unsigned long prev = 5000, interval = 5000;

void set_next_alarm(void)
{
    struct ts t;
    unsigned char wakeup_sec;

    DS3231_get(&t);

    // calculate the minute when the next alarm will be triggered
    wakeup_sec = (t.sec / sleep_period + 1) * sleep_period;
    if (wakeup_sec > 59) {
        wakeup_sec -= 60;
    }

    // flags define what calendar component to be checked against the current time in order
    // to trigger the alarm
    // A1M1 (seconds) (0 to enable, 1 to disable)
    // A2M2 (minutes) (0 to enable, 1 to disable)
    // A2M3 (hour)    (0 to enable, 1 to disable) 
    // A2M4 (day)     (0 to enable, 1 to disable)
    // DY/DT          (dayofweek == 1/dayofmonth == 0)
    uint8_t flags[5] = {0, 0, 1, 1, 1 };

    // set Alarm2. only the minute is set since we ignore the hour and day component
    DS3231_set_a2(wakeup_sec, 0, 0, flags);

    // activate Alarm2
    DS3231_set_creg(DS3231_INTCN | DS3231_A2IE);
}

void setup()
{
 pinMode(in1, OUTPUT);
 pinMode(in2, OUTPUT);
 pinMode(in3, OUTPUT);
 pinMode(in4, OUTPUT);

  
    Serial.begin(9600);
    Wire.begin();
    DS3231_init(DS3231_INTCN);
    DS3231_clear_a2f();
    set_next_alarm();
}

void loop()
{
    char buff[BUFF_MAX];
    unsigned long now = millis();
    struct ts t;

    // once a while show what is going on
    if ((now - prev > interval) && (Serial.available() <= 0)) {
        DS3231_get(&t);

        // display current time
        snprintf(buff, BUFF_MAX, "%d.%02d.%02d %02d:%02d:%02d", t.year,
             t.mon, t.mday, t.hour, t.min, t.sec);
        Serial.println(buff);

        // display a2 debug info
        DS3231_get_a2(&buff[0], 59);
        Serial.println(buff);

        if (DS3231_triggered_a2()) {
            Serial.println(" -> alarm2 has been triggered");
            set_next_alarm();
            digitalWrite(in1, HIGH);  
            
            
          
            // clear a2 alarm flag and let INT go into hi-z
            DS3231_clear_a2f(); 
delay(2000);

      digitalWrite(in1, LOW);                       
              
        }
        prev = now;
    }


}

Kijk eens naar blink without delay.

okay, je hebt gelijk met delay staat het even stil en krijg daarom krijg je ook weer een afwijking in de tijd!

Maar nu heb ik flink zitten spelen met blink without delay, maar heb weer het volgende probleem dat ik vier led wil gebruiken en dat eerst leds om de beurten aan gaan. Dus eerst led 1 aan, led2-4 uit daarna led2 aan en de rest uit enz.

Nu kan ik wel kiezen tussen led1 aan rest uit(kan ook aan trouwens) en daarna de andere leds aan en de eerst weer uit. Maar misschien moet je nog een keer "else" tussen voegen, maar dat lukt mij niet of je kan niet "else"niet meerder keren gebruiken achter elkaar.

De regel met " if (led1State == LOW) { " lukt mij ook niet er te verander in " if (led1State, led2State, Led3State, led4State == low) of plaats van komma te gebruiken het en(&) teken. Maar dat zal ik ook wel verkeerd doen of het heeft misschien helemaal geen zin om dat te doen.

bijgevoegd de aangepaste code!

// constants won't change. Used here to set a pin number :
const int led1 =  4;      // the number of the LED pin
const int led2 =  5;
const int led3 =  6;      
const int led4 =  7;



// Variables will change :
int led1State = LOW;             // ledState used to set the LED
int led2State = LOW;
int led3State = LOW;            
int led4State = LOW;


// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change :
const long interval = 2000;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    // if the LED is off turn it on and vice-versa:
   if (led1State == LOW) {
      led1State = HIGH;
      led2State = LOW;
      led3State = LOW;
      led4State = LOW;
    } 
    else {
      led1State = LOW; 
      led2State = HIGH;
      led3State = HIGH;
      led4State = HIGH;
    }


    // set the LED with the ledState of the variable:
    digitalWrite(led1, led1State);
    digitalWrite(led2, led2State);
    digitalWrite(led3, led3State);
    digitalWrite(led4, led4State);
   
  }
}

Hoi.

De code tags doe je nu goed.
En het leren doe je ook op een goede manier, aanpassen van code om te zien wat er dan gebeurt.

Alleen neem je veel te grote stappen.
Daardoor verlies je heel snel het overzicht en heb je geen idee wat er fout gaat.

Je kijkt nu of LED 1 aan staat, en aan de hand daarvan wil je weten of de andere LEDs ook aan moeten.
Das pas de eerste stap van wat je beschreef.
Je wil iets anders als wat in de originele sketch werd gedaan, dus volstaat het niet om precies hetzelfde te doen met nog iets anders erachteraan geplakt.
De originele sketch kijkt alleen naar de verlopen tijd, en of de LED aan of uit moet, en dat is nu nog niet veranderd.
Jij wil iets toevoegen, dus dan moet je dat ook doen.
Je moet nu weten hoe ver je al bent, dus welke stappen er al gezet hebt.
Dat kun je niet doen door te kijken of LED 1 al aan is.
Wat als je nou eens gaat bijhouden bij welke stap je bent aangekomen (plus dus de tijd) ?
Nu mag jij gaan opschrijven voor jezelf hoeveel stappen je eigenlijk wil zetten (4 is niet het juiste antwoord), dan kun je van daaruit je code verder ontwikkelen.

pff, best lastig hoor. Maar ik ga het nog eens opnieuw uitproberen en bestuderen en opnieuw lezen wat je nou precies bedoelt, want dat snap ik nog niet helemaal. Ik begrijp ook nog niet helemaal de sketch/code met al die functie's.

Ik kom er later nog op terug of iemand kan het misschien anders uitleggen!!

Hoi.

Even iets wat ik eerder maar achterwege heb gelaten:
Waar je nu mee bezig bent, is iets anders en ook een heel andere sketch.
Dat is wel een beetje verwarrend.
De laatste door jou geplaatste sketch is gebaseerd op BlinkWithoutDelay (BWD), vanochtend moest ik even goed kijken wat er nou aan de hand was, omdat de sketches nog niet misschien op elkaar lijken.

En je heb het hierboven over 'al die functies'.
Een functie is binnen het programmeren (in ieder geval bij de C varianten), een stukje van de code dat apart opgeroepen kan worden door een andere functie.
Dat komt niet voor in de BWD sketch, daar heb je alleen de functies setup en loop.
Die beide functies worden aangeduid met void(functie), omdat deze functies niets door of terug geven aan de functie waardoor ze werden opgeroepen.

Als dat niet is wat je bedoelde met het woord 'functies' in je post hierboven, dan graag vertellen wat je wel bedoelde.

Als je misverstanden wil voorkomen, dan is het beter om niet te zeggen "ik snap het nog niet" of "ik begrijp het niet helemaal", maar in plaats daarvan te vertellen wat je er wel van begrijpt.
Dat forceert je om er nog eens een keer over na te denken terwijl je het opschrijft, maar ook kan er zo herkend worden of je het bij het juiste eind hebt of dat er nog wat bijgeschaafd moet worden.

Ik had gehoopt dat je er zelf wat meer van gemaakt zou hebben, en een en ander al een beetje uitgewerkt.
Je kunt veel beter eerst een tijdje nadenken over hoe je iets aanpakt, dan dat je gelijk code gaat zitten typen.
Nico heeft het daar in de verschillende recente threads ook al eens over gehad; eerst wat uitwerken, en dan pas de code gaan maken.

Ik denk begrepen te hebben dat je het volgende wil doen op basis van de BWD sketch.
LED 1 aan, de rest uit.
LED1 en LED 2 aan, LEDs 3 en 4 uit.

Zo kun je dus uitschrijven wat je telkens moet zien gebeuren.
Als je alles hebt uitgeschreven wat je wil zien met je LEDs, kun je gaan uitwerken hoe je elke stap dan moet zetten.
Daarbij zul je vaker iets nieuws bedenken dat wellicht beter werkt.
Als je dat vaak genoeg zo hebt uitgewerkt, dan kom je met de tekst die je dan hebt, al heel dicht in de buurt van de code die je wil uiteindelijk wil hebben.

Trouwens, als je de originele sketch niet helemaal begrijpt, schrijf bij elke regel een commentaar.
Daar kan aan gezien worden of je het goed begrijpt, want in dat geval klopt je commentaar.

xtarx: nu heb je dus een knipperlicht gemaakt die 1 of 3 leds laat aangaan elke 2 seconden.
prima toch
je hebt dus prima geleerd met BWD.
Om nu verder te gaan kijk eens wat state machine is dat werkt met switch case dan kun je weer stappen maken.
zet hiervoor al die leddingen in een functie en roep die functie aan in je loop met een switch.

okay, je hebt gelijk. Ik zal de tips gebruiken wat Shooter bedoel en zal proberen zo al te werk ga. Maar moet wel als tegen argument geven dat iedereen anders is kwa persoon en ook zo'n beetje je eigen werkwijzen.
Maar ik ben natuurlijk om het te leren en daarom zal ik het zo proberen en ook proberen anders mijn vragen te formulieren.

wat de Hoofddoel is, daar was ik volgens mij wel duidelijk in is: 4 leds achter om en om achter elkaar laten knipper(looplicht wordt dat ook wel eens genoemd geloof ik) dus led1, led2-4 uit na 1 seconde led2 en de rest van de leds uit enz steeds 1 led opschuiven.

Maar ik ga het eerst nog proberen per regel voor regel de (functie) te snappen.

Terug komen dat jij zei dat je verwarrend is om weer een andere sketch(BWD) dat komt om dat jullie dat zeggen en dat doe ik dan. Mijn Hoofddoel is en blijft dat ik de stappenmotor op variable tijd 1 stap / per tijd (1min en langer) met rtc zonder afwijking continue wil laten lopen.

Ja mixtarx, dat snap ik wel.
Maar dat was niet zo duidelijk uit je verhaal, en dan word het voor iemand anders dan jezelf een beetje lastig om je te volgen, das wat ik bedoel.

En je hoofddoel, dat maakt voor mij eigenlijk niets uit.
Maar wel voor jezelf.
Als je het opschrijft, dan kun je wat je hebt opgeschreven nog eens bekijken en nadenken over wat daar staat, en hoe je dat zou oplossen.
Das dus een hulpje voor jezelf.
Later zul je dat minder nodig hebben, omdat je dan al wat ervaring hebt opgedaan met programmeren.
Het is niet voor iedereen weggelegd dat ie meteen in zijn hoofd een voorstelling kan maken over hoe het programma er uit zal gaan zien, en dit zou je daar wel eens bij kunnen helpen.

Overigens, als je er tijd in wil steken, kun je allerlei knipperpatronen bedenken met je 4 LEDs en die hebben dan dus allemaal een net iets andere benadering nodig.
Of je dat al meteen in een berg functies moet steken of alles in loop stopt, moet je zelf weten.
Maar ik raad je wel aan om voor alles wat je doet, steeds maar met 1 probleem (leerstof) tegelijk bezig te zijn.
Als je dat ene probleem onder de knie hebt, kun je met de volgende aan de slag.
Daarmee maak je het jezelf veel gemakkelijker.

Een RTC is eigenlijk gewoon een seconde teller, en die zit er ook gewoon in hoor.
de rest is allemaal rekenwerk.

dus als je dan zover bent dan kun je net als je met millis() doet ook met now() doen.
maar eerst dus je stappen in een functie zetten die dus telkens als je de functie aanroept een stap zet. (dat zijn dus jouw 4 stappen en als de teller op 5 staat dan weer bij 1 beginnen.
dan maak je in de loop hetzelfde als je bij blink without delay doet maar dan met now ipv met millis().
zo stapje voor stapje kom je er vanzelf.

Overigens stepper speed werkt wel met millis() dus dat gaat bij jou niet goed.

Hallo Mas3, ik snap er gelukkig steeds meer van, ik heb nu volgens mij de code goed aangepast.

Helaas snap ik nog steeds niet alles van deze code, maar ik ga eerst nog verder stoeien, besturen en daarna proberen duidelijk te vragen/ benoemen wat ik niet snap, maar daar ben ik nog niet zo ver voor.

Bedankt Scooter voor de tips van de rtc, misschien snap ik het maar ik ga eerst ff nog met deze code stoeien voor dat ik ga proberen jou tips toe te passen. Want eerlijk gezegd wordt het nu wel een beetje veel en verwarden voor mij aan het worden al die verschillende code's. Dus ga ik nu rustig stapje voor stapje verder. Gelukkig heb ik al een hoop geleerd, maar het blijft wel complex hoor!!

Nogmaals allemaal bedankt, ik beging het nu een beetje leuk te vinden, maar soms ook wel een beetje stressen hoor.

// constants won't change. Used here to set a pin number :

const int led1 =  4;      // the number of the LED pin
const int led2 =  5;
const int led3 =  6;      
const int led4 =  7;

// Variables will change : 

int led1State =LOW;             // ledState used to set the LED        
int led2State =LOW;
int led3State =LOW;            
int led4State =LOW;



// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
     
unsigned long previousMillisled1 = 0;  // will store last time LED was updated
unsigned long previousMillisled2 = 0;
unsigned long previousMillisled3 = 0;
unsigned long previousMillisled4 = 0;

// constants won't change :
        
const long led1Interval = 1000;      // interval at which to blink (milliseconds)
const long led2Interval = 500;
const long led3Interval = 300;
const long led4Interval = 100;



void setup() {
  // set the digital pin as output:
  
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();
 
 if (currentMillis - previousMillisled1 >= led1Interval) {
    // save the last time you blinked the LED
    previousMillisled1 = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (led1State == LOW) {
      led1State = HIGH;
    } else {
      led1State = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(led1, led1State);
  }
  
  if (currentMillis - previousMillisled2 >= led2Interval) {
    // save the last time you blinked the LED
    previousMillisled2 = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (led2State == LOW) {
      led2State = HIGH;
    } else {
      led2State = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(led2, led2State);
  }
    if (currentMillis - previousMillisled3 >= led3Interval) {
    // save the last time you blinked the LED
    previousMillisled3 = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (led3State == LOW) {
      led3State = HIGH;
    } else {
      led3State = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(led3, led3State);
  }
   if (currentMillis - previousMillisled4 >= led4Interval) {
    // save the last time you blinked the LED
    previousMillisled4 = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (led4State == LOW) {
      led4State = HIGH;
    } else {
      led4State = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(led4, led4State);
  }
}

Hoi.

Zoals je ziet aan de tijd dat dit antwoord is geplaatst, ik ben laat thuis en ben redelijk moe.
Maar ik heb wel even je code bekeken (dus het kan zijn dat ik zo snel iets gemist heb).
Het ziet er goed uit.
Maar deze code doet wel iets anders als wat je eerder beschreef.
Namelijk de LEDs per stuk in een ander ritme laten knipperen.
Een van de LEDs loopt daarbij uit de pas bij de andere LEDs.
Je ziet daarbij dat het ritme van de ene LED, die van de andere LEDs niet verstoort.
Dat komt dus omdat je een andere en veel betere oplossing hebt gebruikt dan delay().

Doet het wat je ervan verwachtte ?

Je kunt de code vermoedelijk nog wel iets efficiënter laten werken, maar daar gaat het hier niet om.
Het gaat er om of het doet wat je wil.

Als dat zo is, dan kun je proberen om die ene LED wel in de pas te laten lopen (is erg eenvoudig).
Als het nu niet doet wat je wilde, dan is het natuurlijk zaak dat je uitzoekt waarom dat zo is, en het dan nog ff oplossen natuurlijk ;).

klopt, deze code was alleen om het te laten zien dat alle 4 leds een eigen functie hebben gekregen. Maar ben nog al niet klaar met deze code hoor. En wil zeker ook nog weten hoe efficiënter kan, want ik wil nu alles van weten/ leren, hahaha.

Sorry mannen, maar ik ga even stoppen met vragen stellen en hinten toepassen. Ik wordt er nu helemaal crazy van en krijg er letterlijk nachtmerries van en praat(schreeuw) in mijn slaap dat ik GEEN DELAY mag gebruiken.Mijn vrouw vind dat ook niet meer zo leuk!! Zo kom ik niet verder met de aanwijzingen van jullie(goed bedoelt natuurlijk) en dat ik dan nog steeds net niet snap. Ik heb al veel geleerd, maar natuurlijk nog lang niet alles. Vaak denk ik nu heb ik het, maar dan zit ik net steeds een beetje ernaast,pfffff. Ik heb nu ook geleerd dat ik alles moet opschrijven wat ik wil, maar soms snap ik het zelfs nu niet meer wat die stappen zijn. Ik moet ook goed opletten hoe ik iets moet formulieren anders komen er alleen maar verwarringen van.

IK heb vandaag twee boeken gekocht in het nederlands.

deze Arduino, Günter Spanner | 9789053811115 | Boeken | bol.com

en deze Arduino in control, Marc Friedheim | 9789053812808 | Boeken | bol.com

IK hoop dat dit de geschikte boeken zijn, want ik kan er niet door heen bladeren.

Ik had al uiteraard al veel gelezen op internet en video gezien. En natuurlijk veel sketch uitgeprobeerd en veranderd, maar ik denk dat ik gewoon weer bij nul begint met behulp van de boeken het beste nu is.

IK hoop weer snel terug te zijn en dat ik dan zelf de oplossing heb gevonden voor de stappenmotor met rtc module. Zo niet dan hoop ik betere, gerichte vragen te kunnen stellen van wat ik dan nog niet duidelijk is.

laterrrr

Tja er valt weinig te zeggen over die boeken omdat er weinig meer te zien is dan een inhoudsopgave. Wel zie ik vrijwel de meeste beginners dezelfde fout maken. Eerst doen en dan denken. We beginnen gelijk met typen....
Zelf blijf ik een voorstander van eerst voorbereiden. En weet ik iets niet dan zoek ik net zolang tot ik het wel weet. En die nachtmerries zijn herkenbaar als is het na ruim 40 jaar wel een tijdje geleden...
Wel ben ik een sterke voorstander van visualiseren. Dus trek het probleem uit elkaar. Er zijn verschillende methodieken voor om gestructureerd te programmeren. Koop een pak papier bij de action (500 vel voor 2.75 zei Shooter jaren geleden) en leer het probleem uit elkaar te trekken. Geen tooltjes gebruiken zolang je de techniek niet beheerst. En dan pas coderen (omzetten in een taaltje C, C#, C++, Java of whatever).
Nu gaan de meesten gelijk tikken of kopiëren een sketch ergens vandaan en proberen er gelijk een andere sketch erin te plakken. En toen werkte het niet meer.
Of die boeken je dat allemaal gaan leren weet ik niet dat zal de tijd leren. Maar in de kern moet je eerst abstract leren denken. En een pak papier helpt je daarbij. Beredeneer een oplossing. Kan je dat niet dan heb je vrijwel de garantie dat het niet werkt. Je beheerst jouw oplossing niet.... Dus waarom zou je hem ontwikkelen. Beheers je hem wel kunnen er best stukken zijn die je nog niet snapt. Goede reden om daar apart op in te zoomen en daar eerst een oplossing voor te vinden. Wederom net zolang tot je het begrijpt. En voor je zelf continu de vraag stellen "Waarom moet het zo?"
Stel je die vraag niet ben je gewoon aan het gokken.... Kun je net zo goed naar het casino gaan.... Ben je ook gelijk je geld kwijt.....

Ik ben het helemaal mee met je eens. Normaal wil ik eerst ook iets begrijpen voor dat ik iets ga doen. En leren door het te doen werkt ook wel goed tot op een zekere hoogte, want als het complex is kan het zo veel zijn, zelfs een lullig ( of een { die je ERGENS vergeet!!

Ik vind het ook prettig om te horen hoe je vooral de werkwijze worden gebruikt, dan zie je vaak net iets anders dan je zelf ziet.

Papier uitschrijven klinkt makkelijk, maar is als beginneling moeilijker dan je zou denken hoor. Ik pas het sinds kort nu ook toe.

Video kijken werkt best prettig vind ik zelf.

Video is kunstje kijken en onthouden.... Pak papier is kunstje zelf ontwikkelen en begrijpen...

Ja Nico, dat probeerde ik dus ook al aan de man te brengen.
Jij deze keer met iets meer woorden.

Ik heb het al veel vaker gezegd:
Op papier je ideeën neerzetten.
Zeg maar een verlanglijstje.
Dat lijstje mag je als een lijstje met problemen zien, maar meestal bestaan die problemen uit een combinatie van deelproblemen.
Dus je problemen afbreken in kleinere problemen, totdat je problemen krijgt die heel gemakkelijk op te lossen zijn.
Dat lijkt veel werk.
Maar als je het zo doet, dan behoud je het overzicht.
Niet telkens als je er langer dan 3 minuten over na moet denken het hele spul overboord gooien en het volgende gaan doen.
Maar gewoon stug volhouden.
Wanneer je bedenkt dat je aanpak op dat moment fout is, dan niet dat papier met een gang in de bak gooien, maar netjes opzij leggen.
Dan kun je bij de volgende poging nog eens nakijken waar het die vorige keer ook weer fout ging (maar natuurlijk ook wat er goed ging).

Schijnbaar is dat een hopeloos ouderwetse aanpak, Nico.
Maar voor mij werkt die heel goed.
Enige nadeel is dat mijn handschrift zo slecht is, dat ik er zelf ook af en toe problemen mee heb te lezen wat er nou eigenlijk staat…

@mas: Het maakt mij niet zoveel uit wat men wel of niet overneemt. Ik zie ze dagelijks vanuit de MBO's en HBO's.... Lopen stuk voor stuk vast. Maar dan hebben ze wel mazzel.... krijgen ze gewoon een verplichte cursus :slight_smile: