Join this video course on Udemy. Click the below link
https://www.udemy.com/mastering-rtos-hands-on-with-freertos-arduino-and-stm32fx/?couponCode=SLIDESHARE
>> The Complete FreeRTOS Course with Programming and Debugging <<
"The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs"
STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,
1) Eclipse + STM32F4xx + FreeRTOS + SEGGER SystemView
2) FreeRTOS+Simulator (For windows)
Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.
Join this video course on Udemy. Click the below link
https://www.udemy.com/mastering-rtos-hands-on-with-freertos-arduino-and-stm32fx/?couponCode=SLIDESHARE
>> The Complete FreeRTOS Course with Programming and Debugging <<
"The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs"
STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,
1) Eclipse + STM32F4xx + FreeRTOS + SEGGER SystemView
2) FreeRTOS+Simulator (For windows)
Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.
Join this video course on Udemy. Click the below link
https://www.udemy.com/mastering-rtos-hands-on-with-freertos-arduino-and-stm32fx/?couponCode=SLIDESHARE
>> The Complete FreeRTOS Course with Programming and Debugging <<
"The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs"
STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,
1) Eclipse + STM32F4xx + FreeRTOS + SEGGER SystemView
2) FreeRTOS+Simulator (For windows)
Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.
This document provides an introduction to FreeRTOS version 6.0.5. It outlines the course objectives, which are to understand FreeRTOS services and APIs, experience different FreeRTOS features through labs, and understand the FreeRTOS porting process. The document describes key FreeRTOS concepts like tasks, task states, priorities, and provides an overview of task management APIs for creation, deletion, delaying, and querying tasks.
Low-cost microcontrollers are being used more and more often in embedded applications that previously may have used a microprocessor. Microcontrollers often run a real-time operating system (RTOS) rather than a full operating system like Linux. In this webinar we introduce FreeRTOS, a popular RTOS for microcontrollers that has been ported to 35 microcontroller platforms.
The document discusses real-time operating systems (RTOS) and FreeRTOS. It defines an RTOS as an OS intended for real-time applications that processes data without buffering delays. Popular RTOS include VxWorks, QNX Neutrino, FreeRTOS, and others. FreeRTOS is an open source RTOS kernel for embedded devices that provides task management, communication and synchronization primitives. It supports various architectures and is designed to be small, simple and provide low overhead.
This document provides an introduction to FreeRTOS V6.0.5. It outlines the course objectives, which are to understand FreeRTOS services and APIs, experience different FreeRTOS features, and understand the porting process. It then describes the course structure and labs covering the FreeRTOS kernel structure, task management, queue management, semaphore/mutex management, co-routine management, advanced features, and porting FreeRTOS.
Join this video course on udemy . Click here :
https://www.udemy.com/microcontroller-programming-stm32-timers-pwm-can-bus-protocol/?couponCode=SLIDESHARE
learn STM32 TIMERS, CAN,RTC, PWM,LOW POWER embedded systems and program them using STM32 Device HAL APIs STEP by STEP
>>Welcome to the course which teaches you advanced Micro-controller programming. In this course you are going to learn and master TIMERS, PWM, CAN, RTC, LOW POWER MODES of STM32F4x Micro-controller with step by step guidance. Highly recommended if you are seeking a career in the domain of Embedded software. <<
In this course, you will understand behind the scene working of peripherals with supportive code exercises. I have included various real-time exercises which help you to master every peripheral covered in this course and this course thoroughly covers both theory and practical aspects of TIMERS, PWM, CAN, RTC, LOW POWER MODES of STM32F4x Micro-controller.
An RTOS differs from a common OS in that it allows direct access to the microprocessor and peripherals, helping to meet deadlines. An RTOS provides mechanisms for multitasking like scheduling, context switching, and IPC. It uses techniques like priority-based preemptive scheduling and memory management with separate stacks and heaps for tasks. Common RTOS services include timing functions, synchronization, resource protection and communication between processes.
Join this video course on Udemy. Click the below link
https://www.udemy.com/mastering-rtos-hands-on-with-freertos-arduino-and-stm32fx/?couponCode=SLIDESHARE
>> The Complete FreeRTOS Course with Programming and Debugging <<
"The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs"
STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,
1) Eclipse + STM32F4xx + FreeRTOS + SEGGER SystemView
2) FreeRTOS+Simulator (For windows)
Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.
Join this video course on Udemy. Click the below link
https://www.udemy.com/mastering-rtos-hands-on-with-freertos-arduino-and-stm32fx/?couponCode=SLIDESHARE
>> The Complete FreeRTOS Course with Programming and Debugging <<
"The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs"
STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,
1) Eclipse + STM32F4xx + FreeRTOS + SEGGER SystemView
2) FreeRTOS+Simulator (For windows)
Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.
This document provides an introduction to FreeRTOS version 6.0.5. It outlines the course objectives, which are to understand FreeRTOS services and APIs, experience different FreeRTOS features through labs, and understand the FreeRTOS porting process. The document describes key FreeRTOS concepts like tasks, task states, priorities, and provides an overview of task management APIs for creation, deletion, delaying, and querying tasks.
Low-cost microcontrollers are being used more and more often in embedded applications that previously may have used a microprocessor. Microcontrollers often run a real-time operating system (RTOS) rather than a full operating system like Linux. In this webinar we introduce FreeRTOS, a popular RTOS for microcontrollers that has been ported to 35 microcontroller platforms.
The document discusses real-time operating systems (RTOS) and FreeRTOS. It defines an RTOS as an OS intended for real-time applications that processes data without buffering delays. Popular RTOS include VxWorks, QNX Neutrino, FreeRTOS, and others. FreeRTOS is an open source RTOS kernel for embedded devices that provides task management, communication and synchronization primitives. It supports various architectures and is designed to be small, simple and provide low overhead.
This document provides an introduction to FreeRTOS V6.0.5. It outlines the course objectives, which are to understand FreeRTOS services and APIs, experience different FreeRTOS features, and understand the porting process. It then describes the course structure and labs covering the FreeRTOS kernel structure, task management, queue management, semaphore/mutex management, co-routine management, advanced features, and porting FreeRTOS.
Join this video course on udemy . Click here :
https://www.udemy.com/microcontroller-programming-stm32-timers-pwm-can-bus-protocol/?couponCode=SLIDESHARE
learn STM32 TIMERS, CAN,RTC, PWM,LOW POWER embedded systems and program them using STM32 Device HAL APIs STEP by STEP
>>Welcome to the course which teaches you advanced Micro-controller programming. In this course you are going to learn and master TIMERS, PWM, CAN, RTC, LOW POWER MODES of STM32F4x Micro-controller with step by step guidance. Highly recommended if you are seeking a career in the domain of Embedded software. <<
In this course, you will understand behind the scene working of peripherals with supportive code exercises. I have included various real-time exercises which help you to master every peripheral covered in this course and this course thoroughly covers both theory and practical aspects of TIMERS, PWM, CAN, RTC, LOW POWER MODES of STM32F4x Micro-controller.
An RTOS differs from a common OS in that it allows direct access to the microprocessor and peripherals, helping to meet deadlines. An RTOS provides mechanisms for multitasking like scheduling, context switching, and IPC. It uses techniques like priority-based preemptive scheduling and memory management with separate stacks and heaps for tasks. Common RTOS services include timing functions, synchronization, resource protection and communication between processes.
FreeRTOS basics (Real time Operating System)Naren Chandra
A presentation that covers all the basics needed to understand and start working with FreeRTOS . FreeRTOS is comparable with more than 20 controller families and 30 plus supporting tools and IDEs.
FreeRTOS is a market-leading real-time operating system (RTOS) for microcontrollers and small microprocessors. Distributed freely under the MIT open source license, FreeRTOS includes a kernel and a growing set of libraries suitable for use across all industry sectors. FreeRTOS is built with an emphasis on reliability and ease of use.
Tiny, power-saving kernel
Scalable size, with usable program memory footprint as low as 9KB. Some architectures include a tick-less power saving mode
Support for 40+ architectures
One code base for 40+ MCU architectures and 15+ toolchains, including the latest RISC-V and ARMv8-M (Arm Cortex-M33) microcontrollers
Modular libraries
A growing number of add-on libraries used across all industries sectors, including secure local or cloud connectivity
IoT Reference Integrations
Take advantage of tested examples that include all the libraries essential to securely connect to the cloud
This presentation includes a detail of various real time operating systems and it focuses on Vx Works. It will also help you understand what not is a RTOS.
This document discusses real-time systems and real-time operating systems (RTOS). It begins by defining real-time systems as systems where the correctness depends on both the logical result of computation and the time at which results are produced. It then describes two types of real-time systems - those with hard deadlines and soft deadlines. The document uses the example of a car's controlling system to illustrate a sample real-time system and its components. It also discusses key functions of an RTOS like task management and scheduling, inter-task communication and synchronization, and dynamic memory allocation. Finally, it analyzes approaches to using Linux as an RTOS and their advantages and disadvantages.
The document discusses real-time operating systems (RTOS). It defines an RTOS as an operating system intended for real-time applications that must respond to events within strict time constraints. An RTOS has two main components - the "real-time" aspect which ensures responses within deadlines, and the "operating system" aspect which manages hardware resources and allows for multitasking. Common features of RTOSes include task scheduling, synchronization between tasks, and communication between tasks. The document outlines several RTOS concepts such as task management, scheduling, and inter-task communication methods like semaphores.
Team Emertxe's document provides an overview of functions in C, including:
1. Functions allow code reuse, modularity, and abstraction. They define an activity with inputs, operations, and outputs.
2. Functions are defined with a return type, name, and parameters. They are called by name with arguments. Functions can return values or ignore returned values.
3. Parameters can be passed by value or by reference. Pass by reference allows changing the original argument. Arrays can be passed to functions.
4. Recursive functions call themselves to break down problems. Function pointers allow functions to be called indirectly. Variadic functions accept variable arguments.
5. Common pitfalls include
This document discusses real-time operating systems (RTOS). It defines an RTOS as a program that schedules execution in a timely manner, manages system resources, and provides a consistent foundation for developing application code. The key components of an RTOS include a scheduler, objects like tasks and semaphores, and services like interrupt management. The scheduler uses algorithms to determine which task executes when and includes important elements like context switching. Objects help with synchronization between tasks. Services perform operations on objects and other kernel functions.
This document provides an overview of real-time operating systems (RTOS), including their key characteristics, scheduling approaches, and commercial examples. RTOS are used in applications that require tasks to complete work and deliver services on time. They use priority-based and clock-driven scheduling algorithms like rate monotonic analysis and earliest deadline first to ensure real-time constraints are met. Commercial RTOS aim to provide features like priority levels, fast task preemption, and predictable interrupt handling for real-time applications.
Linux has emerged as a number one choice for developing OS based Embedded Systems. Open Source development model, Customizability, Portability, Tool chain availability are some reasons for this success. This course gives a practical perspective of customizing, building and bringing up Linux Kernel on an ARM based target hardware. It combines various previous modules you have learned, by combing Linux administration, Hardware knowledge, Linux as OS, C/Computer programming areas. After bringing up Linux, you can port any of the existing applications into the target hardware.
An unique module combining various previous modules you have learnt by combing Linux administration, Hardware knowledge, Linux as OS, C/Computer programming areas. This is a complete module on Embedded OS, as of now no books are written on this with such practical aspects. Here is a consolidated material to get real hands-on perspective about building custom Embedded Linux distribution in ARM.
This document provides an overview of the FreeRTOS real-time operating system. It discusses FreeRTOS's task management features including task creation, states, data structures, and blocking behavior. It describes how tasks can create other tasks and pass parameters. It also summarizes FreeRTOS configuration options, licensing, and commercial variants.
The document discusses the Linux kernel and its structure. The Linux kernel acts as the interface between hardware and software, contains device drivers for peripherals, handles resource allocation and tracking application access to files. It is also responsible for security and access controls for users. The kernel version numbers use even numbers to indicate stable releases.
LAS16-402: ARM Trusted Firmware – from Enterprise to EmbeddedLinaro
LAS16-402: ARM Trusted Firmware – from Enterprise to Embedded
Speakers:
Date: September 29, 2016
★ Session Description ★
ARM Trusted Firmware has established itself as a key part of the ARMv8-A software stack. Broadening its applicability across all segments, from embedded to enterprise, is challenging. This session discusses the latest developments, including extension into the 32-bit space.
★ Resources ★
Etherpad: pad.linaro.org/p/las16-402
Presentations & Videos: http://connect.linaro.org/resource/las16/las16-402/
★ Event Details ★
Linaro Connect Las Vegas 2016 – #LAS16
September 26-30, 2016
http://www.linaro.org
http://connect.linaro.org
FreeRTOS is an open source real-time operating system that allows for multitasking on microcontrollers using preemptive scheduling. It uses queues to allow tasks to communicate by sending messages between each other, and semaphores to synchronize this communication. Tasks in FreeRTOS can be in one of four states: running, ready, blocked, or suspended. The FreeRTOS code handles task creation, scheduling, and maintenance using around 9,000 lines of code, with additional hardware-dependent code for the specific microcontroller.
This document provides an agenda and overview for a Hands On OpenCL course. The course will cover setting up OpenCL platforms, important OpenCL concepts like the platform and memory models, and programming with OpenCL APIs. Exercises will allow students to set up OpenCL, run simple programs, and optimize programs for performance. Lectures will cover topics like kernels, work-items, memory hierarchies, profiling, and debugging OpenCL programs. The goal is for students to learn portable parallel programming with OpenCL for heterogeneous systems like CPUs, GPUs, and other processors.
LCU13: Deep Dive into ARM Trusted Firmware
Resource: LCU13
Name: Deep Dive into ARM Trusted Firmware
Date: 31-10-2013
Speaker: Dan Handley / Charles Garcia-Tobin
C has been the most commonly used language. This slideshare is all about the introduction to Advanced C. You will learn the fundamentals and the problem solving skills. You will also get an idea on building algorithms and the conditions regarding it. There are also slides which will give knowledge about operators and their types. As a whole you will gain knowledge on three important fundamentals of C.
This presentation covers the general concepts about real-time systems, how Linux kernel works for preemption, the latency in Linux, rt-preempt, and Xenomai, the real-time extension as the dual kernel approach.
The document discusses robot simulation software called maXbox Starter 45. It provides instructions on using maXbox to simulate robot movement and programming using scripts. maXbox allows controlling a simulated robot and tracking a blue line by recording mouse movements. It also discusses handling exceptions, capturing output from DOS commands, and includes references and external links about robot software.
The document discusses real-time operating systems for embedded systems. It describes that RTOS are necessary for systems with scheduling of multiple processes and devices. An RTOS kernel manages tasks, inter-task communication, memory allocation, timers and I/O devices. The document provides examples of creating tasks to blink an LED and print to USART ports, using a semaphore for synchronization between tasks. The tasks are run and output is seen on a Minicom terminal.
FreeRTOS basics (Real time Operating System)Naren Chandra
A presentation that covers all the basics needed to understand and start working with FreeRTOS . FreeRTOS is comparable with more than 20 controller families and 30 plus supporting tools and IDEs.
FreeRTOS is a market-leading real-time operating system (RTOS) for microcontrollers and small microprocessors. Distributed freely under the MIT open source license, FreeRTOS includes a kernel and a growing set of libraries suitable for use across all industry sectors. FreeRTOS is built with an emphasis on reliability and ease of use.
Tiny, power-saving kernel
Scalable size, with usable program memory footprint as low as 9KB. Some architectures include a tick-less power saving mode
Support for 40+ architectures
One code base for 40+ MCU architectures and 15+ toolchains, including the latest RISC-V and ARMv8-M (Arm Cortex-M33) microcontrollers
Modular libraries
A growing number of add-on libraries used across all industries sectors, including secure local or cloud connectivity
IoT Reference Integrations
Take advantage of tested examples that include all the libraries essential to securely connect to the cloud
This presentation includes a detail of various real time operating systems and it focuses on Vx Works. It will also help you understand what not is a RTOS.
This document discusses real-time systems and real-time operating systems (RTOS). It begins by defining real-time systems as systems where the correctness depends on both the logical result of computation and the time at which results are produced. It then describes two types of real-time systems - those with hard deadlines and soft deadlines. The document uses the example of a car's controlling system to illustrate a sample real-time system and its components. It also discusses key functions of an RTOS like task management and scheduling, inter-task communication and synchronization, and dynamic memory allocation. Finally, it analyzes approaches to using Linux as an RTOS and their advantages and disadvantages.
The document discusses real-time operating systems (RTOS). It defines an RTOS as an operating system intended for real-time applications that must respond to events within strict time constraints. An RTOS has two main components - the "real-time" aspect which ensures responses within deadlines, and the "operating system" aspect which manages hardware resources and allows for multitasking. Common features of RTOSes include task scheduling, synchronization between tasks, and communication between tasks. The document outlines several RTOS concepts such as task management, scheduling, and inter-task communication methods like semaphores.
Team Emertxe's document provides an overview of functions in C, including:
1. Functions allow code reuse, modularity, and abstraction. They define an activity with inputs, operations, and outputs.
2. Functions are defined with a return type, name, and parameters. They are called by name with arguments. Functions can return values or ignore returned values.
3. Parameters can be passed by value or by reference. Pass by reference allows changing the original argument. Arrays can be passed to functions.
4. Recursive functions call themselves to break down problems. Function pointers allow functions to be called indirectly. Variadic functions accept variable arguments.
5. Common pitfalls include
This document discusses real-time operating systems (RTOS). It defines an RTOS as a program that schedules execution in a timely manner, manages system resources, and provides a consistent foundation for developing application code. The key components of an RTOS include a scheduler, objects like tasks and semaphores, and services like interrupt management. The scheduler uses algorithms to determine which task executes when and includes important elements like context switching. Objects help with synchronization between tasks. Services perform operations on objects and other kernel functions.
This document provides an overview of real-time operating systems (RTOS), including their key characteristics, scheduling approaches, and commercial examples. RTOS are used in applications that require tasks to complete work and deliver services on time. They use priority-based and clock-driven scheduling algorithms like rate monotonic analysis and earliest deadline first to ensure real-time constraints are met. Commercial RTOS aim to provide features like priority levels, fast task preemption, and predictable interrupt handling for real-time applications.
Linux has emerged as a number one choice for developing OS based Embedded Systems. Open Source development model, Customizability, Portability, Tool chain availability are some reasons for this success. This course gives a practical perspective of customizing, building and bringing up Linux Kernel on an ARM based target hardware. It combines various previous modules you have learned, by combing Linux administration, Hardware knowledge, Linux as OS, C/Computer programming areas. After bringing up Linux, you can port any of the existing applications into the target hardware.
An unique module combining various previous modules you have learnt by combing Linux administration, Hardware knowledge, Linux as OS, C/Computer programming areas. This is a complete module on Embedded OS, as of now no books are written on this with such practical aspects. Here is a consolidated material to get real hands-on perspective about building custom Embedded Linux distribution in ARM.
This document provides an overview of the FreeRTOS real-time operating system. It discusses FreeRTOS's task management features including task creation, states, data structures, and blocking behavior. It describes how tasks can create other tasks and pass parameters. It also summarizes FreeRTOS configuration options, licensing, and commercial variants.
The document discusses the Linux kernel and its structure. The Linux kernel acts as the interface between hardware and software, contains device drivers for peripherals, handles resource allocation and tracking application access to files. It is also responsible for security and access controls for users. The kernel version numbers use even numbers to indicate stable releases.
LAS16-402: ARM Trusted Firmware – from Enterprise to EmbeddedLinaro
LAS16-402: ARM Trusted Firmware – from Enterprise to Embedded
Speakers:
Date: September 29, 2016
★ Session Description ★
ARM Trusted Firmware has established itself as a key part of the ARMv8-A software stack. Broadening its applicability across all segments, from embedded to enterprise, is challenging. This session discusses the latest developments, including extension into the 32-bit space.
★ Resources ★
Etherpad: pad.linaro.org/p/las16-402
Presentations & Videos: http://connect.linaro.org/resource/las16/las16-402/
★ Event Details ★
Linaro Connect Las Vegas 2016 – #LAS16
September 26-30, 2016
http://www.linaro.org
http://connect.linaro.org
FreeRTOS is an open source real-time operating system that allows for multitasking on microcontrollers using preemptive scheduling. It uses queues to allow tasks to communicate by sending messages between each other, and semaphores to synchronize this communication. Tasks in FreeRTOS can be in one of four states: running, ready, blocked, or suspended. The FreeRTOS code handles task creation, scheduling, and maintenance using around 9,000 lines of code, with additional hardware-dependent code for the specific microcontroller.
This document provides an agenda and overview for a Hands On OpenCL course. The course will cover setting up OpenCL platforms, important OpenCL concepts like the platform and memory models, and programming with OpenCL APIs. Exercises will allow students to set up OpenCL, run simple programs, and optimize programs for performance. Lectures will cover topics like kernels, work-items, memory hierarchies, profiling, and debugging OpenCL programs. The goal is for students to learn portable parallel programming with OpenCL for heterogeneous systems like CPUs, GPUs, and other processors.
LCU13: Deep Dive into ARM Trusted Firmware
Resource: LCU13
Name: Deep Dive into ARM Trusted Firmware
Date: 31-10-2013
Speaker: Dan Handley / Charles Garcia-Tobin
C has been the most commonly used language. This slideshare is all about the introduction to Advanced C. You will learn the fundamentals and the problem solving skills. You will also get an idea on building algorithms and the conditions regarding it. There are also slides which will give knowledge about operators and their types. As a whole you will gain knowledge on three important fundamentals of C.
This presentation covers the general concepts about real-time systems, how Linux kernel works for preemption, the latency in Linux, rt-preempt, and Xenomai, the real-time extension as the dual kernel approach.
The document discusses robot simulation software called maXbox Starter 45. It provides instructions on using maXbox to simulate robot movement and programming using scripts. maXbox allows controlling a simulated robot and tracking a blue line by recording mouse movements. It also discusses handling exceptions, capturing output from DOS commands, and includes references and external links about robot software.
The document discusses real-time operating systems for embedded systems. It describes that RTOS are necessary for systems with scheduling of multiple processes and devices. An RTOS kernel manages tasks, inter-task communication, memory allocation, timers and I/O devices. The document provides examples of creating tasks to blink an LED and print to USART ports, using a semaphore for synchronization between tasks. The tasks are run and output is seen on a Minicom terminal.
This document provides an overview of the FreeRTOS real-time operating system. It discusses that FreeRTOS is an open source, portable, and royalty-free RTOS kernel that is used in various commercial and industrial applications. It describes some of FreeRTOS's key components like tasks, queues for inter-process communication, semaphores for synchronization, and its preemptive priority-based scheduler. The document also provides details on FreeRTOS configuration, task states, priorities, the idle task, and how tasks are created and controlled using task control blocks and API calls.
The document discusses various tools and interfaces available in the Metasploit framework. It describes the purpose of tools like msfconsole, msfcli, msfrpcd, msfd, msfencode and msfpayload which can be used for tasks like exploitation, payload generation, encoding and interacting with the framework remotely. It also provides usage examples and basic syntax for many of these tools.
Vawtrak Trojan, also known as Neverquest or Snifula, has been an enduring banking Trojan for a long time and is still one of the most prevalent banking Trojans in the wild today.
This report forms part of Blueliv’s investigation into the Vawtrak group. Reversing the Trojan was a mandatory element of this investigation in order to understand and track the cybercriminal groups and malicious actors behind the Vawtrak malware technical security researchers and reverse engineers can use this report to increase their understanding of how the banking Trojan works.
Contiki is an open source operating system for the Internet of Things. Contiki connects tiny low-cost, low-power microcontrollers to the Internet.
the presentation explains how to install the simulator, teach the reader some concepts of contiki OS, goes through API used in platform specific examples, and most importantly explains some example(Blinking example, Light and temperature sensor web demo).
REST uses HTTP requests to transfer data in common formats like JSON and XML, while MQTT is a lightweight publish-subscribe messaging protocol designed for low-power IoT devices to efficiently distribute data via topics with different quality of service levels and can send "will" messages if a device disconnects unexpectedly. Both protocols are widely used with REST leveraging existing web standards and MQTT optimized for constrained devices and real-time data streaming applications.
Forti gate troubleshooting_guide_v0.10Phong Nguyễn
The document provides troubleshooting guidance for FortiGate devices. It begins with requirements for opening support tickets, such as clearly describing the problem and network configuration. It then gives initial troubleshooting steps for issues like IPsec VPNs, high availability (HA), and traffic blocking. Debugging commands are suggested to gather key information for issues with interfaces, anti-spam, web filtering, and the FortiAnalyzer Security Appliance Extension (FSAE).
Powering your next IoT application with MQTT - JavaOne 2014 tutorialBenjamin Cabé
When it comes to connecting physical objects from daily life to the internet, you’re faced with several challenges. MQTT is a protocol for the Internet of Things that addresses the aforementioned challenges and makes it possible to build scalable sensor networks. This tutorial aims to give you a hands-on experience with the MQTT protocol and walk you through the creation of an end-to-end M2M/Internet of Things application, using open source Java components such as Eclipse Paho, Mosquitto, and Kura. You will leave the session knowing all the cool features of MQTT and how you can integrate it into your Java solutions.
This document provides an introduction to using the RTX real-time operating system with the Keil uVision IDE. It describes how to create a basic RTX application with multiple tasks and use RTX functions for task scheduling and synchronization. The document gives an example 4-task application that blinks LEDs, increments counters, and displays text. It also discusses using semaphores, specifically mutexes, to control access to shared resources between tasks in a real-time system.
Letselectronic.blogspot.com robotic arm based on atmega mcu controlled by win...Aymen Lachkhem
This document describes the design and implementation of a robotic arm project controlled by a Windows application.
The robotic arm uses an ATmega328 microcontroller and is controlled through a C# Windows application built in Visual Studio. The application features a login system, controls for individual and coordinated servo movement, and serial communication with the microcontroller to control the arm. The microcontroller code interprets commands from the application to move the servos to desired positions. Diagrams and code snippets are provided to explain the hardware and software components of the complete robotic arm project.
This document provides instructions for interpreting debug output on a Cisco router. The steps have a student configure debugging for IP routing on router R1. Interface Serial 0/0/0 between R1 and R2 is then configured with an IP address. Debug messages indicate the route is added but its state is initially false since the remote side is not yet configured. After fully configuring the local interface, debug output shows the interface state change to down until the remote side is also configured. The steps aim to demonstrate how debug output can provide insight into route states during router configuration.
This document discusses tools for working with time series data, including InfluxDB for storing time series data, Telegraf for collecting metrics, and Kapacitor for processing and alerting on metrics. It provides an overview of how to install and use InfluxDB, describes its HTTP and UDP APIs, query language, and advantages over alternatives. Continuous queries, input and output plugins for Telegraf, and alerting capabilities of Kapacitor are also summarized. The document encourages representing log lines and other time-indexed data as compact time series for scalability.
15LLP108_Demo4_LedBlinking.pdf1. Introduction In D.docxfelicidaddinwoodie
15LLP108_Demo4_LedBlinking.pdf
1. Introduction
In Demo3, we have learned how to read sensor values of light, temperature and humidity of a node
and output these values to the console. In this demonstration, we will use the code from Demo3 and
learn how to turn on/off the LEDs and make them blinking regularly on the sensor node XM1000,
meanwhile to count how many times the LED has blinked and output the count to the console.
2. Timer
In order to make the blue LED on the XM1000 sensor node to blink in every half second (i.e. On 0.5S
and Off 0.5S), we also need a timer. Follow the instructions in Demo3 for configure and reset a timer.
We aslo need to create an infinite while() loop so that it runs our functions repeatedly, such as
counting the times the LED has blinked, output the counter’s value and actually turn on or off the
LEDs to make it blinking.
Please follow timer and while() loop structure in Demo3.
3. LED Blinking
To get access to the LED functionalities in Contiki, we need to include the LED header file in the
source code:
#include "leds.h" // file is in directory /home/user/contiki/core/dev
After the process begin, we have to initialise the LEDs on the sensor node by calling the following
function:
leds_init(); // Initialise the LEDs
And finally we can turn on, off, or blink the LEDs by the following functions:
void leds_on(unsigned char leds);
void leds_off(unsigned char leds);
void leds_toggle(unsigned char leds);
void leds_invert(unsigned char leds);
For example, if you want to blink the Blue LED, yon need to call the toggle function as:
void leds_toggle(LEDS_BLUE); // Toggle the blue LED
4. Exercise
Modify the program from Demo3 with periodic timer to make the BLUE led blinking in every half
second, also to count the blinking times and output the counted number to the console.
Can your change the code so that the BLUE LED is lighted for 1 second and off for 0.5 second
periodically?
15LLP108 – Internet of Things and Applications
Lab Session 2: Demo 4 – LED Blinking
Prepared by Xiyu Shi
5. Source code
Here is the source code for reference
#include "contiki.h"
#include "leds.h"
#include <stdio.h> /* for printf() */
static struct etimer timer;
/*____________________________________________________*/
PROCESS(led_blinking_process, "LED Blinking Process");
PROCESS(LED_process, "LED process");
AUTOSTART_PROCESSES(&LED_process);
/*____________________________________________________*/
PROCESS_THREAD(LED_process, ev, data)
{
static int count = 0;
PROCESS_BEGIN();
etimer_set(&timer, CLOCK_CONF_SECOND/2); // 0.5S timer
leds_init(); // intialise the LEDs
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev==PROCESS_EVENT_TIMER); // wait for timer event
count++; // count the blinking times
process_start(&led_blinking_process, NULL); // to blink the BLUE Led
printf("Count: %d\n", count); // output the counte ...
This document provides steps to connect MicroPython to the SPIKE Prime hub and run code. It introduces the hub module for accessing hub functions like displaying text on the light matrix. The first challenge is to print "Hello World" by importing hub and using hub.display.show(). The document was created by Sanjay and Arvind Seshan to teach MicroPython on SPIKE Prime.
The Role Of Software And Hardware As A Common Part Of The...Sheena Crouch
This document discusses the implementation of a software-defined networking (SDN) system using Field Programmable Gate Arrays (FPGAs). It describes an SDN switch core that can modify packet headers based on flow tables and forward packets to different ports. An SDN controller programmed the flow tables and monitored packet flows. Attacker nodes, implemented with a Microblaze processor, transmitted packets to the SDN switch network at programmable rates. The system allowed observation and testing of the SDN switches and network. Hardware and software implementations are discussed to realize the SDN system on FPGAs.
This document provides an introduction to embedded systems through a training program. It defines embedded systems as the integration of software and hardware to perform a specific task. It then categorizes embedded systems as stand-alone, real-time, mobile, or networked. Examples are given for each category. The document outlines the basic components and skills needed for embedded systems, including software/hardware components and coding/analysis skills. It also provides instructions for creating a first project in Eclipse to blink an LED and introduces LCD interfacing with the ATmega16 microcontroller.
PVS-Studio and Continuous Integration: TeamCity. Analysis of the Open RollerC...Andrey Karpov
One of the most relevant scenarios for using the PVS-Studio analyzer is its integration into CI systems. Even though a project analysis by PVS-Studio can already be embedded with just a few commands into almost any continuous integration system, we continue to make this process even more convenient. PVS-Studio now supports converting the analyzer output to the TeamCity format-TeamCity Inspections Type. Let's see how it works.
A brief overview of linux scheduler, context switch , priorities and scheduling classes as well as new features. Also provides an overview of preemption models in linux and how to use each model. all the examples are taken from http://www.discoversdk.com
Similar to PART-2 : Mastering RTOS FreeRTOS and STM32Fx with Debugging (20)
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
PART-2 : Mastering RTOS FreeRTOS and STM32Fx with Debugging
1. Mastering RTOS: Hands on FreeRTOS
and STM32Fx with Debugging
Learn Running/Porting FreeRTOS Real Time Operating System on
STM32F4x and ARM cortex M based Mircocontrollers
Created by :
FastBit Embedded Brain Academy
Visit www.fastbitlab.com
for all online video courses on MCU programming, RTOS and
embedded Linux
PART-2
2. FastBit Embedded Brain Academy is an online training wing of Bharati Software.
We leverage the power of the internet to bring online courses at your fingertip in the domain of embedded
systems and programming, microcontrollers, real-time operating systems, firmware development,
Embedded Linux.
All our online video courses are hosted in Udemy E-learning platform which enables you to
exercise 30 days no questions asked money back guarantee.
For more information please visit : www.fastbitlab.com
Email : contact@fastbitlab.com
About FastBit EBA
10. RTOS Task Notification
Each RTOS task has a 32-bit notification value which is initialised
to zero when the RTOS task is created
An RTOS task notification is an event sent directly to a task that
can unblock the receiving task, and optionally update the
receiving task's notification value in a number of different
ways. For example, a notification may overwrite the receiving
task's notification value, or just set one or more bits in the
receiving task's notification value.
12. xTaskNotifyWait()
If a task calls xTaskNotifyWait() , then it waits
with an optional timeout until it receives a
notification from some other task or interrupt
handler.
14. xTaskNotifyWait() Parameters
ulBitsToClearOnEntry Any bits set in ulBitsToClearOnEntry will be
cleared in the calling RTOS task's notification
value on entry to the xTaskNotifyWait()
function (before the task waits for a new
notification) provided a notification is not
already pending when xTaskNotifyWait() is
called.For example, if ulBitsToClearOnEntry is
0x01, then bit 0 of the task's notification value
will be cleared on entry to the function.
Setting ulBitsToClearOnEntry to 0xffffffff
(ULONG_MAX) will clear all the bits in the
task's notification value, effectively clearing the
value to 0.
*This explanation is taken from https://www.freertos.org/xTaskNotifyWait.html
15. xTaskNotifyWait() Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotifyWait.html
ulBitsToClearOnExit Any bits set in ulBitsToClearOnExit will be
cleared in the calling RTOS task's notification
value before xTaskNotifyWait() function exits if a
notification was received.The bits are cleared
after the RTOS task's notification value has
been saved in *pulNotificationValue (see the
description of pulNotificationValue below).
For example, if ulBitsToClearOnExit is 0x03,
then bit 0 and bit 1 of the task's notification
value will be cleared before the function exits.
Setting ulBitsToClearOnExit to 0xffffffff
(ULONG_MAX) will clear all the bits in the
task's notification value, effectively clearing the
value to 0.
16. xTaskNotifyWait() Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotifyWait.html
pulNotificationValue Used to pass out the RTOS task's
notification value. The value copied to
*pulNotificationValue is the RTOS task's
notification value as it was before any bits
were cleared due to the ulBitsToClearOnExit
setting.If the notification value is not required
then set pulNotificationValue to NULL.
17. xTaskNotifyWait() Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotifyWait.html
xTicksToWait The maximum time to wait in the Blocked
state for a notification to be received if a
notification is not already pending when
xTaskNotifyWait() is called.The RTOS task
does not consume any CPU time when it is
in the Blocked state.
The time is specified in RTOS tick periods.
The pdMS_TO_TICKS() macro can be used
to convert a time specified in milliseconds
into a time specified in ticks.
18. xTaskNotifyWait() Return value
*This explanation is taken from https://www.freertos.org/xTaskNotifyWait.html
Returns:
pdTRUE if a notification was received, or a notification was
already pending when xTaskNotifyWait() was called.
pdFALSE if the call to xTaskNotifyWait() timed out before a
notification was received
19. xTaskNotify()
xTaskNotify() is used to send an event directly to and potentially
unblock an RTOS task, and optionally update the receiving task's
notification value in one of the following ways:
Write a 32-bit number to the notification value
Add one (increment) the notification value
Set one or more bits in the notification value
Leave the notification value unchanged
This function must not be called from an interrupt service routine
(ISR). Use xTaskNotifyFromISR() instead.
21. xTaskNotify Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotify.html
xTaskToNotify The handle of the RTOS task being notified.
This is the subject task;
22. xTaskNotify() Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotify.html
ulValue Used to update the notification value of
the subject task. See the description of
the eAction parameter below.
23. xTaskNotify() Parameters
*This explanation is taken from https://www.freertos.org/xTaskNotify.html
eAction An enumerated type that can take
one of the values documented in
the table below in order to perform
the associated action
eNoAction
eIncrement
eSetValueWithOverwrite
24. MS to Ticks conversion
xTicksTowait = ( xTimeInMs * configTICK_RATE_HZ ) / 1000
Example :
If configTICK_RATE_HZ is 500, then Systick interrupt is going to happen for every
2ms.
So, 500ms of delay is equivalent to 250 ticks duration
25. Write a program which creates 2 tasks task_led and task_button with
equal priorities.
When button is pressed, task_button should notify the task_led and
task_led should run on the CPU to toggle the LED . Also task_led
should print how many times user has pressed the button so far.
task_led should not unnecessarily run on the CPU and it should be in
Block mode until it receives the notification from the task_button .
Exercise
26. Time
Task execution
Task_LED
Task_LED runs, but there are no
notifications. So blocks
Task_button
Task_button runs always because
Task_LED is blocked
Task_LED
Task_LED runs because it
received notification from
Task_button . It Toggles LED and
again blocks because of no new
notifications
Task_button
Task_button runs always because
Task_LED is blocked
User presses the button
Notify
Here “Idle” Task never runs because Task_button is of higher priority than Idle task and it never blocks
28. FreeRTOS is Free “Don’t worry “
You can use it in your commercial applications “No problem ”
No need to give any royalty to freertos.org “ Awesome “
Its based on GNU GPL license and you should make open your code changes made to
FreeRTOS kernel “That’s Ok “
You need not to open source your applications Written using freeRTOS API
Does it pass any safety standard ? No it doesn't
Is it safe to use freeRTOS in Safety critical applications ? “No No No ”
29. Does freertos.org provide any legal protection ? No it doesn’t
Does freeRTOS.org provides any technical support ? No it doesn’t
31. FreeRTOS: Commercial licensing
If you want ,
Legal Support
Technical Support during your Product development
Ensure meeting safety standard
Then you have to go for Commercial Licensing of
freertos.org
32. FreeRTOS : Commercial licensing
SAFERTOSTM is a derivative version of FreeRTOS that has been analyzed, documented
and tested to meet the stringent requirements of the IEC 61508 safety standard. This
RTOS is audited to verify IEC 61508 SIL 3 conformance.
OpenRTOSTM is a commercially licensed version of FreeRTOS. The OpenRTOS license
does not contain any references to the GPL
40. RAM and Flash
RAM FLASH
1) To store your application data like global arrays,
global variables, etc
2) You can download code to RAM and Run
(e.g patches )
1) A part of RAM is used as STACK to store local
variables , function arguments, return address, etc
2) A part of RAM is used as HEAP for dynamic memory
allocations
1) Flash is used to hold your application code
2) Flash also holds constants like string
initialization
3) Flash holds the vector table for interrupts and
exceptions of the MCU
41. Stack and Heap in embedded Systems
RAM
Low High
stackHeap
This RAM space is used for
Global data, arrays, static variables, etc
42. Stack and Heap in embedded Systems
out of order access of memory
Fist in Last out Order Access
43. sp : Stack Pointer
used : Unavailable stack (already used )
args : function arguments
ret : return address
locals : local variable
free : available stack
Stack
44. char do_sum( int a , int b, int c )
{
char x=1;
char y=2;
char *ptr;
ptr = malloc(100);
x = a+b+c;
return x ;
}
Local variables
Some operations
Exiting [R0 = x]
R0
R1
R2
Return address
X = 1
Y = 2
Ptr = 0x400000
a
b
c
used
Free
SP
used
Free
Stack
45. Heap
How to manage Heap memory ?
Total Heap size
A heap is a general term used for any memory that is allocated dynamically and randomly.
I understand stack is managed by SP and dedicated instructions like PUSH n POP , how Heap is
managed ?
How the heap is managed is really up to the runtime environment. C uses malloc and C++
uses new .
But for embedded systems malloc and free APIs are not suitable because they eat up large code
space , lack of deterministic nature and fragmented over time as blocks of memory are allocated
46. FreeRTOS Stack and heap management
Temperature monitoring
application
Task 1
Sensor data
gathering
Task-2
Updating
display
Task-3
User input
processing
Every task creation will consume some memory in RAM to store its
TCB and stack
TCB-1
Stack-1
So , 1 task creation consumes TCB size + Stack size in RAM
TCB-2
Stack-2
TCB-3
Stack-3
47. FreeRTOS Stack and heap
RAM
Low High
Heap
Who decides the starting address and size of the heap?
By default the FreeRTOS heap is declared by FreeRTOS kernel
Setting configAPPLICATION_ALLOCATED_HEAP to 1 allows the heap to instead be declared by
the application
53. /* Allocate space for the TCB. Where the memory comes from depends
on the implementation of the port malloc function and whether or not
static allocation is being used. */
pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
if( pxNewTCB != NULL )
{
/* Allocate space for the stack used by the task being created.
The base of the stack memory stored in the TCB so the task can
be deleted later if required. */
pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t )
usStackDepth ) * sizeof( StackType_t ) ) );
54. FreeRTOS Heap management Schemes
FreeRTOS APIs and
Applications
heap_1.c heap_2.c heap_3.c heap_4.c heap_5.c
pvPortMalloc() pvPortMalloc()
vPortFree()
pvPortMalloc()
vPortFree()
pvPortMalloc()
vPortFree()
pvPortMalloc()
vPortFree()
Application uses any one of these Schemes according to its requirements
Your_own
_mem.c
pvPortMalloc()
vPortFree()
57. Synchronization between Tasks
I need some data to consume .
But waiting for Task A to produce
some data.
Task A
Task B
Data Producer
58. Synchronization between Tasks
Signal
I produced data
Sending Task B a signal to consume
data
Task A
Data Producer Just Received the signal from the
Task A. Lets come out of waiting
state and start executing
Task B
59. Synchronization between Task and
Interrupt
I filled the queue with some data
.Sending a signal to consume data
Keyboard
ISR
Data Producer Received signal to wakeup
Looks like Queue has some data, lets
wakeup and display it on LCD
LCD Task AEmpty
Queue
60. Synchronization between Task and
Interrupt
Received signal to wakeup
Looks like Queue has some data, lets
wakeup and display it on LCD
I filled the queue with some data
.Sending a signal to consume data
QueueKeyboard
ISR
Data Producer
LCD Task A
61. How to achieve this signaling ?
Events (or Event Flags)
Semaphores ( Counting and binary )
Queues and Message Queues
Pipes
Mailboxes
Signals (UNIX like signals)
Mutex
All these software subsystems
support signaling hence can be
used in Synchronization
purposes
62. You will Learn More :
1) How to use Binary semaphore?
2) How to use Counting semaphore ?
3) How to synchronize between tasks ?
4) How to synchronize between a task and interrupt ?
5) How to use queues for synchronizations ?
6) Code examples.
63. Mutual Exclusion Services of FreeRTOS
Mutual exclusion
means that only a single thread should be able to access the shared resource at
any given point of time. This avoids the race conditions between threads
acquiring the resource. Usually you have to lock that resource before using and
unlock it after you finish accessing the resource.
Synchronization
means that you synchronize/order the access of multiple threads to the shared
resource.
64. This code acts on shared item “Counter”
So needs protection
69. Variables of type ’unsigned long’ are prefixed with ’ul’, where the 'u' denotes 'unsigned'
and the 'l' denotes 'long'.
Variables of type ’unsigned short’ are prefixed with ’us’, where the 'u' denotes
'unsigned' and the 's' denotes 'short‘
Variables of type ’unsigned char’ are prefixed with ’uc’, where the 'u' denotes 'unsigned'
and the 'c' denotes 'char'.
Variables of non stdint types are prefixed with ‘x’
Unsigned variables of non stdint types have an additional prefix ’u’
Enumerated variables are prefixed with ‘e’
Variables Convention
70. Pointers have an additional prefix ‘p’, for example a pointer to a uint16_t will have
prefix ’pus’.
In line with MISRA guides, unqualified standard ’char ’types are only permitted to hold
ASCII characters and are prefixed with ‘c’.
In line with MISRA guides, variables of type ’char *’ are only permitted to hold pointers
to ASCII strings and are prefixed ’pc’
Variables Convention
72. API functions are prefixed with their return type, as per the convention defined
for variables, with the addition of the prefix ’v’ for void.
API function names start with the name of the file in which they are defined.
For example vTaskDelete is defined in tasks.c, and has a void return type
File scope static (private) functions are prefixed with ’prv’.
Functions Convention
74. Macros are pre-fixed with the file in which they are defined. The pre-fix is lower
case. For example, configUSE_PREEMPTION is defined in FreeRTOSConfig.h.
Other than the pre-fix, macros are written in all upper case, and use an
underscore to separate words.
Macros
78. Deleting a Task
RAM
Low High
Heap (configTOTAL_HEAP_SIZE)
Task -1
TCB
Stack
TCB1
STACK-1
Task -2
TCB
Stack
TCB-2
STACK-2
This RAM space is used for
Global data, arrays, static variables,
etc
xTaskCreate() xTaskCreate()
79. Deleting a Task
RAM
Low High
Heap (configTOTAL_HEAP_SIZE)
Task -1
TCB
Stack
TCB1
STACK-1
This RAM space is used for
Global data, arrays, static variables,
etc
xTaskCreate()
void vTaskDelete( xTaskHandle pxTaskToDelete );
81. Write an application which launches 2 tasks task1 and task2.
task1 priority = 1
task2 priority = 2
task 2 should toggle the LED for every 1 sec and should delete itself
when button is pressed by the user.
task1 should toggle the same led for every 200ms.
Exercise
84. configKERNEL_INTERRUPT_PRIORITY
This config item, decides the priority for the kernel Interrupts
What are the kernel interrupts ?
#define configTICK_RATE_HZ ( (portTickType)1000)
Time
Systick
Interrupt
PendSV interrupt
SVC interrupt
1
2
3
86. configKERNEL_INTERRUPT_PRIORITY
This config item, decides the priority for kernel Interrupts
What are the kernel interrupts ?
#define configTICK_RATE_HZ ( (portTickType)1000)
Time
Systick
Interrupt
PendSV interrupt
SVC interrupt
1
2
3
87. configMAX_SYSCALL_INTERRUPT_PRIORITY
In the newer version of FreeRTOS Port file, its name is changed to
configMAX_API_CALL_INTERRUPT_PRIORITY
This is a threshold priority limit for those interrupts which use freeRTOS APIs
which end with “FromISR”
Interrupts which use freeRTOS APIs ending with “FromISR” , should not use
priority greater than this value.
Greater priority = less in numeric value
89. Priority Register
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Implemented Not implemented
Microcontroller Vendor XXX Microcontroller Vendor YYY
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Implemented Not implemented
8 Levels of Priority level 16 Levels of Priority level
Write has no effect Write has no effect
0x00,0x20,0x40,0x60,
0x80,0xA0,0xC0, 0xE0
0x00,0x10,0x20,0x30,0x40,0x50,
0x60,0x70,0x80,0x90,0xa0,0xb0,0xc0,0xd0,0xe0,0xf0
AT91SAM3X8ESTM32F4xxTM4C123G
90. Priority Register
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Implemented Not implemented
Microcontroller Vendor XXX Microcontroller Vendor YYY
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Implemented Not implemented
8 Levels of Priority level 16 Levels of Priority level
Write has no effect Write has no effect
0x00,0x20,0x40,0x60,
0x80,0xA0,0xC0, 0xE0
0x00,0x10,0x20,0x30,0x40,0x50,
0x60,0x70,0x80,0x90,0xa0,0xb0,0xc0,0xd0,0xe0,0xf0
AT91SAM3X8ESTM32F4xxTM4C123G
configMAX_SYSCALL_INTERRUPT_PRIORITY
Highest Priority
Lowest Priority
the interrupt service routine that
uses an RTOS API function must
have its priority manually set to a
value that is numerically equal to
or greater than this point.
91. 0x00, 0x10, 0x20, 0x30, 0x40, 0x50,
0x60, 0x70, 0x80, 0x90, 0xA0, 0XB0,
0xC0, 0xD0, 0xE0, 0xF0
Highest Priority configMAX_SYSCALL_INTERRUPT_PRIORITY
Lowest Priority
The interrupt service routine that uses an RTOS API function must have its priority
manually set to a value that is numerically equal to or greater than this point. Remember
in ARM greater prio. Value lesser is the priority(urgency)
Priority values of those ISRs which do not call
FreeRTOS APIs which end with “FromISR”
Priority values of those ISRs which call FreeRTOS
APIs which end with “FromISR”
92. FreeRTOS APIs that end in "FromISR" are interrupt safe, but even these APIs should not
be called from ISRs that have priority(Urgency) above the priority defined by
configMAX_SYSCALL_INTERRUPT_PRIORITY
Therefore, any interrupt service routine that uses an RTOS API function must have its
priority value manually set to a value that is numerically equal to or greater than
configMAX_SYSCALL_INTERRUPT_PRIORITY setting
Cortex-M interrupts default to having a priority value of zero. Zero is the highest possible
priority value. Therefore, never leave the priority of an interrupt that uses the interrupt
safe RTOS API at its default value.
ConcludingPoints
93. ConcludingPoints
First we learnt there are 2 configuration items
configKERNEL_INTERRUPT_PRIORITY
configMAX_SYSCALL_INTERRUPT_PRIORITY
configKERNEL_INTERRUPT_PRIORITY : The kernel interrupt priority config item
actually decides the priority level for the kernel related interrupts like systick,
pendsv and svc and it is set to lowest interrupt priority as possible.
configMAX_SYSCALL_INTERRUPT_PRIORITY : The max sys call interrupt priority
config item actully decides the maximum priority level , that is allowed to use for
those interrupts which use freertos APIs ending with “FromIsr” in their interrupt
service routines.
96. Non-ARM Cortex M Architectures
lower priority means higher numeric value
interrupt-1
2Priority
interrupt-2
5Priority
Lower logical Priority means
higher numeric priority value
100. API to set Priority
void vTaskPrioritySet( xTaskHandle pxTask,
unsigned portBASE_TYPE uxNewPriority );
101. API to Get Priority
unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle pxTask );
102. Write an application which creates 2 tasks
task 1 : Priority 2
task 2 : Priority 3
task 2 should toggle the LED at 1 sec duration and task 1 should
toggle the led at 100ms duration.
When application receives button interrupt the priority must be
reversed in side the task handlers.
Exercise
106. Interrupt Un-Safe APIs
FreeRTOS APIs which don’t end with the word “FromISR”
are called as interrupt unsafe APIs
e.g.
xTaskCreate(),
xQueueSend()
xQueueReceive()
etc
107. If you want to send a data item in to the queue from the ISR, then use xQueueSendFromISR()
instead of xQueueSend().
xQueueSendFromISR() is an interrupt safe version of xQueueSend().
If you want to Read a data item from the queue being in the ISR, then use
xQueueReceiveFromISR() instead of xQueueReceive().
xQueueReceiveFromISR() is an interrupt safe version of xQueueReceive( ).
xSemaphoreTakeFromISR() is an interrupt safe version of xSemaphoreTake() : which is used to
‘take’ the semaphore
xSemaphoreGiveFromISR() is an interrupt safe version of xSemaphoreGive() : which is used to
‘give’ the semaphore
Interrupt Safe and Un-safe APIs
110. Queue_write(QUEUE *qptr , void * data)
{
1. write to queue
2. does write to queue unblock any higher priority task ?
3. if yes, must do taskYIELD()
4. if no, continue with the same task 1
}
113. Ok ,That’s fine but our goal is to understand why the same API
Queue_Write() can not be called from an ISR ?? Why its ISR
flavour Queue_Write_FromISR() must be used in FreeRTOS ??
Why separate interrupt Safe APIs?
115. Queue_write_FromISR (QUEUE *qptr , void * data, void *
xHigherPriorityTaskWoken)
{
1. write to queue
2. does write to queue unblocks any higher priority task ?
3. if yes, then set xHigherPriorityTaskWoken = TRUE
4. if no, then set xHigherPriorityTaskWoken = FALSE
5. return to ISR
}
116. QUEUE some_queue;
ISR_Fun(void *data)
{
unsigned long xHigherPriorityTaskWoken = FALSE;
Queue_write_FromISR(&some_queue, data, & xHigherPriorityTaskWoken );
next statement 1;
next statement 2;
.
.
.
/* yielding to task happens in ISR Context , no tin API context */
if(xHigherPriorityTaskWoken )
portYIELD()
}
118. Interrupt Safe APIs: Conclusion
Whenever you want use FreeRTOS API from an ISR its ISR version must be used,
which ends with the word “FromISR”
This is for the reason, Being in the interrupt Contex (i.e being in the middle of
servicing the ISR) you can not return to Task Context (i.e making a task to run by
pre-empting the ISR)
In ARM cortex M based Processors usage exception will be raised by the
processor if you return to the task context by preempting ISR .
122. Top Level Task States- Simplistic Model
Not-Running
Running
Only one task can be
in running at any
given point in time
All other tasks which
are not running
currently on the CPU
are in Not running state
125. What is blocking of a Task ?
A Task which is Temporarily or permanently chosen not to run on CPU
for ( int i=0 ; i < 5000 ; i++ );
Generate delay of ~ 10ms
CPU
This code runs on CPU continuously for
10ms, Starving other lower priority tasks.
Never use such delay implementations
vTaskDelay(10)
This is blocking delay API which blocks the
task for 10ms. That means for the next
10ms other lower priority tasks can run.
After 10ms the task will wake up
CPUNot runs for 10ms
runs for 10ms
Engaged
Not-Engaged
126. Advantages of blocking:
1. To implement the blocking Delay – For example a task may enter the Blocked state
to wait for 10 milliseconds to pass.
2. For Synchronization –For example, a task may enter the Blocked state to wait for
data to arrive on a queue. When the another task or interrupt fills up the queue , the
blocked task will be unblocked.
FreeRTOS queues, binary semaphores, counting semaphores, recursive
semaphores and mutexes can all be used to implement synchronization and thus
they support blocking of task.
127. Blocking Delay APIs
vTaskDelay()
vTaskDelayUntil()
Queues Semaphores Mutex
All these kernel objects support APIs which can block a task during
operation , which we will explore later in their corresponding sections
Not-Running State
138. t1 t2 t3 t4 t5 t6 t7 t8
Task 2
Task 1
Time
At time t1, Task 1 enters the
running state and executes until
time t2
At time t2 Task 2 enters the running state
and executes until time t3-at which point
Task1 re enters the Running state
Task 2
Task 1
Time
Tick interrupt
The Scheduler Runs in the Tick interrupt but selects
the same task. Task 2 is always in the running state
and Task 1 is always in the Not Running State
Kernel
Case 1 :
Task 1 and Task-2 having same
priorities
Case 2 :
Task-1 is having lower priority
than Task-2
143. Conclusion
Never use for loop based delay implementation , which
doesn’t do any genuine work but still consumes the CPU .
Using for loop for delay implementation may also prevent
any lower priority task to take over the CPU during the
delay period.
150. t1 t2 tn
Task 2
Task 1
Time
Task 1 prints status of the
LED over UART, then it too
enters the Blocked state by
calling VTaskDelay(1000)
When the delay expires the scheduler moves the
tasks back into the ready state, where both
execute again before once again calling
vTaskDelay() causing then to re-enter the blocked
state. Task-2 executes first as it has the higher
Priority
Idle
Task 2 has the highest priority so runs first. It
toggles the LED then calls vTaskDelay(1000) and
in so doing enters the blocked state, permitting
the lower priority Task 1 to execute.
2
3
1
At this point both applications tasks are
In the blocked state-so the idle task
runs
4
1000ms
1000ms
152. Idle Task hook function
Idle task hook function implements a callback from idle task to your application
You have to enable the idle task hook function feature by setting this config item
configUSE_IDLE_HOOK to 1 within FreeRTOSConfig.h
Then implement the below function in your application
void vApplicationIdleHook( void );
That’s it , whenever idle task is allowed to run, your hook function will get called, where
you can do some useful stuffs like sending the MCU to lower mode to save power
153. FreeRTOS Hook Functions
Idle task hook function
RTOS Tick hook function
Dynamic memory allocation failed hook function (Malloc Failed Hook
Function)
Stack over flow hook function
These hook functions you can implement in your application code if required
The FreeTOS Kernel will call these hook functions whenever corresponding
events happen.
154. Idle task hook function
configUSE_IDLE_HOOK should be 1 in FreeRTOSConfig.h
and your application source file (main.c) should implement the below function
void vApplicationIdleHook( void )
{
}
FreeRTOS Hook Functions
155. RTOS Tick hook function
configUSE_TICK_HOOK should be 1 in FreeRTOSConfig.h
and your application source file (main.c) should implement the below function
void vApplicationTickHook ( void )
{
}
FreeRTOS Hook Functions
156. Malloc Failed hook function
configUSE_MALLOC_FAILED_HOOK should be 1 in FreeRTOSConfig.h
and your application source file (main.c) should implement the below function
void vApplicationMallocFailedHook ( void )
{
}
FreeRTOS Hook Functions
157. Stack over flow hook function
configCHECK_FOR_STACK_OVERFLOW should be 1 in FreeRTOSConfig.h
and your application source file (main.c) should implement the below function
void vApplicationStackOverflowHook( TaskHandle_t xTask, signed char
*pcTaskName )
{
}
FreeRTOS Hook Functions
158. Write a program to send Microcontroller to sleep mode when Idle
task is scheduled to run on the CPU and take the current
measurement.
Exercise
161. Preemption
Preemption is the act of temporarily interrupting an already
executing task with the intention of removing it from the
running state without its co-operation .
163. Pre-emptive Scheduling
Task 1
Task 2
Task 3
task 1 is executing.1
OS tick interrupt happens(time slice is over)2
Task 1 is swapped out3
Task 2 is allowed to run4
Task 2 is swapped out and
Task 3 resumes to run
5
Task 3 blocked due to some
reason
6
Task 1 is resumed working
Due to task yielding
7
8
Task 1 swapped out
And Task 2 is allowed to run
t1 t2 t3 t4 t5 t6 t7
164. What RTOS tick ISR does ? : Conclusion
Tick ISR Runs
xPortSysTickHandler()
portDISABLE_INTERRUPTS();
xTaskIncrementTick() ==
TRUE
Pend the PendSV
portENABLE_INTERRUPTS();
xTickCount++
checks to see if the new tick
value will cause any
tasks to be unblocked
Calls application hook
function if enabled
Returns TRUE if context
switch is required
xTaskIncrementTick()
1
2
3
4 Exit from ISR
SysTick interrupt
False
True
166. Prioritized Pre-emptive Scheduling
Task-1
Task List
Task-2
Priority
1
Priority
5
If you call
vTaskStartScheduler() ,
then I will run and I
make Task-2 to run first
Task 2
t1 t2 t3 t4 t5 t6 t7 t8 t9
Task 2 is blocked ,
CPU is yielded to task-1(Pend PendSV)
Task 1
167. Prioritized Pre-emptive Scheduling
If you call
vTaskStartScheduler() ,
then I will run and I make
Task-2 to run first
Task 2
Task 1
Task-1
Task List
Task-2
Priority
1
priority
5
Task 2 is finished its work
So it yields the processor (call for context
swtich )
168. t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12
t13
Idle ( Continuous task )
Task 3 ( low, event)
Task 2 ( med, Periodic)
Task 1(high, event)
Task 3 pre-empts
the idle task
Task 2 pre-empts
Task-3
Task 1 pre-empts
Task-2
Task 2 pre-empts
the idle task
Event processing is
delayed until higher
priority tasks leaves the
CPU
Prioritized Pre-emptive Scheduling
169. Prioritized Pre-emptive Scheduling
taskYield() - is used to request a context switch to another
task
A B C A D ATasks
SysTick ISR
PendSV
handler
IRQ
taskYIELD()
vTaskDelay()
Set semaphore which unblocks
Higher priority Task D
171. Co-Operative scheduling
As the name indicates, it is a co-operation based
scheduling . That is Co-operation among tasks to
run on the CPU.
172. taskYield() - is used to request a context switch to another
task
Tasks
SysTick ISR
PendSV
handler
IRQ
taskYIELD()
vTaskDelay()
A B C C
Co-operative scheduling
174. Conclusion
First we learnt about simple preemptive scheduling, here priorities of tasks are irrelevant .
Equal amount of time slice is given to each ready state tasks.
Where as in priority based preemptive scheduling, the context switch will always happen to
the highest priority ready state task.
So, here Priority will play a major role in deciding which task should run next .
And in the co-operative scheduling , the context switch will never happen without the co-
operation of the running task. Here, the systick handler will not be used to trigger the
context switch.
When the task thinks that it no longer need CPU. then it will call task yield function to give
up the cpu for any other ready state tasks.