Merge pull request #3111 from madeline-underwood/cmsip

Enhance documentation for CMSIS-DSP Python learning path with improve…

Author: pareenaverma

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/_index.md

@@ -1,6 +1,8 @@
 ---
 title: Getting started with CMSIS-DSP using Python
 
+description: Learn how to prototype and port DSP algorithms using the CMSIS-DSP Python package, mapping Python code to efficient C implementations for embedded Cortex-M and Cortex-A platforms.
+
 minutes_to_complete: 45
 
 who_is_this_for: This is an advanced topic for developers looking to integrate the CMSIS-DSP library into their applications using Python.

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-3.md

@@ -79,7 +79,7 @@ slices = sliding_window_view(data,winLength)[::winOverlap,:]
 slices_q15 = sliding_window_view(dataQ15,winLength)[::winOverlap,:]
 ```
 
-Refer to the [NumPy documentation](https://numpy.org/doc/stable/reference/generated/numpy.lib.stride_tricks.sliding_window_view.html) for details about `sliding_window_view`. It's not the most efficient function, but it is sufficient for this tutorial. The signal is split into overlapping blocks: each block reuses half of the samples from the previous block as defined by the `winOverlap` variable.
+Refer to the [NumPy documentation](https://numpy.org/doc/stable/reference/generated/numpy.lib.stride_tricks.sliding_window_view.html) for details about `sliding_window_view`. It's not the most efficient function, but it's sufficient for this tutorial. The signal is split into overlapping blocks: each block reuses half of the samples from the previous block as defined by the `winOverlap` variable.
 
 By running that last block, you have an audio signal that has been split into overlapping blocks. 
 

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-5.md

@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Understand the mathematics behind noise suppression
 
-In this section, you will learn about the mathematics that serves as a basis for the use case. Then, you will use those principles to create a reference implementation using NumPy.
+In this section, you'll learn about the mathematics that serves as a basis for the use case. Then, you'll use those principles to create a reference implementation using NumPy.
 
 ### Overlapping windows
 
-The blocks of audio samples you created in the previous steps will be multiplied by a Hanning window function, which you will achieve by running the following in the Jupyter notebook:
+The blocks of audio samples you created in the previous steps will be multiplied by a Hanning window function, which you'll achieve by running the following in the Jupyter notebook:
 
 ```python
 window=dsp.arm_hanning_f32(winLength)
@@ -148,7 +148,7 @@ The constructor for `NoiseSuppressionReference`:
 
 #### Subnoise
 
-Calculates the approximate Wiener gain and it is applied to all frequency bands of the FFT. The `v` argument is a vector. If the gain is negative, it is set to 0. A small value is added to the energy to avoid division by zero.
+Calculates the approximate Wiener gain and it's applied to all frequency bands of the FFT. The `v` argument is a vector. If the gain is negative, it's set to 0. A small value is added to the energy to avoid division by zero.
 
 ```python
 def subnoise(self,v):

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-7.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Converting functions
 
-Now that your Python prototype is verified, it's time to translate the key functions into C using the CMSIS-DSP library. Because the CMSIS-DSP Python API closely mirrors the C API, the conversion is generally straightforward. In this section, you will have a look at two examples to understand how the conversion works.
+Now that your Python prototype is verified, it's time to translate the key functions into C using the CMSIS-DSP library. Because the CMSIS-DSP Python API closely mirrors the C API, the conversion is generally straightforward. In this section, you'll have a look at two examples to understand how the conversion works.
 
 ### Rescaling
 
@@ -108,7 +108,7 @@ int16_t signal_energy_q15(q15_t *window,uint32_t nb)
     // Fixed point format of result is on 16 bit
     // but the specific format has not been identified
     // to make this tutorial easier.
-    // We just know it is not q15
+    // We just know it's not q15
     int16_t dB;
 
     arm_vlog_q15(&energy,&dB,1);
@@ -119,4 +119,4 @@ int16_t signal_energy_q15(q15_t *window,uint32_t nb)
 
 As you can see, a DSP function written in Python using the CMSIS-DSP Python wrappers can be directly mapped to a very similar C function with only minor adjustments. This makes it easy to prototype quickly in Python and then migrate to efficient, production-ready C code for embedded platforms.
 
-In the final section, you will explore some additional resources to learn more and start using CMSIS-DSP in your applications.
+In the final section, you'll explore some additional resources to learn more and start using CMSIS-DSP in your applications.

content/learning-paths/embedded-and-microcontrollers/cmsisdsp-dev-with-python/how-to-8.md

@@ -21,8 +21,8 @@ While the CMSIS-DSP Python package makes prototyping and conversion to C relativ
 
 - Part of the difficulty in this Learning Path comes from splitting and recombining the signal. Porting the block-handling logic from Python to C introduces additional complexity.
 
-[CMSIS-Stream](https://github.com/ARM-software/CMSIS-Stream) can help with this. It is a platform-independent technology designed to simplify the use of block-processing functions with sample streams. 
+[CMSIS-Stream](https://github.com/ARM-software/CMSIS-Stream) can help with this. It's a platform-independent technology designed to simplify the use of block-processing functions with sample streams. 
 
-If you are planning to deploy your DSP algorithms in streaming, real-time systems, it is worth exploring CMSIS-Stream. It can greatly simplify handling streams of data with block-based processing, offering a clean and efficient way to bridge the gap between theory and deployment.
+If you're planning to deploy your DSP algorithms in streaming, real-time systems, it's worth exploring CMSIS-Stream. It can greatly simplify handling streams of data with block-based processing, offering a clean and efficient way to bridge the gap between theory and deployment.
 
 You should now have a better idea of what the CMSIS-DSP Python package is capable of, and how it relates to its C equivalent.