Use HELM, gud, projectile. Update readme

Author: Alexandr Lutsay

Readme.md

@@ -2,73 +2,44 @@
 ***
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
-Some functions for work with stm32 arm microcontrollers in EMACS.
+Some functions for work with ARM microcontrollers in EMACS. All functions works in respect of projectile project and uses HELM for selection.
 
-Video of work: https://youtu.be/M7RBQsq5_lc
-
-here is an overview of how it works, the starting and loading process to the microcontroller.
-
-![Projectile Demo](assets/overview.gif)
+- `stm32-start-gdb-server` starts openocd gdb server with selected config
+- `stm32-start-gdb-elf` starts openocd gdb server with selected config and `arm-none-eabi-gdb` session with selected `.elf`
+- `stm32-flash-to-mcu` executes `load` and `cont` commands in GDB session
+- `stm32-kill-gdb` stops openocd and GDB session
+- `stm32-open-cubemx` open CubeMX with selected `.ioc` or without
 
 
 ## Required:
 ***
-- irony-mode https://github.com/Sarcasm/irony-mode
-- rtags
-- python
-- cmake
-- clang
-- https://github.com/SL-RU/STM32CubeMX_cmake
-- (optional) st-link https://github.com/texane/stlink
-- (optional) openocd
-- (optional) Ninja
+- openocd
+- arm-none-eabi-gdb
+- [helm](https://emacs-helm.github.io/helm/)
+- [projectile](https://docs.projectile.mx/projectile/index.html)
+- [friendly-shell-command](https://github.com/p3r7/friendly-shell)
+- [s.el](https://github.com/magnars/s.el)
+- (optional) CubeMX
 
 
 ## Install:
 ***
-0) install and configure irony-mode and rtags
+0) install and configure helm, projectile and other deps
 1) clone repository to /.emacs.d/stm32
-2) execute "git submodule update --init" to clone STM32CubeMX\_cmake to /.emacs.d/stm32/STM32CubeMX_cmake
-3) Change paths to yours in stm32.el
-4) add to your init file (require 'stm32)
+2) add to your init file (require 'stm32)
+3) customize if needed
+
 
 ## How to use:
 ***
-WORK IN PROGRESS!!!
-`STM32-Emacs` can use two diferent tools for debuggin
-
-### GDB and st-link
-***  
-1) Create STM32CubeMx project and generate it for `Makefile`
-2) <kbd>M-x</kbd>`stm32-new-project`<kbd>[RET]</kbd>*select CubeMX project path*
-3) open main.c
-4) C-c . C or <kbd>M-x</kbd>`stm32-cmake-build`<kbd>[RET]</kbd> to compile
-5) connect stlink to your PC
-6) <kbd>M-x</kbd>`stm32-run-st-util`<kbd>[RET]</kbd> to start gdb server
-7) start GDB debugger with <kbd>M-x</kbd>`stm32-start-gdb`<kbd>[RET]</kbd>
-8) in gdb) "load" to upload file to MC and "cont" to run. Or execute <kbd>M-x</kbd>`stm32-flash-to-mcu`<kbd>[RET]</kbd>. For more see https://github.com/texane/stlink
-9) good luck!
-
-**NOTE**: The step 6 can be omited as the step 7 cheks if `st-util` is running and starts it if it's not running, but it is recommended the first time to run the steps one by one in case of configuration errors, once you are in the debug window you can skip step 6 in the next debugging sessions.
-
-### GDB and Openocd
-***
-Openocd requieres a .cfg file to properly function you need to provide the file in this case it must be called openocd.cfg(you may change it in the custom varible `*stm32-openocd-config-name*`), and example file is provided (openocd.cfg) the file needs to be located in your project root.
-
-1) Create STM32CubeMx project and generate it for `Makefile`
-2) <kbd>M-x</kbd>`stm32-new-project`<kbd>[RET]</kbd> *select CubeMX project path*
-3) put the board.cfg in your project root(an example file named board.cfg is provided in this repo)
-3) open main.c
-4) C-c . C or <kbd>M-x</kbd>`stm32-cmake-build`<kbd>[RET]</kbd> to compile
-5) connect stlink to your PC
+Openocd requieres a `.cfg` file to properly function you need to place `.cfg` in any directory of current project.
+
+1) Create project and compile `.elf`
+2) <kbd>M-x</kbd>`stm32-start-gdb-eld`<kbd>[RET]</kbd>, select openocd config `.cfg`, then select `.elf`
 6) <kbd>M-x</kbd>`stm32-run-openocd`<kbd>[RET]</kbd> to start openocd server
-7) start GDB debugger with <kbd>M-x</kbd>`stm32-start-openocd-gdb`<kbd>[RET]</kbd>
-8) in gdb) "load" to upload file to MC and "cont" to run. Or execute <kbd>M-x</kbd>`stm32-flash-to-mcu`<kbd>[RET]</kbd>.
+8) in gdb console execute `load` to upload file to MCU and `cont` to run. Or execute <kbd>M-x</kbd>`stm32-flash-to-mcu`<kbd>[RET]</kbd>.
 9) debug your project and good luck!
 
-**NOTE**: The step 6 can be omited as the step 7 cheks if `openocd` is running and starts it if it's not running, but it is recommended the first time to run the steps one by one in case of configuration errors, once you are in the debug window you can skip step 6 in the next debugging sessions.
-
-**NOTE**: You can manually select executable to debug using `stm32-run-openocd-gdb-custom-path`
 
 #### RTOS support
 ***
@@ -89,15 +60,6 @@ If your RTOS is supported you need to do the following steps for enabling debugg
 ***
 Once you are in the debuger window you can load and test your prject, but the default gdb window acts like a terminal and is not very helpful in regards of context and data, so its a good idea to use gdb in many windows mode you can activate it in your startup config file with `(gdb-many-windows 1)` or with <kbd>M-x</kbd> gdb-many-windows <kbd>[RET]</kbd>
 
-### Compilation funcitions
-***
-You can build or clean and build your projects with the following functions.
-
-- <kbd>M-x</kbd>`stm32-cmake-build` <kbd>[RET]</kbd>
-  this is the equivalent of cleand and build of most IDE's and it recompiles every source file of your project
-
-- <kbd>M-x</kbd>`stm32-make-build` <kbd>[RET]</kbd>
-  the equivalent of build of most IDE's with this you can compile only the modified source files of your project scince the last compilation, this is useful if you only changed a couple of lines in your project as it makes the compilation proces faster.
 
 ### Closing stm32-debugger
 ***
@@ -110,10 +72,6 @@ This will kill the gdb process and the st-link or openocd proces depending on wh
 After CubeMx project regeneration or adding new libraries or new sources you need to do M-x stm32-cmake-build
 
 
-# IMPORTANT
-***
-If you have error in cmsis_gcc.h do <kbd>M-x</kbd>`M-x stm32-fix-vfpcc`<kbd>[RET]</kbd>. It will change some lines in cmsis_gcc.h and will create backup cmsis_gcc.h.bak.
-
 # License:
 ***
 This program is distributed under the terms of GNU General

stm32.el

@@ -17,7 +17,7 @@
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
-;; Required: helm, friendly-shell-command, projectile, cl-lib, s
+;; Required: helm, friendly-shell-command, projectile, s
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
@@ -53,7 +53,7 @@
   :type 'string)
 
 (defcustom stm32-gdb-command
-  "arm-none-eabi-gdb -iex \"target extended-remote localhost:3333\" "
+  "arm-none-eabi-gdb -iex \"target extended-remote localhost:3333\" -i=mi "
   "Command to run gdb for gud with openocd remote port."
   :group 'stm32
   :type 'string)
@@ -64,112 +64,135 @@
   :group 'stm32
   :type 'string)
 
-(require 'cl-lib)
 (require 'gdb-mi)
 (require 'gud)
 (require 'friendly-shell-command)
 (require 'projectile)
 (require 'helm)
 (require 's)
 
-(defun stm32-select-file (root filter)
+
+
+(defun stm32--select-file (root filter)
   "Select file using helm in ROOT directory and find by FILTER."
   (let* ((out (s-split
                "\n"
                (friendly-shell-command-to-string
                 (s-concat "find . -type f -name '" filter "'")
                 :path root)))
          (files (delete "" out)))
-    (when (> (length files) 0)
-      (helm :sources (helm-build-sync-source "test"
-                       :candidates files
-                       :fuzzy-match t)
-            :buffer "*helm find stm32*"
-            :case-fold-search helm-file-name-case-fold-search))))
+    (if (> (length files) 0)
+        (helm :sources (helm-build-sync-source (concat "Select " filter)
+                         :candidates files
+                         :fuzzy-match t)
+              :buffer "*helm find stm32*"
+              :case-fold-search helm-file-name-case-fold-search)
+      (user-error "No matching files"))))
+
+(defun stm32--close-process-buffer (process signal)
+  "Close process buffer when PROCESS sends exit SIGNAL."
+  (when (memq (process-status process) '(exit signal))
+    (kill-buffer (process-buffer process))))
+
+(defun stm32--start-process-buffer (buffer-name cmd)
+  "Run CMD in the buffer named BUFFER-NAME."
+  (let* ((output-buffer (generate-new-buffer buffer-name))
+         (proc (progn
+                 (message (concat "Running " cmd))
+                 (async-shell-command cmd
+                                      output-buffer
+                                      "*Messages*")
+                 (get-buffer-process output-buffer))))
+    (when (process-live-p proc)
+      (set-process-sentinel proc #'stm32--close-process-buffer))))
+
+(defun stm32--kill-gdb-if-started ()
+  "Kill gdb and openocd if running."
+  (gud-set-buffer)
+  (let ((proc-ocd (get-buffer-process "*stm32-gdb-server*"))
+        (proc-gdb (get-buffer-process gud-comint-buffer)))
+    (when (or proc-ocd proc-gdb)
+      (if (y-or-n-p "Kill currently running gdb? ")
+	  (stm32-kill-gdb)
+	(user-error "GDB already running!")))))
+
+
 
 (defun stm32-start-gdb-server ()
-  "Run gdb server."
+  "Run gdb server with selected config.  Config files are filtered using '*.cfg'."
   (interactive)
-  (let ((p (get-buffer-process "*stm32-gdb-server*")))
-    (when p
-      (if (y-or-n-p "Kill currently running stm32-gdb-server? ")
-	  (interrupt-process p)
-	(user-error "Stm32-gdb-server already running!"))))
-  (sleep-for 1) ;wait for process being killed
-  (let ((root (projectile-project-root)))
+  (stm32--kill-gdb-if-started)
+  (let ((root (projectile-project-root))
+        (buffer-name "*stm32-gdb-server*"))
     (when 'root
-      (let ((file (stm32-select-file root "*.cfg")))
+      (let* ((file (stm32--select-file root "*.cfg"))
+             (cmd (concat stm32-openocd-command " -f " (concat root file)))
+             (output-buffer (generate-new-buffer buffer-name)))
         (when file
-          (with-temp-buffer
-            "*stm32-gdb-server*"
-	    (async-shell-command (s-concat stm32-openocd-command " -f " (concat root file))
-				 "*stm32-gdb-server*"
-				 "*Messages*")))))))
+          (async-shell-command cmd
+                               output-buffer
+                               "*Messages*")
+          (let ((proc (get-buffer-process output-buffer)))
+            (when (process-live-p proc)
+              proc)))))))
 
 (defun stm32-start-gdb-elf ()
   "Run arm-none-eabi-gdb and select elf."
   (interactive)
-  (let ((root (projectile-project-root))
-        (p (get-buffer-process "*stm32-gdb-server*")))
-    (when (not p)
-      (stm32-start-gdb-server))
-    (when 'root
-      (let ((file (stm32-select-file root "*.elf")))
+  (stm32--kill-gdb-if-started)
+  (let* ((root (projectile-project-root))
+         (p (get-buffer-process "*stm32-gdb-server*"))
+         (server-started (when (not p)
+                           (stm32-start-gdb-server))))
+    (when (and 'root 'server-started)
+      (let ((file (stm32--select-file root "*.elf")))
         (when file
-          (gud-gdb (s-concat stm32-gdb-command " " (concat root file))))))))
+          (save-window-excursion
+            (gdb (s-concat stm32-gdb-command " " (concat root file)))))))))
 
 (defun stm32-flash-to-mcu ()
   "Upload compiled binary to stm32 through gdb if gdb has been started."
   (interactive)
-  (if (and (get-buffer "*stm32-gdb-server*")
-               (get-buffer "*gud-target extended-remote localhost:3333*"))
-      (progn (gdb-io-interrupt)
-             (gud-basic-call "load")
-             (gud-basic-call "cont"))
-    (message "No gdb has been started")))
+  (gud-set-buffer)
+  (let ((proc (get-buffer-process gud-comint-buffer)))
+    (or proc (error "Current buffer has no process"))
+    (with-current-buffer gud-comint-buffer
+      (save-excursion
+        (interrupt-process proc)
+        (gud-basic-call "load")
+        (gud-basic-call "cont")))))
 
 (defun stm32-kill-gdb ()
   "Kill all gdb or openocd processes and buffers."
   (interactive)
-  (when (get-buffer-process "*gud-target extended-remote localhost:3333*")
-    (kill-process (get-buffer-process "*gud-target extended-remote localhost:3333*")))
+  (gud-set-buffer)
+  (let ((proc (get-buffer-process gud-comint-buffer)))
+    (when proc
+      (kill-process proc)))
   (when (get-buffer-process "*stm32-gdb-server*")
     (kill-process (get-buffer-process "*stm32-gdb-server*")))
   (sleep-for 1)
+  (kill-buffer gud-comint-buffer)
   (when (get-buffer "*stm32-gdb-server*")
-    (kill-buffer "*stm32-gdb-server*"))
-  (when (get-buffer "*gud-target extended-remote localhost:3333*")
-    (kill-buffer "*gud-target extended-remote localhost:3333*")))
+    (kill-buffer "*stm32-gdb-server*")))
 
 
-(defun stm32--close-process-buffer (process signal)
-  "Close process buffer when PROCESS sends exit SIGNAL."
-  (when (memq (process-status process) '(exit signal))
-    (kill-buffer (process-buffer process))
-    (message process "stopped")))
 
 (defun stm32--start-cubemx (&optional file)
   "Run CubeMX in the buffer and open FILE."
-  (let* ((name (concat " *CubeMX " file "*"))
-         (output-buffer (generate-new-buffer name))
-         (cmd (if 'file
-                  (concat stm32-cubemx " " file)
-                stm32-cubemx))
-         (proc (progn
-                 (message (concat "Running " cmd))
-                 (async-shell-command cmd output-buffer)
-                 (get-buffer-process output-buffer))))
-    (when (process-live-p proc)
-        (set-process-sentinel proc #'stm32--close-process-buffer))))
-
+  (let ((name (concat " *CubeMX " file "*"))
+        (cmd (if 'file
+                 (concat stm32-cubemx " " file)
+               stm32-cubemx)))
+    (stm32--start-process-buffer name cmd)))
 
 (defun stm32-open-cubemx ()
   "Open current project in cubeMX or just start application."
   (interactive)
   (save-window-excursion
     (let ((root (projectile-project-root)))
       (if root
-          (let ((file (stm32-select-file root "*.ioc")))
+          (let ((file (stm32--select-file root "*.ioc")))
             (if file
                 (stm32--start-cubemx (concat root file))
               (stm32--start-cubemx)))