Posts | Comments

Planet Arduino

Archive for the ‘seeedstudio’ Category

Lug
21

Visual report from Maker Faire Shenzhen

china, Featured, Genuino, Maker Faire, Maker Faire Shenzhen, MakerFaire, seeedstudio Commenti disabilitati su Visual report from Maker Faire Shenzhen 

gallery1

Arduino/Genuino team were in China last month to be part of Shenzhen Maker Faire and present to local makers the new Genuino boards, together with Seeedstudio. They  also had the pleasure to meet with Arduino users, teachers, students and makers of all ages with great skills.
Here’s a selection of pictures form those amazing days (all the pictures are on our Flickr).

Thanks to all the people visiting our booth and warmly welcoming us in China!

gallery9 gallery8 gallery7 gallery6 gallery5 gallery4 gallery3 gallery2 gallery1 gallery0 Gallery10 Gallery11 Gallery12 Gallery13 Gallery14
Giu
23

Watch Makezine’s interview with Massimo Banzi and Eric Pan

arduino, Featured, Genuino, Hardware, Interview, Maker Faire Shenzhen, Makezine, manufacturing, seeedstudio Commenti disabilitati su Watch Makezine’s interview with Massimo Banzi and Eric Pan 

Seeed_post

According to Make, the biggest news coming out of Maker Faire Shenzhen, outside the size and intensity of the event itself, was the partnership involving our team at Arduino and SeeedStudio.  Massimo Banzi during his talk presented Arduino boards using the new sister brand Genuino which will be made in China by Seeedstudio.

Dale Dougherty was in Shenzhen with them and did this video interview and article:

Giu
20

Arduino and Seeedstudio announce partnership in Shenzhen

Announcements, arduino, china, Featured, Genuino, Hardware, manufacturing, open source, Partnership, seeedstudio Commenti disabilitati su Arduino and Seeedstudio announce partnership in Shenzhen 

SEEDGenuinoLow

Today, June 20th, 2015, Massimo Banzi, Co-founder of Arduino, and Eric Pan, founder and CEO of Seeedstudio announced at Maker Faire Shenzhen 2015 a strategic partnership between Arduino LLC and Seeedstudio.

Seeedstudio will manufacture and distribute Arduino LLC products using the new Genuino brand in China and other Asian markets.

The new Genuino name certifies the authenticity of boards, in line with the open hardware and open source philosophy that has always characterized Arduino. Genuino is Arduino LLC new sister-brand created by co-founders Massimo Banzi, David Cuartielles, Tom Igoe and David Mellis for markets outside of the USA.

“We are very excited to partner with SeeedStudio to manufacture our products in China. We’ve known and appreciated Seeed for years, we share the same values and I think they are one of the most forward looking companies in China” said Massimo Banzi.

And he also explained about Genuino: “Arduino is very popular in China but the brand is used heavily without permission. Genuino allows the market to clearly identify which products are contributing to the Open Source Hardware process. With Genuino, the Arduino.cc community will easily be able to recognize the partners who are contributing to support the development of the platform.”

Eric Pan, founder of Seeedstudio, explained: “Arduino is becoming a global language of making, we are proud to help provide Genuino branded localized products to carry on the conversation in China. Here we already have a huge Arduino user base and growing, it’s time to get us involved deeper with global ecosystem. “

Genuino-branded products will be sold on Seeed’s store on Taobao and soon on http://www.genuino.cc.

The partnership between Arduino LLC and Seeedstudio is a bold new step of a global development plan by Arduino LLC. Arduino LLC has recently launched the Genuino brand and is already working with market-leading, innovative manufacturers/distributors in Asia, Europe, South America, Canada and Africa.

Genuino UNO - Front Genuino UNO - Back Genuino MICRO - front Genuino MICRO - back Genuino MEGA - front Genuino MEGA - back
Nov
19

Arduino Tutorials – Chapter 15 – RFID

