Phipps Electronics

Order within the next 

$0.00
0

SHOPPING LIST

0
Subtotal: $0.00
No products in the cart.
$0.00
0

SHOPPING LIST

0
Subtotal: $0.00
No products in the cart.

FREE SHIPPING OVER $199

50,000+ ORDERS

WORLDWIDE SHIPPING

SSL SECURED

Employment

Welcome to the employment hub for Phipps Electronics, here you will find positions we are currently looking to hire for, if you see a role you would like to apply for, please use the form at the bottom of the page to apply.

If there are no advertised jobs of interest, you can still send through your information for consideration for future roles, to do this, select “Interest for future positions” from the JOB ID drop down.

The Bluetooth Speaker DIY Kit

Do you want to practice your soldering and assembly skills through a neat electronics kit? Want to know where to purchase one and get complete instructions for it? The Bluetooth Speaker DIY Kit is just right for you. See the article below.

Introduction

It’s more fun to learn about electronics the practical way. That’s why here, you’ll get to know about a neat electronics kit to step up your learning curve and get you engaged. The kit is called the  Bluetooth Speaker DIY Kit.

What's inside the Kit

Inside the kit are the discrete components to fully build it. It has resistors, capacitors, a transistor,  an IC, a potentiometer, some LEDs, and a mini microphone. Just right to get you acquainted with electronic parts. These components are ready to be mounted and soldered on the supplied PCB.

You also have miscellaneous components such as speakers, 2-pin connectors, a USB wire connector, some screws, and plastic posts. You also have the Bluetooth/IR module ready to be mounted on the front panel. A remote control IR unit is added for convenient remote operation.

The chassis is composed of acrylic shells precisely trimmed by a CNC machine. These shells join together tightly, enclosing the project through 2 pillar screws. 

Who's this Kit for?

Anyone who wants to get acquainted with electronic parts and the assembly process. These include children and teens (provided they are monitored on the use of the soldering iron and on working with small electronic parts). They can also be assembled as an introductory lesson for electronics for technicians and students alike. Additionally, old folks wanting to sharpen their senses and learn about electronics are welcome to purchase this kit.

Instructions for the Kit

Many people complain about hard-to-understand user guides and manuals with electronic kits. However, Phipps quickly solves this through an easy-to-understand and complete user/assembly guide. You don’t need to search for several YouTube videos to assemble your kit correctly; Phipps provides this all.

The Bluetooth Speaker DIY Kit in Action

Here is a video of the Bluetooth Speaker DIY kit already assembled in action. Enjoy 🙂

How to Create a New Project in ESP-IDF Using Visual Studio Code

Don’t know how to create a new project in ESP-IDF using visual studio code? Want to know the specific steps? Read the article below to start creating code for your ESP32 projects.

Introduction

Previously, you’ve learned how to install ESP-IDF in Windows and through the Visual Studio Code plug-in. By this time, you may have found the pros and cons programming for each environment.

Using the command-line version of ESP-IDF can be quite challenging. You may have to review several Powershell or Command Shell Prompt commands to get things done. Besides, it’s hard not to have a handy GUI to help you during your programming sessions.  Having an IDE can definitely make things a lot easier. 

The ESP-IDF CMD Shell

ESP-IDF on Visual Studio Code, How to Start a New Project?

After going through several example codes using ESP-IDF in VS Code, how do you create your first project? You may already have your hair pulled several times after trying to look for the “Start a New ESP-IDF Project” on the Visual Studio Code command menu but ended up in vain.

The Command Pallete will help you with this. Simply go to View -> Command Pallete. If you have ESP-IDF installed, you should see “ESP-IDF: New Project” without searching too much. Click on this.

After this, a New Project window dialogue appears. You can input several details here, such as the Project Name, Project directory, and the Serial Port to use. The Choose ESP-IDF Board drop-down shows you several options for programming Espressif Boards.  You can select your ESP32 chip (via ESP-PROG) if you have a board with an FDTI chip. Choose other ESP-IDF Boards and programming methods if you need to.

