[Discussie] Arduino-topic

[Raven]

Waarom gebruik je een aparte voeding? Van wat ik lees kan dat ding zonder problemen vanuit een Arduino gevoed worden.

[naaitsab]

Zit meer spul op, o.a. LCD met BL en 4-kanaals 250V/10A relais. De Uno heeft al een Wiznet shield op zich zitten dus ik weet niet of hij dat leuk gaat vinden op 1 voeding. Zou het ook kunnen proberen door de voeding van de Uno op de plug te zetten en USB enkel voor data te gebruiken. Vanavond de boel weer eens erbij pakken

Maar mocht ik de boel willen uitbreiden hoe zou ik dan het beste de GND (rail) van de breadboard aan kunnen sluiten?

[Raven]

Als je een USB voeding gebruikt, misschien een idee om dan een splitter (Y kabel) te gebruiken om de voeding van de Arduino iets te ontlasten en dan rechtstreeks stroom van de USB voeding te gebruiken? De sensor dan laten voeden door de Arduino en LCD op de y kabel aansluiten?

[ Voor 16% gewijzigd door Raven op 20-04-2013 16:39 ]

[naaitsab]

Heb een normale voeding erbij, 9Volt uit m'n hoofd. USB is sowieso max 500mA dus dat is ook niet gek veel.

[Sissors]

naaitsab schreef op zaterdag 20 april 2013 @ 15:23:
Ik heb ook wat vreemde waardes met mijn SHT11 (industriële kwaliteit) sensor met te hoge temperatuur en luchtvochtigheid die niet klopt.

De sensor zit op een breadboard gevoed door een losse voeding nu las ik dat de GND met de arduino verbonden moet worden ivm zwevende waardes, dit laatste is mij bekend maar hoe zou ik het geheel dan aan moeten sluiten door de boel wel knap te configureren met die losse voeding. Ik dacht namelijk dat je dan problemen krijgt met de voeding/kortsluiting.

Gewoon GND van arduino verbinden met GND van je breadboard. Dat zou geen probleem moeten zijn tenzij er ergens anders iets fout hebt gedaan.

[Raven]

naaitsab schreef op zaterdag 20 april 2013 @ 17:03:
Heb een normale voeding erbij, 9Volt uit m'n hoofd. USB is sowieso max 500mA dus dat is ook niet gek veel.

De USB2 specs van USB poorten in computers hebben die limiet, maar er zijn voedingen die veel meer leveren. Maar dan zou je telkens bij programmeren de Y kabel moeten ontkoppelen omdat anders je pc het moeilijk krijgt.

[naaitsab]

Raven schreef op zaterdag 20 april 2013 @ 17:26:
[...]

De USB2 specs van USB poorten in computers hebben die limiet, maar er zijn voedingen die veel meer leveren. Maar dan zou je telkens bij programmeren de Y kabel moeten ontkoppelen omdat anders je pc het moeilijk krijgt.

Ja daarom hou ik het liever gescheiden. Die tablet laders (o.a. ipad) hebben 2A volgens mij.

Sissors schreef op zaterdag 20 april 2013 @ 17:04:
[...]

Gewoon GND van arduino verbinden met GND van je breadboard. Dat zou geen probleem moeten zijn tenzij er ergens anders iets fout hebt gedaan.

De GND van de BB is al verbonden door dat voedings printje, gaat dat geen problemen opleveren dan? Zonder bordje is dat uiteraard geen probleem door GND en 5V rails op de BB te verbinden met de Arduino.

[Sissors]

De ground van dat voedingsprintje zit echter (als ik het goed begrijp) nu los van de Arduino ground, die moet je met elkaar verbinden om gemeenschappelijke referentie te hebben.

Wat je niet moet doen is twee verschillende voedingen verbinden, ook niet als ze ongeveer dezelfde spanning horen te hebben.

[naaitsab]

Het is dus geen probleem om de GND zowel via de BB voedings printplaat te laten lopen (zit op GND en 5V rails op BB) en de GND van de arduino?

[Icekiller2k6]

Normaal als je 2 aparte stroombronnen hebt verbind je de GND's met elkaar zodat de "vergelijkings"voltage gelijk is.. als je me niet gelooft probeer eens een max232 serial device te gebruiken zonder de ground van device A me de arduino te verbinden resultaten gaan zeer onregelmatig zijn.

[naaitsab]

Hmm ik dacht altijd dat je de GND moest "koppelen" aan dezelfde voedingsbron, in dit geval de Arduino OF de losse voeding plaat. Ik zal morgen eens kijken of dit de problemen oplost, anders zal ik de soldeer punten nog eens controleren wellicht dat die niet helemaal 100 zijn.

Weer wat geleerd

[Icekiller2k6]

Mja ik heb geen wetenschappelijk/gedocumenteerd bewijs van (geen electronica gestudeerd) enkel uit praktijk ervaring gezien (zitten zoeken waarom communicatie niet lukte code 1000x herschreven..)

[Hans1990]

Een GND is slechtst een referentiepunt. Als je +5V voeding hebt, heb je een spanningsbron die 5V hoger ligt dan GND.
Een andere 5V voeding heeft dat wederom maar beide GND's kunnen op een heel ander 'absoluut' niveau liggen. Die 5V is dus eigenlijk relatief. Daarom moet je de GND's aan elkaar verbinden.

Kortsluitingen zou ik mij enkel zorgen maken over de positieve voedingslijnen die niet worden kortgesloten.
Tenzij je een hele grote mess gaat maken van je bedrading , ga je niet zomaar last krijgen van dingen zoals ground loops of zo.

Ik heb wel eens een project gehad waarmee ik een programmeerpoort en een DB9 RS232 poort had. Werkte allemaal prima. Toen ik een keer het project in een behuizing wilde zetten, kreeg ik geen data meer over de seriele poort.
Bleek dat ik de GND niet had doorverbonden (de verkeerde pin), en vandaar dus niet werkte. Klein draadje er heen, en het werkte prima.

[Raven]

Raven schreef op donderdag 11 april 2013 @ 17:30:
Mijn Mega is nu wireless

pricewatch: TP-Link TL-WR702N is vandaag aangekomen. Die ingesteld als client, laten verbinden met mijn WLAN, aan de Arduino met ethernetshield gehangen en de Arduino zit nu draadloos de tijd op te halen van de TimeServer in mijn router en dat terwijl dit dingetje maar €20 kostte (+ €13 voor ethernetshield) itt de €69 dat 't wifi-shield kost.

Helaas pakt de Arduino de UTC tijd, die loopt 2u achter.

Nu heb ik wel een stukje code gevonden dat dat op zou moeten lossen, maar zit mij af te vragen of ik die zomaar kan kopiëren en plakken tussen de code van http://arduino.cc/en/Tutorial/UdpNtpClient

http://arduino.cc/forum/index.php/topic,40286.0.html

C:

int adjustDstEurope()
{
  // last sunday of march
  int beginDSTDate=  (31 - (5* year() /4 + 4) % 7);
  Serial.println(beginDSTDate);
  int beginDSTMonth=3;
  //last sunday of october
  int endDSTDate= (31 - (5 * year() /4 + 1) % 7);
  Serial.println(endDSTDate);
  int endDSTMonth=10;
  // DST is valid as:
  if (((month() > beginDSTMonth) && (month() < endDSTMonth))
      || ((month() == beginDSTMonth) && (day() >= beginDSTDate))
      || ((month() == endDSTMonth) && (day() <= endDSTDate)))
  return 7200;  // DST europe = utc +2 hour
  else return 3600; // nonDST europe = utc +1 hour
}

Later nog maar eens naar kijken. Kan iig draadloos data versturen vanuit de meterkast wanneer de TCRT5000's er zijn

Ondertussen met de maker van die code aan het mailen, maar vooralsnog niet werkend weten te krijgen in de UdpNtpClient code Of er verandert niks, of er staat ineens een heel lang getal op de plaats van de uren.

Heeft iemand toevallig al een werkende NTP client sketch met ondersteuning voor DST?

edit: Het lijkt nu na nog een aanpassing te werken, al is het wel wachten op de eerstvolgende keer dat de klokken aangepast moeten worden om het zeker te weten, maar de tijd wordt nu iig goed weergegeven voor deze tijdzone, GMT+1 met DST dus..

C:

#include <SPI.h>        
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <Time.h>

// Enter a MAC address for your controller below.
// Newer Ethernet shields have a MAC address printed on a sticker on the shield
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
unsigned int localPort = 8888;      // local port to listen for UDP packets
IPAddress timeServer(192, 168, 1, 1); 
const int NTP_PACKET_SIZE= 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets

// A UDP instance to let us send and receive packets over UDP
EthernetUDP Udp;

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // start Ethernet and UDP
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    for(;;)
      ;
  }
  Udp.begin(localPort);
  
}

