I succeeded to be run printipi on rpi3,But I have got other problem.

[Mokutsuno]

I succeeded being run this on rpi3 .
I used pigpio.
So,I made new own primitiveiopin.h , mitpi.h and mitpi.cpp ,which used pigpio.

And I got a problem.
printpi toggles PWM ,when I send command of "G1 ....".
It moves as intended.
However, To toggle PWM isn't end,that is,printipi doesn't move on next command.
Also "command: G1... "and"response:ok" are not outputted.

I think that printpi moves on next command ,when "exitEventLoop()" is called.
So, something problem have occured, then "exitEventLoop()" haven't called.

//////////////////////////////////////////////////////////////////////
#ifndef PLATFORMS_RPI_PRIMITIVEIOPIN_H
#define PLATFORMS_RPI_PRIMITIVEIOPIN_H

#include <cassert>

#include "mitpi.h" //for GpioPin
//#include "hardwarescheduler.h" //for ability to schedule PWM
#include "platforms/auto/chronoclock.h" //for EventClockT.
//for MAX_RPI_PIN_ID
#include "compileflags.h"
#include <pigpiod_if.h>
namespace plat {
	namespace rpi2 {

		class PrimitiveIoPin {
			//logical index of this pin (0-53, I believe)
			mitpi::GpioPin pinIdx;
		public:
			//@return a pin with an invalid output
			//
			//Note that it is undefined to call any function on a null pin except for <isNull> and <id>.
			inline static PrimitiveIoPin null() {
				return PrimitiveIoPin(mitpi::NULL_GPIO_PIN);
			}
			//@return true if the pin is equal to the one constructed by the <null> function.
			inline bool isNull() const {
				return pinIdx == mitpi::NULL_GPIO_PIN;
			}
			//@pinIdx *logical* index of the pin
			//@pullUpDown direct this pin to either pull up to 3.3v, down to gnd, or no pull at all.
			//Note that this pull direction will be applied **even when operating as an output pin**.
			// The rpi's pull resistors preserve state across reboots.
			// This makes it so that when the Pi resets, its pins will still be in a defined state (no runaway heater while the Pi is still booting)
			// Of course, it's still a VERY GOOD IDEA to use hardware pull resistors as well.
			//**Also note:** @pullUpDown acts the same regardless of the <IoPin>'s read/write inversions.
        template <typename ...T> PrimitiveIoPin(mitpi::GpioPin pinIdx, mitpi::GpioPull pullUpDown = mitpi::GPIOPULL_NONE) {
				assert((pinIdx == mitpi::NULL_GPIO_PIN || pinIdx <= MAX_RPI_PIN_ID) && "Make sure to appropriately set MAX_RPI_PIN_ID (see compileflags.h) or else some pins might not behave correctly");
				if (pinIdx != mitpi::NULL_GPIO_PIN) {
					mitpi::init();
					//we CANNOT set the pin pull of a null gpio pin
					mitpi::setPinPull(pinIdx, pullUpDown);
				}
        }
			//@return the logical index of the pin (for use with other platform-specific functions)
			inline mitpi::GpioPin id() const {
				return pinIdx;
			}
			//configure the pin as an output, and set its output state
			inline void makeDigitalOutput(IoLevel lev) {
				mitpi::makeOutput(pinIdx);
				digitalWrite(lev);
			}
			//configure the pin as a PWM output & set its duty cycle and period (if applicable)
			inline void makePwmOutput(float duty, EventClockT::duration desiredPeriod) {
				mitpi::makeOutput(pinIdx);
				//mitpi::pwmWrite(pinIdx, duty, desiredPeriod);
				pwmWrite(duty, desiredPeriod);
			}
			//configure the pin to be an input
			inline void makeDigitalInput() {
				mitpi::makeInput(pinIdx);
			}
			//read the pin's input value (must call makeDigitalInput beforehand)
			inline IoLevel digitalRead() const {
				return mitpi::readPinState(pinIdx);
			}
			//write a digital value to the pin. IoHigh = 3.3v, IoLow = 0v. Must call makeDigitalOutput beforehand
			inline void digitalWrite(IoLevel lev) {
				mitpi::setPinState(pinIdx, lev);
			}
			//set pwm duty cycle & period (if applicable). Must call makePwmOutput beforehand.
			inline void pwmWrite(float duty, EventClockT::duration desiredPeriod) {
				float minPeriod = std::chrono::duration_cast<std::chrono::duration<float>> (desiredPeriod).count();
				int intMinPeriod = (int)minPeriod;
				uint32_t intDuty = 1000000*duty;
				hardware_PWM(this->id(), intMinPeriod, intDuty);
					//mitpi::pwmWrite(pin, duty, desiredPeriod);
				//HardwareScheduler().queuePwm(*this, duty, desiredPeriod);
			}
		};
	}
}
#endif
///////////////////////////////////////////////////////////////

About pwmWrite(), I haven't understood very much yet.

You said you not actively developing Printipi ,so please reply to me, if it's OK with you..

[Wallacoloo]

You haven't given me much information to work on, here. I would suggest you run Printipi under a debugger (like gdb). You could interrupt it when it hangs (with Ctrl+C) and then get a stack trace by typing bt. This might reveal if it's stuck in a loop / blocking call, etc.

One thing I would also do is check the return code of hardware_PWM. I'm not sure which parts of the code you've edited, but you should make sure that the original hardwarescheduler.cpp isn't being compiled - it also uses DMA and might conflict with the DMA channel that pigpio's hardware_PWM function is using.

[Wallacoloo]

I just dug up the documentation for hardware_PWM. It looks to me like this is calling into a separate daemon to manage the gpios. As such, if you haven't started the pigpio daemon before running printipi, it's quite possible that their code is written in a way where it stalls until the daemon is started.

[Mokutsuno]

Thank you for your reply.

printipi doesn't hang. printipi executes first command (G1 Y0.1 F6000 e.g.),but doesn't execute next command. It keeps outputting "[inf0] RCThermistor2Pin read timeout" during running it.

The original hardwarescheduler.cpp isn't being compiled.
The pigpio daemon has been start since boot the raspberry pi 3.

I used gdb. As a result,hardware_PWM() did not return 0. It returned -95.
I noticed that hardware_PWM()(pwmWrite()) was called twice only.
First,it is called about V1_GPIO_P1_08 (probably FAN).
Second,called about V1_GPIO_P1_10 (probably HOTEND). Both return -95.
hardware_PWM()(pwmWrite()) isn't called, when I input commands.
I can't understand why GPIO toggle (But as above, it doesn't work as intended). There are no functions to make PWM other than hardware_PWM()(pwmWrite()) in printipi. Why?

I followed https://github.com/Wallacoloo/printipi/wiki/Adding-support-for-a-new-CPU-architecture
There are "chronoclock.cpp","chronoclock.h","mitpi.cpp","mitpi.h","primitiveiopin.h" and "hardwarescheduler.cpp". under platform/rpi2 directory.
"chronoclock.cpp" and "chronoclock.h" are the same as https://github.com/Wallacoloo/printipi/blob/master/src/platforms/rpi/chronoclock.cpp
https://github.com/Wallacoloo/printipi/blob/master/src/platforms/rpi/chronoclock.h
I changed "primitiveiopin.h" a little.

mitpi.cpp

#include "mitpi.h"
#include <sys/mman.h> //for mmap
#include <sys/time.h> 
#include <time.h> //for nanosleep / usleep (if have -std=gnu99)
#include <unistd.h> //for usleep
#include <stdlib.h> //for exit
#include <cassert> //for assert
#include <fcntl.h> //for file opening
#include "common/logging.h"
#include "platforms/auto/primitiveiopin.h"
#include <pigpiod_if.h>
#include <sys/time.h>
#include "platforms/auto/chronoclock.h" //for EventClockT
namespace mitpi {
#define PI_INPUT 0
#define PI_OUTPUT 1
#define PI_LOW 0
#define	PI_HIGH 1
	static volatile uint32_t *gpioBaseMem = nullptr;
	static volatile uint32_t *timerBaseMem = nullptr;
	static volatile uint32_t *gpioPadBaseMem = nullptr;

	static void assertValidPin(PinIntType pin) {
		(void)pin; //unused when assertions are disabled.
		//printf("%d\n",(int)pin);
		assert(pin >= 0 && pin < 64);
	}

	bool init() {
		// Connect to pigpiod
		int status = pigpio_start(0, 0);
		if (status < 0){ LOG("Failed \pigpio_start\n");}

		return 0; //init OK
	}

	void makeOutput(PinIntType pin) {
		assertValidPin(pin);
		set_mode(pin, PI_OUTPUT);
	}
	void makeInput(PinIntType pin) {
		assertValidPin(pin);
		//set_mode(pin, PI_INPUT);
	}
	void setPinHigh(PinIntType pin) {
		assertValidPin(pin);
		gpio_write(pin, PI_HIGH); // 1 is HIGH
	}
	void setPinLow(PinIntType pin) {
		assertValidPin(pin);
		gpio_write(pin, PI_LOW); // 0 is LOW
	}
	