If you want to program something that’s not on the list (such as custom boards), you can choose Custom Board and then select the ESP-IDF Target chip and programming method you want.

Now that you’ve finished inputting your project details, click Choose Template to start with a pre-defined project template that works with ESP-IDF out of the box. This template prevents you from worrying about your project’s default include directories and other configuration or programming options. 

The set of templates are the one’s below. Here we’ll concentrate on the template-app.

This new template already creates the necessary Make files to successfully build your project. The template likewise sets up the proper include source file directories for an ESP-IDF program to run (such as driver/gpio.h, freeRTOSH/freeRTOS.h, and the like). Click Create project using template template-app to proceed.

You’ll notice the Create project using template template-app button change it’s font color from white to black. This means your new project has been created.  

You now need to open the folder where your new project with the template app was created to make it active on the VS Code Explorer pane. Click File -> Open Folder

Then click Select Folder.

Your new project will appear on the Explorer pane on the left. Expand the main folder and click the main.c file to see its contents.

You can now start writing your code. As an example, here is a simple blinky code. You can immediately include the necessary ESP-IDF component header files you need without worrying about them not being recognized during the compilation process. Here, the components header files to include are driver/gpio.h, freeRTOS/freeRTOS.h, and freeRTOS/task.h  

				
					#include <stdio.h>

#include "driver\gpio.h"
#include "freeRTOS\freeRTOS.h"
#include "freeRTOS\task.h"

#define BUILTIN_LED GPIO_NUM_2


void app_main(void)
{
 
    gpio_set_direction(BUILTIN_LED, GPIO_MODE_DEF_OUTPUT);
 
    while(1)
    {
        gpio_set_level(BUILTIN_LED, 1);
        vTaskDelay(100);
        gpio_set_level(BUILTIN_LED, 0);
        vTaskDelay(100);
    }

}
				
			

Tips on Using your Microcontroller I/O Ports

Find tips and advices on using your microcontroller i/o ports in this article!

Introduction

The Arduino ecosystem has made it easy to work with microcontrollers. However, because of this, you may miss out on certain concepts related to your device’s characteristics. Here is a guide to help you dig deeper into the functions of your microcontroller i/o ports.

On Using Your Micorcontroller Digital Input Pins

Don't leave your Digital Inputs Floating

Digital inputs have a defined value. You’ll usually see this in the Electrical Specifications of your Datasheet. It should be labeled as Digital input VHigh Min and Max or VLow Min and Max. Because of this, you should avoid getting input values in between these min and max values. When you leave your digital inputs floating, it’s most likely that you’ll get random values. You can set your input port to turn on an internal pull-up or pull-down resistor if your port has this capability. Otherwise, tie up these inputs externally to Vcc or GND through external pullup or pulldown resistors.

The value used for a pull up or pull down resistor should be in the range of at least 10 times lower than the internal impedance of the input pin. Generally, this input impedance should be in the 100k – 1M ohm range. With this, choose a value appropriately. Too high a value can create a large voltage drop on the resistor that can hamper the valid logic voltage range on the input pin.

On using Push Buttons on your DigitaL I/O pins

Push buttons help microcontrollers interact with the outside world through finger presses from a user. Push button inputs are still digital inputs, so make sure you enable an internal or external pull-up or pull-down resistor for them. Additionally, debounce these inputs either through hardware or software to eliminate glitchy values.

The figure above implements RC0 as an active low switch input while RC5 is an active high. Note that since there are no series protection resistors, avoid configuring these ports as outputs.

A hardware debouncer is composed of a diode, capacitor, resistor, and a Schmitt trigger. A more dedicated post should explain its operation in detail. For now see that the RC combination act as a low-pass filter for your switch, the diode acts to shorten the time of charging of the capacitor and, the Schmitt trigger ensures you have a digital waveform output fed to your input pin.