void loop()
{
  sendNTPpacket(timeServer); // send an NTP packet to a time server

    // wait to see if a reply is available
  delay(1000);  
  if ( Udp.parsePacket() ) {  
    // We've received a packet, read the data from it
    Udp.read(packetBuffer,NTP_PACKET_SIZE);  // read the packet into the buffer

    //the timestamp starts at byte 40 of the received packet and is four bytes,
    // or two words, long. First, esxtract the two words:

    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);  
    // combine the four bytes (two words) into a long integer
    // this is NTP time (seconds since Jan 1 1900):
    unsigned long secsSince1900 = highWord << 16 | lowWord;  
    // now convert NTP time into everyday time:
    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
    const unsigned long seventyYears = 2208988800UL;    
    // subtract seventy years:
    unsigned long epoch = secsSince1900 - seventyYears;  
    setTime(epoch);
    setTime(epoch + adjustDstEurope());
    Serial.print(hour());
    printDigits(minute());
    printDigits(second());
    Serial.print(" ");
    Serial.print(day());
    Serial.print("-");
    Serial.print(month());
    Serial.print("-");
    Serial.print(year());
    Serial.println();   
  } 
  Serial.print("My IP address: ");
    for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }
  Serial.println();
  // wait ten seconds before asking for the time again
  delay(5000);
}

// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address)
{
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;

  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:         
  Udp.beginPacket(address, 123); //NTP requests are to port 123
  Udp.write(packetBuffer,NTP_PACKET_SIZE);
  Udp.endPacket();
}

int adjustDstEurope()
{
  // last sunday of march
  int beginDSTDate=  (31 - (5* year() /4 + 4) % 7);
  int beginDSTMonth=3;
  //last sunday of october
  int endDSTDate= (31 - (5 * year() /4 + 1) % 7);
  int endDSTMonth=10;
  // DST is valid as:
  if (((month() > beginDSTMonth) && (month() < endDSTMonth))
      || ((month() == beginDSTMonth) && (day() >= beginDSTDate)) 
      || ((month() == endDSTMonth) && (day() <= endDSTDate)))
  return 7200;  // DST europe = utc +2 hour
  else return 3600; // nonDST europe = utc +1 hour
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

En het is misschien handiger om die NTP request uit het main programma te halen om die dan 1* per dag ofzo uit te laten voeren. Maar dat zal wel lukken denk ik

[ Voor 53% gewijzigd door Raven op 23-04-2013 13:24 ]

[ThinkPad]

Ben nog maar net begonnen met Arduino, en wil nu graag 3 LED's laten branden door ze elk via een GET parameter aan te roepen. De rode LED wil ik graag laten knipperen, ik krijg dit echter niet voor elkaar, omdat ik nu 2 loops in elkaar heb, en dat pikt de Arduino compiler niet.

Helaas heb ik er nog niet genoeg verstand van om een andere situatie te bedenken.

Iemand die mij een duwtje in de goede richting kan geven?

C:

#include <EtherCard.h>

// ethernet mac address - must be unique on your network
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
// ethernet interface ip address
static byte myip[] = { 192,168,1,199 };
// gateway ip address
static byte gwip[] = { 192,168,1,252 };

byte Ethernet::buffer[500]; // tcp/ip send and receive buffer

// Using a Variable for the Pin, but it is not necessary 
const int red_pin = 2;
const int orange_pin = 4;
const int green_pin = 6;




// Some stuff for responding to the request
char* on = "ON";
char* off = "OFF";
char* statusLabel;
char* buttonLabel;

// Small web page to return so the request is completed
char page[] PROGMEM =
"HTTP/1.0 503 Service Unavailable\r\n"
"Content-Type: text/html\r\n"
"Retry-After: 600\r\n"
"\r\n"
"<html>"
  "<head><title>"
    "Arduino 192.168.1.199"
  "</title></head>"
  "<body>"
   "<h3>Arduino 192.168.1.199</h3>"
  "</body>"
"</html>"
;

void setup(){
  Serial.begin(9600);      // open the serial port at 9600 bps: 
  
// Set Pin2 to be an Output
  pinMode(red_pin, OUTPUT);
// Set Pin4 to be an Output
  pinMode(orange_pin, OUTPUT);
  // Set Pin6 to be an Output
  pinMode(green_pin, OUTPUT);

// Scary complex intializing of the EtherCard - I don't understand this stuff (yet0  
  ether.begin(sizeof Ethernet::buffer, mymac);
// Set IP using Static
  ether.staticSetup(myip, gwip);
}
void loop(){
  
  word len = ether.packetReceive();
  word pos = ether.packetLoop(len);
  
// state=OK ---> Green LED on
  if(strstr((char *)Ethernet::buffer + pos, "GET /?state=ok") != 0) {
      Serial.print("Received alarm=true command");
      digitalWrite(red_pin, LOW);
      digitalWrite(orange_pin, LOW);
      digitalWrite(green_pin, HIGH);
    }  
    
// state=warning ---> Orange LED on
  if(strstr((char *)Ethernet::buffer + pos, "GET /?state=warning") != 0) {
      Serial.print("Received alarm=true command");
      digitalWrite(red_pin, LOW);
      digitalWrite(orange_pin, HIGH);
      digitalWrite(green_pin, LOW);
    }     
    
// IF state=critical
  if(strstr((char *)Ethernet::buffer + pos, "GET /?state=critical") != 0) {
      Serial.print("Received alarm=true command");
      
          digitalWrite(red_pin, LOW);
          digitalWrite(orange_pin, LOW);
          digitalWrite(green_pin, LOW);
    
    
    void loop(){
          digitalWrite(red_pin, HIGH);   // turn the LED on (HIGH is the voltage level)
          delay(1000);               // wait for a second
          digitalWrite(red_pin, LOW);    // turn the LED off by making the voltage LOW
          delay(1000);           // wait for a second
          } 

          
    }  
//Return a page so the request is completed.

    memcpy_P(ether.tcpOffset(), page, sizeof page);
    ether.httpServerReply(sizeof page - 1);
  
}

[ Voor 43% gewijzigd door ThinkPad op 26-04-2013 22:52 ]

[Icekiller2k6]

Logisch toch? De 2de loop blijft nu "eeuwig" de baas en je komt nooit meer aan de andere data, wat je kunt doen (en wat ik aanraad..) is een

code:

boolean keeprunning=false;
while(!keeprunning){

          digitalWrite(red_pin, HIGH);   // turn the LED on (HIGH is the voltage level) 
          delay(1000);               // wait for a second 
          digitalWrite(red_pin, LOW);    // turn the LED off by making the voltage LOW 
          delay(1000);           // wait for a second 
  

}

de loop moet je dus weghalen... idd onlogisch zoals het er stond fail copypaste ^^

[ Voor 9% gewijzigd door Icekiller2k6 op 28-04-2013 23:17 . Reden: foutje ]

[foekie01]

Als je die led blijvend wilt laten loopen, zul je iets met een while moeten maken, zoals eerder voorgesteld. Aangezien je toch al een loop hebt, kun je die while in je loop zetten. Je zou dus het volgende krijgen: (fouten voorbehouden, geschreven met een kater )

C:

#include <EtherCard.h> 

// ethernet mac address - must be unique on your network 
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 }; 
// ethernet interface ip address 
static byte myip[] = { 192,168,1,199 }; 
// gateway ip address 
static byte gwip[] = { 192,168,1,252 }; 

byte Ethernet::buffer[500]; // tcp/ip send and receive buffer 

// Using a Variable for the Pin, but it is not necessary  
const int red_pin = 2; 
const int orange_pin = 4; 
const int green_pin = 6; 

// Some stuff for responding to the request 
char* on = "ON"; 
char* off = "OFF"; 
char* statusLabel; 
char* buttonLabel; 

// Small web page to return so the request is completed 
char page[] PROGMEM = 
"HTTP/1.0 503 Service Unavailable\r\n" 
"Content-Type: text/html\r\n" 
"Retry-After: 600\r\n" 
"\r\n" 
"<html>" 
  "<head><title>" 
    "Arduino 192.168.1.199" 
  "</title></head>" 
  "<body>" 
   "<h3>Arduino 192.168.1.199</h3>" 
  "</body>" 
"</html>" 
; 

void setup(){ 
  Serial.begin(9600);      // open the serial port at 9600 bps:  
   
// Set Pin2 to be an Output 
  pinMode(red_pin, OUTPUT); 
// Set Pin4 to be an Output 
  pinMode(orange_pin, OUTPUT); 
  // Set Pin6 to be an Output 
  pinMode(green_pin, OUTPUT); 

// Scary complex intializing of the EtherCard - I don't understand this stuff (yet0   
  ether.begin(sizeof Ethernet::buffer, mymac); 
// Set IP using Static 
  ether.staticSetup(myip, gwip); 
} 

//TOEGEVOEGD
int ledState = 0;
int blink = 0;

void loop()
{    
    word len = ether.packetReceive(); 
    word pos = ether.packetLoop(len); 
   
    // state=OK ---> Green LED on 
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=ok") != 0) 
    { 
        Serial.print("Received alarm=true command"); 
        digitalWrite(red_pin, LOW); 
        digitalWrite(orange_pin, LOW); 
        digitalWrite(green_pin, HIGH); 
        
        //TOEGEVOEGD
        blink = false;
    }   
     
    // state=warning ---> Orange LED on 
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=warning") != 0) 
    { 
        Serial.print("Received alarm=true command"); 
        digitalWrite(red_pin, LOW); 
        digitalWrite(orange_pin, HIGH); 
        digitalWrite(green_pin, LOW); 
        
        //TOEGEVOEGD
        blink = false;
    }      
     
    // IF state=critical 
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=critical") != 0) 
    { 
        Serial.print("Received alarm=true command"); 
       
        digitalWrite(red_pin, LOW); 
        digitalWrite(orange_pin, LOW); 
        digitalWrite(green_pin, LOW); 
        
        //TOEGEVOEGD
        blink = true;
    }
    
    //Toegevoegd
    if(blink)
    { 
          digitalWrite(red_pin, !ledState);    
          delay(1000);             
    }   

    //Return a page so the request is completed. 
    memcpy_P(ether.tcpOffset(), page, sizeof page); 
    ether.httpServerReply(sizeof page - 1);  
}

