when I was building my custom light 4 touch switch panel for my smartHomeDIY I discovered Arduino uno and nano has only 2 hardware interrupts, 
luckly,after searching for a while, I found a blog that helped me to overcome this limitation.
The solution is: pin change interrupts which are supported by the Arduino uno and nano: .

Regular hardware interrupts can be registered for raising or falling or change interrupt, but the pin change interrupts, as their name suggests, are only capable to deliver interrupts when the pin senses a voltage change in any direction, if you need to know which pin was changed you will have to read all pin states (or relevant pins) to know the new state and compare it to the old state (which you have to save on you program.
a small workaround in my case was to register for 2 hardware interrupts and for the other 2 required interrupts I used the pin chagne mechanism, but there are good news, the pin change interrupts are grouped into group of pins 

• A0 to A5
• D0 to D7
• D8 to D13

So I just used different group for each switch and used a counter to ignore the second interrupt - leaving me with a raising interrupt.

When writing code and delivering to customers you usually will find your self (or someone else ...) debugging your code throw log files and probably a lot of them.
I know I do :)
​

So I wrote my self a small helper tool based on Electron and vue.js + vuetifyjs. which makes it cross-platform.
And I made is open source just for you :)

​Logx

You can just drag and drop you files on it and start 'finding' , setting colors for specific phrases or filtering in or out any phrase you like.
​Enjoy.

BTW I used this cool template code from github, to get started easily...

Just note that this is a work-in-progress, feel free to file in issue you find on github :)

If you like your realtime logs monitoring on terminal from anywhere while using your favourite searching and colouring tools like me, then you must read this.
Azure DC/OS is a great tool, but getting the logs from each microservice instance using the dashboard is slow and complected.
So for the rescue here comes dc/os CLI.
This command line utility will make you life much easier in just a couple of steps

1. First ssh into your master dc/os node [help!]
2. Install dc/os CLI like this.
3. Then just type 'dcos task log <your-micro-service-name-here>  --follow'
   1. This will aggregate logs from all instances of this service.
4. To see logs of the master just type 'dcos node log --leader --follow'
5. To lean some more cool commands - read here. here and here

Good luck  and happy debugging ... :)

During my search to start and learn embedded system programming, I was not able to find a good reference to start with.
I was searching a reference that will easy me in into this topic.
Because this topic not only hard to learn it is also consists from several topics:

• Hardware architecture
• CPU architecture in my case ARM-Cortex
• Hardware protocols and communications such as I2C or SPI
• In Some cases analog electronics and digital basic electronics
• And finally professional  c and c++ coding in relation to embedded hardware programming.

So after searching a lot and for a long time I came up with the following YouTube playlists and couple of links that will ease you into this very interesting field.

1. Intro
2. I2C,I2C
3. SPI, SPI
4. UART

• Microcontroller (Arduino) TimersMicrocontroller (Arduino) Timers
• Port Manipulation, Bit Math, Faster PWM/ADC
• Analog-to-Digital Converter
• PWM, And another one
• Best 555 tutorial ever, 555 Timer
• OpAmp (Operational Amplifier), Another one, And Another one, and this

• ​​Basic Electricity - What is an amp?
• Basic Electricity - What is voltage?
• Basic Electricity - Power and watts
• Basic Electricity - Resistance and Ohm's law
• All about batteries
• Capacitors
• Transistors
• MOSFETS and BJTs
  
• How does a Diode work
• What is a schottky diode?
• What is a zener diode?, And more
• Inductor basics - What is an inductor?, And here, And here
• Passive RC low pass filter
• Passive RC high pass filter
• Voltage divider​​
• Comparator
• How do antennas work​​
• 
  

• ​Oscilloscope tutorials

Today I wanted to talk about a video that inspired me by Joop Brokking
it’s a tutorial video about STM32F103C8T6 ARM STM32 Minimum System Development board known also as the Blue Pill and how to program it to use the MPU-6050 sensors board via I2C

In this video Joop tested the i2c communication from the MPU-6050 sensors board to the STM32F103C8T6 ARM-M3 Micro controller

He used a real hardware Oscilloscope to test the signal
and show the errors and how to fix them

These hardware Oscilloscopes are very useful
but could also be quite expensive, especially for a beginner

