[Discussie] Arduino-topic

[wolly_a]

mcDavid schreef op woensdag 27 januari 2016 @ 11:08:
[...]

Heb wel eens zo'n ding met 2 poten gebruikt om de vochtigheid van de potgrond van een plantje te bepalen, maar vond het maar lastig om er een duidelijke meetwaarde uit te halen. Maar voor niveaubepaling (water/geen water op de pootjes) moet het best werken ja.

Betwijfel alleen of in zo'n geval met wasmachine, de arduino-opstelling daadwerkelijk betrouwbaarder is dan het deurtje van de wasmachine

@Raven: Als je liever een vlotter gebruikt zou je die gewoon in een buisje kunnen plaatsen.

Het ding geeft bij mij heel stabiele waarden. Het deurtje van de wasmachine staat los van mijn oorspronkelijke doel. Het water zou uit meer delen van de wasmachine kunnen lekken. Ik heb de wasmachine op zolder staan in zo'n grote lekbak en daarin de detector gemonteerd. Lekt de wasmachine, dan zal de sensor in een mum van tijd onder water staan en dat levert meer dan voldoende variatie in signaal op om alarm te slaan.

[barrymossel]

AlexanderB schreef op woensdag 27 januari 2016 @ 12:16:
Zijn dezelfde chips, dus ja, lijkt me dat dat prima zou moeten werken.

tsjoender schreef op woensdag 27 januari 2016 @ 12:17:
[...]

Geen probleem. Gewoon in de Arduino IDE een Uno of Nano selecteren. Zelf al regelmatig met dezelfde sketch tussen Nano's en Uno's gewisseld.

Ah, mooi. Thanks.

Ben aan het kijken of ik een app als ArduDroid kan gebruiken om de VU meter die ik wil maken kan bedienen via bluetooth.

[Raven]

mcDavid schreef op woensdag 27 januari 2016 @ 11:08:
@Raven: Als je liever een vlotter gebruikt zou je die gewoon in een buisje kunnen plaatsen.

Dat zou nog kunnen ja

[RobV]

AlexanderB schreef op woensdag 27 januari 2016 @ 10:16:
Maar om te detecteren *of* dr vloeistof water is, is 2 draadjes op zich voldoende. En voor vochtigheid in grond heb ik laatst ook ergens een module gezien die z'n eigen blokgolf 'wisselspanning' maakte, zodat de vochtigheid-detectie-plaatjes inderdaad niet wegcorroderen.

Tegen het wegroesten schijn je oog gebruik kunnen maken van potloodvullngen (fatsoenlijke dikte) de koolstof is wel geleidend maar roest niet. Had ik vorige week nog gelezen hier http://tiny.systems/categorie/lcdProjekt/BonsaiWatchdog.html

[AlexanderB]

Oh, ja, das ook een mooie oplossing. Soms kan 't zo simpel zijn.

[icegodd]

ik wil binnen starten met een new project met RGB + tijd schakeling. tot heden heb ik DS1307 gevonden om RTC te programmeren. maar DC1307 heeft 1 nadeel, dat het zn tijd kan verliezen(project heeft geen interface/display.. simple/cheap) en zomer/winter tijd?

daarnaast heb ik ook iets gevonden voor mijn issue namelijk radio gestuurde tijd:


er zijn paar chip die ook met arduino werkt: MSF en DCF.
welke raden jullie mij aan? ik kon ook niks vinden op ebay.

[mcDavid]

Een RTC heeft (meestal) een backup batterijtje zodat hij op tijd blijft lopen, zelfs al schakel je de stroom uit. Zo'n ding zou een paar jaar moeten kunnen blijven lopen op het knoopcelletje.
En je kunt natuurlijk pushbuttons maken om de tijd in/bij te stellen en evt zelf een zomer/winter tijd algoritme implementeren.

Een radiografische klok is wel gaaf natuurlijk, maar als je die wegstopt in een betonnen gebouw moet je maar afwachten of 'ie het nog doet.

[ Voor 18% gewijzigd door mcDavid op 28-01-2016 10:40 ]

[Verwijderd]

RobV schreef op woensdag 27 januari 2016 @ 13:28:
Tegen het wegroesten schijn je oog gebruik kunnen maken van potloodvullngen (fatsoenlijke dikte) de koolstof is wel geleidend maar roest niet. Had ik vorige week nog gelezen hier http://tiny.systems/categorie/lcdProjekt/BonsaiWatchdog.html

Dan zou ik toch even echte koolstofgeleiders halen, zoals die bijvoorbeeld in elektromotoren zitten

[barrymossel]

Mijn VU meter werkt! Alleen werkt deze nu op de speaker output en aangezien de leds in de subwoofer komt reageer de meter alleen op de lage (sub) tonen. Liever gebruik ik dus de audio input voor het signaal. Alleen heb ik niet genoeg kabels om dat signaal naar de subwoofer te krijgen (4 kabels van radio naar sub, waarvan twee voor de speaker output worden gebruikt en daarnaast heb ik nog voeding van de leds nodig). Vraag is dus of ik dat signaal draadloos richting de subwoofer kan sturen?

[AllesKan]

barrymossel schreef op woensdag 27 januari 2016 @ 12:04:
Ongetwijfeld een hele domme vraag, maar is een Arduino Nano compatible met de Arduino Uno. Met andere woorden, kan ik code die geschreven is voor de Uno gebruiken voor de Nano?

Normaliter wel. Alleen als er gebruik wordt gemaakt van de watchdogtimer functie dan werkt deze functie niet, d.w.z. hij reset wel als de watchdogtimer ingrijpt, maar hij start niet meer opnieuw op.

Dat kun je oplossen door de bootloader van de Uno in de Nano te programmeren. (Dat geeft je ook gelijk 1,5K meer flashgeheugen tot je beschikking). Daarna moet je dan voortaan de Nano programmeren door in de Arduino IDE gewoon de Uno te kiezen.

[barrymossel]

Ik wil mijn VU meter bedienen met een Android app via bluetooth. Momenteel ben ik eerst wat aan het testen met de serial monitor. Ik gebruik een serialEvent die een string opslaat tot er een bepaald teken wordt gestuurd ")".
Op dat moment wordt in de loop gekeken wat er in de string staat. In eerste instantie werd er gekeken naar een precieze overeenkomst, waarna er iets wordt uitgevoerd.

code:

if (inputString) == "P1)") { 
    Serial.print("Change parameters");
    toggleChangeParams();

Echter viel het me op dat er regelmatig een byte wegvalt, waardoor e.e.a. niet wordt uitgevoerd. Ik dacht dit op te lossen met de volgende code:

code:

if (inputString.substring(0) == "P") { 
    Serial.print("Change parameters");
    toggleChangeParams();

Waarbij ik dan gewoon meerdere P's verstuur naar de string. Ik heb het nog niet kunnen testen, maar het lijkt me dat dit beter werkt.

Alleen denk ik niet dat dit de beste oplossing is (bijvoorbeeld wanneer ik de brightness wil versturen die een waarde heeft van 0-255). Zijn er andere oplossingen op die wegvallende bytes te voorkomen?

[AlexanderB]

dunno, maar je kan waardes met Serial.parseInt() en Serial.parseFloat() dr uit halen, dat vond ik zelf voor het doorgeven van waardes via serieel erg praktisch.

[barrymossel]

Die Serial.parseInt() heb ik eerst gebruikt, maar die is te traag voor mijn toepassing. Ik wil bijvoorbeeld een slider gebruiken voor de brightness van mijn led strip. Die moet dan dus vrijwel realtime reageren. En zover ik kan zien wacht de Serial.parseInt() telkens een halve sec.

[RobV]

barrymossel schreef op dinsdag 02 februari 2016 @ 10:39:
Die Serial.parseInt() heb ik eerst gebruikt, maar die is te traag voor mijn toepassing. Ik wil bijvoorbeeld een slider gebruiken voor de brightness van mijn led strip. Die moet dan dus vrijwel realtime reageren. En zover ik kan zien wacht de Serial.parseInt() telkens een halve sec.

Halve seconden om een int te parsen? Dan doe je toch ergens echt iets fout. enkele 10.000'en parses per seconde moet geen probleem zijn op een arduino.

[AlexanderB]

Dan gaat dr iets fout inderdaad, dat moet veel sneller gaan. Tenzij je parsefloat gebruikte om een int te parsen, dan wacht ie tot er een punt binnenkomt, of totdat de timeout (die ook instelbaar is) voorbij is.

[Delchrys]

Hallo allemaal,
ik ben nu een paar maandjes bezig met een Arduino Mega, maar ik krijg mijn sketch niet stabiel. ZO af en toe heb ik dat hij blijft hangen, kan niet echt reproduceren of dit een vast interval is of niet. Gisteren heeft hij bijna 24 uur gedraaid en een andere keer maar een uur of 9.
Zou het ergens aan mijn sketch kunnen liggen???
Graag zou ik willen vragen of iemand eens naar mijn code kan kijken of ik het ergens beter aan kan pakken. Ben een beginner in het programmeren en tips zijn altijd welkom.

Het gaat hier over een TCRT500 welke aan mijn ferraris Kwh meter hangt in de meterkast, bij elke puls wordt een interrupt gegenereerd en wordt er een berekeningetje gedaan welke vervolgens via een ESP8266 ESP-05 verzonden wordt naar EmonCMS.org.
ESP8266 wordt door een aparte voeding gevoed, een PTR08100W welke aangesloten is op de 5V direct van de Arduino af, deze reduceert naar 3.3V voor de ESP8266.
De TCRT5000 aangesloten op D2 en +5V en GND.
Rx/Tx van ESP8266 op Tx/Rx van serial 1 op de MEGA.

code:

//================================Benodigdheden voor Kwh meter==========================================
const float Stroom_C = 187.5; 
unsigned long pulseCountTotalStroom = 0;      // pulsenteller totalen stroom
unsigned long pulseCountTotalStroomUpload = 0;
unsigned long pulseCountStroom = 0;           // pulsencounter Stroom
unsigned long prevMillisStroom = 0;           // starttime Stroom
unsigned long prevMillisAnaloog = 0;          // starttime Stroom
unsigned long pulseTimeStroom = 0;            // time for 1 pulse
volatile int wattpulse = LOW;                 // volatile interrupt = low
int usewifi = 1;                              // 0 = uit/1 = aan
int afstelPinAan = 0;                         // gebruik pin A5 voor afstellen sensor
float curWatts = 0;                           // current watt
float totalKwh = 0;                           // total Kwh
int ledPinStroom = 8;                         // knipperen bij puls
unsigned long uploaderror = 0;
int ledState = LOW; 
const float beginstand = 59016;

//================================wifi update en settings===============================================
unsigned long prevMilliswifi = 0;                 // tijd voor de wifi update
#define SSID "XXXXX"                           // accespoint naam
#define PASS "XXXXX"                         // wachtwoord
#define wifi Serial1
boolean lastConnectionStatus;
//================================Declarations for Exosite================================
#define IP "emoncms.org"                        //IP waarmee de TCP verbinding wordt gemaakt
#define API "XXXXX"  //unieke identiefier voor de upload
String myDataString = "";                       //string maken voor de te verzenden data

 //================================ upload naar emoncms.org=================================================
boolean upload(){
  String cmd;
  cmd = String("AT+CIPSTART=\"TCP\",\"") + String(IP) + String("\",80");
  Serial.println(cmd);
  sendDebug(cmd);
  delay(100);
  if(wifi.find("Error")){
    Serial.print("RECEIVED: Error");
    return false;
  }
  cmd = "GET http://emoncms.org/input/post.json?json=";
  cmd += "{curWatts:";
  cmd += (curWatts);
  cmd += "},";
  cmd += "{pulsen:";
  cmd += (pulseCountTotalStroom);
  cmd += "},";
  cmd += "{KWh:";
  cmd += (totalKwh);
  cmd += "}&apikey=XXXXXX";
  cmd += "\r\n";
  wifi.print("AT+CIPSEND=");
  wifi.println(cmd.length());
     
  if(wifi.find(">"))
  {
     Serial.print(">");
    Serial.println(cmd);
    wifi.print(cmd);
  }
 
  if (wifi.find("OK"))
  {
 
    Serial.println("ontvangen: OK");
    uploaderror = 0;
    pulseCountStroom = 0;
    digitalWrite(9,HIGH);
   
    wifi.println("AT+CIPCLOSE");
    delay(15);
    return true;
      }
  else
  {
    Serial.println("niet ontvangen: ERROR");
    uploaderror ++;
    if ((uploaderror >= 1))
    {
    wifi.println("+++");
    delay(15);
        wifi.println("+++");
        delay(15);
              wifi.println("AT+CIPCLOSE");
      digitalWrite(9, LOW);
      upload();
    }
      
      if ((uploaderror >= 3))
      {
        resetwifi();
        connectwifi();
        upload();
      }
     }
    
} // updateThingSpeak
 //================================What to do on Pulse=================================================
void onPulseStroom(){
  if ((millis() - prevMillisStroom) > 2000) 
  {
    wattpulse = HIGH;
  }
}
//================================Function to connect to wifi===========================================

boolean connectwifi()
{
  String cmd = "AT+CWMODE=1";
  sendDebug(cmd);
  delay(500);
  cmd  = "AT+CWJAP=\"";
  cmd += SSID;
  cmd += "\",\"";
  cmd += PASS;
  cmd += "\"";
  sendDebug(cmd);
  delay(5000);
  if(wifi.find("OK")){
    Serial.println("Aangesloten op WiFi. Jippie laten we beginnen");
    return true;
  }
  else{
    Serial.println("Connect Error op WiFi, jammer dit gaan we opnieuw proberen");
    return false;
  }
  
  //Set Singale Connection
wifi.println("AT+CIPMUX=0");
 delay(2000);
}


//================================Reset wifi============================================================
boolean resetwifi(){
  String cmd = "AT+RST";
  sendDebug(cmd);
  delay(2000);
  if(wifi.find("OK")){
    Serial.println("AT+RST uitgevoerd en OK ontvangen");
    return true;
  }
  else{
    Serial.println("AT+RST error teruggekregen");
    return false;
  }
} // resetwifi


//================================Send Debug============================================================
void sendDebug(String cmd){
  Serial.print("SEND: ");
  Serial.println(cmd);
  Serial.flush();
  wifi.println(cmd);
}

//================================SETUP=================================================================
void setup()
{
 
  wifi.begin(115200);
  wifi.setTimeout(2000);
  Serial.begin(115200);

     if (usewifi >0)
{
  wifi.println("AT");
  delay(3000);
  if(wifi.find("OK")){
    Serial.println("Ja, AT command is binnengekomen door naar Wifi connecten....");
    lastConnectionStatus = connectwifi();
}

  else

{
    Serial.println("Ooops, ESP8266 dingetje niet gevonden, controleer bedrading!");
    while(1);
}
  delay(1000);
   
// pinMode(2,INPUT);                            //Pin D2 als input
attachInterrupt(0, onPulseStroom, LOW);             //Pin D2 voor kwh TCRT5000     
pinMode(8, OUTPUT);                                 //led kwh pulsen
pinMode(9, OUTPUT);                                 //led succesvolle upload.
  }
}


//================================The LOOP=================================================================

void loop() {
// Ensure that the ESP8266 is connected to the wifi network
  if (!lastConnectionStatus) {
    lastConnectionStatus = resetwifi();
    lastConnectionStatus = connectwifi();
}
   if (afstelPinAan >0)
{
//afstelregel op analoog 5 om de beste positie van de sensor te bepalen
  if ((millis() - prevMillisAnaloog) >= 100) {
  prevMillisAnaloog = millis();
 Serial.println(analogRead(5));
  }
}
//einde afstelregel
  if (wattpulse == HIGH)
{
  pulseCountStroom++;                                              //pulsenteller +1
  pulseCountTotalStroom++;                                         //totale pulsenteller +1
  pulseCountTotalStroomUpload++;
  pulseTimeStroom = (millis() - prevMillisStroom);                 //bereken pulstijd
  prevMillisStroom = millis();  //reset de tijd
  curWatts = (( 3600000 / Stroom_C ) * 1000 ) / pulseTimeStroom;   //bereken huidige verbruik
  totalKwh = ((1 / Stroom_C) * pulseCountTotalStroom) + beginstand ;               //Totale KWh.
  if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }
  digitalWrite(ledPinStroom, ledState);

//Print de waardes in de Serial Monitor.
Serial.print("pulsecounts = ");
Serial.print(pulseCountStroom);
Serial.print("\t");
Serial.print("pulsecounttotal = ");
Serial.print(pulseCountTotalStroom);
Serial.print("\t");
Serial.print("currwatts = ");
Serial.print(curWatts,0);
Serial.print("\t");
Serial.print("totalKwh = ");
Serial.print(totalKwh,4);
Serial.print("\t");
Serial.print("tijd tussen pulsen= ");
Serial.print(pulseTimeStroom);
Serial.print("\t");
Serial.print("error = ");
Serial.print(uploaderror);
Serial.println();
delay(50);
wattpulse = LOW;
}

// elke puls de standen loggen via ethernet
if ((pulseCountTotalStroomUpload >= 1) )
{
  pulseCountTotalStroomUpload = 0;
  upload();
 
  }
}

[barrymossel]

RobV schreef op dinsdag 02 februari 2016 @ 11:17:
[...]

Halve seconden om een int te parsen? Dan doe je toch ergens echt iets fout. enkele 10.000'en parses per seconde moet geen probleem zijn op een arduino.

AlexanderB schreef op dinsdag 02 februari 2016 @ 13:02:
Dan gaat dr iets fout inderdaad, dat moet veel sneller gaan. Tenzij je parsefloat gebruikte om een int te parsen, dan wacht ie tot er een punt binnenkomt, of totdat de timeout (die ook instelbaar is) voorbij is.

I guess that's back to the drawing board Of kan het op mijn eerdere genoemde manier ook? Want het lijkt me dat ook bij Serial.parseInt() bytes verloren kunnen gaan?

---edit---

Misschien even duidelijk maken wat ik precies wil:

Er zijn meerdere commando's die ik door wil geven via bluetooth vanuit een app, vooralsnog:

• Button in app om mode te wisselen: changeMode()
• Button in app om te schakelen tussen de daadwerkelijke loop en het aanpassen van parameters: toggleParameters()
• Schuif in app die brightness aanpast: waarde van 0-255
• Wanneer parameters getoggled is: aanpassen kleuren (RGB-waarden)
• Of wanneer parameters getoggled is: aanpassen cyclespeed (schuif met waarde van 0-11)

Wat zou de "beste" manier hiervoor zijn?

[ Voor 29% gewijzigd door barrymossel op 02-02-2016 14:10 . Reden: toevoeging ]

[Binolirao]

Onlangs heb ik een aantal KAKU ontvangers gekocht (3 ontvangers + afstandsbediening). Met de gedachte dat ik deze ga bedienen met mijn Logitech harmony ultimate afstandsbediening (zodat tv en staande lamp tegelijk aangaan).

Nu heb ik onderstaande modules los van elkaar werkend:
- 433 library van Fuzzillogic, deze heb ik werkend middels een button op mijn breadboard (lamp gaat aan zodra ik deze schakel)
- infrarood via IRRemote (werkt ook, er gaat een LED aan als ik een bepaalde button indruk op mijn IR afstandsbediening).

Echter krijg ik met geen mogelijkheid deze twee libraries in 1 project (stabiel) aan de gang (deze werkt nu 1 op de 1000 button presses op mijn afstandsbediening), weet iemand of deze twee libraries een conflict met elkaar hebben?

[AlexanderB]

barrymossel schreef op dinsdag 02 februari 2016 @ 14:04:
Misschien even duidelijk maken wat ik precies wil:

Er zijn meerdere commando's die ik door wil geven via bluetooth vanuit een app, vooralsnog:

• Button in app om mode te wisselen: changeMode()
• Button in app om te schakelen tussen de daadwerkelijke loop en het aanpassen van parameters: toggleParameters()
• Schuif in app die brightness aanpast: waarde van 0-255
• Wanneer parameters getoggled is: aanpassen kleuren (RGB-waarden)
• Of wanneer parameters getoggled is: aanpassen cyclespeed (schuif met waarde van 0-11)

Wat zou de "beste" manier hiervoor zijn?

Ik weet niet precies hoe jij 't wil gaan doen, maar hoe mijn project werkte was met G-code, ofwel een losse hoofdletter, en dan een int of float dr achter.

Mijn programma bestond in 3 grove stappen uit:
-indien beschikbaar, 1 byte uit de seriële buffer lezen, op letter storteren met een switch-case, en bijbehorende int/float in bijbehorende variabele dumpen totdat een puntkomma (commentaar) of newline character gedetecteerd wordt, waarna er een "ok" teruggestuurd wordt als bevestiging.
-uitvoeren van de codes uit variabelen, bepaalde letters zetten in de voorgaande switch-case een "vlag" om aan te geven wat voor soort commando er binnen was gekomen, en aan het eind van het uitvoeren wordt de vlag terug op 0 gezet, zodat de instructie niet 2x wordt uitgevoerd.
-het daadwerkelijke uitvoeren van de gewenste acties, een zooi functies die vanuit de voorgaande G- en M-code switch-cases kan worden aangeroepen.

Dit is hoe ik 't gedaan heb, misschien dat 't bij jou anders moet, maar als je protocol vergelijkbaar is (-enkele-letter en daarna een getal om een commando en/of waarde door te geven), dan kan je 't op een zelfde manier programmeren.. Als je wil kan ik wel ff wat code posten..

[barrymossel]

AlexanderB schreef op dinsdag 02 februari 2016 @ 15:10:
[...]

Ik weet niet precies hoe jij 't wil gaan doen, maar hoe mijn project werkte was met G-code, ofwel een losse hoofdletter, en dan een int of float dr achter.

Mijn programma bestond in 3 grove stappen uit:
-indien beschikbaar, 1 byte uit de seriële buffer lezen, op letter storteren met een switch-case, en bijbehorende int/float in bijbehorende variabele dumpen totdat een puntkomma (commentaar) of newline character gedetecteerd wordt, waarna er een "ok" teruggestuurd wordt als bevestiging.
-uitvoeren van de codes uit variabelen, bepaalde letters zetten in de voorgaande switch-case een "vlag" om aan te geven wat voor soort commando er binnen was gekomen, en aan het eind van het uitvoeren wordt de vlag terug op 0 gezet, zodat de instructie niet 2x wordt uitgevoerd.
-het daadwerkelijke uitvoeren van de gewenste acties, een zooi functies die vanuit de voorgaande G- en M-code switch-cases kan worden aangeroepen.

Dit is hoe ik 't gedaan heb, misschien dat 't bij jou anders moet, maar als je protocol vergelijkbaar is (-enkele-letter en daarna een getal om een commando en/of waarde door te geven), dan kan je 't op een zelfde manier programmeren.. Als je wil kan ik wel ff wat code posten..

Zoiets zou ik inderdaad kunnen gebruiken; het zijn bij mij inderdaad ook meerdere (soorten) commando's die gestuurd (kunnen) worden. Als je wat code hebt, dan graag. Kan ik vanavond weer wat meer proberen (hopelijk is mijn bluetooth bordje er dan ook).

[AllesKan]

barrymossel schreef op dinsdag 02 februari 2016 @ 09:50:
Echter viel het me op dat er regelmatig een byte wegvalt, waardoor e.e.a. niet wordt uitgevoerd.

Ik zou proberen de oorzaak daarvan te achterhalen en dat op te lossen. Normaal is het in ieder geval niet.

Probeer eens een andere baudrate, of combinatie van baudrate's (als je bv de hardwareserial en een softwareserial tegelijk gebruikt.)

[barrymossel]

AllesKan schreef op dinsdag 02 februari 2016 @ 15:26:
[...]

Ik zou proberen de oorzaak daarvan te achterhalen en dat op te lossen. Normaal is het in ieder geval niet.

Probeer eens een andere baudrate, of combinatie van baudrate's (als je bv de hardwareserial en een softwareserial tegelijk gebruikt.)

Ik las ook iets over een delay toevoegen. Daar duik ik vanavond ook nog even in. Het is namelijk alleen de eerste byte.

[AlexanderB]

Serial.read() gooit 'm bij het lezen weg, Serial.peek() kijkt alleen, maar laat 'm vooraan in de seriële buffer staan.

[RobV]

Ik heb ook zo'n sketch lopen. Gezien het feit dat de animatie vloeiend moet zijn kan ik niet wachten tot alle commando's helemaal binnen zijn. Ik gebruik dus de volgende routine om zonder 'delays' te werken. Pseudocode uit het hoofd:

C:

char buffer[100];
int index = 0;

loop()
{
   while(Serial.available() > 0)
   {
      char c = serial.Read();
      buffer[index++] = c;
      buffer[index] = '\0';   //afsluiten.
      if( c == newline)
      {
         verwerkbuffer();
         index = 0;
      }
   }

   //doe andere dingen
}

void verwerkbuffer()
{
   int waarde;

   if(sscanf(buffer, "G%d\n", &waarde) == 0)
   {
      //doe iets met commando 'G' en een getalletje.
   }
}

De code leest net zolang regeltjes totdat een newline binnenkomt. Code doet geen fout afhandeling, buffer overrun of bewuste pogingen om het te laten crashen, die mag je zelf inbouwen..

[barrymossel]

Momenteel heb ik het als volgt opgelost (en ja ik heb stukjes code uit voorbeelden gebruikt ):

code:

void loop()
{

  // send data only when you receive data:
  if (Serial.available() > 0) {
    // read the incoming byte:
    codeLetter = Serial.read();

    // say what you got:
    Serial.print("I received: ");
    Serial.println(codeLetter);

    switch (codeLetter) {
      case 77:
        Serial.println("Change Mode");
        if (Serial.read() == '\n') {
          changeMode();
        }
        break;
      case 76:
        Serial.println("Brightness");
        newBrightness = Serial.parseInt();
        if (Serial.read() == '\n') {
          newBrightness = constrain(newBrightness, 0, 255);
          Serial.println(newBrightness);
          leftStrip.setBrightness(newBrightness);
          rightStrip.setBrightness(newBrightness);
          if (brightness != newBrightness) {
            EEPROM.write(EEPROM_BRIGHTNESS_ADDR, newBrightness);
            brightness = newBrightness;
          }
        }
        break;
      default:
        // if nothing else matches, do the default
        // default is optional
        break;
      case 82:
        Serial.println("Red");
        redVal = Serial.parseInt();
        if (Serial.read() == '\n') {
          redVal = constrain(redVal, 0, 255);
          Serial.println(redVal);
        }
        break;
      case 71:
        Serial.println("Green");
        grnVal = Serial.parseInt();
        if (Serial.read() == '\n') {
          grnVal = constrain(grnVal, 0, 255);
          Serial.println(grnVal);
        }
        break;
      case 66:
        Serial.println("Blue");
        bluVal = Serial.parseInt();
        if (Serial.read() == '\n') {
          bluVal = constrain(bluVal, 0, 255);
          Serial.println(bluVal);
        }
        break;
      case 10:
        Serial.println("Cycle Speed");
        newCycleSpeed = Serial.parseInt();
        if (Serial.read() == '\n') {
          newCycleSpeed = constrain(newCycleSpeed, 0, 11);
          if (cycleSpeed != newCycleSpeed) {
            EEPROM.write(EEPROM_CYCLE_SPEED_ADDR, newCycleSpeed);
            cycleSpeed = newCycleSpeed;
          }
        }
        break;

    }

  }

Waarom de Serial.parseInt() vertraging had kwam geloof ik doordat ik het parsen niet afkapte met:

code:

if (Serial.read() == '\n') {

Kan dat kloppen? Nu lijkt het prima te werken. Al loopt de app die het bestuurt regelmatig vast. Iemand een idee waardoor dat zou kunnen komen? Het lijkt te gebeuren wanneer ik met een slider "een hoop" serial data ineens stuur (van 0 naar 255 en op en neer). Misschien iets met een buffer? Of juist dat de Arduino weer veel terugstuurt naar de app?

[RobV]

Er zit nog een kans in dat het fout gaat.

code:

if (Serial.available() > 0)

kijk namelijk of er in elk geval 1 karakter in de buffer zit, terwijl je verderop gewoon Serial.read()'s doet zonder te controleren of je wel genoeg bytes klaar hebt staan. Het kan dus zijn dat je hele pakketje nog niet verstuurd is terwijl de code al wel begint te lezen.

Die read() == '\n' na je parseInt() kan nooit de oorzaak/oplossing zijn, immers de parseInt is al afgelopen op het moment dat je naar een '\n' gaat kijken.

Je bent goed op weg, maar *ik* zou de parseInt op een andere manier doen. En ik ben *heul* eigenwijs, dus je moet het vooral zelf bepalen.

[barrymossel]

Ik moet nogmaals zeggen ik dat twee weken geleden voor het eerst met Arduino (of C, of whatever) code ben bezig geweest. Sowieso is programmeren nieuw voor me, dus be gentle Ik probeer zoveel mogelijk uit te zoeken, maar ook in zo'n kort mogelijk tijd dit allemaal te leren. Dus ieder advies is welkom en sturing zelfs zeer gewenst!

RobV schreef op woensdag 03 februari 2016 @ 12:17:
Er zit nog een kans in dat het fout gaat.

code:

if (Serial.available() > 0)

kijk namelijk of er in elk geval 1 karakter in de buffer zit, terwijl je verderop gewoon Serial.read()'s doet zonder te controleren of je wel genoeg bytes klaar hebt staan. Het kan dus zijn dat je hele pakketje nog niet verstuurd is terwijl de code al wel begint te lezen.

Ik moet überhaupt eens beter inlezen in die serial buffer. Maar aangezien ik niet weet hoeveel bytes er worden verstuurd - dit verschilt per commando - weet ik niet ik niet zo goed hoe ik dat moet oplossen? Of moet elk commando vanuit de app dezelfde grootte hebben?
Nu verstuurt de app namelijk bijvoorbeeld voor changeMode "M\n" en voor brightness "L255\n" of "L10\n".

Die read() == '\n' na je parseInt() kan nooit de oorzaak/oplossing zijn, immers de parseInt is al afgelopen op het moment dat je naar een '\n' gaat kijken.

Blijft vreemd. In de serial monitor tik ik een commando in. Deze moet na een parseInt() weer terug geprint worden in de monitor. Wanneer ik die read() =='\n' niet toepas komt wordt de print met vertraging getoond. Ook als ik het dat niet toepas bij de eerder genoemde code dan is er aanzienlijk vertraging tussen het de opdracht vanuit de app en de zichtbare uitvoering door Arduino.
Ik kan het vanavond eens filmen, zodat je ziet wat er gebeurt. Verklaren kan ik het niet, maar het is weg na het toepassen van de read() == '\n'. Kan dit ook komen doordat ik überhaupt de \n vanuit de app verstuur? Dit deed ik voorheen niet geloof ik (bedenk ik me net)...

Je bent goed op weg, maar *ik* zou de parseInt op een andere manier doen. En ik ben *heul* eigenwijs, dus je moet het vooral zelf bepalen.

Hoe zou jij het dan aanpakken? Volgens je eerder genoemde code? Want die vind ik nog een beetje lastig haha. Bijvoorbeeld:

code:

 if(sscanf(buffer, "G%d\n", &waarde) == 0)

[RobV]

Het grote verschil is dat ik pas ga scannen/beoordelen als ik een hele regel tot en met \n in de buffer array heb ontvangen.

Geen probleem dat je het vraagt. Als je het allemaal al wist had je ons niet nodig

[ Voor 26% gewijzigd door RobV op 03-02-2016 12:59 ]

[RobV]

Stel, in je serial port komt 12345 binnen zonder newline. ParseInt leest karakters tot dat er een niet-nummer komt. Staat er niets meer in de buffer? Dan wacht hij gewoon tot er aksnog een nummer komt, of een timeout. Misschien komt et nóg wel een 6 achteraan om '123456' te maken?

Met de \n erachter weet parseint dat het getal ophoudt en is dus sneller klaar.

[barrymossel]

Ah duidelijk, dan komt de vertraging dus gewoon daar door. Zolang ik een newline verstuur vanuit de app heb ik de vertraging dus niet. Dus de regels met if (Serial.read() == '\n') kunnen gewoon weg. Deze regel had ik overigens uit dit voorbeeld.

Ik zal ook eens in sscanf() duiken. Gaat weer een stapje verder zie ik al

RobV schreef op woensdag 03 februari 2016 @ 12:57:
Het grote verschil is dat ik pas ga scannen/beoordelen als ik een hele regel tot en met \n in de buffer array heb ontvangen.

Ik stuur sowieso nooit meerdere commands per keer/regel (in de huidige situatie) en ben dat ook niet van plan binnen deze toepassing. In deze situatie is bovenstaande niet nodig toch? En dan zou mijn oplossing (die ik deels gebaseerd heb op AlexanderB in "[Discussie] Arduino-topic") ook voldoende zijn toch?

Dan blijft wel nog de vraag waarom mijn app blijft hangen. Vanavond maar weer eens verder spelen. Sowieso is de volgende stap om andersom serial data te gaan sturen en ontvangen. Op basis daarvan wil ik knoppen/sliders in de app en-/disablen. Beetje bij beetje...

[lordprimoz]

ik snap niet helemaal waarom je gaat wachten op een newline character? Je maakt al gebruik van een switch op het character(byte) wat je binnenkrijgt. Afhankelijk van de waarde die je ontvangen hebt voer je iets uit.

Letterlijk de data die je in je serial buffer hebt staan zijn de commandos die je na elkaar wilt uitvoeren neem ik aan? Of zie ik nou iets verkeerd...

Als je meerdere bytes achter elkaar wilt sturen omdat je er echt meer moet versturen, dan zou ik nog altijd geen newline character gebruiken, maar bijv zoiets schijven op de seriele bus: 'aaf9AD###' , waarbij de ### jouw einde van je data aangeeft.
Als je er een paar van achter elkaar plakt kan je er zeker van zijn dat je het einde van het bericht ontvangen hebt.

Een andere optie zou zijn door gebruik te maken van een checksum die je achter je data plakt. Als de checksum niet klopt gooi je het hele pakket aan data weg.

[RobV]

barrymossel schreef op woensdag 03 februari 2016 @ 13:41:
Ik stuur sowieso nooit meerdere commands per keer/regel (in de huidige situatie) en ben dat ook niet van plan binnen deze toepassing. In deze situatie is bovenstaande niet nodig toch? En dan zou mijn oplossing (die ik deels gebaseerd heb op AlexanderB in "[Discussie] Arduino-topic") ook voldoende zijn toch?

Ik heb het geloof ik niet goed genoeg uitgelegd.

Het heet niet voor niets SERIEEL. 1 voor 1. Ook al stuur je maar 1 commando van 6 bytes, het kan best zo zijn dat je Arduino al begint te lezen wanneer per pas 2 bytes zijn verstuurd. En de arduino is 'much faster' dan 9600 baud dus je routine kan best al doorgelopen zijn terwijl je pas de helft van je regel hebt verzonden. Dan stuit je op het punt dat je routine een '192' leest terwijl je '1926' bedoelde (even uitgaande van het ontbreken van een sluit-teken). Om *deze* reden wacht ik met het verwerken van de data tot ik een hele regel binnen heb.

Dan kan ik ondertussen andere dingetjes doen.

[barrymossel]

Hmm, duidelijk dat ik nog een hoop moet leren. Ik ga even een stapje terug haha.

Wat mij nog steeds niet duidelijk is, is waarom de tutorial van Arduino zelf dit niet uitlegt. Zover ik het daar kan lezen is het:
Wanneer een byte binnenkomt begin je met lezen en plaats je de eerste cijfers in 'red', na een karakter de volgende cijfers in 'green' en de volgende in 'blue'. Wanneer de regel klaar is ga je verder met dit en dat en daarna laat je zien wat er in de variabelen geplaatst wordt.

Maar nergens wordt een woord gerept over mogelijk gemiste bytes.

[mcDavid]

...als je slechts een waarde nodig hebt voor een RGB pwm aansturing is één byte per kleur dan ook voldoende over het algemeen.

[RobV]

...bovendien getuigen de voorbeelden van Arduino zelf niet van topkwaliteit. Zo is delay() eigenlijk een no-no in de embedded wereld want je legt spreekwoordelijk je CPU plat terwijl je andere dingen zou kunnen doen (uitgezonderd interrupts). Maargoed ik draai door.

[barrymossel]

Vanavond ga ik ermee verder, maar hebben jullie misschien een stukje voorbeeldcode inclusief de data die dan serieel verstuurd wordt?

Dus je stuurt A123A123A123A123A\n om uiteindelijk de waarde 123 over te brengen. En dat vang je dan op met code X. Misschien dat ik het dan wat beter begrijp (ik werk doorgaans met voorbeelden om te leren, maar als die van Arduino zelf niet het allerbeste zijn, dan heb ik liever iets anders waarmee ik verder kan).

Voor de volledigheid zou ik dus via knoppen in de app (per knop) een stukje code activeren en met sliders waardes van 0-255 (brightness, RGB).

Zou erg fijn zijn als jullie me kunnen voorzien van een voorbeeld of een site die het goed doet qua code.

[lordprimoz]

die "\n" is echt niet nodig aan het einde. De reden dat die er vaak achteraan gestuurd wordt is meestal omdat je gebruik maakt van de serial.println functie. Als je gewoon serial.print gebruikt kan je je eigen delimiter characters definieren.

Het is inderdaad handig als je van te voren definieert hoe groot je pakket met data precies is. Maar voor het versturen van een rgb waarde zou ik heel simpel een pakketje versturen wat er ongeveer zo uitziet:

start R G B end
(byte)(byte)(byte)(byte)(byte)

Dit komt dus neer op 5 bytes per keer aan data. (die start byte is trouwens niet speciaal nodig, maar wel handig om je pakketjes te definieren als je andere types aan data wilt sturen.

Je kan dus bijv !3A5# sturen waarbij de ! aangeeft dat je nu een rgb data pakket gaat ontvangen met de R(51) G(65) B(53) en afsluiten met je end byte #. Deze laatste byte kan je atijd nog gebruiken voor een checksum.

Je gaat dan overigens pas lezen als je ziet dat er meer als 4 bytes aan data beschikbaar zijn in je seriele buffer. ( serial.available > 4)

[RobV]

barrymossel schreef op donderdag 04 februari 2016 @ 12:41:
Vanavond ga ik ermee verder, maar hebben jullie misschien een stukje voorbeeldcode inclusief de data die dan serieel verstuurd wordt?
[..]
Zou erg fijn zijn als jullie me kunnen voorzien van een voorbeeld of een site die het goed doet qua code.

barry, ik heb enkele posts terug een vrijwel werkend stukje voorbeeldcode gegeven. als je er specifieke vragen over hebt ga ik die graag voor je beantwoorden, maar ik ga niet *jouw* project voor je schrijven.

Als je wilt kijken hoe ik het bij elkaar gehackt heb: https://bitbucket.org/rob...Firmware/Aduro/?at=master

[ Voor 12% gewijzigd door RobV op 04-02-2016 14:18 ]

[Pizza_Boom]

RobV schreef op donderdag 04 februari 2016 @ 14:17:
maar ik ga niet *jouw* project voor je schrijven.

Waar betalen we je dan voor

[RobV]

Pizza_Boom schreef op donderdag 04 februari 2016 @ 14:29:
[...]
Waar betalen we je dan voor

Betalen?

[Pizza_Boom]

RobV schreef op donderdag 04 februari 2016 @ 14:46:
[...]

Betalen?

Jaaa, exposure...

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 14:17:
[...]

barry, ik heb enkele posts terug een vrijwel werkend stukje voorbeeldcode gegeven. als je er specifieke vragen over hebt ga ik die graag voor je beantwoorden, maar ik ga niet *jouw* project voor je schrijven.

Als je wilt kijken hoe ik het bij elkaar gehackt heb: https://bitbucket.org/rob...Firmware/Aduro/?at=master

Haha, dat vraag ik ook he-le-maaaaal niet. Ik werk alleen graag vanaf een voorbeeld (zoals in die mooie Aduro.ino ). En het voorbeeld is helemaal duidelijk als ik weet wat er in gestopt wordt qua data. Dan kan ik op basis van de code, wat ge-google en de seriele input vast achterhalen hoe het precies werkt en wat de best practices zijn.

Dus dit helpt me al heel veel verder! Thanks!

[barrymossel]

RobV schreef op dinsdag 02 februari 2016 @ 16:11:
Ik heb ook zo'n sketch lopen. Gezien het feit dat de animatie vloeiend moet zijn kan ik niet wachten tot alle commando's helemaal binnen zijn. Ik gebruik dus de volgende routine om zonder 'delays' te werken. Pseudocode uit het hoofd:

C:

char buffer[100];
int index = 0;

loop()
{
   while(Serial.available() > 0)
   {
      char c = serial.Read();
      buffer[index++] = c;
      buffer[index] = '\0';   //afsluiten.
      if( c == newline)
      {
         verwerkbuffer();
         index = 0;
      }
   }

   //doe andere dingen
}

void verwerkbuffer()
{
   int waarde;

   if(sscanf(buffer, "G%d\n", &waarde) == 0)
   {
      //doe iets met commando 'G' en een getalletje.
   }
}

De code leest net zolang regeltjes totdat een newline binnenkomt. Code doet geen fout afhandeling, buffer overrun of bewuste pogingen om het te laten crashen, die mag je zelf inbouwen..

Je andere code is momenteel nog een stapje te ver Bovenstaande daarentegen denk ik te begrijpen, alleen lijkt het niet te werken. Zoals ik hem begrijp (correct me if I'm wrong):

Zolang er seriële data beschikbaar is zet je iedere byte in c die je daarna toevoegt aan buffer. Zodra c gelijk is aan newline (die Arduino niet kent en ik vervangen heb met '\n') voer je verwerkbuffer uit.

De sscanf zet de int in waarde als er een G voor staat (en newline achter komt) en voert als er geen waardes uitkomen (==0) iets uit. Maar volgens mij moet dat dan toch == 1 zijn?

[RobV]

barrymossel schreef op donderdag 04 februari 2016 @ 20:44:
Maar volgens mij moet dat dan toch == 1 zijn?

Je hebt het begrepen, en als bonus heb je ook nog eens de instinker gevonden! sscanf geeft als returnwaarde het aantal matching placeholders terug (in tegenstelling tot strcmp/strncmp die == 0 geeft als de strings gelijk zijn).

quote: robv

Pseudocode uit het hoofd

Toch goed om te lezen dat mijn pseudocode bijna probleemloos door de compiler komt. Volgens mij ben ik verleerd om pseudocode te schrijven.

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 21:10:
[...]

Je hebt het begrepen, en als bonus heb je ook nog eens de instinker gevonden! sscanf geeft als returnwaarde het aantal matching placeholders terug (in tegenstelling tot strcmp/strncmp die == 0 geeft als de strings gelijk zijn).


[...]


Toch goed om te lezen dat mijn pseudocode bijna probleemloos door de compiler komt. Volgens mij ben ik verleerd om pseudocode te schrijven.

Haha, echter, ik zou verwachten dat dit iets zou opleveren:

code:

void setup() {
  // put your setup code here, to run once:

}
char buffer[100];
int index = 0;
void loop() {
   while(Serial.available() > 0)
   {
      char c = Serial.read();
      buffer[index++] = c;
      buffer[index] = '\0';   //afsluiten.
      if( c == '\n')
      {
         verwerkbuffer();
         index = 0;
      }
   }

   //doe andere dingen
}

void verwerkbuffer()
{
   int waarde;

   if(sscanf(buffer, "G%d\n", &waarde) == 0)
   {
      Serial.print(waarde);
   }
}

Helaas. Wat betekent precies de % voor waarde? En waarom krijg ik niks terug, zelfs als ik op een eerder moment c wil printen?

---edit---
Overigens wordt 'buffer' oranje in de Arduino IDE (zelfde kleur als een function - is buffer dat ook? lijkt me dat dat een variabele moet zijn)...

[ Voor 6% gewijzigd door barrymossel op 04-02-2016 21:24 ]

[RobV]

Je setup mist een Serial.begin(..);

En ik zou de == 0 toch echt naar een == 1 aanpassen als je daarwerkelijk een getal wilt lezen.

[barrymossel]

Haha, kak, je hebt helemaal gelijk... Damn. (de == 0 had ik voorheen wel goed, maar heb echt vanalles geprobeerd).

---edit---
Werkt precies zoals ik het wil. Zo eens toepassen op de rest van de code. Thanks!

[ Voor 29% gewijzigd door barrymossel op 04-02-2016 21:27 ]

[RobV]

%d is een placeholder voor een 'decimal'. Zo heb je ook '%s' voor string en '%f' voor float (from the top of my head). Google zelf even op 'sscanf pattern' oid.

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 21:27:
%d is een placeholder voor een 'decimal'. Zo heb je ook '%s' voor string en '%f' voor float (from the top of my head). Google zelf even op 'sscanf pattern' oid.

Sorry, ik bedoelde de & voor &waarde. De %d was redelijk essentieel om het voorgaande te begrijpen.

[RobV]

sscanf moet het resultaat van de parse ergens kwijt kunnen. Met de & geef je het adres van de variabele mee (een pointer), zo van "Hey beste functie, hier kun je het antwoord in proppen". Mocht je Visual Basic kennen, dan is het een BYREF variabele.

http://www.thegeekstuff.com/2011/12/c-pointers-fundamentals/

[ Voor 11% gewijzigd door RobV op 04-02-2016 21:33 ]

[barrymossel]

Ik snap hem. Thanks. Ik ga verder en als je het niet erg vindt (jullie) gooi ik hier mijn code straks nog eens neer.

[barrymossel]

code:

char buffer[100];
int index = 0;

void loop()
{
  while (Serial.available() > 0)
  {
    char c = Serial.read();
    if (c == 'M') {
      changeMode();
      break;
    }
    else {
      buffer[index++] = c;
      buffer[index] = '\0';   //afsluiten.
      if ( c == '\n')
      {
        verwerkbuffer();
        index = 0;
      }
    }
  }

  showVU();
}

void verwerkbuffer()
{
  int waarde;

  if (sscanf(buffer, "L%d\n", &newBrightness) == 1)
  {
    Serial.print("Brightness: ");
    Serial.println(newBrightness);
    leftStrip.setBrightness(newBrightness);
    rightStrip.setBrightness(newBrightness);
    if (brightness != newBrightness) {
      EEPROM.write(EEPROM_BRIGHTNESS_ADDR, newBrightness);
      brightness = newBrightness;
    }
  }
  else if (sscanf(buffer, "R%d\n", &redVal) == 1)
  {
    Serial.print("Red: ");
    Serial.println(redVal);
  }
  else if (sscanf(buffer, "G%d\n", &grnVal) == 1)
  {
    Serial.print("Green: ");
    Serial.println(grnVal);
  }
  else if (sscanf(buffer, "B%d\n", &bluVal) == 1)
  {

    Serial.print("Blue: ");
    Serial.println(bluVal);
  }
  else if (sscanf(buffer, "C%d\n", &newCycleSpeed) == 1)
  {
    Serial.print("Cyclespeed: ");
    Serial.println(newCycleSpeed);
  }

  else if (sscanf(buffer, "I%d\n", &inputCeiling) == 1)
  {
    Serial.print("Sensitivity: ");
    Serial.println(inputCeiling);
  }

}

Is dit eindelijk iets logisch?

• M past de mode aan
• L0-255 past de brightness aan
• RGB0-255 past de RGB aan (van één van de modi)
• C0-11 past van één van de modi de snelheid aan
• I0-1023 past de gevoeligheid aan van de VU meter

E.e.a. moet nog opgeslagen worden op de EEPROM en ik zal dan ook nog kijken naar evt. checksum (of is dat voor zo'n klein prutprojectje niet écht nodig?). Daarna ga ik de app eens leuk maken (kijken of ik de RGB met een color picker kan doen en bepaalde functies (zoals RGB en cyclespeed) alleen tonen wanneer dat van toepassing is op de mode.

[RobV]

Die 'if(c== 'M') snap ik niet, Waarom staat hij specifiek daar?

En de `break` heeft daar geen effect (ik weet ook niet wat je probeert te bereiken daarmee).
De `int waarde` wordt nergens meer gebruikt dus die moet je weghalen.

..en iets zegt mij dat dit niet je hele code is (veel ongedefinieerde variabelen, geen includes, etc.)

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 22:17:
Die 'if(c== 'M') snap ik niet, Waarom staat hij specifiek daar?

En de `break` heeft daar geen effect (ik weet ook niet wat je probeert te bereiken daarmee).
De `int waarde` wordt nergens meer gebruikt dus die moet je weghalen.

..en iets zegt mij dat dit niet je hele code is (veel ongedefinieerde variabelen, geen includes, etc.)

Inderdaad, de break heeft geen nut (duh). Dat ik de M daar neerzet is omdat daar nooit een waarde achter komt. Maar inderdaad die zou net zo goed in de verwerkbuffer() kunnen zetten. Maakt dat uit?

De rest van de code heb ik inderdaad niet erbij staan. Als je die ook wilt zien, dan post ik die graag. Grootste deel komt van Marius: https://github.com/Matikas/VU_meter

[RobV]

[b]barrymossel schreef op donderdag 04 februari 2016 @ 22:22:
Maar inderdaad die zou net zo goed in de verwerkbuffer() kunnen zetten. Maakt dat uit?

Wat zou er nu gebeuren als je een M midden in een regel typt denk je? Of een M zonder newline?

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 22:24:
[...]

Wat zou er nu gebeuren als je een M midden in een regel typt denk je? Of een M zonder newline?

True, dankje. Zou in principe niet moeten gebeuren op basis van de app/wensen, maar inderdaad, daar had ik niet aan gedacht. Ik zet hem wat lager (als in: in verwerkbuffer() ).

[ Voor 3% gewijzigd door barrymossel op 04-02-2016 22:43 ]

[TTIelu]

Vraag - Ik ben op zoek achter een leuke Arduino kit.

• Ik ben een ervaren software ontwikkelaar
• Ik heb tenminste een universitair begrip van elektrische schakelingen
• Ik heb geen specifiek project in gedachten
• Een sterke interesse in alles dat beweegt, alle soorten motors
• Een sterke interesse in communicatie tussen componenten, bvb radio of infrarood
• Ik wil graag een deftige documentatie bij mijn kit, of tenminste iets dat ik begrijp zonder constant google translate te gebruiken

Wat raden jullie mij aan? Momenteel kijk ik naar de officiele Arduino kit, maar ik lees overal dat het zoveel goedkoper kan of met meer componenten. Maar alle andere kits hebben geen enkele documentatie?

Bedankt!
(Sorry als dit een fout topic is hiervoor!)

[LED-Maniak]

TTIelu schreef op maandag 08 februari 2016 @ 17:48:
Vraag - Ik ben op zoek achter een leuke Arduino kit.

• Ik wil graag een deftige documentatie bij mijn kit, of tenminste iets dat ik begrijp zonder constant google translate te gebruiken

Wat raden jullie mij aan? Momenteel kijk ik naar de officiele Arduino kit, maar ik lees overal dat het zoveel goedkoper kan of met meer componenten. Maar alle andere kits hebben geen enkele documentatie?

Je zoekt dus een Nederlandse gebruikshandleiding bij een Arduino? Dat verkleint de zoektocht nogal.

[TTIelu]

Engelstalig is ook goed uiteraard.

Maar bvb Funduino komt voor zover ik zie enkel met een heeeeel korte handleiding in het Engels en hun website is volledig Duits - dan verkies ik toch een andere kit ..

[Opifex]

Alle Arduino clones zijn nagenoeg hetzelfde. De tutorials vanop de Arduino site werken ook op een Funduino...

[mcDavid]

Watvoor documentatie zou je uberhaupt verwachten - buiten wat je op de arduino website vindt?

edit: en evt. atmel datasheets...

[ Voor 16% gewijzigd door mcDavid op 08-02-2016 20:44 ]

[barrymossel]

RobV schreef op donderdag 04 februari 2016 @ 22:24:
[...]

Wat zou er nu gebeuren als je een M midden in een regel typt denk je? Of een M zonder newline?

Er gaat toch nog iets niet goed. Het volgende stukje code reageert mijn inziens vreemd.

code:

  else if (sscanf(buffer, "R %d %d %d %d\n", &redVal, &grnVal, &bluVal, &trsVal) == 4)
  {
    Serial.print("Red: ");
    Serial.println(redVal);
    Serial.print("Green: ");
    Serial.println(grnVal);
    Serial.print("Blue: ");
    Serial.println(bluVal);
    Serial.print("Trans: ");
    Serial.println(trsVal);
  }

Als ik hier R 255 255 255 255\n ingeef krijg ik:

Red: 0
Green: 0
Blue: 255
Trans: 255

Waar doe ik het fout? Kom er namelijk echt niet uit.

[RobV]

barrymossel schreef op maandag 08 februari 2016 @ 20:43:
[...]

Er gaat toch nog iets niet goed. Het volgende stukje code reageert mijn inziens vreemd.

code:

  else if (sscanf(buffer, "R %d %d %d %d\n", &redVal, &grnVal, &bluVal, &trsVal) == 4)
  {
    Serial.print("Red: ");
    Serial.println(redVal);
    Serial.print("Green: ");
    Serial.println(grnVal);
    Serial.print("Blue: ");
    Serial.println(bluVal);
    Serial.print("Trans: "); ;) 
    Serial.println(trsVal);
  }

Als ik hier R 255 255 255 255\n ingeef krijg ik:

Red: 0
Green: 0
Blue: 255
Trans: 255

Waar doe ik het fout? Kom er namelijk echt niet uit.

Zoek eens in de docs wat %d voor datatype wil hebben en kijk dan hoe je redVal e.d. Hebt gedeclareerd.

[barrymossel]

RobV schreef op maandag 08 februari 2016 @ 21:21:
[...]

Zoek eens in de docs wat %d voor datatype wil hebben en kijk dan hoe je redVal e.d. Hebt gedeclareerd.

Haha, dank je. Dat was hem.

[RobV]

barrymossel schreef op maandag 08 februari 2016 @ 21:28:
[...]

Haha, dank je. Dat was hem.

Top!

[almightyarjen]

Ik ben met een Arduino Micro bezig en een aantal pinnen werken alleen als de USB voeding eraan hangt. Zodra ik een labvoeding met 12V op de Vin en GND aansluit, blijven deze pinnen (8 t/m 13) laag, ook als ik ze via de software hoog maak. Met alleen USB voeding verspringen de pinnen netjes naar hoog/laag zoals geprogrammeerd maar zodra er een externe voeding bij komt werkt het niet terwijl de andere pinnen wel gewoon werken. Iemand een idee?

Edit: laat maar, ik had nog een interrupt aan staan

[ Voor 6% gewijzigd door almightyarjen op 09-02-2016 13:35 ]

[sjimmie]

Ik wil een Arduino op 3.3V laten draaien omdat er een CC1150 module aan komt te hangen (communiceert middels SPI en accepteert max 3.6V). Nu wil ik er ook een MQ135 sensor aan hangen om een (ruwe) CO2 meting te doen (wordt gevoed met 5V en die levert zijn actuele waarde naar een analoge poort op basis van 5V).
Kan ik dan op de Arduino met analogReference() kiezen voor EXTERNAL en 5V op de AREF zetten?
Of lopen de dingen dan helemaal scheef?
Ik wil voorkomen dat ik de (theoretische) 0-5V output van de MQ135 eerst weer moet omvormen naar 0-3.3V met weerstanden, en ik wil ook de Arduino niet op 5V laten draaien omdat ik dan de signalen met de CC1150 niet goed kan doen.

[LED-Maniak]

Waarschijnlijk moet je AREF onder VCC liggen(check datasheet).
Gebruik een weerstandsdeler voor 0-3Volt of zet je arduino op 5Volt en gebruik een buffer IC voor de verschillende levels.

[sjimmie]

De 5V met 2 weerstanden delen naar 3.3V is dan de makkelijke optie.
Het lastige is dat ik voor de MQ135 een bestaande library wil gebruiken waarin wel een calibratie zit om bij 400ppm de juiste waarde te lezen, maar ik vermoed dat waardes hoger/lager dan dat calibratiepunt dan weer gaan afwijken.
Een buffer ic toevoegen tussen de arduino en de cc1150 maakt het technisch voorlopig te complex, als het uiteindelijke ontvangende apparaat dan niets ontvangt dan zijn is die ic nog een mogelijk probleempunt wat latig is te debuggen (voor mij dan).

[Looney11]

Een levelshifter niet een optie?

[LED-Maniak]

Dat doet hetzelfde als een buffer of een weerstandsdeler.

Tsja, dan heb je geen andere opties.

[sjimmie]

Nouja, ik heb nog niet echt gevonden of je echt geen 5V op de ARef mag/kan zetten als je Vcc 3.3V is. Wel dat je er niet meer op mag zetten dan je Vcc van 5V. Dus dat zou wellicht een optie kunnen zijn. Volgens mij is dan de enige voorwaarde dat ik een analogReference() geef voordat ik de eerste read doe.

[RobV]

sjimmie schreef op donderdag 11 februari 2016 @ 20:49:
Nouja, ik heb nog niet echt gevonden of je echt geen 5V op de ARef mag/kan zetten als je Vcc 3.3V is. Wel dat je er niet meer op mag zetten dan je Vcc van 5V. Dus dat zou wellicht een optie kunnen zijn. Volgens mij is dan de enige voorwaarde dat ik een analogReference() geef voordat ik de eerste read doe.

Uit de datasheet 29.8 ADC Characteristics:

http://www.atmel.com/imag...8P_datasheet_Complete.pdf

code:

AVCC  Analog Supply Voltage    VCC - 0.3       VCC + 0.3    V
VREF  Reference Voltage        1.0             AVCC         V
VIN   Input Voltage            GND             VREF         V

[sjimmie]

RobV schreef op vrijdag 12 februari 2016 @ 07:55:
[...]

code:

AVCC  Analog Supply Voltage    VCC - 0.3       VCC + 0.3    V
VREF  Reference Voltage        1.0             AVCC         V
VIN   Input Voltage            GND             VREF         V

Thanks dus dan is VREF max VCC+0.3V, helaas.
Dan maar 2 weerstandjes en hopen dat het een beetje klopt (gaat toch maar om een indicatie van de hoeveelheid CO2).

[sjimmie]

sjimmie schreef op vrijdag 12 februari 2016 @ 09:27:
[...]

Thanks dus dan is VREF max VCC+0.3V, helaas.
Dan maar 2 weerstandjes en hopen dat het een beetje klopt (gaat toch maar om een indicatie van de hoeveelheid CO2).

Na wat experimenteren ben ik er ook achter wat er gebeurt al je toch een hogere spanning op de Vref zet. Met een Vref > Vcc wordt de Arduino gevoed vanuit de Vref. Dus Vcc 3.3V en Vref 5V wordt een voedingsspanning van 5V (waarschijnlijk minus 0,3-0,4 vanwege een diode ergens). Daarom kan Vref dus praktisch gezien niet meer zijn dan Vcc +0,3V.

Met twee weerstandjes heb ik het nu wel aardig geregeld. De MQ135 op 5V, zijn output via een spanningsdeler van 2 weerstanden naar A0.

[Promy]

@jvdmast: welke lib gebruik je? ik heb hier ook ooit mee geëxperimenteerd maar ik kreeg geen deftige resultaten, zelfs niet na het "calibreren" van de sensor door deze "in open veld" te plaatsen en de vars aan te passen tot de waarde van defaultppm 399 was.

[sjimmie]

Promy schreef op zaterdag 13 februari 2016 @ 15:03:
@jvdmast: welke lib gebruik je? ik heb hier ook ooit mee geëxperimenteerd maar ik kreeg geen deftige resultaten, zelfs niet na het "calibreren" van de sensor door deze "in open veld" te plaatsen en de vars aan te passen tot de waarde van defaultppm 399 was.

Ik ben uitgegaan van deze https://hackaday.io/proje...363-mq135-arduino-library
Er zijn er meerdere en ik ben gewoon met deze begonnen.
Wat me nu wel opvalt is dat er een aardig verschil is met dezelfde lib en calibratie tussen een 5V opstelling en een 3.3V opstelling. De MQ135 wordt in beide gevallen met 5V gevoed en zijn uitgang wordt in de 3.3V opstelling gedeeld via een 2k2/1k weerstandsetje. Wellcht zit het verschil al gewoon in het feit dat 2k2 geen 2k0 is, of omdat ik de interne weerstanden van de A0 input en uitput niet meereken.

[Promy]

@jvdmast: ik had met deze getest maar ik merk toch een zeer groot verschil in berekening

De jouwe werkt met

code:

 ((1023./(float)val) * 5. - 1.)*RLOAD;

waarbij RLOAD 10 is en val de analoog gemeten waarde
de mijne werkt met

code:

((float)22000*(1023-valr)/valr)

waarbij valr de analoog gemeten waarde

Dat geeft een totaal andere output, wat raar is want ze gebruiken vervolgende dezelfde formule om tot een ppm te komen

Bij mijn opstelling is de analog output wel via 10K ohm verbonden met gnd, hoe zit dat bij de jouwe? (dus die 102 smd resistor tegenover de aansluitingen op het printje vervangen door een 10Kohm weerstand)

Update: in 1 van de comments van de door jou gebruikte git zie ik dat iemand meldt dat die * 5 niet correct is in bovenstaande code. Wat gebruik jij?

[ Voor 24% gewijzigd door Promy op 13-02-2016 20:23 ]

[sjimmie]

Promy schreef op zaterdag 13 februari 2016 @ 17:07:
@jvdmast: ik had met deze getest maar ik merk toch een zeer groot verschil in berekening

Update: in 1 van de comments van de door jou gebruikte git zie ik dat iemand meldt dat die * 5 niet correct is in bovenstaande code. Wat gebruik jij?

Ik ben er net gisteravond even mee begonnen en heb hem dus eigenlijk nog zelfs niet echt kunnen calibreren (buiten veel te koud voor goede calibratie). Momenteel heb ik dus geen flauw idee of de waardes kloppen.
Die ene comment zie ik nu ook, daarvoor is wel een fix aangebracht.
In de cpp die gisteren heb gedownload staat ook:

code:

return ((1023./(float)val) * 5. - 1.)*RLOAD;

Promy schreef op zaterdag 13 februari 2016 @ 17:07:Bij mijn opstelling is de analog output wel via 10K ohm verbonden met gnd, hoe zit dat bij de jouwe? (dus die 102 smd resistor tegenover de aansluitingen op het printje vervangen door een 10Kohm weerstand)

Bedoel je dat je die smd eraf hebt gehaald en vervangen? Waarom? Ik heb gewoon de boel gebruikt zoals via ebay geleverd.

[Promy]

sjimmie schreef op zaterdag 13 februari 2016 @ 21:26:
Bedoel je dat je die smd eraf hebt gehaald en vervangen? Waarom? Ik heb gewoon de boel gebruikt zoals via ebay geleverd.

Ik had er vorige zomer mee zitten "prutsen" en toen zag ik dat die 102 eigenlijk een 1kohm weerstand is. Op de meeste plaatsen spreken ze om een 10k ohm te gebruiken, dus heb ik die vervangen.

Ik heb nog wat verder zitten uitpluizen en als je die *5 weglaatdan geeft "jouw" en "mijn" schets dezelfde resulaten als je dezelfde constanten gebruikt (met een factor 100 verschil).
Als het morgen niet regent toch nog eens proberen te calibreren (heb nu beide methodes in 1 sketch gestopt), via jouw methode kan je calibreren met andere temp en RH (via gasSensor.getCorrectedRZero(temp,hum) )

[sjimmie]

Promy schreef op zaterdag 13 februari 2016 @ 21:34:
[...]
via jouw methode kan je calibreren met andere temp en RH (via gasSensor.getCorrectedRZero(temp,hum) )

Ik ben erg benieuwd, ik had er gisteravond even die getCorrectedRZero in gezet maar dat week bij mij toen zoveel af van de waarde zonder correctie dat dat me niet leek te kloppen.
Maar nogmaals ik ben er net mee begonnen en heb nog geen idee wat ik hier uberhaubt voor waardes zou moeten verwachten want ik heb verder geen referentie.

Die libs die jij gebruikt hebben wel meteen heel veel overkill om gewoon 1 MQ135 uit te kunnen lezen...

En ik kwam er net achter dat mijn externe 5V voeding geen 5 maar 6.5V geeft, wat in ieder geval de grote afwijking verklaart tussen voeden via de 5V lijn van de Arduino (aan USB) of via het externe voedinkje.
Meten was weer weten. Dat bracht me vooral op een dwaalspoor toen ik een vergelijking wilde maken tussen een opstelling met alles op USB-5V of met een esp8266 op 3.3V (en de MQ135 zelf los op 5V, wat dus nu 6.5V bleek te zijn).

EDIT: Deze wijzigingen zal je dan ook vast nuttig en interessant vinden:
https://github.com/GeorgK...ture/improve-calculations

[ Voor 7% gewijzigd door sjimmie op 13-02-2016 22:16 . Reden: Versie met aanvullingen ]

[Promy]

Net eens proberen te calibreren. Als waardes kom ik uit dat de gewone R0 ongeveer 27.72 is en de gecorrigeerde 24,xx is. Wat ik echter raar vindt is dat als ik de formules overzet naar excel de ppm en ppm_corrected niet gelijk zijn (met de ene de R en de R0_corrected)?

Ik zou ook veronderstellen dat bij 20° en 35 rel vochtigheid, de correctiefactor 1 zou zijn... maar deze is dan 1.87??

[sjimmie]

Calibreren met temp+RH schijnt ook niet te kloppen.
https://hackaday.io/proje...363-mq135-arduino-library

The library also provides functions to apply the temperature/humidity correction that is shown in Fig 4 of the datasheet, but I do not trust the datasheet there, so this should not be used for the moment.

[Promy]

Het geeft hier alvast een waarde, maar of die betrouwbaar is is natuurlijk iets anders.... ik meet hier aan buro iets van een 1800 a 2800ppm, maar dat is met een voltage van 4.6 a 4.7V op de 5V lijn (er hangt nog een dht11 en een lcdtje aan, op een mega2560 met externe 1A voeding)

[sjimmie]

Ik vind het nog erg moeilijk (onmogelijk) om in te schatten wat klopt.
Met de originele libs die ik noemde krijg ik, na calibreren, binnen1300-1400, met de door hun later aangepaste lib is het dan 900-1000. Dat is een veel te groot verschil om nog iets mee te kunnen, maar ik weet dus niet welke eventueel zou kunnen kloppen.
En nu ik hem met diezelfde lib aansluit aan een esp8266 krijg ik weer hogere waardes (maar dat is 3.3V en dan zal het weer opnieuw gecalibreerd moeten worden?).

Maar jij had het over het vervangen van die 102 smd (1k). In "mijn" lib kan ik aangeven welke RLOAD erop zit, dus zet ik die op 1.0 (k). Of dat goed is, of dat 1k sowieso niet goed is ben ik dan ook nog niet uit (op de arduino site staat dat 2-47k gebruikelijk is) Moet ik die dus vervangen?

En weet jij waar de potmeter op de module toe dient?
EDIT: die schijnt dus voor een alarm trigger op de D0 aansluiting te zijn. https://arduino-info.wiki...-Environmental-Monitoring

[ Voor 9% gewijzigd door sjimmie op 14-02-2016 19:12 ]

[BladeSlayer1000]

Heeft iemand hier toevallig ervaring met de Arduino 101, ik ben in bezit van een Arduino Esplora echter merk je gauw dat de processor (Atmega32u4) door zijn lage klokfrequentie nogal traag is met rekenen.
Nu wil ik eigenlijk een soort controller maken van de Esplora doormiddel van de ISP header en SPI, en die linken naar de Arduino 101, om daar al het rekenwerk te laten gebeuren, en het scherm aan te sturen.

Enige wat ik mij afvraag, is hoe krachtig de Arduino 101 is. de klokfrequentie ligt 2x hoger, en hij heeft ook 2 kernen. Het zou alleen zonden zijn, als het achteraf blijkt dat het niet zoveel verbetering is als ik denk.

[RobV]

BladeSlayer1000 schreef op maandag 15 februari 2016 @ 19:27:
Heeft iemand hier toevallig ervaring met de Arduino 101, ik ben in bezit van een Arduino Esplora echter merk je gauw dat de processor (Atmega32u4) door zijn lage klokfrequentie nogal traag is met rekenen.
Nu wil ik eigenlijk een soort controller maken van de Esplora doormiddel van de ISP header en SPI, en die linken naar de Arduino 101, om daar al het rekenwerk te laten gebeuren, en het scherm aan te sturen.

Enige wat ik mij afvraag, is hoe krachtig de Arduino 101 is. de klokfrequentie ligt 2x hoger, en hij heeft ook 2 kernen. Het zou alleen zonden zijn, als het achteraf blijkt dat het niet zoveel verbetering is als ik denk.

Als CPU power je bottleneck is, stap dan gewoon over op een rPI oid en stop er niet teveel tijd en energie in. Tegen de tijd dat je een oplossing gevonden hebt komt er weer een nieuwe CPU/Arduino uit.

[mcDavid]

BladeSlayer1000 schreef op maandag 15 februari 2016 @ 19:27:
Heeft iemand hier toevallig ervaring met de Arduino 101, ik ben in bezit van een Arduino Esplora echter merk je gauw dat de processor (Atmega32u4) door zijn lage klokfrequentie nogal traag is met rekenen.
Nu wil ik eigenlijk een soort controller maken van de Esplora doormiddel van de ISP header en SPI, en die linken naar de Arduino 101, om daar al het rekenwerk te laten gebeuren, en het scherm aan te sturen.

Enige wat ik mij afvraag, is hoe krachtig de Arduino 101 is. de klokfrequentie ligt 2x hoger, en hij heeft ook 2 kernen. Het zou alleen zonden zijn, als het achteraf blijkt dat het niet zoveel verbetering is als ik denk.

Wat ben je in hemelsnaam aan het berekenen dat dat te traag gaat dan?

En idd, eens met RobV. Die 101 e.d. schieten allemaal hun doel voorbij als je het mij vraagt. Veel te veel functionaliteit en veel te duur. En het blijft een microcontroller. Als je zware berekeningen wilt doen ben je volgens mij sowieso beter af met een microcomputer.

[BladeSlayer1000]

mcDavid schreef op maandag 15 februari 2016 @ 19:58:
[...]

Wat ben je in hemelsnaam aan het berekenen dat dat te traag gaat dan?

En idd, eens met RobV. Die 101 e.d. schieten allemaal hun doel voorbij als je het mij vraagt. Veel te veel functionaliteit en veel te duur. En het blijft een microcontroller. Als je zware berekeningen wilt doen ben je volgens mij sowieso beter af met een microcomputer.

2 spelers die tegelijk kunnen bewegen, en een balletje wat de hele tijd beweegd

Ik zat inderdaad te twijfelen om dat af te stappen van een microcontroller, en zoals RobV zegt. Tegen de tijd dat je de boel hebt uitgevogeld is er een nieuwe Arduino uit.

[sjimmie]

Promy schreef op zaterdag 13 februari 2016 @ 17:07:
@jvdmast: ik had met deze getest maar ik merk toch een zeer groot verschil in berekening

Ik heb die er nu ook in gezet, maar ik kan nergens vinden hoe je die calibreert?
Als ik hem binnen laat draaien dan krijg ik:

valr 470
Vrl / Rs / ratio:25885 / 40363.00 / 1729.40

En buiten:

valr 223
Vrl / Rs / ratio:13387 / 20875.00 / 0.00

Bij de andere lib kon ik de 'getZero()' waarde in de haderfile zetten als calibratie, maar hier kan ik niet vinden hoe dat zou werken.

EDIT: Oja, ik heb jouw tip opgevolgd en de 102 (1k) weerstand vervangen door een 10k weerstand.
En ik heb meteen de voeding van de meetlijn en van het verwarmingselementje gescheiden zodat ik t.z.t. met 5V kan verwarmen en met 3.3V kan meten. Maar dan moet het eerst eens logische waardes gaan geven...

[ Voor 17% gewijzigd door sjimmie op 16-02-2016 16:30 ]

[Promy]

@jvdmast: de calibratie moet je doen door MQ135_DEFAULTRO te gaan aanpassen tot hij buiten de actuele CO2 waarde geeft (dat is nu ergens begin de 400 zie co2.org)
Ik heb deze echter nooit echt goed gecalibreerd gekregen

[sjimmie]

Promy schreef op woensdag 17 februari 2016 @ 08:51:
@jvdmast: de calibratie moet je doen door MQ135_DEFAULTRO te gaan aanpassen tot hij buiten de actuele CO2 waarde geeft (dat is nu ergens begin de 400 zie co2.org)
Ik heb deze echter nooit echt goed gecalibreerd gekregen

Ah, ik dacht dat ik 1 van de #define waardes moest vullen met iets wat 1 van de functies terug gaf.
Het is dus een kwestie van uitproberen.
Ik krijg juist met de originele en aangepaste GeorgK library de boel niet goed (of het moet binnen echt >4000ppm zijn).

[Promy]

sjimmie schreef op woensdag 17 februari 2016 @ 09:34:
[...]

Ah, ik dacht dat ik 1 van de #define waardes moest vullen met iets wat 1 van de functies terug gaf.
Het is dus een kwestie van uitproberen.
Ik krijg juist met de originele en aangepaste GeorgK library de boel niet goed (of het moet binnen echt >4000ppm zijn).

Vorige week kreeg ik wat rare waardes met de MQ135 (en jouw sketch) maar het viel me op dat de 5V een stuk lager was (maar 4.7 a 4.8V zelfs met een 2A voeding op usb aangesloten, wel met de mq135, lcd met backlight en dht11 aangesloten). Aangzizne ik het op een mega2560 draai heb ik wat verschillende voedingen getest. Door het bordje gelijktijdig met 5V over usb en 12V via de power-in te voeden krijg ik een 4.97V en geeft het redelijk normale waardes (469 ppm binnenshuis)

Is er een methode om de effectieve spanning in rekening te nemen of ervoor te zorgen dat de 5V voldoende hoog is? Al vermoed ik dat een zwaardere voeding nodig zal zijn (meer dan 2A? )

[LED-Maniak]

BladeSlayer1000 schreef op maandag 15 februari 2016 @ 20:04:
[...]


2 spelers die tegelijk kunnen bewegen, en een balletje wat de hele tijd beweegd

Ik zat inderdaad te twijfelen om dat af te stappen van een microcontroller, en zoals RobV zegt. Tegen de tijd dat je de boel hebt uitgevogeld is er een nieuwe Arduino uit.

Misschien tijd om van arduino af te stappen en fatsoenlijk te programmeren zonder overhead? Je kan best wel veel berekeningen doen op 16/20MHz. Anders een STM32 bordje.

[BladeSlayer1000]

LED-Maniak schreef op zaterdag 20 februari 2016 @ 15:18:
[...]

Misschien tijd om van arduino af te stappen en fatsoenlijk te programmeren zonder overhead? Je kan best wel veel berekeningen doen op 16/20MHz. Anders een STM32 bordje.

Ik heb na het advies van jouw eens even een avond besteed aan wat onderzoek over de STM32 borden.
Welke zou jij aanraden in mijn situatie? Ik heb tot nu toe alleen Arduino's geprogrammeerd, en ben bekend met de basis talen om websites te programmeren.

Ik kwam op mijn zoektocht de STM32VL Discovery tegen, zou jij die aanraden voor iemand die nog nooit op deze manier AVR's heeft geprogrammeerd?

[LED-Maniak]

Ik heb zelf een STM32F4 board. Het is net een slag complexer dan een arduino, simpelweg omdat het krachtpatsers zijn waar nog veel meer mogelijk is. Er is veel voorbeeldcode beschikbaar maar je zal toch een hoop zelfstudie moeten doen. Dat is in ieder geval mijn ervaring geweest.

De basis komt natuurlijk op hetzelfde neer.

Misschien is het een idee om stukjes code te delen zodat we kunnen zien of het misschien efficiënter kan? Reken je met floats, delays, groter dan 8-bit int bijvoorbeeld? Moet je altijd waardes uitrekenen en kan dat niet met een LUT?

[ Voor 5% gewijzigd door LED-Maniak op 20-02-2016 22:26 ]

[BladeSlayer1000]

LED-Maniak schreef op zaterdag 20 februari 2016 @ 22:26:
Ik heb zelf een STM32F4 board. Het is net een slag complexer dan een arduino, simpelweg omdat het krachtpatsers zijn waar nog veel meer mogelijk is. Er is veel voorbeeldcode beschikbaar maar je zal toch een hoop zelfstudie moeten doen. Dat is in ieder geval mijn ervaring geweest.

De basis komt natuurlijk op hetzelfde neer.

Misschien is het een idee om stukjes code te delen zodat we kunnen zien of het misschien efficiënter kan? Reken je met floats, delays, groter dan 8-bit int bijvoorbeeld? Moet je altijd waardes uitrekenen en kan dat niet met een LUT?

Ik zal morgen als ik tijd heb de code eens plaatsen (*zucht verplichte schoonouders bezoeken*)

Daarbij moet ik wel zeggen, ik zit al een tijd te denken om een stap verder te gaan dan alleen Arduino. Ik denk dat een STM32 een mooie manier is om te beginnen.
De complexiteit zal mij niet heel erg in de weg zitten, ik ga altijd net zo lang door tot het lukt en ik het begrijp.

[koelkast]

Ik zoek met Aliexpress naar dunne laag-voltagekabel (5v) om wat aan te sluiten op de Arduino. Ik heb nu alleen maar een stapeltje dupont kabels, maar heb behoefte aan iets langers voor wat projecten.
Ben benieuwd of zoiets oké is: http://nl.aliexpress.com/...d1-447d-b8d1-d4da9d0c3aeb

[LED-Maniak]

Het is single-core en op zich OK om te solderen maar AWG30 is echt heel erg dun. Ik heb die rollen hier liggen namelijk.

Als ik jou was zou ik een dikkere zoeken.

[trekker22]

wat is de beste/makkelijkste manier om vanuit een iOS apparaat een arduino te beinvloeden?

Ik wil een ledstrip onder bed gaan bevestigen icm motion sensor. Echter wil ik het ook gebruiken als wakeup-light in de morgen en ook middels mijn iPhone instellen dat de ledstrip gewoon werkt als sfeer verlichting.

Het leuke App Inventor is er alleen voor Android. Is het beste dan te gaan voor het draaien van een simpele webserver op de arduino icm een WiFly Shield?
Of toch Bluetooth?

Edit WiFi lijkt me ook handiger voor tijdsync -> wakeup light / wekker.

Edit na wat meer rondkijken, is een ESP8266 ook niet voor iemand met weinig ervaring? Dan heb je voor weinig geld meteen WiFi erbij:

http://www.instructables....el-LEDs-using-Arduino-ID/

[ Voor 23% gewijzigd door trekker22 op 24-02-2016 19:47 ]