[ Voor 79% gewijzigd door foekie01 op 27-04-2013 14:50 ]

[ThinkPad]

Icekiller2k6 schreef op zaterdag 27 april 2013 @ 10:04:
Logisch toch? De 2de loop blijft nu "eeuwig" de baas en je komt nooit meer aan de andere data, wat je kunt doen (en wat ik aanraad..) is een

code:

boolean keeprunning=false;
while(!keeprunning){
  void loop(){ 
          digitalWrite(red_pin, HIGH);   // turn the LED on (HIGH is the voltage level) 
          delay(1000);               // wait for a second 
          digitalWrite(red_pin, LOW);    // turn the LED off by making the voltage LOW 
          delay(1000);           // wait for a second 
          }  

}

Deze snap ik niet helemaal. Deze code moet ik gebruiken ipv de huidige code waar ik de led pinnen voor "state=critical" stuur?

foekie01 schreef op zaterdag 27 april 2013 @ 11:42:
Als je die led blijvend wilt laten loopen, zul je iets met een while moeten maken, zoals eerder voorgesteld. Aangezien je toch al een loop hebt, kun je die while in je loop zetten. Je zou dus het volgende krijgen: (fouten voorbehouden, geschreven met een kater )

[..]knip[..]

Dit werkt helaas niet, de LED blijft gewoon branden ipv knipperen. Idee is opzich wel goed denk ik.

[ Voor 13% gewijzigd door ThinkPad op 27-04-2013 17:24 ]

[foekie01]

En nu? Ik heb de ledState aangepast.

C:

#include <EtherCard.h>  

// ethernet mac address - must be unique on your network  
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };  
// ethernet interface ip address  
static byte myip[] = { 192,168,1,199 };  
// gateway ip address  
static byte gwip[] = { 192,168,1,252 };  

byte Ethernet::buffer[500]; // tcp/ip send and receive buffer  

// Using a Variable for the Pin, but it is not necessary   
const int red_pin = 2;  
const int orange_pin = 4;  
const int green_pin = 6;  

// Some stuff for responding to the request  
char* on = "ON";  
char* off = "OFF";  
char* statusLabel;  
char* buttonLabel;  

// Small web page to return so the request is completed  
char page[] PROGMEM =  
"HTTP/1.0 503 Service Unavailable\r\n"  
"Content-Type: text/html\r\n"  
"Retry-After: 600\r\n"  
"\r\n"  
"<html>"  
  "<head><title>"  
    "Arduino 192.168.1.199"  
  "</title></head>"  
  "<body>"  
   "<h3>Arduino 192.168.1.199</h3>"  
  "</body>"  
"</html>"  
;  

void setup(){  
  Serial.begin(9600);      // open the serial port at 9600 bps:   
    
// Set Pin2 to be an Output  
  pinMode(red_pin, OUTPUT);  
// Set Pin4 to be an Output  
  pinMode(orange_pin, OUTPUT);  
  // Set Pin6 to be an Output  
  pinMode(green_pin, OUTPUT);  

// Scary complex intializing of the EtherCard - I don't understand this stuff (yet0    
  ether.begin(sizeof Ethernet::buffer, mymac);  
// Set IP using Static  
  ether.staticSetup(myip, gwip);  
}  

int ledState = 0; 
int blink = 0; 

void loop() 
{     
    word len = ether.packetReceive();  
    word pos = ether.packetLoop(len);  
    
    // state=OK ---> Green LED on  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=ok") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, LOW);  
        digitalWrite(green_pin, HIGH);  
         
        //TOEGEVOEGD 
        blink = false; 
    }    
      
    // state=warning ---> Orange LED on  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=warning") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, HIGH);  
        digitalWrite(green_pin, LOW);  
         
        //TOEGEVOEGD 
        blink = false; 
    }       
      
    // IF state=critical  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=critical") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, LOW);  
        digitalWrite(green_pin, LOW);  
         
        //TOEGEVOEGD 
        blink = true; 
    } 
     
    //Toegevoegd 
    if(blink) 
    {  
        if (ledState == LOW)
        {
            ledState = HIGH;
        }
            
        else
        {
            ledState = LOW;
        }
        digitalWrite(ledPin, ledState);  
            
    }    

    //Return a page so the request is completed.  
    memcpy_P(ether.tcpOffset(), page, sizeof page);  
    ether.httpServerReply(sizeof page - 1);   
}

Het is mooier om niet met delay te werken, maar met millis. Zie onderstaand voorbeeld.

C:

#include <EtherCard.h>  

// ethernet mac address - must be unique on your network  
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };  
// ethernet interface ip address  
static byte myip[] = { 192,168,1,199 };  
// gateway ip address  
static byte gwip[] = { 192,168,1,252 };  

byte Ethernet::buffer[500]; // tcp/ip send and receive buffer  

// Using a Variable for the Pin, but it is not necessary   
const int red_pin = 2;  
const int orange_pin = 4;  
const int green_pin = 6;  

// Some stuff for responding to the request  
char* on = "ON";  
char* off = "OFF";  
char* statusLabel;  
char* buttonLabel;  

// Small web page to return so the request is completed  
char page[] PROGMEM =  
"HTTP/1.0 503 Service Unavailable\r\n"  
"Content-Type: text/html\r\n"  
"Retry-After: 600\r\n"  
"\r\n"  
"<html>"  
  "<head><title>"  
    "Arduino 192.168.1.199"  
  "</title></head>"  
  "<body>"  
   "<h3>Arduino 192.168.1.199</h3>"  
  "</body>"  
"</html>"  
;  

void setup(){  
  Serial.begin(9600);      // open the serial port at 9600 bps:   
    
// Set Pin2 to be an Output  
  pinMode(red_pin, OUTPUT);  
// Set Pin4 to be an Output  
  pinMode(orange_pin, OUTPUT);  
  // Set Pin6 to be an Output  
  pinMode(green_pin, OUTPUT);  

// Scary complex intializing of the EtherCard - I don't understand this stuff (yet0    
  ether.begin(sizeof Ethernet::buffer, mymac);  
// Set IP using Static  
  ether.staticSetup(myip, gwip);  
}  

int ledState = 0; 
int blink = 0; 

//TOGEVOEGD 28-04
long previousMillis = 0; //houdt de vorige millis bij
long interval = 1000;     //elke 1000 milliseconden willen we ledState veranderen

void loop() 
{     
    word len = ether.packetReceive();  
    word pos = ether.packetLoop(len);  
    unsigned long currentMillis = millis();
    
    // state=OK ---> Green LED on  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=ok") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, LOW);  
        digitalWrite(green_pin, HIGH);  
        blink = false; 
    }    
      
    // state=warning ---> Orange LED on  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=warning") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, HIGH);  
        digitalWrite(green_pin, LOW);  
        blink = false; 
    }       
      
    // IF state=critical  
    if(strstr((char *)Ethernet::buffer + pos, "GET /?state=critical") != 0)  
    {  
        Serial.print("Received alarm=true command");  
        
        digitalWrite(red_pin, LOW);  
        digitalWrite(orange_pin, LOW);  
        digitalWrite(green_pin, LOW);   
        blink = true; 
    } 
     
    ////TOGEVOEGD 28-04
    if(blink) 
    {  
        //1000 milliseconden voorbij? Ja -> verander ledState en schrijf dit naar de LED
        if(currentMillis - previousMillis > interval) 
        {
            previousMillis = currentMillis;   
            
            //Vorige keer LOW geschreven? Dan schrijven we nu HIGH en andersom.
            if (ledState == LOW)
            {
                ledState = HIGH;
            }
            else
            {
                ledState = LOW;
            }
            digitalWrite(ledPin, ledState);
        }               
    }    

    //Return a page so the request is completed.  
    memcpy_P(ether.tcpOffset(), page, sizeof page);  
    ether.httpServerReply(sizeof page - 1);   
}

[ Voor 0% gewijzigd door foekie01 op 28-04-2013 10:58 . Reden: typo ]

[Appel105]

Hallo,

ik wil graag een arduino in een casemod gaan gebruiken. Ik wil de powerbutton, de fans en leds aan de arduino zetten, zodat ik hem kan gebruiken als fancontroller en voor de besturing van de leds (felheid, patronen enz.).

Het makkelijkst leek mij het gebruik van optocouplers, gewoon alles aan molex stekkers aansluiten en dan dmv een aantal optocouplers de fans en leds besturen. Maar nu zit ik met het probleem dat de optocouplers die ik heb nog vrij veel weerstand bieden. Ik gebruik een 4N35 optocoupler. Als ik de arduino HIGH laat sturen en ik meet de weerstand kom ik uit op 80 Ohm. Voor een ledje is dit laag genoeg, maar een fan draait er direct (bijna) niet meer mee. Is er een manier hoe ik deze weerstand omlaag kan brengen? Een ander model optocoupler? Of een heel andere aanpak?

Mvg JBee

[ThinkPad]

foekie01 schreef op zondag 28 april 2013 @ 10:56:
En nu? Ik heb de ledState aangepast.

[..]
code blok 1
[..]

[..]
code blok 2
[..]

Het eerste voorbeeld werkt niet, LED bleef wederom branden.