Another method you can use to detect button presses reliably is to use a software debounce routine or statements on your firmware. The debounce routine/statement can be simple such as adding a delay once you detect a button press. It can also be more complex such as determining all or some of the states of a switch bounce using timers. In either case, your end goal is simply to know when a user has pressed the push button switch.

Here is a fairly simple code to debounce your push button switch using a delay.

				
					// define buttons
#define button1 A3
#define button2 A4
#define button3 A0
#define button4 A1
				
			
				
					void setup(void)
{
  while (!Serial);  // Required for Flora & Micro
  delay(500);

  // prepare button inputs
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);  
  pinMode(button3, INPUT_PULLUP);
  pinMode(button4, INPUT_PULLUP);
				
			
				
					  if(digitalRead(button2) == 0)
  {
    delay(500);
    ble.print("AT+BleHidControlKey=");
    ble.println("HOME");
    if( ble.waitForOK() )
    {
      Serial.println( F("OK!") );
    }else
    {
      Serial.println( F("FAILED!") );
      //Failed, probably pairing is not complete yet
      Serial.println( F("Please make sure Bluefruit is paired and try again") );
    }

  }
				
			

On another note, you can create a more complex debounce routine using code from the Arduino Examples menu.

				
					/*
  Debounce

  Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
  press), the output pin is toggled from LOW to HIGH or HIGH to LOW. There's a
  minimum delay between toggles to debounce the circuit (i.e. to ignore noise).

  The circuit:
  - LED attached from pin 13 to ground through 220 ohm resistor
  - pushbutton attached from pin 2 to +5V
  - 10 kilohm resistor attached from pin 2 to ground

  - Note: On most Arduino boards, there is already an LED on the board connected
    to pin 13, so you don't need any extra components for this example.

  created 21 Nov 2006
  by David A. Mellis
  modified 30 Aug 2011
  by Limor Fried
  modified 28 Dec 2012
  by Mike Walters
  modified 30 Aug 2016
  by Arturo Guadalupi

  This example code is in the public domain.

  https://www.arduino.cc/en/Tutorial/BuiltInExamples/Debounce
*/

// constants won't change. They're used here to set pin numbers:
const int buttonPin = 2;  // the number of the pushbutton pin
const int ledPin = 13;    // the number of the LED pin

// Variables will change:
int ledState = HIGH;        // the current state of the output pin
int buttonState;            // the current reading from the input pin
int lastButtonState = LOW;  // the previous reading from the input pin

// the following variables are unsigned longs because the time, measured in
// milliseconds, will quickly become a bigger number than can be stored in an int.
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
}

void loop() {
  // read the state of the switch into a local variable:
  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH), and you've waited long enough
  // since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != buttonState) {
      buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (buttonState == HIGH) {
        ledState = !ledState;
      }
    }
  }

  // set the LED:
  digitalWrite(ledPin, ledState);

  // save the reading. Next time through the loop, it'll be the lastButtonState:
  lastButtonState = reading;
}

				
			

On Using your Microcontroller's Digital Output pins

Different kinds of microcontrollers employ different characteristics on their digital pins configured as output. It can be that their outputs can supply a large amount of current that can drive an LED. On the other hand, it can be that their output can supply current just enough to communicate with a sensor or another microcontroller. Check your micorcontroller’s datasheet and look for both output current per pin and output current per group or overall ports.

Digital Outputs in Open Drain Mode

Some microcontrollers allow open drain outputs. When turned on, these outputs drive its external pin to ground through one internal MOSFET inside the chip. This is unlike plain GPIOs, which have push-pull circuitry (which actually has two complementary internal MOSFETs) that simply outputs a high or low value to communicate with sensors or other peripherals.

An open drain output has the ability to sink current generated from a higher or lower valued voltage source than your microcontroller’s Vdd. This means you can drive peripherals or communicate with other IC’s that has a different supply voltage.

Conclusion

You’ve just learned different concepts related to your microcontroller’s i/o ports. Digital inputs should always have defined logic levels for you to get reliable data. This can be done by employing pull ups or pull down resistors. You’ve also learned how to use push buttons properly. Additionally, your output ports have differrent characteristics you can take advantage of when driving your circuits.

STM32CubeIDE Tutorial

Have you tried to program using STM32CubeIDE? Want a tutorial and a guide on how to use it? Read through the article to find out.

Introduction

ST Microelectronics has created their own IDE for programming their STM32 microcontroller devices. This is called STM32CubeIDE. This IDE integrates several ST software components that will make debugging and programming of your ST devices much easier. 

What do you need to program with STM32CubeIDE?

You simply need to download STM32CubeIDE from ST’s website and have an ST-Link hardware programmer/debugger. The downloaded software installation package automatically installs and updates the necessary packages for you. With this, you’re up and ready to start your STM32CubeIDE tutorial. 

Start Programming with STM32 Cube IDE using your BluePill

Although your BluePill can be programmed using the Arduino environment, using official tools from ST makes things a lot easier. See the process below:

Open STM32Cube IDE and see the welcome screen.

Pick Start new STM32 project on the left. You’ll be shown a target selector to pick your STM32 chip or development board. Click Next to continue.

You’ll be asked to input a project name next. For starters, choose the default parameters and then click Finish.

The process will continue to the STM32 CubeMX graphical interface. This is were you can easily assign pins and various functions to your chip.

Let’s assign an LED port. Since PC13 is where the builtin LED of the BluePill is, let’s assign it here. You’ll have to left click on the pin and then set it as GPIO Output. To label the pin, right click on it then click on Enter User Label.

One more thing, you have to select a proper clock source for your chip to work. With this, go to the System Core -> RCC and select Crystal Ceramic Resonator as High Speed Clock Source.

Now go to the Clock Configuration tab to establish your system clock. There is an auto configuration tool here so watch the video below on how to set a maximum system clock rate of 72 MHz. 

After this, you can proceed to generate a C code that you can edit by saving. With this, click the save icon on the upper left, and then proceed to the programming editor perspective view.

On the programming editing perspective window, make the changes you want on user code areas in the main loop to toggle the LED. Simply toggle the LED with a 1 second delay as seen below.

				
					  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
	  HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
	  HAL_Delay(1000);
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
				
			

You can begin compiling the code by clicking the Build button. You can program the board by clicking the Run button. With this, make sure you’ve attached your ST-Link to your BluePill and PC.

Hope you’ve learned a lot on this STM32CubeIDE tutorial!

BluePill Programming via USB

Don’t always have an ST-Link or USB-to-UART converter with you to program your STM32 BluePill? Would you like to do BluePill programming via its own USB port? Read the rest of the article to find out.

Introduction

Two of the previous blogs discussed the process of programming your BluePill (stm32F103C8T6) via ST-Link and via UART. However, there may be times you don’t carry around a ST-Link or a USB-to-UART Converter. In this case, it would be more convenient to simply use the built-in USB port of your BluePill for programming. However, there are prerequisites before you can accomplish this task.

Things You'll Need

First, you need to pre-program your BluePill with a USB bootloader code in boot ROM. The reason for this is that the bootloader code will fetch your custom code through USB and then flash this code in  internal program flash memory. With this, you’ll initially need either a USB-to-UART converter or an ST-Link to program the said bootloader code.

Note that if you previously installed the Arduino STM32 board manager (by Roger Clarke Melbourne), you may have to uninstall it to avoid having conflicts. With this, you can try to remove the Arduino-STM32 folder in your ~/Arduino folder.

The steps to program your BluePill via ST-Link or UART was already discussed in the previous topics so you may want to review them.

You’ll also need to download a USB bootloader code via GitHub. There are several available. However, the latest bootloader code officially supported by ST Microelectronics will be used here. A shortcut method to get this code is through Seradisis. Specifically through the STM32 HID Bootloader Releases.

Navigate through the directories after downloading the ZIP file to find your specific BluePill model. For this example, the hid_generic_pc13.bin file is selected since the LED of this BluePill model is on port PC13.

Program the USB Bootloader on your BluePill

