Official Blog of Silicon Labs

    Publish
     
      • Webinar: From Imagination to the IoT

        Siliconlabs | 09/265/2015 | 09:15 AM

        iot-grib.jpg

         

        With growing product demands in today's Internet of Things world, you are probably evaluating different ways to add the ability to sense, compute and connect to your next product.

         

        Date: September 23rd, 2015

        Wed Sept 23rd, 10 AM HKT - Asia (Mandarin)
        Wed Sept 23rd, 11 AM HKT - Asia (English) 
        Wed Sept 23rd, 10 AM BST - Europe (English) 
        Wed Sept 23rd, 10 AM PST - Americas (English)

         

        Date: October 5th, 2015

        Mon Oct. 5, 11 AM JST - Asia (English)

         

        original (2).png

         

        Join Silicon Labs' experts to discuss the latest solutions that can transform your ideas into IoT devices. During the webinar, we'll be covering:

        • Selecting the ideal MCU and Sensor technology for your application
        • Connectivity deep dive: Bluetooth vs Wi-Fi vs ZigBee/Thread vs Proprietary Sub-GHz radios
        • Demos with Silicon Labs' Sensor Puck, Blue Gecko Bluetooth module, Home Automation & and Lighting Reference Designs
        • Live Q&A with our team of Application Engineers -- try to stump them, we dare you!
      • Chapter 7: Sprinkler Timer Part 2 - Create the Timer Set/Adjust Mechanism

        lynchtron | 09/261/2015 | 10:21 AM

        makersguide_ch7_2.png

        This is part 2 of a five part series on how to build a garden sprinkler timer.  In part 1, we learned how to control the LCD display on the Wonder Gecko Starter Kit.  The display is used to display the time of day and for setting the start/stop schedule of the timer.  Now we will make use of the buttons on the Starter Kit to control the display.

         

        In this section, we will learn how to recognize the differences between short and long button presses, and a “double button” press where two buttons are pressed at once.  We will utilize GPIO interrupts so that the timer responds immediately to user input.


        User Interface Buttons

        The Starter Kit has two buttons at our disposal for user interface purposes.  Like many alarm clocks and other gadgets that have limited user input mechanisms, we have to make the best of what we are given.  I can give different meanings to single-button presses, as well as long single-button and long double-button presses.  So I will designate PB0 on the Starter Kit as my “Adjust” button and PB1 as my “Set” button.  I also designate a double-button long press to be used for my “Program” button.

         

        7.2_buttons.png 

         

        I will create a user interface that will allow the user to set the time of day, as well as the start and stop times for the valve to be open that will repeat every 24 hours.  When the device first powers up, the default mode will be to display 00:00 on the time display and the word OFF on the second row.  When the user presses both buttons together for a second, the device will enter programming mode where the time of day, start and stop times can be programed one by one.  Like common alarm clocks, the field that is to be adjusted will be blinking when in programming mode.  Pressing the Adjust button causes the number to count up through its range of valid values until it rolls over.  Pressing the Set button causes the device to move to the next field in the sequence.   Once the time of day and start/stop times are programmed, the device moves to the ON state, displaying the time of day and that the timer is ON.   A single press on Set will toggle the ON/OFF mode.  At this point, the Adjust button will do nothing.  The only way to see what is programed for start/stop is to enter programming mode again, where the currently-stored values will be displayed and able to be modified.

         

        7.2_clock_programming.png

        User Interface Sequence

        The first thing that we must do to implement this sequence is to create is a mechanism that fetches the button state at any time, including both long and short presses since they do different things.  We really don’t want to mess around with this functionality.  It has to be solid.  This is the perfect candidate for the SysTick interrupt, which can be used to periodically check if a button is pressed and figure out if the button press was long, short, or if both buttons were pressed at about the same time during a long press. 

         

        First, I need to create a data structure for the buttons, since firmware will need to keep track of whether there is a short or long button press, the time that the button is pressed, and the pin on the port that is associated with each button.  I need a virtual button as well for the program button, to represent the double-button press.  The logic will only look for long button presses for that button.  I then place all of these buttons in an array of pointers, so that I can loop over the available buttons later in the SysTick interrupt. 

        #define BUTTON_PORT                       gpioPortB
        #define ADJUST_BUTTON_PIN                 9
        #define SET_BUTTON_PIN                    10
         
        // Button states
        typedef struct button_struct_type
        {
              bool short_press;
              bool long_press;
              uint32_t time_pressed;
              uint16_t pin;
        } button_struct ;
         
        button_struct set_button;
        button_struct adjust_button;
         
        // Third button is virtual, formed by pressing two together
        button_struct program_button;
         
        button_struct * button_array[3];
         
        #define SET_BUTTON_INDEX            0
        #define ADJUST_BUTTON_INDEX         1
        #define PROGRAM_BUTTON_INDEX        2
         
        #define LONG_PRESS_THRESH           1000

         

        All of the button press detection and state management takes place in the SysTick interrupt handler.  This allows my sequential program code to just wait around for a certain button to be pressed for either a short or long press before it does something about it.

         

         

        #define DEBUG_BREAK  __asm__("BKPT #0");
        int main(void) {       // Chip errata       CHIP_Init();         CMU_ClockEnable(cmuClock_GPIO, true);         // Set up the user interface buttons       GPIO_PinModeSet(BUTTON_PORT, SET_BUTTON_PIN, gpioModeInput,  0);       GPIO_PinModeSet(BUTTON_PORT, ADJUST_BUTTON_PIN, gpioModeInput,  0);         set_button.short_press = false;       set_button.long_press = false;       set_button.pin = SET_BUTTON_PIN;         adjust_button.short_press = false;       adjust_button.long_press = false;       adjust_button.pin = ADJUST_BUTTON_PIN;         program_button.short_press = false;       program_button.long_press = false;         button_array[SET_BUTTON_INDEX] = &set_button;       button_array[ADJUST_BUTTON_INDEX] = &adjust_button;       button_array[PROGRAM_BUTTON_INDEX] = &program_button;         // Set 1ms SysTick       if (SysTick_Config(CMU_ClockFreqGet(cmuClock_CORE) / 1000))       {             DEBUG_BREAK;       }   while (1)    ; } void SysTick_Handler(void) {       // Blink and delay code removed for clarity         // Keep track of button presses       // High state is unpressed.  Low state is pressed       // Only need to loop over the two physical buttons       for (int i=0; i < 2; i++)       {             // A button high means it is unpressed, so clear things             if (GPIO_PinInGet(BUTTON_PORT, button_array[i]->pin))             {                   button_array[i]->short_press = false;                   button_array[i]->long_press = false;                   button_array[i]->time_pressed = 0;             }             else  // A button was found low, meaning pressed             {                   // No need to do anything more if already found long_press                   if (!button_array[i]->long_press)                   {                         // Only need to fire short_press once                         if (!button_array[i]->time_pressed)                         {                               button_array[i]->short_press = true;                         }                           button_array[i]->time_pressed++;                           // Now check to see if we have a new long press                         if (button_array[i]->time_pressed > LONG_THRESH)                         {                               button_array[i]->long_press = true;                         }                   }             }       }         // Set a long press on the program button if other buttons are both long       if (set_button.long_press && adjust_button.long_press)       {             program_button.long_press = true;       }       else       {             program_button.long_press = false;       } }

         

        The typedef struct I created for button_struct allows me to assign a variable name to a data structure containing all of the relevant information for set_button, adjust_button, and the program_button.  I can access the member variables of those data structures by using a dot notation, such as set_button.short_press and program_button.long_press.  However, when I am looping through an array of pointers to these data structures, the notation must change to the arrow -> notation to access member variables of data structures referenced in this way.   For example, button_array[i]->time_pressed will work, but button_array[i].time_pressed will not compile.

         

        In order to test this implementation, I set up a while loop in main() that looks for a button press on either of the physical buttons and illuminates a test LED on the Starter Kit for each button.  Short presses illuminate the LED until they are no longer pressed.  When the button is pressed longer than the time indicated by LONG_THRESH, the LED goes out, indicating that a long press was detected.  Since I don’t have a third LED to test the program_button, I designed the test code so that if both buttons are pressed, the code executes a DEBUG_BREAK.  You can then release both buttons, click on the delay(10) after the DEBUG_BREAK, right-click and select “Move to Line” from the popup menu.  Then resume execution and you will see that the program_button.long_press was cleared by the SysTick during the 10ms delay.  You can then keep pressing buttons and everything continues to work.

         

        #define LED_PORT                          gpioPortE
        #define LED0_PIN                          2
        #define LED1_PIN                          3
         
        int main(void)
        {
              // Init code removed for brevity – see above example or full code listing
         
              while (1)
              {
                    if (set_button.short_press)
                    {
                          if (!set_button.long_press)
                          {
                                GPIO_PinModeSet(LED_PORT, LED0_PIN, gpioModePushPull,  1);
                          }
                    }
                    else
                    {
                          GPIO_PinModeSet(LED_PORT, LED0_PIN, gpioModePushPull,  0);
                    }
         
                    if (adjust_button.short_press)
                    {
                          if (!adjust_button.long_press)
                          {
                                GPIO_PinModeSet(LED_PORT, LED1_PIN, gpioModePushPull,  1);
                          }
                    }
                    else
                    {
                          GPIO_PinModeSet(LED_PORT, LED1_PIN, gpioModePushPull,  0);
                    }
         
                    if (set_button.long_press)
                    {
                          GPIO_PinModeSet(LED_PORT, LED0_PIN, gpioModePushPull,  0);
                    }
         
                    if (adjust_button.long_press)
                    {
                          GPIO_PinModeSet(LED_PORT, LED1_PIN, gpioModePushPull,  0);
                    }
         
                    if (program_button.long_press)
                    {
                          DEBUG_BREAK       // This is our test case
                          delay(10);        // "Move to line" to here, release buttons
                          if (program_button.long_press)
                          {
                                DEBUG_BREAK       // This should not occur            
        }
        }       } }

        I think that this button detection mechanism meets the requirement of being robust enough to drive the sprinkler timer.  I have tested all states and tried to get it to fail by holding one button for a long time, then the other and it still detects the program_button as getting a long_press.

         

        Before I can dive into the rest of the programming sequence, I need to describe the clock that I am going to use for timekeeping purposes.  I’ll cover that in the next lesson.

         

        PREVIOUS NEXT 

         

      • SLEEPY BEE starter kit review

        currenthunter | 09/258/2015 | 02:15 PM

        Motivation

        I have some (unlucky) plants in my workroom to make it more convenient but sometimes I forget to water them. I have always wanted to create a watering reminder, but I had more important projects all the time so I kept procrastinating it. I can see now I am not the only one engineer who has problems with keeping the plants alive. It’s high time to make up for it. Some months ago I had seen an introductory video about the new EFM8 8-bit microcontroller then I entered the contest to try it.

        Purpose

        The goal is to create a low power application which can measure the soil water of my plants furthermore it can warn me when it becomes dry.

        Hardware

        I have chosen SLSTK2011A starter kit for my application. The kit equipped with a nice Sharp memory LCD, Si7021 temperature and humidity sensor, RGB LED, joystick, push buttons and last but not least EFM8SB20F64 microcontroller. It has a 4352bytes RAM and 64kB flash and it is based on 8051 core.

        Contrary to the EFM32ZG starter kit, it is contains everything what you need for the first run (3V coin cell and mini USB cable).

        Let’s see the software side.

        I had already installed Simplicity Studio before but only with ARM components. I had to add further EFM8 packages. It is easy as one by one with Add/Remove packages button in the top right corner of the Simplicity Studio on the Simplicity perspective.

         

        addpackages.jpg

         

        The kit arrived with a pre-programmed clock demo. I would rather had seen something more interesting, so I opened the space invader demo project then I pushed compile button.  Surprisingly I got error message:

        compile_error.jpg

         

        At this point it became clear why I had the following message after installing the components for EFM8 kit. Simplicity Studio uses Keil tool chain to compile the C code for EFM8 microcontrollers, fortunately it provides a possibility to register a full license for this tool free of charge. Good!

         

        lic_job_highlighted.PNG

         

        The licensing procedure takes some minutes and then the activation code arrive in e-mail. At first the code didn’t work, but it was my fault, the copy-paste takes the carriage return character from the end of the code…

         

        licensing_succeed.PNG

         

        It is important to clean the project before rebuilding and finally the space invaders compiled successfully. It runs smoothly on the EFM8 SB2. So far so good.

         

        Solution

        To measure the soil water of my plants I chose a simple voltage divider method. I did a simple sensor from a piece of prototyping board.

         

        sensor.jpg

         

        To prevent the electrolysis I just set voltage with one of the IO pins for the time of the measurement. The resistance of the sensor after watering was around 300kOhm so I put another 300kOhm resistor to divide the voltage in half. When the soil becomes dry, the resistance of the sensor rises and the voltage of the analogue input as well. In this way it is easy to find a threshold for alarm.

         

        watered.jpg

         

        To store more nice notification images the 64kByte of flash memory comes in handy.

         

        Current consumption

        To keep the project simple and portable I prefer to supply the circuit with battery. At this point the low power possibilities of the CPU become important.

        In active mode with LCD the setup requires 4.4mA

        active_LCD_current.png

         

        In Idle mode with LCD the current consumption goes down to 2.46mA. It is better, however,  for a battery powered application it is still high.

        idle_LCD_current.png

         

        Finally in suspend mode with LCD I see a value that is much better.

        suspend_LCD_current.png

         

        Conclusions

        As regards the software side it was a pleasure for me to use the same IDE to EFM8 microcontroller as the EFM32 micros. Good getting started videos and well prepared demos help the user in the first steps. During developing low power application the integrated Advanced Energy Monitor is a very helpful tool to check the current consumption of the system. Using the VMCU pin to supply the external hardware makes possible to test the complete project energy hunger.

        This EFM8 SLEEPY BEE starter kit contains a lot of possibilities to play with. The 20 pin expansion header makes more comfortable to connect our external hardware without soldering. If it is not enough, it is easy to solder a pin connector to the upper and lower side of the development board where all of the microcontroller pins are broken out accompanied by power supply and GND.

        Thank you, Silabs, for the opportunity to try your new product.

      • September, 2015 Member Spotlight: sergeilb

        Siliconlabs | 09/254/2015 | 05:21 AM

        We are featuring one of the Silicon Labs Community members who is active or new in the community on a monthly basis to help members connect to each other.

         

        Meet our September member of the month: sergeilb

        sergei.jpg

         

        Q: Congrats on becoming our featured member of the month! Can you introduce yourself to our community members?

         

        I am a Professor at the University of Wisconsin - Superior, USA. My background is Math (Ph.D. from the Moscow State University, Russia) and Computer Science (Habilitation from the University of Paderborn, Germany).


        Electrical Engineering is rather my hobby, since I do not have a degree in it.
        However, I deal with electronics as long as I remember myself, back to the high school years. Now it becomes a part of my job, as I started to offer "Embedded Systems" course, which involves practical student projects.


        This course was offered 6 times so far, each time based on a different architecture (PIC16/18, MSP430, AVR8, C8051, RL78, Kinetis ARM). Besides, I do my own microcontroller projects, and am involved into some commercial ones.

         

        Q: How did you know about the Silicon Labs Community?

         

        Almost by chance by browsing Silicon Labs web site, which I visit pretty often basically for information on new products. I saw an announcement for the Summer Project contest and decided to participate, because I use quite a bit of Silicon Labs parts, anyway. It is my second contest, the first one was with TI several years ago.

         

        Q: You recently posted the Weather Station and the Low-power temp/humidity meters projects in the community. What's the motivation behind building the projects?

         

        I am pretty sensitive to the weather conditions and climate in general, and need a way to monitor them. Inexpensive commercial meters that I initially purchased were noticeably inaccurate. The readings of 3 devices placed at the same spot differ in 10% of humidity, which is inacceptable. Also, the alkaline batteries in the transmitting units of there models did not last for more than 3-4 months and did not work at all in winter in our snow climate.


        The Weather Station project was designed to address these limitations.
        Concerning the other project, low-power devices are my major interest in the microcontroller business. Besides, I am very interested in IoT applications and worked a lot with TI's and Silicon Labs Sub-1 GHz radios. Now I start working with BLE solutions from Broadcom and Cypress. I did not try Silicon Labs Bluetooth products yet, but plan to do it.

         

        Q: Do you have something in mind for your next project?

         

        Yah sure, there are plenty of them. The closest ones to the completion are the Thunderstorm monitor (based on the AS3935 and MSP430FR57xx microcontroller) and wireless Rain Gauge (based on the Silicon Labs Si1083/Si4467 wireless CPU/radios and EFM32TG822 microcontroller). I used EFM32 before, but by various reasons am stuck with Freescale/NXP Kinetis MCUs for the past 2 years. Now I am really excited to go forwards with the TG822 that fits well into my design.

         

        Q: What pages do you usually visit in the community, and why?

         

        I am a relatively new Community member and did not explore it in full depth yet. So far I mostly read the Projects site for ideas and implementation details.

         

        Q: Thanks for answering the questions. Any final comment?

         

        For the moment and unclear even to me reason, I am mostly active in Russian microcontroller forums, where I published over 30 project articles. A good number of them uses Silicon Labs parts and may be interesting to this Community. As time permits, I plan to translate some of them into English and publish here.

      • Chapter 7: Create a Sprinkler Timer Part 1 – Interface the On-board LCD

        lynchtron | 09/251/2015 | 11:14 PM

        Maker's Guide Chapter 7 Part 1.png

         

        Have you ever watered a lawn or garden by hand?  Sure, you could turn the hose on and then try to remember to turn it off, but then you have to go back outside again.  Luckily, you are learning about embedded design and with these new skills, we can do much better than that.  In this chapter, we will build a portable electronic timer to control a garden hose sprinkler.   We will leave the confines of the breadboard used in the previous lessons and develop a solution to a common problem.  We spent a lot of time and effort in the last lesson understanding all about clocking and interrupts and now we can put that to good use in the construction of an actual gadget.

         

        In order to control the flow of water to a sprinkler, we need some help from a device that can turn the water on or off.  The device that does that is called a solenoid valve.  A solenoid is an electromagnetic device that turns energy into motion, and in this case it uses that motion to open a valve that allows the water to flow.  The solenoid for this project runs on a different voltage (12V) than your kit, and therefore requires some additional switching circuitry to control that voltage.

         

        The EFM32 MCU gives us the ability to inject software control into a variety of low-power devices, but it sometimes requires additional electronic circuitry to make it all happen.  In this case of a garden watering timer, the MCU will provide the timer clock and a user interface to the timer, and connect an external solenoid valve to control the water flow.  We will use buttons on the Starter Kit to control the onboard LCD screen, to allow programming of the watering schedule.

         

        7.1_circuit.png

         

        We can apply the topic of this chapter to a myriad of portable electronic gadgets that all must have an inexpensive user interface, the ability to keep track of time over long periods and be user programmable while conserving battery life.  This chapter will make all of those kinds of gadgets possible.

         

         

        Materials Needed for This Lesson

        • 12V garden hose solenoid valve
        • 12V battery pack
        • PN2222A NPN Transistor, 1 Amp Rating
        • Diode
        • Resistors, 1k and 2k, through-hole
        • Coin cell battery CR2032
        • Waterproof enclosure for a smartphone or tablet – optional
        • Silicone caulk for sealing holes in the enclosure – optional

        Liquid Crystal Display (LCD) Driver for User Interface

        The LCD included with your Starter Kit is a low-power user interface that has lots of individually-addressable segments.  Just look at all of the segments:

        7.1_lcd_display.png

         

        I am using a library that is supplied with the EFM32 Starter Kit examples to make addressing all of those segments easier.  This is not a standard em_ library because it is tied to the Wonder Gecko Starter Kit only so the procedure for finding and porting that code over to your project is to navigate to the install directory of Simplicity Studio, then copy the following files into your project’s emlib directory:

        • SimplicityStudio\v3\developer\sdks\efm32\v2\kits\EFM32WG_STK3800\config\segmentlcdconfig.h
        • SimplicityStudio\v3\developer\sdks\efm32\v2\kits\common\drivers\segmentlcd.c
        • SimplicityStudio\v3\developer\sdks\efm32\v2\kits\common\drivers\segmentlcd.h

        To implement a sprinkler timer, I will need to display the time of day and the start/stop time of the opening of the valve solenoid.  The LCD on the Starter Kit has two rows.  The top row displays numbers only and is perfect for the time, so I will dedicate that section for time displays.  The LCD also has a second row that can be any string of seven alphanumeric characters.  I can use that row to guide the user through the programming sequence.  I would also like some LCD blinking ability for programming and informing the user when the hours or minutes are being set.  Therefore, I will create functions that allow me to easily set the contents of those fields and apply blinking.

         

        // Time segments
        #define HOUR_SEGMENTS                     0x60
        #define MINUTE_SEGMENTS                   0x18
        enum segment_enum { NONE, TIME, HOURS, MINUTES };
         
        // Storage for the time currently on the display
        uint16_t display_hours = 0;
        uint16_t display_minutes = 0;
         
        // Function used to update the display
        // No bounds checking.
        void display_time(const uint16_t set_hours, const uint16_t set_minutes)
        {
              display_hours = set_hours;
              display_minutes = set_minutes;
         
              SegmentLCD_Number((display_hours << 8) + display_minutes);
        }
         
        // Hide the time segment given by segment_enum
        void hide_segment(uint16_t segment)
        {
              if (segment == TIME)
              {
                    SegmentLCD_NumberOff();
              }
              else if (segment == HOURS)
              {
                    for (int i=1; i<9; i++)
                    {
                          LCD_SegmentSetHigh(i, HOUR_SEGMENTS, 0);
                    }
              }
              else if (segment == MINUTES)
              {
                    for (int i=1; i<9; i++)
                    {
                          LCD_SegmentSetHigh(i, MINUTE_SEGMENTS, 0);
                    }
              }
        }
        int main(void)
        {
              // Chip errata
              CHIP_Init();
         
              CMU_ClockEnable(cmuClock_GPIO, true);
         
              // Enable LCD without voltage boost
              SegmentLCD_Init(false);
         
              // Turn on the colon in the time display
              SegmentLCD_Symbol(LCD_SYMBOL_COL10, 1);
         
              display_time(0,0);
         
              SegmentLCD_Write("OFF");
         
              while (1)
                    ;
        }

        As usual, I am not including all of the code in each code listing to keep things brief.  You can see the full code listing on the GitHub website.  It turns out that the segmentlcd.c driver file provides most of what I need to implement the time display functionality including code to initialize the LCD, turn the display on or off, and set the message on the second line of text.

         

        The only tricky part was figuring out the segments that make up the HOURS and MINUTES segments in order to creat the hide_segment() function.  There was a function called SegmentLCD_NumberOff() in the segmentlcd.c driver that I followed via the right-click -> Open Declaration option until I found a curious bit of code:

        #define LCD_NUMBER_OFF() \
        do { \
          LCD_SegmentSetHigh(1, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(2, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(3, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(4, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(5, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(6, 0x00000078, 0x00000000); \
          LCD_SegmentSetHigh(7, 0x00000078, 0x00000000); \
        } while (0)

        This code turned off the whole time field, but I only wanted to control the hours and minutes.  So I played around with different values until I found out that 0x60 controlled some of the segments for hours while 0x18 controlled some of the segments for minutes.  When you perform an OR operation on those two values, you get 0x78.  So I was able to turn off just hours or minutes with the use of 0x60 or 0x18.  To turn them back on, I call upon the display_time() function again and turn everything back on.

         

        To set up the blinking of hours, minutes or time, I created a function called blink() that set up a global variable with the segment to blink and set a timer for the next blink action.  Then, I configured the SysTick interrupt to take care of the blinking forever more.  This is the way that I like to use the SysTick -- to do something forever that my code doesn’t have to manage after it gets it started.  The blinking of an LCD isn’t time-critical, so there is no need to invoke a separate hardware timer.

        #define BLINK_HALF_PERIOD_MS        500
        // Blink state storage
        uint16_t blink_segment = NONE;
        uint32_t blink_timer = 0;
        bool blink_state = 1;
        // Blink time segments given by the segment_enum
        // Only one time enum at a time
        void blink(uint16_t segment)
        {
              if (segment)
              {
                    blink_timer = set_timeout_ms(BLINK_HALF_PERIOD_MS);
                    blink_segment = segment;
              }
              else
              {
                    blink_segment = NONE;
                    display_time(display_hours, display_minutes);
              }
        }
        void SysTick_Handler(void)
        {
              msTicks++;
         
              // Handle blinking segments
              if (blink_segment)
              {
                    if (expired_ms(blink_timer))
                    {
                          if (blink_state)
                          {
                                hide_segment(blink_segment);
                          }
                          else
                          {
                                display_time(display_hours, display_minutes);
                          }
                          blink_state = !blink_state;
                          blink_timer = set_timeout_ms(BLINK_HALF_PERIOD_MS);
                    }
              }
        }

        The result is an LCD interface that is ready for functionality to be placed behind it, shown here:

        7.1_lcd.jpg


        In the next lesson, we will  program the buttons on the Starter Kit to be captured by our software.

         

        PREVIOUS NEXT 

      • Low Power Contest

        Siliconlabs | 09/251/2015 | 07:51 AM

        low-power-contest-square.png

         

        Do you have a cool low power design idea that you can build with an EFM32 starter kit? It's time to share your idea with community members to win an EFM32 STK to make your concept come to life.

         

        We have two contests: 1) an idea contest for you to share your low power concept and 2) a design contest to submit actual products of what you've built.

         

        Contest Timeline:

        • Low Power Idea Contest: September 1-26th 2015 (GMT)
        • Winner Announcement: October 2nd 2015  
        • Low Power Design Contest: November 30th 2015 (GMT)
        • Winner Announcement: December 18th 2015

        learn more.png

      • European Utility Week 2015 (AT)

        Siliconlabs | 09/251/2015 | 07:41 AM

        621_n_euw2015-med.jpg

        Location:

        Boothnumber: A.k03

        Messe Wien

        Messeplatz 1, 1020 Wien, Austria

         

        Date:

        November3-5, 2015

         

        European Utility Week is the annual landmark event of the European energy calendar bringing ​together all significant market forces and stakeholders under one roof.

         

        Silicon Labs (Boothnumber: A.k03) will present leading silicon, software and system solutions for the Internet of Things. Backed by our world-class team of hardware and software engineers with unsurpassed mixed-signal expertise, Silicon Labs empowers developers with the tools and technologies they need to advance quickly and easily from initial idea to final product.

         

        Products & Services: Chips / Semiconductors, Home Automation, Home Control / Energy Management, Security Systems, Thermostat / HVAC control, Gas Metering, Water Metering, Electricity Metering , Communication Infrastructure, Internet of Things

         

        learn more.png

      • Happy Gecko starterkit review part 2

        uSasha | 09/246/2015 | 05:02 PM

        2 MCU cool features

        In this part of review i want to talk about Happy Gecko MCU itself.

         

        Let’s check what we got here: 

        New USB controller. It’s device mode only with 3 + 3 endpionts, which means you can make up to 3 bidirectional devices (e.g. keyboard + virtual COM port + mass storage). You barely can put more functionality on such small memory device.

         

        There is a good demo which implements 3 USB classes composite device.

        Code compiled with GCC is 42K Flash and 4K RAM.

        Capture.PNG

         

        With optimisation for size it will be 26K and 4K respectively.

        Capture1.PNG

         

        What is interesting there are 1.5K RAM  for endpoints’ FIFO and dedicated DMA controller, so USB subsystem should consume a huge part of the die area.

         

        There is 3.3V LDO build in with 50mA output, so you can power whole board from USB without external hardware.

        Capture2.PNG

         

        USB should be capable to operate without external crystal, but I did not found a section about it in reference manual.

        Basically MCU use Start-Of-Frame bits to tune internal RC oscillator.

        The most interesting part of HG’s USB is a capability to automatically turn off clock while idle. It can save a ton of energy in low traffic application such as HID. And of course USB is connected to PRS and can generate interrupts on SOF.

        Capture4.PNG

         

        For example in normal mode MCU will consume 7.27 mA as HID keyboard, but with low energy mode enabled it’s only 4.9 mA, good Gecko!



        3 Fun project

        So let’s do something fun! Writing reports are always boring and Happy Gecko wants to help us.

        We gonna take USB HID keyboard demo from Simplicity Studio and modify it. Just open SS, connect the kit and press Software Examples button.

        Capture4.PNG

         

        Choose usbdhidkbd and press finish. SS should copy all necessary files and open SS-IDE.

         

        We should modify ScanTimeout handler to pass our own codes to PC.

        PB0 will make COPY and PB1 will make PASTE.

        descriptors.c contains all keyboard codes that Gecko should pass to PC.

        You can find all of them on usb.org:

        http://www.usb.org/developers/hidpage/Hut1_12v2.pdf

        0x06 - is C, 0x19 - is V and modifier 0x01 is Ctrl.

         

        Now copy-pasting should work.



        Let’s also create a custom image, for this I will create 128x128 picture in GIMP and export it as .xbm

        Capture5.PNG

         

        open it in text editor and you will see C array:

        Capture6.PNG

         

        You can paste it into the code now.

        Capture6.PNG

         

         

        Full project can be found here: https://github.com/uSasha/gecko_reporter

      • Engineering "Great Stuff"

        deirdrewalsh | 09/244/2015 | 02:38 PM

        776n5ZJAXwgHBbsqm62xhKTjhZfRoKCOfZjzw_kqQS8.png

         

        Today's IoT Hero story is literally from my own backyard! I was recently introduced to Tres Hill, the VP of engineering at Great Stuff, Inc, by a mutual friend.  I got to interview this other Austin local about embedded development, eliminating tangled extension cords, and the future of Internet of Things. 

         

        Tres, tell me a bit about yourself and your involvement in embedded development? 

        My name is Tres Hill, and I am the VP of Engineering at Great Stuff, Inc. in Austin, Texas. In the late 90’s, the embedded systems that I worked on required almost everything to be created from scratch. Now there are many integrated system boards available that include embedded microprocessors with built-in wireless functionality and advanced power management features which help to accelerate product development cycles. It has also become much easier to manage Internet connected embedded systems using web applications that can be accessed from almost any type of personal computing device.

         

        What does your company, Great Stuff, make? 

        By combining award winning product designs with innovative software, wireless connectivity, and highly reliable electric motors Great Stuff has changed the definition of what a modern reel system should be. RoboReel Water, Air and Power cord reel products "make life a little easier" with one-touch retraction, power-assisted extraction, and a wide range of patented built-in safety features that no other competitors are able to offer. 

         

        What's next for the business?  

        Along with making constant improvements to our existing products, Great Stuff is currently working on a new commercial Hose Reel system. This system is being designed with Silicon Labs radio chipsets in the main system board, and in a remote control button that can be attached at the end of the hose.

         

        Can you talk about your use of Silicon Labs products? 

        We chose the Silicon Labs SI4421 transceiver chipset because it uses less power than any other radio that was available at the time of design, and it has proven to be a very good choice. The RoboReel Water Hose Reel system is powered by a 12V battery. The SI4421 chipset supports a wide variety of custom low-power radio configuration settings that have helped to extend the battery life of the 12V Water Hose Reel, the 6V Water Valve, and the 3V Water Hand Remote that is used to control the entire system. The flexible configuration settings for the SI4421 chipset also helped Great Stuff to fulfill all of the requirements of the FCC certification process for these devices.

         

        It's a big question, but what does the future hold for IoT? 

        More and more embedded wireless devices are going to be attached to the Internet. Over the next decade, there is going to be a new wave of embedded technology innovations that will extend from increasingly small form-factor embedded sensors, to amazing new automation solutions that will be found within the home, in public spaces, and at work.

         

        The amount of data that these embedded devices will generate and collect is going to continue to increase at an exponential rate for many years to come. In order to protect this data and maintain individual privacy, more and more vendors are going to need to make sure that their embedded devices are secure.

         

        End-to-end data security solutions that extend from within the device, to wireless communications, Internet databases, and the applications that ultimately control these devices are going to become increasingly important.

         

        In many ways, it has never been easier to create an embedded device and attach it to the Internet, but the new Internet of Things (IoT) future will only succeed if the engineers creating these solutions take the time to make sure that these devices, their communication networks, and the data they depend on are safe, reliable and secure.