Tweede voorbeeld werkt wel, de LED knippert nu netjes als ik http://192.168.1.199/?state=critical aanroep. Thanks!

Moest overigens nog wel

C:

digitalWrite(ledPin, ledState);

aanpassen naar

C:

digitalWrite(red_pin, ledState);

Nu wil ik alleen nog inbouwen dat hij bij het aanzetten alle lampen een voor een even aan zet. Waar kan ik dat het beste doen?

Heb in de void setup() dit al geplaatst:

C:

 
digitalWrite(red_pin, LOW); 
  digitalWrite(orange_pin, LOW); 
  digitalWrite(green_pin, LOW);  
 
  digitalWrite(red_pin, LOW); 
  digitalWrite(orange_pin, LOW); 
  digitalWrite(green_pin, HIGH); 

digitalWrite(red_pin, LOW); 
  digitalWrite(orange_pin, HIGH); 
  digitalWrite(green_pin, LOW); 

digitalWrite(red_pin, HIGH); 
  digitalWrite(orange_pin, LOW); 
  digitalWrite(green_pin, LOW); 
  
  digitalWrite(red_pin, LOW); 
  digitalWrite(orange_pin, LOW); 
  digitalWrite(green_pin, LOW); 

maar dat werkt niet.

[ Voor 41% gewijzigd door ThinkPad op 28-04-2013 13:27 ]

[foekie01]

ThinkPadd schreef op zondag 28 april 2013 @ 13:11:
Het eerste voorbeeld werkt niet, LED bleef wederom branden.

Klopt, omdat ik de delay was vergeten

ThinkPadd schreef op zondag 28 april 2013 @ 13:11:
Moest overigens nog wel
digitalWrite(ledPin, ledState);

aanpassen naar
digitalWrite(red_pin, ledState);

My bad

ThinkPadd schreef op zondag 28 april 2013 @ 13:11:
Heb in de void setup() dit al geplaatst:

Klopt, dit werkt niet. Dit komt omdat je alles achter elkaar zet zonder even te wachten. Als de code uit voert loopt hij die één voor één na, maar omdat je niet wacht, gaan ze meteen weer uit. Hier kun je gewoon delay gebruiken.

C:

digitalWrite(red_pin, LOW);  
digitalWrite(orange_pin, LOW);  
digitalWrite(green_pin, LOW);  

delay(1000); 
  
digitalWrite(red_pin, LOW);  
digitalWrite(orange_pin, LOW);  
digitalWrite(green_pin, HIGH);  

delay(1000);

digitalWrite(red_pin, LOW);  
digitalWrite(orange_pin, HIGH);  
digitalWrite(green_pin, LOW);  

delay(1000);

digitalWrite(red_pin, HIGH);  
digitalWrite(orange_pin, LOW);  
digitalWrite(green_pin, LOW);  
   
delay(1000);

digitalWrite(red_pin, LOW);  
digitalWrite(orange_pin, LOW);  
digitalWrite(green_pin, LOW);

[ Voor 40% gewijzigd door foekie01 op 28-04-2013 15:41 ]

[foekie01]

Appel105 schreef op zondag 28 april 2013 @ 12:55:
Hallo,

ik wil graag een arduino in een casemod gaan gebruiken. Ik wil de powerbutton, de fans en leds aan de arduino zetten, zodat ik hem kan gebruiken als fancontroller en voor de besturing van de leds (felheid, patronen enz.).

Het makkelijkst leek mij het gebruik van optocouplers, gewoon alles aan molex stekkers aansluiten en dan dmv een aantal optocouplers de fans en leds besturen. Maar nu zit ik met het probleem dat de optocouplers die ik heb nog vrij veel weerstand bieden. Ik gebruik een 4N35 optocoupler. Als ik de arduino HIGH laat sturen en ik meet de weerstand kom ik uit op 80 Ohm. Voor een ledje is dit laag genoeg, maar een fan draait er direct (bijna) niet meer mee. Is er een manier hoe ik deze weerstand omlaag kan brengen? Een ander model optocoupler? Of een heel andere aanpak?

Mvg JBee

Klopt, dit werkt niet. Je zult fan met een FET aan moeten sturen. Bijvoorbeeld een TIP120 o.i.d.

Voorbeeld circuit:
http://www.rcrowley.com/images/ArduinoTIP120motor.png

[Appel105]

foekie01 schreef op zondag 28 april 2013 @ 15:34:
[...]


Klopt, dit werkt niet. Je zult fan met een FET aan moeten sturen. Bijvoorbeeld een TIP120 o.i.d.

Voorbeeld circuit:
http://www.rcrowley.com/images/ArduinoTIP120motor.png

direct even uitgeprobeerd, en het werkt inderdaad! Klopt het dan dat ik geen PWM kan gebruiken? De fan begint dan namelijk piepend geluid te maken.



Dat komt dus zeker omdat ik geen PWM fan gebruik...

[Raven]

Hoeveel draadjes heeft die fan? 3? -> geen pwm

[Appel105]

Raven schreef op zondag 28 april 2013 @ 16:43:
Hoeveel draadjes heeft die fan? 3? -> geen pwm

hij heeft er inderdaad 3: 1 ground, 1 power voor de led en een power voor de fan. Maar is het altijd zo dat een fan met maar 3 draadjes geen pwm heeft? In mijn kast zit achterin ook een fan met 3 draadjes die wel op verschillende snelheden kan draaien. Of werkt dat dan niet met pwm?

[Raven]

Fans met 3 draadjes gaan langzamer draaien door een lagere spanning, bij PWM (met 4 draadjes) blijft de spanning hetzelfde maar die wordt in pulsjes gestuurd, hoe minder pulsjes, hoe langzamer.

[ThinkPad]

foekie01 schreef op zondag 28 april 2013 @ 15:32:
[...]

Super bedankt man! Het werkt nu helemaal zoals ik wil Echt bedankt voor het op weg helpen. Het lijkt misschien een beetje lui, maar het is gewoon lastig om zoiets te vinden met Google (lastig om de goede zoektermen te vinden voor datgene waar je naar op zoek bent). Ik snap Arduino nu al stukken beter

[ Voor 66% gewijzigd door ThinkPad op 29-04-2013 00:13 ]

[almightyarjen]

Je kan ook gewoon een PWM signaal via een FET direct op de fan zetten, je hebt dan alleen geen terugkoppeling hoe hard en of de fan draait. Om het piepen van de fan te voorkomen kan je de PWM frequentie aanpassen:

code:

TCCR2B = (TCCR2B & 0xF8) | 1; // change PWM frequency

[Appel105]

ik heb de code in de setup ingeplaatst, en jahoor de fan doet het gewoon. Heeft dit stuk code ook nog effect op andere delen van het programma? Zoals de leds bijvoorbeeld? Ik heb echt geen idee wat die code betekent namelijk

[almightyarjen]

Deze code heeft alleen effect op Timer2 in de ATmega. Bij jouw gebruik heeft het verder geen invloed volgens mij. De standaard PWM frequentie ligt rond de 10kHz geloof ik, in ieder geval binnen het bereik van het menselijk gehoor. Door het PWM signaal gaan de spoelen in de fan op dezelfde frequentie resoneren en dit hoor je dus. Door bovenstaande code toe te passen verhoog je de PWM frequentie tot boven de 20kHz, wat je niet meer kan horen

hier meer info

[Appel105]

Heel erg bedankt! Zo leer ik er snel dingen bij

[Dr.Roelski]

Nog even een tip voor iedereen hierboven die dingen wil schakelen met een fet: meestal worden deze met 5V aansturing niet volledig open gestuurd. Gebruik hiervoor speciale fet's die dit bij 5V wel doen zoals bijv. http://www.conrad.nl/ce/nl/product/162873/ (IRLZ34N).

[ThinkPad]

Zoals hierboven te lezen is werkt mijn Arduino projectje nu zoals het hoort. Wil nu het hardware gedeelte gaan opbouwen. Wil alle elektronica in een lasdoos stoppen, maar m'n Duemilanove is nogal groot daarvoor, en dan moet ik weer een nieuwe Arduino bestellen.

Ik wil daarom een Arduino Nano bestellen, en dan alles netjes solderen en wegwerken in die lasdoos. Maar als ik deze Nano van eBay bestel, heb ik dan alles, of mis ik nog wat?



http://www.ebay.com/itm/N...ain_0&hash=item1e76aae237

Voeding regel ik via een 5V USB voeding die ik voor dit doel wel opoffer

[almightyarjen]

Ik mis een USB aansluiting?

Je kan ook de chip van de Duemilanove op een eigen gemaakte printplaat zetten, met een kristal van 16MHZ, scheelt weer een aankoop...

[naaitsab]

Denk dat je de boel moet programmeren via de pins, bijv door een andere Arduino te gebruiken.
Zou zelf een nano nemen, is iets groter maar zit gewoon USB op.

[ThinkPad]

Ah ik zat even niet op te letten. Had ze ook gezien met micro USB aansluiting

Ik bestel deze dan:

http://www.ebay.com/itm/A...welry&hash=item2a27c2402b

[ Voor 21% gewijzigd door ThinkPad op 29-04-2013 19:04 ]

[mcDavid]

De nano heeft mini-usb. Ik zou zeggen neem een micro, is maar ietsje duurder en heeft de chip van de Leonardo.

-edit- oh om te embedden is dat niet zo boeiend, dan kun je ook wel met een mini af. die kun je programmeren met je andere arduino.