So I thought why not replicate the hardware setup and try the same experiment with my Hantek 6022BE PC USB Digital portable Oscilloscope
And see how the single looks like or if it’s even capable measuring these kind of signals

​The Hantek 6022BE PC USB Digital portable Oscilloscope, is a PC USB Digital portable Oscilloscope that features 2 20MHz analog Channels at 48M, and single can be shown on the computer with a dedicated software that comes with it
​
I have tested the 100KHz and 400KHz with no problem
You can see the clock signal and the data signal
As can be seen here it works great and it only costs around 70$

There are multiple ways to investigate the signal
and the software has some nice measuring capabilities

But of course it has less features than the hardware ones
and probably will not work at the higher scales of Mhz signals

I have also tried the same experiment with my USB 24MHz 8 Channel Logic Analyzer and the results were also great and this one only costs around 10$, but cannot debug analog signals only digital ones (i2c, spi, UART , etc...)

To program the STM32 you will beed an FTDI programer connected to the STM32 B6 and B7

Check out the full tutorial about programming the STM32F103C8T6 here

As part of my SmartHomeDIY project (open source), I need as small and efficient server which could also talk to my Arduino stations that are using RF24 module, so for the rescue came my Raspberry PI and it's serial GPIO pins.

All of my Arduino stations are talking to each other with the RF24 module (connected via SPI) and I needed a fast lightweight server (and small in size) to talk to that network.
I wanted to use the PI to do that job and I knew I could use it's GPIOs as serial (usually used for console logging in Hardware development stages)
So I figured why not connect a serial device to the PI GPIOs and through this device I will talk to my network.
​So I figured up the following setup

I connected the PI to a serial BT device called Bluetooth HC-05
This device can talk via serial and forward everything to the other side BT device which is connected to an Arduino which in turn checks the commands and forward these commands to the specified Arduino station via the RF24 module, we will talk about the protocol and the BT device configuration in a moment.

To use the PI serial you will first need to disable PI console prints to serial, to do that go here
To know more about pi serial read here
If cannot disable serial for pi read more here
As a summary here is what you will have to do:

1. download a utility

2.  disable serial

3. ​check status

​You will need to connect the bluetooth module to the PI GPIOs as shown above - here is a closeup
BE SURE TO DOUBLE CHECK BECAUSE THE PI DOES NOT HAVE PROTECTION CIRCUITRY - YOU CAN BURN YOUR PI FOREVER!

Note that there are at least 2 types of revision for the PI board - so make sure which one you have - each one has a different GPIO layout

 To config the 2 BT modules to talk to each other and act as an over the air UART we will need to enter the AT command configuration mode, to do that we will give power to HC-05 while key pin is connected to Arduino pin (9) and pin (9) is already HIGH (or other pin you wish to use or any HIGH level source).

1. Note the BT serial baud-rate is correct - regular operation (getting and sending data) is used on a different baud-rate then the configuration mode, for configuration mode use: 38400 for operation mode you can configure what ever you need.
2. Note that the console is at "Both NL & CR" state (console can be any serial terminal such as putty or the Arduino IDE serial monitor

We will set: 

1. Master and Salve to be binded and using auto connect mode
2. The salve will be set to AT+ CMODE:2  (Which means "Slave-Loop" - which will make the auto connection work). 
3. the module on the PI side will be Master, to do that use: AT+ROLE=1
4. AT+BIND=YOUR_BT_MAC_ADDRESS (to get the master address use: AT+ADDR?)
5. The dispatch station will use: AT+ROLE=2 and then AT+CMODE=2

After all these commands the BT modules should be binded and auto connect always.

For more AT Commands info look:

1. Here
2. And here
3. And here
4. And here
5. And the attached AT commands HC_05 reference PDF at the bottom.

​​​
After all the configurations, if everything is fine, the BT modules will blink at a slower rate, which indicates that the modules are in sync and connected to each other. note that every time you will reset the modules they will blink fast until connected to each other and in sync, I am using that indication a lot, for example to see if the modules are in range when installed in my house walls.

After everything is connected and configured all we have to do is to send the data (commands) in my case through the serial (UART) port to the dispatch station
To do that will we have to use node serial module
https://www.npmjs.com/package/serialport
Install it as any node module.

And here is an code example how to use it 

Every command that we will send from this serial site will go through BT module and received on the other BT module and the Arduino on the dispatch station side will received that data as any other serial data, from there that station can parse that and forward it via SPI to the other stations
Here is the code for the dispatch station.
Important parts of the code are highlighted here.

To trail and error with Arduino sketchs you will need some tools, one of them is an oscilloscope, lets learn the basics of this important tool.

An oscilloscope is a debugging tool for electronics circuits where you can prob any point and check out the signal in watch it in real time (voltage over time)
for example you could check an Arduino PWM signal with this tool and measure the duty cycle, voltage or if it is even working at all.
I bought mine here
This is a starting level device and it has it's limitation but it is cheap and will do the job.
It does not have it's own display like and expensive, portable and professional ones, but it will rather connect to your computer via USB and you will see the signal over the computers screen when lunching the application that comes with it.

Please check out this video to see it in action

Also note that you can use the scope with the software provided or use
the open source ​PulseView or the another great alternative is ​basicscope

As I was building my SmartHomeDIY platform (OpenSource) one of the first things I was looking for (except of debug tools and board), was a bootloader for Arduino which supports over the air flashing of the internal sketch.
I needed this because I was about to mount all the Arduino board inside my wall, and I did not wanted to take them apart every time I had a bug.
So the way to go, is over the air (OTA), which Arduino does not supports out of the box, so lets learn how to do exactly that.

In order to get OTA working on your Arduino You will need to flash on it a special bootloader that support OTA, but not just any boatloader, you will need one specific to the type of your communication board - in my case, RF24,

If you do not know what is a bootloader please read here.

I wanted this bootloader with work with the rf24 [1] radio board - which you can buy [here]
You will need an Arduino library which support this board which you can find here
I am using Mirf and you will probably need to use it to if you will take my code

So, to start with I needed an open source code that has a modified version of the original Arduino bootloader or a custom basic bootloader like this one.

And I found one on github that does just that and it is called optiboot-nrf24l01
which is a fork of this git

What this code does is not too complicated.
When you flash a program using the Arduino IDE what that is actually happening is that the USB driver (you Arduino board is probably connected via USB) is resting the Arduino in to a bootloader state (think of the bootloader as an operating system or a bios)
Then the bootloader waits for couple of fractions on the UART to receive a spesific data (bytes) which tells it to start the flashing process,
If it gets it then he will flash and override the sketch that is already there.
if it does not get anything (timeout) it will just start the sketch that is already there and run it in a loop.
​
So what we need is to:

1. Find a way NOT TO BE RESETED BY THE USB PORT.
2. Get the bytes (sketch data) from the computer
3. Forward the bytes to the remote station
4. Capture the bytes on the remote station
5. Override the sketch on the remote station.

The code over optiboot-nrf24l01 is the one responsible of capturing the bytes on the remote station and overriding the sketch there.

But we still need a local flasher program which was also forked and modified by the same guy here.

This code is responsible to get the bytes (sketch data) from the computer and forward theme to the remote station.

The problem that I had is that every time I was trying to flash the remote station I was eventually flashing the local station.

This is where point 1 is getting into the picture and it took me some time figure it out and find the right solution
what you will have to do is put a 10uF capacitor in between the RESET pin on the Arduino and the GND pin
This way when ever the USB driver is trying to reset the board it will fail but will continue with the flashing process.

​The above is the hardware setup as I was using it, note the 10uF capacitor.
The led here is just for debugging.
I used it to make sure I am getting the bytes and was really thing to forward them to the remote station (write the to the rf24 registers over SPI).
If you need the debug code you can get it here

Once you have the above local station connected you will need to flash the remote station with the custom bootloader who has the OTA support (note that the remote station hardware configuration configuration is actually the same as the above except the capacitor)

First this is to compile the bootloader once you have that you can run avrdude commands against it in order to flash the remote station. by the end of this process you should have an bootloader.hex file.

To flash the ota-bootloader hex file you will need 2 commands and an AVR Programmer,
You can probably use another Arduino to burn the bootloader but using the programmer is much more convenient

Just connect the AVR Programmer to the computer and to the Arduino header like this

Note the 0xDA on the first command - it will not work without it.
optiboot_atmega328_without_watchdog.hex is the compiled bootloader hex file.

Btw, I compiled my bootloader without the watchdog option (by default it will reset into bootloader every 10 sec or so to allow remote bootloading automatically, in my code I just added to my sketch the option to reset the Arduino when it gets a specific command) - read more here

When this is done you should see something like that:

​All that is left out is to run an avrdude command to flash the local station as if it the remote one - we will just flash our hex file (the same way Arduino IDE does behind the scenes).

​When you compile you sketch on Arduino IDE it just puts it on a directory on your computer
I usually just copy it to my avrdude directory and flash it from there.
To read more about getting the sketch hex file read here.
If you need more here with flashing the boot loader check this.

1. The capacitor for the local station - more info about disabling reset from USB here
2. Flashing commands - the 0xDA flag
3. use my code for debug with LEDs for the bootloader and the flasher if it does not work for you - it will light-up some LEDs to let you know packets are flowing over the air. if need to learn how to turn led on and off in bootloader mode, read this reference about Port Registers manipulations.
4. In my case the sketch that I needed was using RF24 communications as well, so I needed the boot loader and the sketch to use the same RF24 library so I used mirf24 lib . that way once the sketch is loaded so it will be able to reset in to boot loader and flash (registers state on the rf24 board stays the same and this make the process work better).
5. Note that timing here is a problem so you might need to rest the remote station manually for trail and error with the reset button on the remote Arduino station.

Arduino board: http://s.click.aliexpress.com/e/ZBeuJey
USBtinyISP AVR ISP programmer bootloader: http://s.click.aliexpress.com/e/aUvjA2F

All the Arduino schemes attached here where generated with the cool tool:
http://fritzing.org/home/

Hope it will serve you all well,
Fill free to comment or email me with questions.
Please subscribe my Youtube channel.
And my facebook page.

If your are learning to code to Arduino and you write your own sketchs sooner to later you will need to learn about avrdude, so let's do that.

​avrdude is a command line utility developed by Atmel.
It is used to burn sketches to your Arduino, configure your Arduino register and fuses and also flash a different bootloader then the stock one for example the optiboot a smaller bootloader which will free up some memory space for your sketch.

​This command will burn your Arduino with custom bootloader hex file.
Check out this article about this custom bootloader to learn more.
 
You can learn how to install it here.
if you are not familiar with adafruit you should definitely do so.
This site by ladyada explains everything you should know about avrdude commands.

While building my SmartHomeDIY project I encountered a problem trying to use multiple SPI devices connected to the same Arduino.
Although the SPI bus should support multiple devices at the same time (toggling the Chip-Select line), this does not always work (mostly due to part using the bus not respecting the chip select or other configuration issues).
So after reading for some time and experimenting I came up with the following solution. learn more about transistors here

 The above station is an IR recorder and transmitter station.
It can be set into recording state which then saved the recorded IR-in data into and SDCard connected over SPI.
But when not in recording mode it will listen over the RF24 (also connected via SPI) for commands.
Once a command is given it will try to send the IR code request (for example turn TV on)
To do that it will again have to move to SDCard mode and read the previously recorded data and retransmit it over the IR out LED.

So to solve this I have connected the SPI lines to couple of transistors/switches,
They just CUT the lines of the component which is not being used at the moment and there for prevent the SPI lines collision.

Attached is the code and hardware layout to do just that

Note that it does not matter which type of project you have.
You can always do the same transistor-switch trick to cut of the problematic SPI lines while using the others.

A special note for the transistor configurations,
It will not work if you design you transistor configuration as usually suggested, which means to set a logic level by design at the output of the transistor so that the base will toggle the out voltage (same as an amplifier).
Instead I set the signal to go trough the transistor, which needed so testing to select the transistor which does not affect the actual signal (it will depend on the transistor type, spec and configuration...)
So it took me some time to figure out the right transistor values and configuration.

For trail and error I used this logic analyzer 8 logic lines or better yet one of these pro logic analyzers or one from ebay and there is also a very cool one which has 8 digital channels and one analog - perfect for beginners.
I inspected the incoming signal and the outgoing signal to make sure the transistor does not temper with the incoming signal so everything will continue to work as expected (the transistor are transparent to the actual data)

You could also try this Hantek 6022BE PC USB Digital Oscilloscope which is working perfectly on Window 10 environment.
You could also get one on ebay

You could also use this logic multiplexer [8 Channel Logic Level Converter Convert TTL Bi-directional] to do the same job which I have not tested yet.
But I think my way is more fun! :)