125 kHz, access, arduino, EM4100, lesson, RDM630, rfid, RFR101A1M, RFR103B2B, seeedstudio, system, tronixstuff, TTL, tutorial Commenti disabilitati su Arduino Tutorials – Chapter 15 – RFID 

Learn how to use RFID readers with your Arduino. In this instalment we use an RDM630 or RDM6300 RFID reader. If you have an Innovations ID-12 or ID-20 RFID reader, we have a different tutorial for you.

This is chapter fifteen of our huge Arduino tutorial seriesUpdated 19/11/2013

Introduction

RFID – radio frequency identification. Some of us have already used these things, and they have become part of everyday life. For example, with electronic vehicle tolling, door access control, public transport fare systems and so on. It sounds complex – but isn’t.

To explain RFID for the layperson, we can use a key and lock analogy. Instead of the key having a unique pattern, RFID keys hold a series of unique numbers which are read by the lock. It is up to our Arduino sketch to determine what happens when the number is read by the lock.  The key is the tag, card or other small device we carry around or have in our vehicles. We will be using a passive key, which is an integrated circuit and a small aerial. This uses power from a magnetic field associated with the lock. Here are some key or tag examples:

Arduino RFID tags

In this tutorial we’ll be using 125 kHz tags – for example. To continue with the analogy our lock is a small circuit board and a loop aerial. This has the capability to read the data on the IC of our key, and some locks can even write data to keys. Here is our reader (lock) example:

Seeedstudio RFID reader Arduino

These readers are quite small and inexpensive – however the catch is that the loop aerial is somewhat fragile. If you need something much sturdier, consider the ID20 tags used in the other RFID tutorial.

Setting up the RFID reader

This is a short exercise to check the reader works and communicates with the Arduino. You will need:

Simply insert the RFID reader main board into a solderless breadboard as shown below. Then use jumper wires to connect the second and third pins at the top-left of the RFID board to Arduino 5V and GND respectively. The RFID coil connects to the two pins on the top-right (they can go either way). Finally, connect a jumper wire from the bottom-left pin of the RFID board to Arduino digital pin 2:

Arduino RFID reader setup

Next, upload the following sketch to your Arduino and open the serial monitor window in the IDE:

#include <SoftwareSerial.h>
SoftwareSerial RFID(2, 3); // RX and TX

int i;

void setup()
{
  RFID.begin(9600);    // start serial to RFID reader
  Serial.begin(9600);  // start serial to PC 
}

void loop()
{
  if (RFID.available() > 0) 
  {
     i = RFID.read();
     Serial.print(i, DEC);
     Serial.print(" ");
  }
}

If you’re wondering why we used SoftwareSerial – if you connect the data line from the RFID board to the Arduino’s RX pin – you need to remove it when updating sketches, so this is more convenient.

Now start waving RFID cards or tags over the coil. You will find that they need to be parallel over the coil, and not too far away. You can experiment with covering the coil to simulate it being installed behind protective surfaces and so on. Watch this short video which shows the resulting RFID card or tag data being displayed in the Arduino IDE serial monitor.

As you can see from the example video, the reader returns the card’s unique ID number which starts with a 2 and ends with a 3. While you have the sketch operating, read the numbers from your RFID tags and note them down, you will need them for future sketches.

To do anything with the card data, we need to create some functions to retrieve the card number when it is read and place in an array for comparison against existing card data (e.g. a list of accepted cards) so your systems will know who to accept and who to deny. Using those functions, you can then make your own access system, time-logging device and so on.

Let’s demonstrate an example of this. It will check if a card presented to the reader is on an “accepted” list, and if so light a green LED, otherwise light a red LED. Use the hardware from the previous sketch, but add a typical green and red LED with 560 ohm resistor to digital pins 13 and 12 respectively. Then upload the following sketch:

#include <SoftwareSerial.h>
SoftwareSerial RFID(2, 3); // RX and TX