[ Voor 38% gewijzigd door mcDavid op 29-04-2013 20:25 ]

[foekie01]

ThinkPadd schreef op maandag 29 april 2013 @ 18:28:
Zoals hierboven te lezen is werkt mijn Arduino projectje nu zoals het hoort. Wil nu het hardware gedeelte gaan opbouwen. Wil alle elektronica in een lasdoos stoppen, maar m'n Duemilanove is nogal groot daarvoor, en dan moet ik weer een nieuwe Arduino bestellen.

Ik wil daarom een Arduino Nano bestellen, en dan alles netjes solderen en wegwerken in die lasdoos. Maar als ik deze Nano van eBay bestel, heb ik dan alles, of mis ik nog wat?

[afbeelding]

http://www.ebay.com/itm/N...ain_0&hash=item1e76aae237

Voeding regel ik via een 5V USB voeding die ik voor dit doel wel opoffer

Voor deze moet je een FTDI kabel hebben.

Het blijft een persoonlijke kwestie (en een kwestie van "wat ga je er mee doen?") welke arduino variant je in je project wilt gebruiken.

Voor jouw simpele applicatie, zijn beide goed. Alleen moet je bij de eerste dan nog een extra kabel kopen, dus de tweede is goedkoper.

[ Voor 3% gewijzigd door foekie01 op 30-04-2013 11:40 ]

[naaitsab]

FTDI is toch enkel voor programmeren? Volgens mij kan je dan ook niet zo gemakkelijk verbinden met de PC voor evt serial data/functies. Of zie ik dat verkeerd?

[Raven]

Geloof het wel ja, maar voor serial output zijn er meestal nog aparte Tx/Rx pinnen, zie http://arduino.cc/en/Reference/serial

[ Voor 7% gewijzigd door Raven op 30-04-2013 14:15 ]

[ThinkPad]

Makkelijk programmeren is wel een vereiste, dus ik heb de tweede gekocht Die heeft al een FTDI USB>Serial converter aan boord

[foekie01]

naaitsab schreef op dinsdag 30 april 2013 @ 12:55:
FTDI is toch enkel voor programmeren? Volgens mij kan je dan ook niet zo gemakkelijk verbinden met de PC voor evt serial data/functies. Of zie ik dat verkeerd?

Jawel dit kan gewoon. FTDI is niet meer dan een chip die data om zet, net als bijvoorbeeld een PL2303 en die zichzelf laat zien als COM poort op de PC.

The chip on the board translates the serial data coming from a device into USB data and vice-versa. It is widely used to upload firmware to the Arduino Pro Mini, but it can communicate with any serial-enabled device.

Bron:
https://www.sparkfun.com/tutorials/245

[ Voor 3% gewijzigd door foekie01 op 30-04-2013 17:00 ]

[almightyarjen]

Ik heb een Arduino Mega via een externe voeding aangesloten: er gaat 9V naar de power jack van de Arduino, met dezelfde GND als de voeding. De 3,3V en 5V geven de juiste waarde af en het programma werkt ook perfect zolang ik de USB kabel erin laat zitten. Zodra ik die eruit trek stopt het programma na een paar seconden en wordt de Arduino gereset. Ook als ik de power erop zet zonder USB kabel draait het programma voor een paar seconden, daarna wordt de Arduino gereset (daar lijkt het iig op).

Het maakt niet uit als ik de 5V van de externe voeding op de 5V van de Arduino zet. Wat WEL werkt is als ik een USB stekker pak (230VAC/5VDC) en deze aansluit op de Arduino. Dit duidt dus op een power issue. Maar hoe/wat, ik kan er met de kop niet bij! Iemand een idee?

Via google kom ik er ook niet achter: 10K weerstanden tussen RX/TX zoals ergens geopost werkt ook niet...

Edit: er zijn een aantal motoren die worden aangestuurd via een L298 (bidirectional motor driver). Het probleem doet zich alleen voor als de motoren van linksdraaiend in één keer naar rechtsdraaiend worden gezet. Als ik de motoren eerst stop en dan van draairichting verander werkt het allemaal wel. Ik denk dat er een magnetische puls oid wordt opgewekt die het zaakje verstoord. Geen idee alleen hoe ik het moet oplossen

[ Voor 19% gewijzigd door almightyarjen op 01-05-2013 11:52 ]

[foekie01]

almightyarjen schreef op woensdag 01 mei 2013 @ 10:19:
Het probleem doet zich alleen voor als de motoren van linksdraaiend in één keer naar rechtsdraaiend worden gezet. Als ik de motoren eerst stop en dan van draairichting verander werkt het allemaal wel.

Dit komt, zoals je zelf al zegt door de motoren. Je moet het zo zien: de motoren draaien naar links. De kracht van de motor is dus naar links gericht. Als je nu in één keer zegt dat ze naar rechts moeten draaien krijg je het volgende:

De motoren draaien naar links.
Jij zegt draait naar rechts.
De motoren willen naar rechts draaien
Doordat de motoren al naar links aan het draaien waren moeten de motoren veel kracht leveren om zichzelf af te remmen en naar rechts te draaien.
De motoren trekken daarom een heel hoog vermogen, waardoor je dus waarschijnlijk het vermogen zodanig weg neemt dat het arduino bordje te weinig krijgt en dus uit gaat en weer aan gaat als het vermogen weer minder is.

Dit is dus geen goed idee. Je zult ze eerst af moeten remmen en dan pas omschakelen.

[almightyarjen]

foekie01 schreef op woensdag 01 mei 2013 @ 14:05:
[...]


Dit komt, zoals je zelf al zegt door de motoren. Je moet het zo zien: de motoren draaien naar links. De kracht van de motor is dus naar links gericht. Als je nu in één keer zegt dat ze naar rechts moeten draaien krijg je het volgende:

De motoren draaien naar links.
Jij zegt draait naar rechts.
De motoren willen naar rechts draaien
Doordat de motoren al naar links aan het draaien waren moeten de motoren veel kracht leveren om zichzelf af te remmen en naar rechts te draaien.
De motoren trekken daarom een heel hoog vermogen, waardoor je dus waarschijnlijk het vermogen zodanig weg neemt dat het arduino bordje te weinig krijgt en dus uit gaat en weer aan gaat als het vermogen weer minder is.

Dit is dus geen goed idee. Je zult ze eerst af moeten remmen en dan pas omschakelen.

Klopt. Ik was er net zelf ook achter gekomen: ik zag dat het LCD knipperde tijdens het omdraaien van de polariteit van de motoren en realiseerde me dat de motoren alle vermogen wegtrokken Toch wel knap trouwens, de accu heeft een inhoud van 3,2Ah dus kan aardig wat vermogen leveren.

Je kan het oplossen door een condensator over de Vin en de GND van de Arduino te plaatsen. Maar het lijkt me beter om het zo te programmeren dat de motoren eerst stoppen voordat ze de andere kant opdraaien ivm accu levensduur...

[foekie01]

almightyarjen schreef op woensdag 01 mei 2013 @ 14:21:
[...]
Je kan het oplossen door een condensator over de Vin en de GND van de Arduino te plaatsen. Maar het lijkt me beter om het zo te programmeren dat de motoren eerst stoppen voordat ze de andere kant opdraaien ivm accu levensduur...

Klopt, je kunt de arduino bufferen, maar ik zou het inderdaad zo programmeren dat dit niet nodig hoeft te zijn

[almightyarjen]

Even een crosspost vanuit het Lego topic, een nieuw robot waar ik mee bezig ben (en waar de discussie hierboven over ging)

[ Voor 6% gewijzigd door almightyarjen op 02-05-2013 10:59 ]

[foekie01]

Ziet er grappig uit Maar waarom die moeite, de robot kan toch op de plaats draaien?

[almightyarjen]

Hij moet zich precies voor de koelkast positioneren om hem open te kunnen doen. Het erheen rijden gaat vrij ruw en hij kan er een 10cm naast komen te staan. Dan kan hij vervolgens zijwaarts naar de goede positie rijden om de de handgreep te pakken

[Mars Warrior]

ThinkPadd schreef op maandag 29 april 2013 @ 19:04:
Ah ik zat even niet op te letten. Had ze ook gezien met micro USB aansluiting

Ik bestel deze dan: [afbeelding]

http://www.ebay.com/itm/A...welry&hash=item2a27c2402b

Ik zat voor wat experimenten ook al op ebay te kijken naar wat goedkoop Nano spul.

De prijzen varieren van €8 tot €15 (incl. USB kabel, soms zelfs inclusief extra kabels) voor ogenschijnlijk identieke hardware (Iduino, Funduino, no-name).

Heeft iemand ervaring met deze varianten als het gaat om de kwaliteit?

[foekie01]

almightyarjen schreef op donderdag 02 mei 2013 @ 12:31:
Hij moet zich precies voor de koelkast positioneren om hem open te kunnen doen. Het erheen rijden gaat vrij ruw en hij kan er een 10cm naast komen te staan. Dan kan hij vervolgens zijwaarts naar de goede positie rijden om de de handgreep te pakken

Ah ok, dat verklaart

Wat zeg je van deze wielen?
http://www.nexusrobot.com/product.php?id_product=82

Mars Warrior schreef op donderdag 02 mei 2013 @ 12:59:
[...]

Ik zat voor wat experimenten ook al op ebay te kijken naar wat goedkoop Nano spul.

De prijzen varieren van €8 tot €15 (incl. USB kabel, soms zelfs inclusief extra kabels) voor ogenschijnlijk identieke hardware (Iduino, Funduino, no-name).

Heeft iemand ervaring met deze varianten als het gaat om de kwaliteit?

Wat heet kwaliteit? De PCB is misschien niet top kwaliteit en de componenten misschien ook niet. Ga je dit merken? Waarschijnlijk niet. Is het het waard om een officiële arduino te kopen? Naar mijn mening niet.

[Mars Warrior]

foekie01 schreef op donderdag 02 mei 2013 @ 13:26:
Wat heet kwaliteit? De PCB is misschien niet top kwaliteit en de componenten misschien ook niet. Ga je dit merken? Waarschijnlijk niet. Is het het waard om een officiële arduino te kopen? Naar mijn mening niet.

Top kwaliteit hoeft inderdaad niet, ik denk dat ik dat echt niet ga merken.
Maar omdat er eigenlijk maar een paar alternatieve merken zijn, vroeg ik me af of daar kwaliteitsverschil tussen zit, en dan waarschijnlijk voornamelijk met het solderen en/of het ontwerp (ontbreken diodes om maar iets te noemen waardoor kortsluiting op de USB/Externe voeding mogelijk is...).

En anders wordt het gewoon wat bestellen, paar weekjes wachten (of uit UK bestellen voor een paar € meer), en kijken hoe het eruit ziet

Zelfde geldt natuurlijk voor de NRF24L01+ break out bordjes. Die varieren in prijs van nog geen €2 tot wel €8, terwijl je aan de buitenkant geen enkel verschil kunt ontdekken. Is blijkbaar maar net wat een gek ervoor over heeft.

[almightyarjen]

foekie01 schreef op donderdag 02 mei 2013 @ 13:26:
[...]


Ah ok, dat verklaart

Wat zeg je van deze wielen?
http://www.nexusrobot.com/product.php?id_product=82

Daarvan zeg ik dat ze leuk zijn, maar niet officieel Lego: ik wil de robot wat betreft onderdelen all Lego houden. Daarnaast komen die omniwheels niet over het drempeltje (zie eerste video)

[foekie01]

Mars Warrior schreef op donderdag 02 mei 2013 @ 14:31:
[...]
Zelfde geldt natuurlijk voor de NRF24L01+ break out bordjes. Die varieren in prijs van nog geen €2 tot wel €8, terwijl je aan de buitenkant geen enkel verschil kunt ontdekken. Is blijkbaar maar net wat een gek ervoor over heeft.

Haha klopt. Grotendeels is het allemaal vergelijkbaar materiaal, ligt er alleen aan hoeveel de gek er voor geeft en hoeveel de gek er voor wilt hebben

[D-Three]

Iemand hier die al een Due gebruikt heeft? Eigenlijk zwaar overkill voor de zaken die ik er mee wil doen. Maar aangezien ik op dit moment nog geen enkel shield gevonden heb die aan mijn eisen voldoet (ik wil geen stapeltje shields), denk ik er aan een eigen shield te maken. En dan kan ik het beter onmiddellijk goed doen en de krachtigste Arduino nemen

[ Voor 7% gewijzigd door D-Three op 02-05-2013 22:20 ]

[almightyarjen]

D-Three schreef op donderdag 02 mei 2013 @ 22:19:
Iemand hier die al een Due gebruikt heeft? Eigenlijk zwaar overkill voor de zaken die ik er mee wil doen. Maar aangezien ik op dit moment nog geen enkel shield gevonden heb die aan mijn eisen voldoet (ik wil geen stapeltje shields), denk ik er aan een eigen shield te maken. En dan kan ik het beter onmiddellijk goed doen en de krachtigste Arduino nemen

De Due draait op 84MHz, heb je dat echt nodig? Het nadeel van de Due is dat die op 3,3V draait en daardoor niet makkelijk compatibel is met andere hardware. Als je aan 16MHz genoeg hebt zou ik voor een Mega gaan, die draait wel gewoon op 5V. De beslissing om voor een "grote" Arduino te gaan met veel I/O is een verstandige als je een eigen shield gaat maken, I/O is als geld: je kan er nooit te veel van hebben

[Sissors]

Even gegoogled, en in tegenstelling tot sommige andere ARM boards is the Due niet 5V tolerant, dus die moet je inderdaad echt op 3.3V draaien.

[D-Three]

Om het even te schetsen: mijn zwaarste toepassing draait op dit moment op een PIC16F877A op 10 MHz. Een Mega is pakweg 5 keer sneller dus ik veronderstel dat die voorlopig wel genoeg zou zijn. Maar qua prijs verschillen een Mega en een Due niet zoveel en dan is de extra power mooi meegenomen. Zeker omdat ik dan misschien meer werk kan laten afhandelen door het bord ipv door de PC en misschien zelfs standalone kan draaien. Eigenlijk wil ik het gebruiken op m'n werk als een soort van algemeen IO bordje. En als ik er effectief een shield voor zou maken dan maakt het niet echt uit dat het bord op 3V3 draait. Alleen kom ik dan waarschijnlijk in de problemen wanneer ik een andere shield wil proberen. Het is mij niet altijd duidelijk of een shield nu compatibel is of niet.

[ Voor 4% gewijzigd door D-Three op 02-05-2013 23:26 ]

[almightyarjen]

Staat de compabiliteit niet altijd vermeld dan, bij de shields?

[D-Three]

Neen. Maar voor zover ik begrepen heb, zouden goed ontwerpen shields wel compatibel moeten zijn. Die gebruiken namelijk de IOREF pin om te werken op de de spanning van het betreffende bord. Dus ik verwacht wel dat alle shields via de officiële site compatibel zijn.

[WVL_KsZeN]

Volgens mij zou je moeten kunnen zien of shields compatible zijn aan het versienummer, vanaf type 3 (even uit mn hoofd) zijn ze geloof ik 5/3.3V compatible... zoiets in ieder geval.. Bij niet officiële shields kun je natuurlijk alle kanten op

[Mars Warrior]

foekie01 schreef op donderdag 02 mei 2013 @ 16:54:
[...]
Haha klopt. Grotendeels is het allemaal vergelijkbaar materiaal, ligt er alleen aan hoeveel de gek er voor geeft en hoeveel de gek er voor wilt hebben

Bij nader inzien / navragen is het toch iets genuanceerder: als je groot inkoopt (200/500/1000) krijg je andere prijzen. Kan zomaar de helft of meer schelen. En als je dan als webshop eigenaar niet de volledige korting doorberekend, dan verdien je netto nog meer ook

Dus dan krijg je zo prijsverschillen van 10 modules voor €15 of €25, voor exact dezelfde tranceiver...

Een collega waarschuwde overigens nog voor de Arduino micro's op ebay. Die zouden een 32U4 moeten hebben, maar alle 5 zijn micro's van een aantal verschillende leveranciers hadden of een 328 of zelfs een 168 erop zitten. In een aantal gevallen ook nog eens zonder bootloader
Om negatieve beoordelingen te ontlopen kreeg hij ze voor €3. Koopje natuurlijk, maar niet wat hij wilde...

[ Voor 0% gewijzigd door Mars Warrior op 03-05-2013 22:16 . Reden: 328 ipv 324 ]

[D-Three]

Vrijdag even een paar van die bordjes getoond aan een projectleider met de vraag of het interessant zou zijn om daar eens iets mee te proberen. Antwoord is dat de prijs geen issue is en dat ik er gerust een paar mag bestellen, dat ging vlotter dan ik hoopte De vraag was uiteraard wel hoeveel tijd ik daar ging in steken. Maar als ik al gratis (als in niet zelf betalen ) wat speelgoed kan krijgen, offer ik gerust wel wat privé tijd op

Iemand een idee of ik een gelijkaardig shield als hieronder kan krijgen bij een grote europese shop zoals rs of farnell? Is gemakkelijker bestellen. Ik heb al zitten zoeken maar niet direct iets gelijkaardig gevonden.
https://shop.ruggedcircui...fo&cPath=4&products_id=14

edit:
Waarschijnlijk bestel ik die dan zelf, ik vrees dat het een te grote rompslomp wordt om dit doorheen de ganse administratie te krijgen. Het grote voordeel aan deze motordriver is de grotere stromen die dit bord kan leveren ten opzichte van andere gemakkelijk vekrijgbare borden. En dat de trappen apart aan te sturen zijn (geen step/dir) waardoor je niet beperkt bent tot enkel stappenmotoren. Het volgende is dan een eigen shield maken met waarschijnlijk nog sterkere drivers

[ Voor 27% gewijzigd door D-Three op 06-05-2013 10:53 ]

[Raven]

Dacht ik een mooi Arduino UPS schakelingetje in elkaar geMacGyverd te hebben, heeft het relay bij het uitschakelen te veel tijd nodig om om te schakelen

[D-Three]

Sneller detecteren en sneller schakelen hé Solid state relais nemen? Wat wil je precies schakelen?

[mcDavid]

En/of een dikke elco erbij

[Raven]

Heb er al een 10.000µF C aan hangen , die is zo te zien groot genoeg om de dip bij het inschakelen op te vangen, helaas gaat het uitschakelen van het relais niet zo snel als het inschakelen.

Er moet tussen 2 voedingen geschakeld worden. Wanneer er spanning is (9vDC adapter), dan moet de adapter met de Arduino verbonden zijn, valt die weg, schakelt het relais uit en wordt er een 8*AAA battery-pack met de Arduino verbonden. Dat werkt prima, op het niet snel genoeg uitschakelen van het relais na dan

SSR's heb ik naar gekeken, kan niet zo gauw een SPDT variant vinden die inschakelt dmv 9v eraan te hangen.

[D-Three]

Maak je gebruik van een flybackdiode?

[ThinkPad]

Mars Warrior schreef op donderdag 02 mei 2013 @ 12:59:
[...]

Ik zat voor wat experimenten ook al op ebay te kijken naar wat goedkoop Nano spul.

De prijzen varieren van €8 tot €15 (incl. USB kabel, soms zelfs inclusief extra kabels) voor ogenschijnlijk identieke hardware (Iduino, Funduino, no-name).

Heeft iemand ervaring met deze varianten als het gaat om de kwaliteit?

Heb hem eergister binnengekregen en hij werkt prima hoor. De USB kabel doet het alleen niet (meer) volgens mij. Maar daar had ik al een andere voor liggen van m'n Duemilanove (ook van eBay btw).

Kon de code van m'n Duemilanove project zo 1:1 overzetten op de Nano (heeft ook een 328).

Vind wel dat de spanningsregelaar die erop zit redelijk warm wordt, maar dat ligt er waarschijnlijk aan dat de ENC28J60 ethernet module redelijk wat stroom gebruikt.

[Mars Warrior]

ThinkPadd schreef op donderdag 09 mei 2013 @ 00:04:
[...]

Heb hem eergister binnengekregen en hij werkt prima hoor. De USB kabel doet het alleen niet (meer) volgens mij. Maar daar had ik al een andere voor liggen van m'n Duemilanove (ook van eBay btw).

Kon de code van m'n Duemilanove project zo 1:1 overzetten op de Nano (heeft ook een 328).

Vind wel dat de spanningsregelaar die erop zit redelijk warm wordt, maar dat ligt er waarschijnlijk aan dat de ENC28J60 ethernet module redelijk wat stroom gebruikt.

Mijn IDuino's zijn nog onderweg en die komen voor een deel op een Nano shield - met eigen voeding - waar ik ook de overige zooi op kan aansluiten. Ik heb al eens oververhitte Nano's gehad nl. Doordat ik ff geen rekening had gehouden met het totale stroomverbruik...

Overigens wel snel, die bestelling van jou!

[Raven]

D-Three schreef op woensdag 08 mei 2013 @ 23:58:
Maak je gebruik van een flybackdiode?

Nope. Die wordt aldus Google gebruikt om een transistor te beschermen waarmee het relay geschakeld wordt, ik maak geen gebruik van een transistor, relay zit rechtstreeks op de voeding aangesloten

---

* Raven is een idioot en doet

bij zichzelf

Heb net het breadboardje er bij gepakt en nog eens goed naar het gedrag van de schakeling gekeken. Wat blijkt nou, iets dat ik net heb bevestigd in Multisim: wanneer het relay ingeschakeld is en daarna geen voeding meer krijgt, is het voor het relay mogelijk om gevoed te worden door de condensator. Er loopt dan vanaf de C, via een R en door het relay een stroom naar de voedingsaansluiting van het relay.

Daarom duurde het uitschakelen zo lang Straks eens op het breadboardje uitproberen.

[ Voor 47% gewijzigd door Raven op 09-05-2013 10:13 ]

[Piepersnijder]

Raven schreef op donderdag 09 mei 2013 @ 09:29:
[...]

Nope. Die wordt aldus Google gebruikt om een transistor te beschermen waarmee het relay geschakeld wordt, ik maak geen gebruik van een transistor, relay zit rechtstreeks op de voeding aangesloten

Ik zou wel een diode gebruiken.




Hierdoor zal het relais eerder afvallen.omdat deze niet gebufferd word door de condensator.

edit: Je was me net voor

[D-Three]

Ah, ok, ik dacht dat de detectie en het schakelen door de arduino gedaan werd. Ik zou het alweer moeilijker maken dan nodig De oplossing is dan inderdaad een diode op de juiste plaats zoals Piepersnijder al zei.

In feite zou je het ook kunnen oplossen zonder relais door de batterij gewoon parallel op de voeding te plaatsen met een diode in sper ten opzichte van de voeding. Dan mag de batterijspanning uiteraard niet hoger zijn dan de voedingsspanning! De batterij zal dan automatisch zijn werk beginnen doen als de voeding lager zakt dan 0,6 à 0,7 V onder de batterijspanning. Dan heb je dat relais en die grote elco niet nodig. Best dan ook nog een diode plaatsen in de voeding die van de adapter komt.

[ Voor 56% gewijzigd door D-Three op 09-05-2013 10:42 ]

[foekie01]

Even een vraag van mijn kant: heeft er iemand van jullie al eens een plugin software architectuur gebouwd met arduino?

Ik zit te denken aan een open source project waar mensen zelf sensoren toe kunnen voegen aan de software. Tot mijn verbazing bracht google-en niet echt veel.

Of moet ik gewoon niet moeilijk doen en een RTOS gebruiken?

[Mars Warrior]

foekie01 schreef op donderdag 09 mei 2013 @ 11:39:
Even een vraag van mijn kant: heeft er iemand van jullie al eens een plugin software architectuur gebouwd met arduino?

Ik zit te denken aan een open source project waar mensen zelf sensoren toe kunnen voegen aan de software. Tot mijn verbazing bracht google-en niet echt veel.

Of moet ik gewoon niet moeilijk doen en een RTOS gebruiken?

Ik snap denk ik niet helemaal wat je nu wilt / bedoelt, maar het klinkt behoorlijk als overkill / comp,ex op een 8-bit controllertje.

Er zijn RTOSsen meen ik op Arduino, maar dan wel heel beperkt.
Aan de andere kant zijn de semi pre-emptive libs wel aanwezig, waar je redelijk onafhankelijke threads / tasks mee kunt maken die in een lusje worden aangeroepen.
Zo kun je 'taakjes' maken die speciefieke sensoren afhandelen, maar dan? Leuk voor hergebruik natuur
Ijk, maar je moet nog steeds weren wat je aan het doen bent, en het wordt er. Niet eenvoudiger op, iets wat toch wel de algemene tendens van sketches is: simpel!

[D-Three]

Ik snap de vraag niet zo goed, hoe wil je plug-ins toepasssen op een Arduino?

[almightyarjen]

Raven schreef op donderdag 09 mei 2013 @ 09:29:
[...]

Nope. Die wordt aldus Google gebruikt om een transistor te beschermen waarmee het relay geschakeld wordt, ik maak geen gebruik van een transistor, relay zit rechtstreeks op de voeding aangesloten

Maar je hebt toch "iets" nodig om het relais te schakelen? Of schakel je hem via een I/O pin van de Arduino? (trekt volgens mij te veel stroom) Either case: je zet dat relais ergens mee aan en dat gebeurt door een transistor, hetzij extern, hetzij binnen in de ATmega chip en in beide gevallen dien je er dan een diode overheen te plaatsen...

[Raven]

Dat "iets" is gewoon de voeding die rechtstreeks op het relay zit aangesloten

Stroom op het stopcontact aanwezig, AC->9vDC adapter werkt, relay gaat aan.
Stroom op het stopcontact afwezig, AC->9vDC adapter werkt niet, relay gaat uit.

[ Voor 50% gewijzigd door Raven op 09-05-2013 17:28 ]

[almightyarjen]

Ah achso, dat stukje had ik ff gemist

[mcDavid]

Kun je trouwens niet gewoon twee diodes plaatsen tussen de accu en adapter? Dan pakt'ie gewoon altijd de bron die de hoogste spanning geeft toch?

[ThinkPad]

Je zou ook volgens het online UPS principe kunnen werken.

Je sluit een lader aan op je accu, en je Arduino hang je gewoon aan je accu. Lader kan ook heel simpel zijn, voor een gelaccu gewoon een LM317 pakken en die afregelen op constant voltage van 13,8V. Kun je hem er eeuwig aan laten hangen (druppelladen), en een LM317 is toch begrensd op max. 1,5A dus extreem hoge laadstromen zul je ook niet krijgen.

En als je terugkoppeling wilt naar de Arduino kan het inderdaad met een relais die je door je adapter laat voeden, en die open/dicht gaat wanneer stroom afvalt en daardoor een signaal geeft aan de Arduino. Ik denk echter dat je qua efficiëntie beter een optocoupler kunt pakken.

[ Voor 25% gewijzigd door ThinkPad op 09-05-2013 23:11 ]

[Raven]

Maar dan wordt de accu toch continu belast? En heb hier een batterijhouder met 8 AAAtjes, geen gelaccu.

mcDavid schreef op donderdag 09 mei 2013 @ 21:25:
Kun je trouwens niet gewoon twee diodes plaatsen tussen de accu en adapter? Dan pakt'ie gewoon altijd de bron die de hoogste spanning geeft toch?

Laat dat nou de batterypack zijn

[ThinkPad]

Als je accu vol is dan verzorgt de lader gewoon de stroom

Gelaccu's zijn ook niet zo duur, en worden in alarmcentrales e.d. ook op deze manier gebruikt.

6 volt model (al is dat misschien net wat te weinig voor de Arduino)
http://www.baco-army-good...el-accu-6volt-1-2amp.html

12 volt model:
http://www.baco-army-good...gel-accu-12volt-1-3a.html

Al zou je je AAA's ook kunnen vervangen door oplaadbare... maar ik weet niet zeker of je die ook 24/7 kunt laten druppelladen.

[ Voor 80% gewijzigd door ThinkPad op 09-05-2013 23:25 ]

[foekie01]

D-Three schreef op donderdag 09 mei 2013 @ 12:47:
Ik snap de vraag niet zo goed, hoe wil je plug-ins toepasssen op een Arduino?

Nou mijn idee was om een projectje te maken met sensoren.

Omdat ieder mens weer andere sensoren heeft/wilt gebruiken zou het fijn zijn als je zelf even een kleine "plugin" kon schrijven voor die betreffende sensor en die kunnen ze dan met andere mensen delen.

Maar misschien is het gewoon beter om een SVN/GIT te gebruiken waar mensen eigen gemaakte dingen aan de library toe kunnen voegen?

[mcDavid]

Raven schreef op donderdag 09 mei 2013 @ 23:13:

[...]

Laat dat nou de batterypack zijn

Andere voeding/accu combi kiezen dan

foekie01 schreef op vrijdag 10 mei 2013 @ 11:29:
[...]


Nou mijn idee was om een projectje te maken met sensoren.

Omdat ieder mens weer andere sensoren heeft/wilt gebruiken zou het fijn zijn als je zelf even een kleine "plugin" kon schrijven voor die betreffende sensor en die kunnen ze dan met andere mensen delen.

Maar misschien is het gewoon beter om een SVN/GIT te gebruiken waar mensen eigen gemaakte dingen aan de library toe kunnen voegen?

Voor vrijwel ieder type sensor bestaat inmiddels wel een library of iets dergelijks om ze aan te spreken. En zo niet kun je die inderdaad zelf schrijven.

[ThinkPad]

He verdorie.... dacht ik m'n Arduino project klaar te hebben, blijkt dat na een tijdje de Arduino z'n netwerkverbinding verliest

Ik gebruik de ENC28J60. Viel me sowieso al op dat het dingetje redelijk wat stroom verbruikt (200mA), en dat hij ook redelijk warm wordt. Maar dat schijnt volgens reacties op internet normaal te zijn.

Het Arduino programma loopt wel gewoon door (de rode LED blijft knipperen), maar de internetpagina van de Arduino is niet meer te bereiken

Dit is mijn code: http://pastebin.com/DhU5Fana

Ligt dit aan een bug in de code, of misschien toch aan de hardware?

[Hans1990]

Kan je je device nog wel pingen? (op je static IP natuurlijk)

Misschien dat de TCP stack vastloopt oid. Echter wordt die EtherCard library volgens mij best veel gebruikt, dus opmerkelijk...
Het is ook niet zo dat na een x aantal requests de Arduino vastloopt?

ENC28J60 wordt idd wel wat warm. Die chip lust ook zeker wel wat power.. niet ongewoon voor ethernet controllers ofzo.

[foekie01]

mcDavid schreef op vrijdag 10 mei 2013 @ 11:36:
Voor vrijwel ieder type sensor bestaat inmiddels wel een library of iets dergelijks om ze aan te spreken. En zo niet kun je die inderdaad zelf schrijven.

Misschien een idee om dan een aantal sensoren toe te voegen van bijvoorbeeld temperatuur sensoren. Dan een enum in een controller klasse maken waarmee je je gewenste sensor kiest en dan vervolgens met die sensor werken?

Hoe zou(den) jij/jullie dat doen?

[Mars Warrior]

foekie01 schreef op vrijdag 10 mei 2013 @ 13:37:
[...]
Misschien een idee om dan een aantal sensoren toe te voegen van bijvoorbeeld temperatuur sensoren. Dan een enum in een controller klasse maken waarmee je je gewenste sensor kiest en dan vervolgens met die sensor werken?

Hoe zou(den) jij/jullie dat doen?

Het is te doen hoor, maar het blijft lastig in de zin van dat als je meerdere temperatuursensoren hebt aangesloten, je deze toch moet configureren (pin nummer, 1-wire adres, etc).
Zeker in het geval van een rijtje 1-wire sensoren, krijg je over 1 verbinding dus meerdere sensoren binnen, en dan is de vraag welk adres hoort nu bij welke sensor die je verder wilt gebruiken??

Wat ik wel eens heb uitgeprobeerd is:

• Maak een vast lijstje van generieke sensoren (analoge / digitale waarde)
• Elke sensor is van een bepaald type (enum)
• Elke sensor krijgt een enum met 'zijn' driver die de waarde ophaalt
• Lijstje met drivers met hun eigen enum
• Driver is dus bijv. een stukje code die de analoge waarde inleest en is geconfigureerd dat dit op poort x zit
• Sensoren en drivers koppelen

Zo moet nog wel elke driver worden aangeroepen om de sensorwaarde te vullen.

Echt vanzelf en simpel gaat het dus niet, maar voor simpele analoge en digitale waarde op een Arduino pin is het wel degelijk goed te doen.

[ Voor 3% gewijzigd door Mars Warrior op 10-05-2013 20:38 ]

[ThinkPad]

Hans1990 schreef op vrijdag 10 mei 2013 @ 12:59:
Kan je je device nog wel pingen? (op je static IP natuurlijk)

Misschien dat de TCP stack vastloopt oid. Echter wordt die EtherCard library volgens mij best veel gebruikt, dus opmerkelijk...
Het is ook niet zo dat na een x aantal requests de Arduino vastloopt?

ENC28J60 wordt idd wel wat warm. Die chip lust ook zeker wel wat power.. niet ongewoon voor ethernet controllers ofzo.

Hij krijgt in de huidige setup geen/weinig requests, dus dat is het probleem niet. Op ping reageert hij ook niet meer dan.

Gebeurt na een minuut of 5

Het lijkt wel alsof de ENC28J60 in die toestand is uitgeschakeld o.i.d., het stroomverbruik is dan nog maar 0,04A bij 11.98V. Als de ENC28J60 nog wel werkt dan is het stroomverbruik 0,20A bij 11.98V

Edit: Het heeft wel iets met de voeding te maken, met een 9V adapter heb ik na meer dan een halfuur nogsteeds geen problemen. Weird... Die 12V voeding is m'n labvoeding namelijk. Eens proberen als ik die op 9V instel...

[ Voor 26% gewijzigd door ThinkPad op 11-05-2013 21:16 ]

[darklord007]

zijn er hier mensen die een alternatieve IDE gebruiken?
Of gebruikt iedereen de standaard IDE?

[Hillman5100]

Eclipse i.c.m. de AVR plugin is wel een goede.

Of Atmel studio dat werkt ook

[Kaalus]

Atmel Studio heb ik laatst geprobeerd maar dat had teveel voeten in de aarde om werkend te krijgen. Omdat ik toch al Visual Studio had heb ik daarvoor een plugin geinstaleerd. Die werkt een stuk beter voor mijn gevoel al heb ik er nog niet heel veel mee gedaan, komt deze week wel

Plugin is hier te vinden: http://www.visualmicro.co...25-446f-9fcf-282c3e0e9dc6
Zou ook moeten werken Werkt dus niet met Visual Studio Express, wel met de gratis Atmel Studio welke op die manier makkelijk op gang te krijgen is voor Arduino.

[ Voor 11% gewijzigd door Kaalus op 12-05-2013 21:11 ]

[naaitsab]

Werkt dat een beetje in Visual Studio ? Die debugger van Arduino heb je meestal vrij weinig aan als er iets niet klopt in je code.

[Kaalus]

Moet het nog testen, maar het ziet er veelbelovend uit vind ik. De opties e.d. van Visual Studio maar wel snel je board en com poort kiezen zoals in de IDE van Arduino. Beste van twee werelden als je het mij vraagt

[foekie01]

naaitsab schreef op zondag 12 mei 2013 @ 21:18:
Werkt dat een beetje in Visual Studio ? Die debugger van Arduino heb je meestal vrij weinig aan als er iets niet klopt in je code.

Die plugin is wat mij betreft lekker handig. Werkt super in de vertrouwde VS2012 omgeving.
De debugger heb ik zelf nog niet geprobeerd. Staat nog op mijn lijst om te proberen.

[Icekiller2k6]

Heeft iemand al snel geheugen geinterfaced met een arduino? (~70ns )

[Mars Warrior]

@foekie01: Kijk eens naar deze library.
Komt denk ik aardig in de buurt van wat jij wilt:
- Ondersteuning van verschillende sensoren
- Extern configureerbaar per I/O pin

Zit qua opzet dicht in de buurt van wat ik eerder aangaf, maar is daarboven op configureerbaar. Oftewel de gebruiker koppelt een sensor op I/O pin x, en configureer vervolgens via de seriele poort deze sensor!

[ Voor 31% gewijzigd door Mars Warrior op 13-05-2013 16:46 ]

[foekie01]

Mars Warrior schreef op maandag 13 mei 2013 @ 16:43:
@foekie01: Kijk eens naar deze library.
Komt denk ik aardig in de buurt van wat jij wilt:
- Ondersteuning van verschillende sensoren
- Extern configureerbaar per I/O pin

Zit qua opzet dicht in de buurt van wat ik eerder aangaf, maar is daarboven op configureerbaar. Oftewel de gebruiker koppelt een sensor op I/O pin x, en configureer vervolgens via de seriele poort deze sensor!

Enorm bedankt voor beide reacties! Ik moet deze week even een project afronden en daarna heb ik tijd om er naar te kijken! Nogmaals bedankt!