Get your ST-Link or USB-to-UART converter ready. Here, we’ll use ST-Link. The BluePill is powered through a USB cable through its USB port. Hence, the 3.3V  port of the ST-Link is disconnected.

Open STM32 Cube Programmer and connect to the BluePill through ST-Link.

Next, click the download and programming button on the left. Browse and select your HID bootloader bin file. After that, sometimes, the programmmer may ask you for the start address to program this bin file. Put it on the very first start address (0x08000000). There is a hint of this address at the right part in the Erase memory window. You can copy this first address.

Once everything’s ready, hit Start Programming. If successful, your BluePill should be ready to run the Bootloader.

To run the USB HID bootloader, simply put the Boot1 Jumper to “1” and then press the Reset button. You should see the LED blink fast if it has reached bootloader mode. 

At this point, your BluePill can program itself without any ST-Link or USB-to-UART converter.

Now, open Arduino IDE and select the correct USB COM Port that connects to your BluePill which is in bootloader mode.

Change your Upload Method to HID Bootloader.

Begin writing a Blinky code just to test.

				
					void setup() {
  // put your setup code here, to run once:
  pinMode(PC13, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(PC13, HIGH);
  delay(1000);
  digitalWrite(PC13, LOW);
  delay(2000);
}

				
			

Hit Upload to program this code via USB. You should see a successful connection and programming status.

After this, bring back the Boot1 Jumper to “0” so that you will be in Normal Operating Mode. Press Reset and you should see your Blinky code running.

BluePill Arduino UART Programming

Would you like to know how your BluePill can be programmed via UART in the Arduino IDE? Read the rest of the article to find out.

Introduction

In the previous blog post, your Bluepill was programmed using ST-Link hardware. However, some of you may not have that hardware available. With this, you can program your Bluepill (or other STM32 microcontrollers) by only using a USB-to-UART converter module.

Bluepill Operating Modes

Before diving into programming your BluePill, it’s better to know its operating modes. This STM32 ARM microcontroller can be in Bootloader or Normal Operating Mode. Being in Bootloader mode means this device is ready to be programmed through USB or UART, flashing firmware into the program memory area, without needing an ST-Link hardware module. 

Note that if you have an ST-Link utility, you can directly program the Bluepill via the SWD lines as was done in Bluepill Arduino IDE ST-Link Programming.

Before you begin, you’ll have to adjust some jumpers in order to enter UART (System) Bootloader mode. Put the Boot0  jumper to position 1 while putting Boot1 to 0 (as seen below).

Normal Operating Mode
UART Bootloader Mode

Once finished, you can return the jumper back in Normal Operating Mode to run your code. Note that you may have to reset your board when switching modes.

Next, wire up your USB-to-UART RX and TX lines with your BluePills A9 and A10 ports. See below.

Then power up your BluePill either through its USB port or in-circuit. The wiring should look something similar below. Don’t forget to connect a common GND line. You can use any commerciallly available USB-to-UART converter as long as it’s outputting a 3.3V level.

Setting-up Programming your Bluepill in Arduino IDE

Make sure you’ve read preparing your Bluepill for Arduino IDE before proceeding.

Define the Upload Method

Next, go to Tools -> Upload Method then choose STM32 Cube Programmer (Serial).

Pick a COM Port

Make sure you pick the COM port of your USB to UART converter accordingly

Create Your Bluepill Program

For starters, try to create a simple Blinky program.

				
					void setup() {
  // put your setup code here, to run once:
  pinMode(PC13, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
  digitalWrite(PC13, HIGH);
  delay(1500);
  digitalWrite(PC13, LOW);
  delay(500);
}
				
			

Program this in your Bluepill

If needed, press reset, to start your Bluepill first in order to be in bootloader mode and then press Upload in Arduino IDE.

If everything goes well, you should see your code uploaded to your Bluepill using the STM32Cube Programmer plug-in program. You can rearrange the jumper to Normal operating mode and then press reset to run your board permanently in this mode.

Scroll to Top