int data1 = 0;
int ok = -1;
int yes = 13;
int no = 12;

// use first sketch in http://wp.me/p3LK05-3Gk to get your tag numbers
int tag1[14] = {2,52,48,48,48,56,54,66,49,52,70,51,56,3};
int tag2[14] = {2,52,48,48,48,56,54,67,54,54,66,54,66,3};
int newtag[14] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // used for read comparisons

void setup()
{
  RFID.begin(9600);    // start serial to RFID reader
  Serial.begin(9600);  // start serial to PC 
  pinMode(yes, OUTPUT); // for status LEDs
  pinMode(no, OUTPUT);
}

boolean comparetag(int aa[14], int bb[14])
{
  boolean ff = false;
  int fg = 0;
  for (int cc = 0 ; cc < 14 ; cc++)
  {
    if (aa[cc] == bb[cc])
    {
      fg++;
    }
  }
  if (fg == 14)
  {
    ff = true;
  }
  return ff;
}

void checkmytags() // compares each tag against the tag just read
{
  ok = 0; // this variable helps decision-making,
  // if it is 1 we have a match, zero is a read but no match,
  // -1 is no read attempt made
  if (comparetag(newtag, tag1) == true)
  {
    ok++;
  }
  if (comparetag(newtag, tag2) == true)
  {
    ok++;
  }
}

void readTags()
{
  ok = -1;

  if (RFID.available() > 0) 
  {
    // read tag numbers
    delay(100); // needed to allow time for the data to come in from the serial buffer.

    for (int z = 0 ; z < 14 ; z++) // read the rest of the tag
    {
      data1 = RFID.read();
      newtag[z] = data1;
    }
    RFID.flush(); // stops multiple reads

    // do the tags match up?
    checkmytags();
  }

  // now do something based on tag type
  if (ok > 0) // if we had a match
  {
    Serial.println("Accepted");
    digitalWrite(yes, HIGH);
    delay(1000);
    digitalWrite(yes, LOW);

    ok = -1;
  }
  else if (ok == 0) // if we didn't have a match
  {
    Serial.println("Rejected");
    digitalWrite(no, HIGH);
    delay(1000);
    digitalWrite(no, LOW);

    ok = -1;
  }
}

void loop()
{
  readTags();
}

In the sketch we have a few functions that take care of reading and comparing RFID tags. Notice that the allowed tag numbers are listed at the top of the sketch, you can always add your own and more – as long as you add them to the list in the function checkmytags() which determines if the card being read is allowed or to be denied.

The function readTags() takes care of the actual reading of the tags/cards, by placing the currently-read tag number into an array which is them used in the comparison function checkmytags(). Then the LEDs are illuminated depending on the status of the tag at the reader. You can watch a quick demonstration of this example in this short video.

 

Conclusion

After working through this chapter you should now have a good foundation of knowledge on using the inexpensive RFID readers and how to call functions when a card is successfully read. For example, use some extra hardware (such as an N-MOSFET) to control a door strike, buzzer, etc. Now it’s up to you to use them as a form of input with various access systems, tracking the movement of people or things and much more.

And if you enjoyed the tutorial, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

tronixstuff

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

The post Arduino Tutorials – Chapter 15 – RFID appeared first on tronixstuff.

Introduction

In this article we examine the Seeedstudio ”Bluetooth Bee“ modules and how they can be used in a simple way in conjunction with Android devices to control the Arduino world.  Here is an example of a Bluetooth Bee:

For the curious, the hardware specifications are as follows:

  • Typical -80dBm sensitivity
  • Up to +4dBm RF transmit power
  • Fully Qualified Bluetooth V2.0+EDR 3Mbps Modulation
  • Low Power 1.8V Operation, 1.8 to 3.6V I/O
  • UART interface with programmable baud rate
  • Integrated PCB antenna.
  • XBee compatible headers

You may have noticed that the Bluetooth Bee looks similar to the Xbee-style data transceivers – and it is, in physical size and some pinouts, for example:

The neat thing with the BtB (Bluetooth Bee) is that it is compatible with Xbee sockets and Arduino shields. It is a 3.3V device and has the same pinouts for Vcc, GND, TX and RX – so an existing Xbee shield will work just fine.

In some situations you may want to use your BtB on one UART and have another for debugging or other data transport from an Arduino – which means the need for a software serial port. To do this you can get a “Bees Shield” which allows for two ‘Bee format transceivers on one board, which also has jumpers to select software serial pins for one of them. For example:

Although not the smallest, the Bees Shield proves very useful for experimenting and busy wireless data transmit/receive systems. More about the Bees Shield can be found on their product wiki.

Quick Start 

In the past many people have told me that bluetooth connectivity has been too difficult or expensive to work with. In this article I want to make things as simple as possible, allowing you to just move forward with your ideas and projects. One very useful function is to control an Arduino-compatible board with an Android-based mobile phone that has Bluetooth connectivity. Using the BtB we can create a wireless serial text bridge between the phone and the Arduino, allowing control and data transmission between the two.

We do this by using a terminal application on the Android device – for our examples we will be using “BlueTerm” which can be downloaded from Google Play – search for “blueterm” as shown below:

In our Quick Start example, we will create a system where we can turn on or off four Arduino digital output pins from D4~D7. (If you are unsure about how to program an Arduino, please consider this short series of tutorials). The BtB is connected using the Bees shield. This is based on the demonstration sketch made available on the BtB Wiki page - we will use commands from the terminal on the Android device to control the Arduino board, which will then return back status.

As the BtB transmit and receive serial data we will have it ‘listen’ to the virtual serial port on pins 9 and 10 for incoming characters. Using a switch…case function it then makes decisions based on the incoming character. You can download the sketch from here. It is written for Arduino v23. If you were to modify this sketch for your own use, study the void loop() section to see how the incoming data is interpreted, and how data is sent back to the Android terminal using blueToothSerial.println

Before using it for the first time you will need to pair the BtB with your Android device. The PIN is set to a default of four zeros. After setting up the hardware and uploading the sketch, wait until the LEDs on the BtB blink alternately – at this point you can get a connection and start communicating. In the following video clip you can see the whole process:


Where to from here?

There are many more commands that can be set using terminal software from a PC with a Bluetooth adaptor, such as changing the PIN, device name and so on. All these are described in the BtB Wiki page along with installation instructions for various operating systems.

Once again I hope you found this article interesting and useful. The Bluetooth Bees are an inexpensive and useful method for interfacing your Arduino to other Bluetooth-compatible devices. For more information and product support, visit the Seeedstudio product pages.

Bluetooth Bees are available from Seeedstudio and their network of distributors.

Disclaimer - Bluetooth Bee products used in this article are promotional considerations made available by Seeedstudio.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

The post Arduino, Android and Seeedstudio Bluetooth Bee appeared first on tronixstuff.

Apr
28

Kit Review – Seeedstudio Electronic Brick Starter Kit

arduino, education, kit review, LCD, learning electronics, microcontrollers, seeedstudio Commenti disabilitati su Kit Review – Seeedstudio Electronic Brick Starter Kit 

Hello readers and friends!

Time for another kit review. Well, perhaps not a kit, but an educational system designed for a beginner to start doing things, fun and educational things, with an Arduino. From the wacky people at Seeedstudio comes their “Electronic Brick” Starter Kit. What on earth could this be all about, you ask?

Imagine a system of components, that connect together easily, can be reused, to work with an Arduino Duemilanove or compatible – allowing you to experiment, learn and rapid prototype projects with ease and safety… This is it. Sort of like electronic lego for arduino!

Let’s have a look…

First of all, it comes in a nice box, keeping all the goodies safe and sound. Although an Arduino board nor USB cable is included, they could also fit inside this box in a pinch.