	void setPinState(PinIntType pin, bool state) {
		state ? setPinHigh(pin) : setPinLow(pin);
	}
	bool readPinState(PinIntType pin) {
		assertValidPin(pin);
		gpio_read(pin);
	}
	
	void setPinPull(PinIntType pin, GpioPull pull) {
		assertValidPin(pin);
		set_pull_up_down(pin, pull);
	}

	void setPadProperties(uint32_t flags, int bank) {

	}

	void usleep(unsigned int us) {
		//explicitly exposed to allow users of the library access to a usleep function
		::usleep(us);
	}
struct timeval sysTimeMicro;
	uint64_t readSysTime() {
		gettimeofday(&sysTimeMicro,NULL);
		return ((uint64_t)(sysTimeMicro.tv_usec));
	}

}

mitpi.h

#ifndef PLATFORMS_RPI_MITPI_H
#define PLATFORMS_RPI_MITPI_H

//for uint32_t
#include <sys/time.h>
#include <stdint.h>
/*
 * Mitpi is a small library used for interfacing with the Raspberry Pi's peripherals, including GPIO and timers,
 *   licensed under the extremely permissive MIT license.
 *
 * Please note that most of its features require superuser priviledges, so you may have to launch any executable which uses this library with `sudo'
 */

namespace mitpi {

//Map physical pin locations to logical pin ids used by the processor
enum GpioPin {
    //There are 2 board revisions (and now the model A+/B+), which have slightly different I/O wiring.
    //P1 header (2x13 pins) for version 1 (i.e. before Sept 2012:
    //looking down at the board with the P1 header in the upper right,
    //The upper-left pin is P1_01,
    //The upper-right pin is P1_02 (so, odds are left, evens are right)
    //numbering increases as you go vertically down 
    V1_GPIO_P1_03     =  0, //(i.e., physical pin #3 is addressed in software as #0)
    V1_GPIO_P1_05     =  1,
    V1_GPIO_P1_07     =  4,
    V1_GPIO_P1_08     = 14,
    V1_GPIO_P1_10     = 15,
    V1_GPIO_P1_11     = 17,
    V1_GPIO_P1_12     = 18,
    V1_GPIO_P1_13     = 21,
    V1_GPIO_P1_15     = 22,
    V1_GPIO_P1_16     = 23,
    V1_GPIO_P1_18     = 24,
    V1_GPIO_P1_19     = 10,
    V1_GPIO_P1_21     =  9,
    V1_GPIO_P1_22     = 25,
    V1_GPIO_P1_23     = 11,
    V1_GPIO_P1_24     =  8,
    V1_GPIO_P1_26     =  7,

    //The P1 header for revision 2:
    //same physical numbering as before
    V2_GPIO_P1_03  =  2,
    V2_GPIO_P1_05  =  3,
    V2_GPIO_P1_07  =  4,
    V2_GPIO_P1_08  = 14,
    V2_GPIO_P1_10  = 15,
    V2_GPIO_P1_11  = 17,
    V2_GPIO_P1_12  = 18,
    V2_GPIO_P1_13  = 27,
    V2_GPIO_P1_15  = 22,
    V2_GPIO_P1_16  = 23,
    V2_GPIO_P1_18  = 24,
    V2_GPIO_P1_19  = 10,
    V2_GPIO_P1_21  =  9,
    V2_GPIO_P1_22  = 25,
    V2_GPIO_P1_23  = 11,
    V2_GPIO_P1_24  =  8,
    V2_GPIO_P1_26  =  7,

    //Revision 2 has another 2x4 header called 'P5'.
    //This doesn't have any pins soldered on by default, so (trivial) physical modification is required to use them
    //Physical numbering is ordered ... how?
    V2_GPIO_P5_03  = 28,
    V2_GPIO_P5_04  = 29,
    V2_GPIO_P5_05  = 30,
    V2_GPIO_P5_06  = 31,

    //The addition of the model A+ and B+ brought a 40-pin GPIO header.
    //The first 26 pins are identical to the model A/B Revision 2, with the latter 14 exposing additional GPIOs
    PLUS_GPIO_P1_03  =  2,
    PLUS_GPIO_P1_05  =  3,
    PLUS_GPIO_P1_07  =  4,
    PLUS_GPIO_P1_08  = 14,
    PLUS_GPIO_P1_10  = 15,
    PLUS_GPIO_P1_11  = 17,
    PLUS_GPIO_P1_12  = 18,
    PLUS_GPIO_P1_13  = 27,
    PLUS_GPIO_P1_15  = 22,
    PLUS_GPIO_P1_16  = 23,
    PLUS_GPIO_P1_18  = 24,
    PLUS_GPIO_P1_19  = 10,
    PLUS_GPIO_P1_21  =  9,
    PLUS_GPIO_P1_22  = 25,
    PLUS_GPIO_P1_23  = 11,
    PLUS_GPIO_P1_24  =  8,
    PLUS_GPIO_P1_26  =  7,
    PLUS_GPIO_P1_29  =  5,
    PLUS_GPIO_P1_31  =  6,
    PLUS_GPIO_P1_32  = 12,
    PLUS_GPIO_P1_33  = 13,
    PLUS_GPIO_P1_35  = 19,
    PLUS_GPIO_P1_36  = 16,
    PLUS_GPIO_P1_37  = 26,
    PLUS_GPIO_P1_38  = 20,
    PLUS_GPIO_P1_40  = 21,

    NULL_GPIO_PIN = 127,
};

//Internal pull-up / down resistors
enum GpioPull {
    GPIOPULL_NONE = 0,
    GPIOPULL_DOWN = 1,
    GPIOPULL_UP   = 2,
};

//Each bank of pins can be set to have different drive strengths, hysteresis and slew.
//pass a bitwise-or'd collection of flags to <setPadProperties>
enum GpioPadProperties {
    //Per-pin drive strength. Defaults to 8 mA at boot.
    //Note: avoid drawing a total of > 50 mA across ALL gpio pins / 3v3 supply
    PAD_DRIVE_2MA  = 0,
    PAD_DRIVE_4MA  = 1,
    PAD_DRIVE_6MA  = 2,
    PAD_DRIVE_8MA  = 3,
    PAD_DRIVE_10MA = 4,
    PAD_DRIVE_12MA = 5,
    PAD_DRIVE_14MA = 6,
    PAD_DRIVE_16MA = 7,
    //Hysteresis settings:
    PAD_HYSTERESIS_DIS = 0,
    PAD_HYSTERESIS_EN  = (1 << 3),
    //Slew rate limit
    //From Wikipedia: Slew rate is defined as the maximum rate of change of output voltage per unit of time and is expressed as volt per second.
    PAD_SLEW_LIMIT =   0,
    PAD_SLEW_NO_LIMIT = (1 << 4),
};

typedef unsigned int PinIntType;

bool init();
void makeOutput(PinIntType pin);
void makeInput(PinIntType pin);
void setPinHigh(PinIntType pin);
void setPinLow(PinIntType pin);
void setPinState(PinIntType pin, bool state);
bool readPinState(PinIntType pin);
void setPinPull(PinIntType pin, GpioPull pull);
//Set the drive strength, hysteresis and slew limits for a set of pins.
//@flags bitwise-or of GpioPadProperties flags
//@bank 0 for pins 0-27, 1 -> pins 28-45, 2 -> pins 46-53
void setPadProperties(uint32_t flags, int bank);
void usleep(unsigned int us);
uint64_t readSysTime();

struct InitMitpiType {
    inline InitMitpiType() {
        init();
    }
};

}
#endif

hardwarescheduler.h

#ifndef PLATFORMS_GENERIC_HARDWARESCHEDULER_H
#define PLATFORMS_GENERIC_HARDWARESCHEDULER_H

#include <cassert> //for assert

#include "platforms/auto/chronoclock.h" //for EventClockT
#include "platforms/auto/primitiveiopin.h"
#include "schedulerbase.h" //for OnIdleCpuIntervalT (cannot forward-declare an enum)
#include "common/logging.h"

//forward declare for class defined in outputevent.h
class OutputEvent;


namespace plat {
	namespace rpi2 {

		struct HardwareScheduler {
			//add this event to the hardware queue, waiting until schedTime(evt.time()) if necessary
			inline void queue(OutputEvent evt) {
				evt.primitiveIoPin().digitalWrite(evt.state());
			}
			//Set the given pin to a pwm duty-cycle of `ratio` using a maximum period of maxPeriod (irrelevant if using PCM algorithm). 
			//E.g. queuePwm(5, 0.4) sets pin #5 to a 40% duty cycle.
			inline void queuePwm(const PrimitiveIoPin &pin, float ratio, float idealPeriod) {
			//	plat::rpi2::PrimitiveIoPin::queuePwmWrite(&pin, ratio, idealPeriod);
			}
			//If an event needs to occur at evtTime, this function should return the earliest time at which it can be scheduled.
			inline EventClockT::time_point schedTime(EventClockT::time_point evtTime) const {
				return evtTime;
			}
			//Can be used to perform routine resource management when there's free cpu.
			//Avoid spending more than a few hundred microseconds in this function, or event scheduling might be impacted
			//@return true if we request more cpu time.
			inline bool onIdleCpu(OnIdleCpuIntervalT interval) {
				(void)interval; //unused
				return false; //no more cpu needed
			}
		};
	}
}


