stm8l_discovery-DMA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# STM8L-Discovery DMA example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load [REMCU](https://remotemcu.com) shared libray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ".L libremcu.so"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add path with header files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ".I remcu_include"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Including necessary header files. The [“remcu.h”](remcu_include/remcu.h) header must be always included before any MCU header files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include \"remcu.h\"\n",
    "#include \"stm8l15x.h\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connection to a debug server. The [**REMCU**](https://remotemcu.com/) library is able to work with [OpenOCD](https://github.com/ilg-archived/openocd/releases/tag/v0.10.0-12-20190422) or [GDB server](https://atollic.com/resources/download/).\n",
    "There is using the [remcu_connect2OpenOCD](https://remotemcu.com/api-v1-0#remcu_getVersion) function for connecting to the OpenOcd server. The functions have the same set of parameters. The first parameter is an IP address of the debug server. The second one is a port of the debug server. For instance, OpenOCD server print the port in log messages. The third parameter is a connection timeout. Upon a successful connection, the function returns the “true” value, otherwise, it returns “false”.\n",
    "\n",
    "> Detailed description of other REMCU function you see in [“remcu.h”](remcu_include/remcu.h) or [API reference](https://remotemcu.com/api-v1-0)\n",
    "\n",
    "Before that, plug STM8L-Discovery board with debugger to PC\n",
    "\n",
    "run openocd utility in command line:\n",
    "```\n",
    "./openocd -f interface/stlink-v2.cfg -f target/stm8l.cfg\n",
    "```\n",
    "Result:\n",
    "![Image](img/openocd_unix.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const char * debug_server_ip = \"localhost\";\n",
    "const uint16_t default_openocd_port = 6666;\n",
    "const int timeout_sec = 3; // It can not be negative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remcu_connect2OpenOCD(debug_server_ip, default_openocd_port, timeout_sec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to use the GDB server of OpenOCD, uncomment and run code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//const uint16_t default_openocd_gdb_port = 3333;\n",
    "//remcu_connect2GDB(debug_server_ip, default_openocd_gdb_port, timeout_sec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If connection were failed and the function returned false. See [Issue](https://github.com/remotemcu/remcu_examples/issues) and [Troubleshooting Page](https://remotemcu.com/troubleshooting-page) \n",
    "    \n",
    "If connection were success... Jupyter Output:\n",
    "![Image](img/success_connection_for_unix.png)\n",
    "\n",
    "Reset the MCU (see [“remcu.h”](remcu_include/remcu.h) or [API reference](https://remotemcu.com/api-v1-0)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remcu_resetRemoteUnit(__HALT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ADC-DMA example\n",
    "This snippet captures ADC data on PC7 pin of STM8L-Discovery and store to MCU's memory(RAM: at 0x0 address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  /*High speed external clock prescaler: 1*/\n",
    "  CLK_SYSCLKDivConfig(CLK_SYSCLKDiv_1);\n",
    "\n",
    "  /* Enable ADC1 clock */\n",
    "  CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);\n",
    "\n",
    "  /* Enable DMA1 clock */\n",
    "  CLK_PeripheralClockConfig(CLK_Peripheral_DMA1, ENABLE);\n",
    "\n",
    "  /* Enable TIM1 clock */\n",
    "  CLK_PeripheralClockConfig(CLK_Peripheral_TIM1, ENABLE);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ADC_SamplingTime_TypeDef SamplingTime;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  SamplingTime = ADC_SamplingTime_4Cycles;\n",
    "\n",
    "  /* Initialize and configure ADC1 */\n",
    "  ADC_Init(ADC1, ADC_ConversionMode_Single, ADC_Resolution_12Bit, ADC_Prescaler_1);\n",
    "  ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, SamplingTime);\n",
    "\n",
    "  /* Enable ADC1 */\n",
    "  ADC_Cmd(ADC1, ENABLE);\n",
    "\n",
    "  /* Enable ADC1 Channels 3 - PC7 pin */\n",
    "  ADC_ChannelCmd(ADC1, ADC_Channel_3, ENABLE); /* connected to Potentiometer RV */"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "const uint16_t ADC_BUFFER_ADDRESS = 0x0;\n",
    "const uint16_t ADC1_DR_ADDRESS  = 0x5344;\n",
    "const uint16_t ADC1_8_DR_ADDRESS  = 0x5345;\n",
    "const uint8_t ADC_BUFFER_SIZE = 0xFF;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " /* Connect ADC to DMA channel 0 */\n",
    "  SYSCFG_REMAPDMAChannelConfig(REMAP_DMA1Channel_ADC1ToChannel0);\n",
    "  DMA_GlobalDeInit();\n",
    "  DMA_DeInit(DMA1_Channel0);\n",
    "  DMA_Init(DMA1_Channel0, ADC_BUFFER_ADDRESS,\n",
    "           ADC1_DR_ADDRESS,           //set ADC1_8_DR_ADDRESS, if you want to use 8-bit mode of ADC\n",
    "           ADC_BUFFER_SIZE,\n",
    "           DMA_DIR_PeripheralToMemory,\n",
    "           DMA_Mode_Circular,\n",
    "           DMA_MemoryIncMode_Inc,\n",
    "           DMA_Priority_High,\n",
    "           DMA_MemoryDataSize_HalfWord           //set DMA_MemoryDataSize_Byte, if you want to use 8-bit mode of ADC\n",
    "           );\n",
    "\n",
    "  /* DMA Channel0 enable */\n",
    "  DMA_Cmd(DMA1_Channel0, ENABLE);\n",
    "\n",
    "  /* DMA enable */\n",
    "  DMA_GlobalCmd(ENABLE);\n",
    "\n",
    "  /* Enable ADC1 DMA requests*/\n",
    "  ADC_DMACmd(ADC1, ENABLE);\n",
    "\n",
    "  /* Start ADC1 Conversion using TIM1 TRGO*/\n",
    "  ADC_ExternalTrigConfig(ADC1, ADC_ExtEventSelection_Trigger2, ADC_ExtTRGSensitivity_Rising);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uint16_t TIM1_Prescaler;\n",
    "uint16_t TIM1_Period;\n",
    "uint8_t TIM1_RepetitionCounter;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  TIM1_Prescaler = 0x0; \n",
    "  TIM1_Period = 0x2;\n",
    "  TIM1_RepetitionCounter = 0;\n",
    "  TIM1_TimeBaseInit(TIM1_Prescaler, TIM1_CounterMode_Up, TIM1_Period, TIM1_RepetitionCounter);\n",
    "/* Master Mode selection: Update event */\n",
    "  TIM1_SelectOutputTrigger(TIM1_TRGOSource_Update);\n",
    "/* Enable TIM1 */\n",
    "  TIM1_Cmd(ENABLE);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include \"xplot/xfigure.hpp\"\n",
    "#include \"xplot/xmarks.hpp\"\n",
    "#include \"xplot/xaxes.hpp\"\n",
    "\n",
    "xpl::figure fig;\n",
    "xpl::linear_scale sx, sy;\n",
    "xpl::lines line(sx, sy);\n",
    "std::vector<uint16_t> adc_data(ADC_BUFFER_SIZE );\n",
    "std::vector<int> x_line(ADC_BUFFER_SIZE );\n",
    "int osc_data[ADC_BUFFER_SIZE] = {0};\n",
    "size_t shift = 0;\n",
    "int i = 0;\n",
    "for( auto & x : x_line){x = i++;}\n",
    "line.x = x_line;\n",
    "line.y = adc_data;\n",
    "fig.add_mark(line);\n",
    "    \n",
    "xpl::axis hx(sx), hy(sy);\n",
    "hy.orientation = \"vertical\";\n",
    "fig.add_axis(hx);\n",
    "fig.add_axis(hy);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Connect a signal generator to PC7 pin of STM8L-Discovery board.\n",
    "Plotting raw data of chip's memory:\n",
    ">Note that Community and Education versions of the REMCU library have a 32-bytes limit on a memory operation. Therefore, if you need to copy big data, you can do it in parts.\n",
    "Also the Community and Education versions have restrictions on memory region where you store and load data. You can use first 1 KBytes of first memory bank(STM8L chip). It is from 0x0 to 1024 address. To clarify that, see the Download page of your chip or the START_AVAILABLE_MEMORY_REGION and EMD_AVAILABLE_MEMORY_REGION constants in device_defines.h(is in remcu_include folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ADC_Cmd(ADC1, DISABLE);\n",
    "adc_data.back() = 0;\n",
    "for(int i = 0; i < ADC_BUFFER_SIZE*sizeof(adc_data.front()); i += 0x20){\n",
    "    remcu_loadFrMem(i, 32, (uint8_t*)(&adc_data.front()) + i);\n",
    "}\n",
    "shift =  DMA_GetCurrDataCounter(DMA1_Channel0);\n",
    "ADC_Cmd(ADC1, ENABLE);\n",
    "\n",
    "line.y = adc_data; //plot graph\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary>You can get the strange signal <b>(click to show)</b></summary>\n",
    "\n",
    "![Image](img/sunus_big_endian.png)\n",
    "</details>\n",
    "As STM8L is big endian processor, a byte reorder is needed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <netinet/in.h>\n",
    "\n",
    "for(int i = 0; i < 0xFF; i++){\n",
    "    uint16_t temp = adc_data[i];\n",
    "    temp = htons(temp);\n",
    "    adc_data[i] = temp;\n",
    "}\n",
    "line.y = adc_data; //plot graph\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary>Signal get rigth wave <b>(click to show)</b></summary>\n",
    "\n",
    "![Image](img/sinus_little_endian.png)\n",
    "</details>\n",
    "<details>\n",
    "  <summary>But it has the artifact because the the ADC’s DMA channel saves its data in a circular fashion and keeps on overwriting old data until is suspended <b>(click to show)</b></summary>\n",
    "\n",
    "![Image](img/artifact.png)\n",
    "</details>\n",
    "\n",
    "<details>\n",
    "  <summary>Left shift of ADC data for a picture like an oscilloscope screen<b>(click to show)</b></summary>\n",
    "\n",
    "![Image](img/sinus_little_endian_shift.png)\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for(int i = 0; i < ADC_BUFFER_SIZE; i++){ osc_data[i] = adc_data[i];}\n",
    "\n",
    "shift =  ADC_BUFFER_SIZE - shift;\n",
    "\n",
    "for(size_t i = 0; i < ADC_BUFFER_SIZE; i++){\n",
    "        int shift_pos = (i + shift) % ADC_BUFFER_SIZE;\n",
    "        adc_data[i] = osc_data[shift_pos];\n",
    "    }\n",
    "line.y = adc_data; //plot graph\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary>Sinus wave like on oscilloscope screen:<b>(click to show)</b></summary>\n",
    "\n",
    "![Image](img/after_shift.png)\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DAC-DMA example\n",
    "This snippet generates a sine siganl on PF0 pin using the DAC and DMA modules of STM8L-Discovery. It can work with the previous snippet ([**ADC-DMA example**](#ADC-DMA-example)) simultaneously"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " const uint16_t MEM_ADDRESS = ADC_BUFFER_SIZE*sizeof(adc_data.front()) + 1;\n",
    " const uint8_t MEM_SIZE = 130;\n",
    " uint8_t SINUS_TABLE[130] = {110,115,121,126,131,137,142,147,\n",
    "152,157,161,166,171,175,179,183,187,191,195,198,201,204,207,209,\n",
    "211,213,215,216,218,219,219,220,220,220,220,219,218,217,216,214,\n",
    "212,210,208,205,202,199,196,193,189,185,181,177,173,168,164,159,\n",
    "154,149,144,139,134,129,123,118,113,107,102,97,91,86,81,76,\n",
    "71,66,61,56,52,47,43,39,35,31,27,24,21,18,15,12,\n",
    "10,8,6,4,3,2,1,0,0,0,0,1,1,2,4,5,7,9,11,13,16,19,22,25,29,33,37,41,45,49,54,59,\n",
    "63,68,73,78,83,89,94,99,105,110, };"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the sinus table into MCU's memory at MEM_ADDRESS address behind the ADC memory buffer:\n",
    ">Note that Community and Education versions of the REMCU library have a 32-bytes limit on a memory operation. Therefore, if you need to copy big data, you can do it in parts.\n",
    "Also the Community and Education versions have restrictions on memory region where you store and load data. You can use first 1 KBytes of first memory bank(STM8L chip). It is from 0x0 to 1024 address. To clarify that, see the Download page of your chip or the START_AVAILABLE_MEMORY_REGION and EMD_AVAILABLE_MEMORY_REGION constants in device_defines.h(is in remcu_include folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for(int i = 0 ; i < MEM_SIZE*sizeof(SINUS_TABLE[0]); i+=10){\n",
    "    remcu_store2mem(MEM_ADDRESS + i, (uint8_t*)SINUS_TABLE + i, 10);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enable clock of DAC and TIMER 4 modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  CLK_PeripheralClockConfig(CLK_Peripheral_DAC, ENABLE);\n",
    "  CLK_PeripheralClockConfig(CLK_Peripheral_TIM4, ENABLE);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  /* DMA channel3 Config -----------------------------------------------------*/\n",
    "#define DAC_CH1RDHRH_ADDRESS      0x5388\n",
    "#define DAC_CH1RD8_ADDRESS      0x5390\n",
    "#define DAC_CH1RDHLH_ADDRESS      0x538C\n",
    "\n",
    "  DMA_DeInit(DMA1_Channel3);\n",
    "  DMA_Init(DMA1_Channel3,  MEM_ADDRESS,\n",
    "           DAC_CH1RD8_ADDRESS,\n",
    "           MEM_SIZE, DMA_DIR_MemoryToPeripheral, DMA_Mode_Circular,\n",
    "           DMA_MemoryIncMode_Inc, DMA_Priority_High,\n",
    "           DMA_MemoryDataSize_Byte\n",
    "          );\n",
    "\n",
    "  /* DMA1 Channel 3 enable */\n",
    "  DMA_Cmd(DMA1_Channel3, ENABLE);\n",
    "  DMA_GlobalCmd(ENABLE);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  /* DAC Channel1 Config: 12bit right ----------------------------------------*/\n",
    "  /* DAC deinitialize */\n",
    "  DAC_DeInit();\n",
    "  \n",
    "  /* Fill DAC Init param DAC_Trigger_T4_TRGO and  DAC Channel1 Init */\n",
    "  DAC_Init(DAC_Channel_1, DAC_Trigger_T4_TRGO, DAC_OutputBuffer_Enable);\n",
    "\n",
    "  /* Enable DAC Channel1 */\n",
    "  DAC_Cmd(DAC_Channel_1, ENABLE);\n",
    "  \n",
    "  /* Enable DMA for DAC Channel1 */\n",
    "  DAC_DMACmd(DAC_Channel_1, ENABLE);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  TIM4_DeInit();\n",
    "  /* Time base configuration */\n",
    "  TIM4_TimeBaseInit(TIM4_Prescaler_1, 0x1);\n",
    "  \n",
    "  /* TIM4 TRGO selection */\n",
    "  TIM4_SelectOutputTrigger(TIM4_TRGOSource_Update);\n",
    "  \n",
    "  /* TIM4 enable counter */\n",
    "  TIM4_Cmd(ENABLE);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see DAC signal in the ADC viewer, link PC7 and PF0 pin of STM8L-Discovery and run code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ADC_Cmd(ADC1, DISABLE);\n",
    "adc_data.back() = 0;\n",
    "for(int i = 0; i < ADC_BUFFER_SIZE*sizeof(adc_data.front()); i += 0x20){\n",
    "    remcu_loadFrMem(i, 32, (uint8_t*)(&adc_data.front()) + i);\n",
    "}\n",
    "shift =  DMA_GetCurrDataCounter(DMA1_Channel0);\n",
    "ADC_Cmd(ADC1, ENABLE);\n",
    "\n",
    "for(int i = 0; i < 0xFF; i++){\n",
    "    uint16_t temp = adc_data[i];\n",
    "    temp = htons(temp);\n",
    "    adc_data[i] = temp;\n",
    "}\n",
    "\n",
    "for(int i = 0; i < ADC_BUFFER_SIZE; i++){ osc_data[i] = adc_data[i];}\n",
    "\n",
    "shift =  ADC_BUFFER_SIZE - shift;\n",
    "\n",
    "for(size_t i = 0; i < ADC_BUFFER_SIZE; i++){\n",
    "        int shift_pos = (i + shift) % ADC_BUFFER_SIZE;\n",
    "        adc_data[i] = osc_data[shift_pos];\n",
    "    }\n",
    "line.y = adc_data; //plot graph\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "  <summary>Result:<b>(click to show)</b></summary>\n",
    "\n",
    "![](img/DAC_signal.png)\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Disconnecting from the debug server. It is finalizing work with REMCU Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remcu_disconnect()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "-std=c++14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}