But what are all these things in there? The “bricks” are basically little PCBs with a particular component mounted on it, an interface circuit if necessary, and a connector that matches the wires included in the starter kit.

From left to right, top to bottom, we have: a terminal block to interface with a pair of wires, a push button, a piezo buzzer, a potentiometer, a light-dependent resistor, a green LED, a tilt switch (bearing in a tube, not mercury), a temperature sensor (using a thermistor) and a red LED.

Furthermore, there is a 16×2 character backlit LCD…

And the major part, the chassis…

The chassis is an arduino shield that extends analogue pins 1~5, digital pins 8-12, the UART and I2C connections. Furthermore, there are three large ten-pin connectors in the centre called “Bus” connections. Each is different, extending a variety of digital/analog pins out. For example, BUS2 consists of digital pins 10~16, power and ground. This allows a direct connection to the LCD screen leaving other pins free for use.

An example project is shown below…

You can see how the chassis shield sits on the Arduino, and the chassis is connected to the LCD module, the potentiometer and an LED. The benefits of this “brick” system are many – for me the greatest thing was the size of the bricks are not too small, and quite strong. They would stand up to quite a beating, which would be good for a classroom setting, a family of enthusiastic arduidans, or just people who are hard on things.

There is no difference to the arduino sketch when  you are using this system, so if you do create a prototype and wish to move further with your project, you only have to change a few pin locations if you decide to use the LCD or input/outputs on other pins. So you don’t have to rewrite your code – neat. As an example, I tested it with my random number sketch from “Getting Started with Arduino” chapter two – all I had to do was change the pins in the LiquidCrystal command. Let’s see how that went, here is the sketch

#include <LiquidCrystal.h> // we need this library for the LCD commands
LiquidCrystal lcd(10,11,12,13,14,15,16);
float noisy = 0;
void setup()
{
lcd.begin(16, 2);             // need to specify how many columns and rows are in the LCD unit
lcd.println(“tronixstuff!    ”);
lcd.setCursor(0,1);
delay(2000);
lcd.clear();
randomSeed(analogRead(0)); // reseed the random number generator with some noise
}
void loop()
{
noisy=random(1000);
lcd.setCursor(0,0);
lcd.print(“Random Numbers!”);
lcd.setCursor(0,1);
lcd.print(“Number: “);
lcd.print(noisy,0);
delay(1000);
}

and the video:

And then some fun with the temperature sensor, the sketch:

#include <LiquidCrystal.h>

// we need this library for the LCD commands
LiquidCrystal lcd(10,11,12,13,14,15,16);
void setup()
{
lcd.begin(16, 2); // tells Arduino the LCD dimensions
lcd.setCursor(0,0);
lcd.print(“Hello electropus!”);
// print text and move cursor to start of next line
lcd.setCursor(0,1);
lcd.print(“Please wait…”);
delay(2000);
lcd.clear(); // clear LCD screen
lcd.setCursor(0,0);
lcd.print(“Temperature is “);
}
float temperature = 0;
void loop()
{
temperature = analogRead(5); // store value from temp brick
temperature = temperature +252-500;
temperature = temperature / 10;
delay (100); // wait for 100 milliseconds
lcd.print(” Temperature is    ”);
lcd.setCursor(0,1);
lcd.print(temperature);
lcd.println(” deg. C.   “);
delay(1000); // wait a second
}

and the video:

So there you have it. This is a simple, yet empowering way of experimenting and learning with the Arduino system. I do recommend this for beginners, or people who don’t want to muck about with tiny components. This in conjunction with an Arduino board would make a great gift for the technically-minded person of almost any age. The manufacturer is working on more bricks, and they should be released shortly.

The Electronic Brick is available from the usual local resellers, including Little Bird Electronics.

Thank you for reading and I look forward to your comments and so on. High resolution photos are available on flickr.

Please subscribe (see the top right of this page) to receive notifications of new articles. If you have any questions at all please leave a comment (below).




  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook