Actions
Forum Thread Details
  • Replies 6 replies
  • Subscribers 42 subscribers
  • Views 202 views
  • Users 0 members are here
Related

Porting GRBL 1.1 to MKR wifi 1010

fyaocn

1 GRBL and G-code

In the realm of computer numerical control (CNC) machining, G-code serves as the universal language for instructing machines on how to perform various operations. GRBL, an open-source software, has emerged as a powerful and efficient interpreter for G-code, enabling precise control over CNC machines. This introduction will delve into the key aspects of GRBL and its interaction with G-code, shedding light on how it simplifies the CNC machining process.​
 
GRBL is a high-performance software that runs on microcontrollers, typically Arduino-based boards. It is designed to interpret and execute G-code commands, translating them into precise movements and actions for CNC machines such as mills, routers, and laser cutters. Developed with a focus on simplicity, reliability, and speed, GRBL has become a popular choice among hobbyists, makers, and small-scale manufacturers.​
One of the standout features of GRBL is its ability to handle real-time control, ensuring smooth and accurate operation even during complex machining tasks. It also supports a wide range of G-code commands, covering everything from basic linear and circular movements to advanced functions like tool changes and feed rate adjustments. This versatility makes GRBL suitable for a variety of applications, from prototyping and woodworking to metal fabrication.​
How GRBL Interprets G-code​
When a G-code program is sent to a CNC machine running GRBL, the software reads and interprets each command in sequence. It analyzes the G-code commands, along with any associated parameters, and converts them into precise step and direction signals for the machine's stepper motors. These signals control the movement of the machine's axes, ensuring that the tool follows the desired path accurately.​
GRBL also takes into account factors such as acceleration and deceleration, ensuring smooth transitions between movements and preventing sudden jerks or vibrations. It can handle complex G-code programs with multiple commands and nested loops, executing them efficiently and without errors.​

2 Incompatible platorm  for open-grbl

Here is the file structure for GRBL, this is for newest release of 1.1, previous version shows a little difference.

grbl
├── config.h
├── coolant_control.c
├── coolant_control.h
├── cpu_map
│ ├── cpu_map_atmega2560.h
│ └── cpu_map_atmega328p.h
├── cpu_map.h
├── defaults
│ ├── defaults_generic.h
│ └── ...
├── defaults.h
├── eeprom.c
├── eeprom.h
├── examples
│ └── ...
├── gcode.c
├── gcode.h
├── grbl.h
├── limits.c
├── limits.h
├── main.c
├── motion_control.c
├── motion_control.h
├── nuts_bolts.c
├── nuts_bolts.h
├── planner.c
├── planner.h
├── print.c
├── print.h
├── probe.c
├── probe.h
├── protocol.c
├── protocol.h
├── report.c
├── report.h
├── serial.c
├── serial.h
├── settings.c
├── settings.h
├── spindle_control.c
├── spindle_control.h
├── stepper.c
├── stepper.h
├── system.c
└── system.h

While this is for AVR core 

image

and incompatible with SAMD core of MKR, 

image

3 There are good software for g-code sender

One of the popular is laser-grbl

image

Here is another one engrave master.

image

It is good start to use one arduino UNO with hex download. This project needs MKR wifi 1010. That would take a great deal time to understand G-code and micro-core for this coding.

  • Hi!

    Wondering if it is mandatory or not to use the MKR board for this challenge. Your requirement seems to be an extremely good use-case for a more powerful board, e.g. Pico 2 WiFi is supported by GBRL as I understand, and the improvement in microcontroller core (plus all round extra resources including RAM) might be beneficial, although I'm just guessing because I have not used this software.

    It's not a TE board but neither is the MKR board so it should be fair to pick your choice ( in my humble opinion).

  • After a quick look at the source code for grbl my guess is that it would take between 1 and 2 weeks of work to port the code to a modern ARM based processor.

    One thing that makes it easier is that the code was written for a very basic 8 bit micro with limited timer capabilities - which will be easy to replicate on a modern chip.

    The hard part is that the grbl code is not very nicely written - for example the gc_execute_line function  in gcode.c is about 1000 lines long - this is not good coding practice !

    I've just seen that   has pointed out that a port to a Pico based board exists. You could use a simple serial interface between that and you MKR board, treating the Pico board as an interface to the motor drivers.

    I think that this would be rather less work.

    MK

  • There is this gbrlHAL that by coincidence I was discussing with Jan on an unrelated project, that supports Pico etc: 

    https://github.com/grblHAL

    Although it looks a bit bloated since it seems to add everything but the kitchen sink into the firmware. But maybe whatever you need could be extracted from that, if not all is needed.

    I don't really know much, I've not looked at any source code so far. Worrisome as mentions  that the code has 1000-line functions that will be hard to understand or make changes to without introducing bugs : (

    But I am interested to give gbrl a go one day, so it will be interesting to see how things go for you. 

  • I am not familiar with GRBL but it would seem from a quick scan of the internet that it already runs on Arduino MKR. It just requires GRBL HAL (for hardware abstraction layer)

  • in reply to shabaz

    Thanks.

    G-code is a cluster of protocol for CNC, laser engraver or even 3D transformation. So does GRBL of which is newest release v1.1.

    Simply use this open source code can do for this challenge. But the most amazing part of element14 community is that it will inspire to seek-for difficulties.

    BTW, one git-repo has been porting to one of most popular  STM32Fxxx boards with CMSIS-HAL frame. It can be quick start point.

  • in reply to michaelkellett

    That is good point. 

    Even in 1000 lines in gcode.c, only basic function is supported. Just enough for laser engravers. The  lasergrbl in github is good enough for most cases and update regularly.