#endif

primitiveiopin.h

#ifndef PLATFORMS_RPI_PRIMITIVEIOPIN_H
#define PLATFORMS_RPI_PRIMITIVEIOPIN_H

#include <cassert>
#include <stdio.h>
#include "mitpi.h" //for GpioPin
//#include "hardwarescheduler.h" //for ability to schedule PWM
#include "platforms/auto/chronoclock.h" //for EventClockT.
//for MAX_RPI_PIN_ID
#include "compileflags.h"
#include <pigpiod_if.h>
namespace plat {
	namespace rpi2 {

		class PrimitiveIoPin {
			//logical index of this pin (0-53, I believe)
			mitpi::GpioPin pinIdx;
		public:
			//@return a pin with an invalid output
			//
			//Note that it is undefined to call any function on a null pin except for <isNull> and <id>.
			inline static PrimitiveIoPin null() {
				return PrimitiveIoPin(mitpi::NULL_GPIO_PIN);
			}
			//@return true if the pin is equal to the one constructed by the <null> function.
			inline bool isNull() const {
				return pinIdx == mitpi::NULL_GPIO_PIN;
			}
			//@pinIdx *logical* index of the pin
			//@pullUpDown direct this pin to either pull up to 3.3v, down to gnd, or no pull at all.
			//Note that this pull direction will be applied **even when operating as an output pin**.
			// The rpi's pull resistors preserve state across reboots.
			// This makes it so that when the Pi resets, its pins will still be in a defined state (no runaway heater while the Pi is still booting)
			// Of course, it's still a VERY GOOD IDEA to use hardware pull resistors as well.
			//**Also note:** @pullUpDown acts the same regardless of the <IoPin>'s read/write inversions.
			inline PrimitiveIoPin(mitpi::GpioPin pinIdx, mitpi::GpioPull pullUpDown = mitpi::GPIOPULL_NONE)
				: pinIdx(pinIdx) {
				assert((pinIdx == mitpi::NULL_GPIO_PIN || pinIdx <= MAX_RPI_PIN_ID) && "Make sure to appropriately set MAX_RPI_PIN_ID (see compileflags.h) or else some pins might not behave correctly");
				if (pinIdx != mitpi::NULL_GPIO_PIN) {
					mitpi::init();
					//we CANNOT set the pin pull of a null gpio pin
					mitpi::setPinPull(pinIdx, pullUpDown);
				}
			}
			//@return the logical index of the pin (for use with other platform-specific functions)
			inline mitpi::GpioPin id() const {
				return pinIdx;
			}
			//configure the pin as an output, and set its output state
			inline void makeDigitalOutput(IoLevel lev) {
				mitpi::makeOutput(pinIdx);
				digitalWrite(lev);
			}
			//configure the pin as a PWM output & set its duty cycle and period (if applicable)
			inline void makePwmOutput(float duty, EventClockT::duration desiredPeriod) {
				mitpi::makeOutput(pinIdx);
				//mitpi::pwmWrite(pinIdx, duty, desiredPeriod);
				pwmWrite(duty, desiredPeriod);
			}
			//configure the pin to be an input
			inline void makeDigitalInput() {
				mitpi::makeInput(pinIdx);
			}
			//read the pin's input value (must call makeDigitalInput beforehand)
			inline IoLevel digitalRead() const {
				return mitpi::readPinState(pinIdx);
			}
			//write a digital value to the pin. IoHigh = 3.3v, IoLow = 0v. Must call makeDigitalOutput beforehand
			inline void digitalWrite(IoLevel lev) {
				mitpi::setPinState(pinIdx, lev);
			}
			//set pwm duty cycle & period (if applicable). Must call makePwmOutput beforehand.
			inline void pwmWrite(float duty, EventClockT::duration desiredPeriod) {
				float minPeriod = std::chrono::duration_cast<std::chrono::duration<float>> (desiredPeriod).count();
				int intMinPeriod = (int)minPeriod;
				uint32_t intDuty = 1000000*duty;
				int flag = hardware_PWM(this->id(), intMinPeriod, intDuty);
				printf("%d",flag);
			}
		};

	}
}
#endif

[Mokutsuno]