3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-23 12:04:19 +00:00
Code Issues Releases Wiki Activity

Prevent compilation of unused u8g-oriented code

Browse Source
This commit is contained in:
Scott Lahteine 2018-05-14 05:35:05 -05:00
parent 35258dd50b
commit fb608938f8
14 changed files with 386 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_shared_hw_spi.cpp
View File

@ -56,108 +56,106 @@
*/ */
#ifdef __SAM3X8E__ #ifdef __SAM3X8E__
// #include <inttypes.h> #include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD)
#include <U8glib.h>
// #include "src/core/macros.h"
// #include "Configuration.h"
#include "../../Marlin.h" #include "../../Marlin.h"
#include "../../inc/MarlinConfig.h"
#include <U8glib.h> #define SPI_FULL_SPEED 0
#define SPI_HALF_SPEED 1
#define SPI_QUARTER_SPEED 2
#define SPI_EIGHTH_SPEED 3
#define SPI_SIXTEENTH_SPEED 4
#define SPI_SPEED_5 5
#define SPI_SPEED_6 6
#define SPI_FULL_SPEED 0 void spiBegin();
#define SPI_HALF_SPEED 1 void spiInit(uint8_t spiRate);
#define SPI_QUARTER_SPEED 2 void spiSend(uint8_t b);
#define SPI_EIGHTH_SPEED 3 void spiSend(const uint8_t* buf, size_t n);
#define SPI_SIXTEENTH_SPEED 4
#define SPI_SPEED_5 5
#define SPI_SPEED_6 6
void spiBegin(); #include <Arduino.h>
void spiInit(uint8_t spiRate); #include "fastio_Due.h"
void spiSend(uint8_t b);
void spiSend(const uint8_t* buf, size_t n);
#include <Arduino.h> void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
#include "../../core/macros.h" PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
#include "fastio_Due.h" g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration); // OUTPUT
}
void u8g_SetPILevel_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
if (level) port->PIO_SODR = mask;
else port->PIO_CODR = mask;
}
void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) { uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1, {
g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration); // OUTPUT switch(msg)
}
void u8g_SetPILevel_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
if (level) port->PIO_SODR = mask;
else port->PIO_CODR = mask;
}
uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{ {
switch(msg) case U8G_COM_MSG_STOP:
{ break;
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_INIT: case U8G_COM_MSG_INIT:
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, 1); u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, 1);
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, 1); u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, 1);
u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_CS); u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_CS);
u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_A0); u8g_SetPIOutput_DUE_hw_spi(u8g, U8G_PI_A0);
u8g_Delay(5); u8g_Delay(5);
spiBegin(); spiBegin();
#ifndef SPI_SPEED #ifndef SPI_SPEED
#define SPI_SPEED SPI_FULL_SPEED // use same SPI speed as SD card #define SPI_SPEED SPI_FULL_SPEED // use same SPI speed as SD card
#endif #endif
spiInit(2); spiInit(2);
break; break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, arg_val); u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_A0, arg_val);
break; break;
case U8G_COM_MSG_CHIP_SELECT: case U8G_COM_MSG_CHIP_SELECT:
u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, (arg_val ? 0 : 1)); u8g_SetPILevel_DUE_hw_spi(u8g, U8G_PI_CS, (arg_val ? 0 : 1));
break; break;
case U8G_COM_MSG_RESET: case U8G_COM_MSG_RESET:
break; break;
case U8G_COM_MSG_WRITE_BYTE: case U8G_COM_MSG_WRITE_BYTE:
spiSend((uint8_t)arg_val); spiSend((uint8_t)arg_val);
break; break;
case U8G_COM_MSG_WRITE_SEQ: { case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
spiSend(*ptr++); spiSend(*ptr++);
arg_val--; arg_val--;
}
} }
break; }
break;
case U8G_COM_MSG_WRITE_SEQ_P: { case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
spiSend(*ptr++); spiSend(*ptr++);
arg_val--; arg_val--;
}
} }
break; }
} break;
return 1;
} }
return 1;
}
#endif // DOGLCD
#endif //__SAM3X8E__ #endif //__SAM3X8E__

9
Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
View File

@ -55,9 +55,12 @@
#ifdef ARDUINO_ARCH_SAM #ifdef ARDUINO_ARCH_SAM
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD)
#include <U8glib.h> #include <U8glib.h>
#include <Arduino.h> #include <Arduino.h>
#include "../../core/macros.h"
#include "../Delay.h" #include "../Delay.h"
void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) { void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
@ -177,4 +180,6 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
return 1; return 1;
} }
#endif //ARDUINO_ARCH_SAM #endif // DOGLCD
#endif // ARDUINO_ARCH_SAM

12
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_hw_spi.cpp
View File

@ -55,11 +55,11 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD)
//#include <inttypes.h> //#include <inttypes.h>
//#include "src/core/macros.h"
//#include "Configuration.h"
#include <U8glib.h> #include <U8glib.h>
#define SPI_FULL_SPEED 0 #define SPI_FULL_SPEED 0
@ -132,4 +132,6 @@ uint8_t u8g_com_HAL_LPC1768_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
return 1; return 1;
} }
#endif //TARGET_LPC1768 #endif // DOGLCD
#endif // TARGET_LPC1768

178
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp
View File

@ -77,113 +77,119 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
#include <U8glib.h> #include "../../inc/MarlinConfigPre.h"
#define I2C_SLA (0x3C*2) #if ENABLED(DOGLCD)
//#define I2C_CMD_MODE 0x080
#define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040
//#define U8G_I2C_OPT_FAST 16 #include <U8glib.h>
uint8_t u8g_com_ssd_I2C_start_sequence(u8g_t *u8g) { #define I2C_SLA (0x3C*2)
/* are we requested to set the a0 state? */ //#define I2C_CMD_MODE 0x080
if (u8g->pin_list[U8G_PI_SET_A0] == 0) return 1; #define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040
/* setup bus, might be a repeated start */ //#define U8G_I2C_OPT_FAST 16
if (u8g_i2c_start(I2C_SLA) == 0)
return 0;
if (u8g->pin_list[U8G_PI_A0_STATE] == 0 ) {
if (u8g_i2c_send_byte(I2C_CMD_MODE) == 0) return 0;
}
else if (u8g_i2c_send_byte(I2C_DATA_MODE) == 0)
return 0;
u8g->pin_list[U8G_PI_SET_A0] = 0; uint8_t u8g_com_ssd_I2C_start_sequence(u8g_t *u8g) {
return 1; /* are we requested to set the a0 state? */
if (u8g->pin_list[U8G_PI_SET_A0] == 0) return 1;
/* setup bus, might be a repeated start */
if (u8g_i2c_start(I2C_SLA) == 0)
return 0;
if (u8g->pin_list[U8G_PI_A0_STATE] == 0 ) {
if (u8g_i2c_send_byte(I2C_CMD_MODE) == 0) return 0;
} }
else if (u8g_i2c_send_byte(I2C_DATA_MODE) == 0)
return 0;
uint8_t u8g_com_HAL_LPC1768_ssd_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) { u8g->pin_list[U8G_PI_SET_A0] = 0;
switch(msg) { return 1;
case U8G_COM_MSG_INIT: }
//u8g_com_arduino_digital_write(u8g, U8G_PI_SCL, HIGH);
//u8g_com_arduino_digital_write(u8g, U8G_PI_SDA, HIGH);
//u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: unknown mode */
u8g_i2c_init(u8g->pin_list[U8G_PI_I2C_OPTION]); uint8_t u8g_com_HAL_LPC1768_ssd_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
u8g_com_ssd_I2C_start_sequence(u8g); switch(msg) {
break; case U8G_COM_MSG_INIT:
//u8g_com_arduino_digital_write(u8g, U8G_PI_SCL, HIGH);
//u8g_com_arduino_digital_write(u8g, U8G_PI_SDA, HIGH);
//u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: unknown mode */
case U8G_COM_MSG_STOP: u8g_i2c_init(u8g->pin_list[U8G_PI_I2C_OPTION]);
break; u8g_com_ssd_I2C_start_sequence(u8g);
break;
case U8G_COM_MSG_RESET: case U8G_COM_MSG_STOP:
/* Currently disabled, but it could be enable. Previous restrictions have been removed */ break;
/* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */
break;
case U8G_COM_MSG_CHIP_SELECT: case U8G_COM_MSG_RESET:
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* Currently disabled, but it could be enable. Previous restrictions have been removed */
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again, also forces start condition */ /* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */
if (arg_val == 0 ) { break;
/* disable chip, send stop condition */
u8g_i2c_stop(); case U8G_COM_MSG_CHIP_SELECT:
u8g->pin_list[U8G_PI_A0_STATE] = 0;
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again, also forces start condition */
if (arg_val == 0 ) {
/* disable chip, send stop condition */
u8g_i2c_stop();
}
else {
/* enable, do nothing: any byte writing will trigger the i2c start */
}
break;
case U8G_COM_MSG_WRITE_BYTE:
//u8g->pin_list[U8G_PI_SET_A0] = 1;
//if (u8g_com_arduino_ssd_start_sequence(u8g) == 0)
// return u8g_i2c_stop(), 0;
if (u8g_i2c_send_byte(arg_val) == 0)
return u8g_i2c_stop(), 0;
// u8g_i2c_stop();
break;
case U8G_COM_MSG_WRITE_SEQ: {
//u8g->pin_list[U8G_PI_SET_A0] = 1;
if (u8g_com_ssd_I2C_start_sequence(u8g) == 0)
return u8g_i2c_stop(), 0;
register uint8_t *ptr = (uint8_t *)arg_ptr;
while (arg_val > 0) {
if (u8g_i2c_send_byte(*ptr++) == 0)
return u8g_i2c_stop(), 0;
arg_val--;
} }
else { }
/* enable, do nothing: any byte writing will trigger the i2c start */ // u8g_i2c_stop();
} break;
break;
case U8G_COM_MSG_WRITE_BYTE: case U8G_COM_MSG_WRITE_SEQ_P: {
//u8g->pin_list[U8G_PI_SET_A0] = 1;
//if (u8g_com_arduino_ssd_start_sequence(u8g) == 0)
// return u8g_i2c_stop(), 0;
if (u8g_i2c_send_byte(arg_val) == 0)
return u8g_i2c_stop(), 0;
// u8g_i2c_stop();
break;
case U8G_COM_MSG_WRITE_SEQ: {
//u8g->pin_list[U8G_PI_SET_A0] = 1; //u8g->pin_list[U8G_PI_SET_A0] = 1;
if (u8g_com_ssd_I2C_start_sequence(u8g) == 0) if (u8g_com_ssd_I2C_start_sequence(u8g) == 0)
return u8g_i2c_stop(), 0; return u8g_i2c_stop(), 0;
register uint8_t *ptr = (uint8_t *)arg_ptr; register uint8_t *ptr = (uint8_t *)arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
if (u8g_i2c_send_byte(*ptr++) == 0) if (u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0)
return u8g_i2c_stop(), 0; return 0;
arg_val--; ptr++;
} arg_val--;
} }
// u8g_i2c_stop(); }
break; // u8g_i2c_stop();
break;
case U8G_COM_MSG_WRITE_SEQ_P: { case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
//u8g->pin_list[U8G_PI_SET_A0] = 1; u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
if (u8g_com_ssd_I2C_start_sequence(u8g) == 0) u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again */
return u8g_i2c_stop(), 0;
register uint8_t *ptr = (uint8_t *)arg_ptr; u8g_i2c_start(0); // send slave address and write bit
while (arg_val > 0) { u8g_i2c_send_byte(arg_val ? 0x40 : 0x80); // Write to ? Graphics DRAM mode : Command mode
if (u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0) break;
return 0;
ptr++;
arg_val--;
}
}
// u8g_i2c_stop();
break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ } // switch
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; return 1;
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again */ }
u8g_i2c_start(0); // send slave address and write bit #endif // DOGLCD
u8g_i2c_send_byte(arg_val ? 0x40 : 0x80); // Write to ? Graphics DRAM mode : Command mode
break;
} // switch
return 1;
}
#endif // TARGET_LPC1768 #endif // TARGET_LPC1768

18
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction
View File

@ -61,16 +61,20 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
#include <U8glib.h> #include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD)
#include <U8glib.h>
//void pinMode(int16_t pin, uint8_t mode); //void pinMode(int16_t pin, uint8_t mode);
//void digitalWrite(int16_t pin, uint8_t pin_status); //void digitalWrite(int16_t pin, uint8_t pin_status);
#define I2C_SLA (0x3C*2) #define I2C_SLA (0x3C*2)
//#define I2C_CMD_MODE 0x080 //#define I2C_CMD_MODE 0x080
#define I2C_CMD_MODE 0x000 #define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040 #define I2C_DATA_MODE 0x040
//static uint8_t I2C_speed; // 3 - 400KHz, 13 - 100KHz //static uint8_t I2C_speed; // 3 - 400KHz, 13 - 100KHz
//#define SPEED_400KHz 3 //#define SPEED_400KHz 3
@ -245,4 +249,6 @@ uint8_t u8g_com_HAL_LPC1768_ssd_sw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_v
return 1; return 1;
} }
#endif // TARGET_LPC1768 #endif // DOGLCD
#endif // TARGET_LPC1768

151
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp
View File

@ -55,103 +55,100 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
//#include <inttypes.h> #include "../../inc/MarlinConfigPre.h"
//#include "src/core/macros.h"
//#include "Configuration.h"
#include <U8glib.h> #if ENABLED(DOGLCD)
#include "../Delay.h"
#define SPI_FULL_SPEED 0 //#include <inttypes.h>
#define SPI_HALF_SPEED 1 #include <U8glib.h>
#define SPI_QUARTER_SPEED 2 #include "../Delay.h"
#define SPI_EIGHTH_SPEED 3
#define SPI_SIXTEENTH_SPEED 4
#define SPI_SPEED_5 5
#define SPI_SPEED_6 6
#define SPI_FULL_SPEED 0
#define SPI_HALF_SPEED 1
#define SPI_QUARTER_SPEED 2
#define SPI_EIGHTH_SPEED 3
#define SPI_SIXTEENTH_SPEED 4
#define SPI_SPEED_5 5
#define SPI_SPEED_6 6
void spiBegin(); void spiBegin();
void spiInit(uint8_t spiRate); void spiInit(uint8_t spiRate);
void spiSend(uint8_t b); void spiSend(uint8_t b);
void spiSend(const uint8_t* buf, size_t n); void spiSend(const uint8_t* buf, size_t n);
static uint8_t rs_last_state = 255;
static uint8_t rs_last_state = 255; static void u8g_com_LPC1768_st7920_write_byte_hw_spi(uint8_t rs, uint8_t val) {
uint8_t i;
static void u8g_com_LPC1768_st7920_write_byte_hw_spi(uint8_t rs, uint8_t val) if ( rs != rs_last_state) { // time to send a command/data byte
{ rs_last_state = rs;
uint8_t i;
if ( rs != rs_last_state) { // time to send a command/data byte if ( rs == 0 )
rs_last_state = rs; /* command */
spiSend(0x0F8);
else
/* data */
spiSend(0x0FA);
if ( rs == 0 ) DELAY_US(40); // give the controller some time to process the data: 20 is bad, 30 is OK, 40 is safe
/* command */
spiSend(0x0F8);
else
/* data */
spiSend(0x0FA);
DELAY_US(40); // give the controller some time to process the data: 20 is bad, 30 is OK, 40 is safe
}
spiSend(val & 0x0F0);
spiSend(val << 4);
} }
spiSend(val & 0x0F0);
spiSend(val << 4);
}
uint8_t u8g_com_HAL_LPC1768_ST7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) uint8_t u8g_com_HAL_LPC1768_ST7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
{ switch(msg) {
switch(msg) case U8G_COM_MSG_INIT:
{ u8g_SetPILevel(u8g, U8G_PI_CS, 0);
case U8G_COM_MSG_INIT: u8g_SetPIOutput(u8g, U8G_PI_CS);
u8g_SetPILevel(u8g, U8G_PI_CS, 0); u8g_Delay(5);
u8g_SetPIOutput(u8g, U8G_PI_CS); spiBegin();
u8g_Delay(5); spiInit(SPI_EIGHTH_SPEED); // ST7920 max speed is about 1.1 MHz
spiBegin(); u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */
spiInit(SPI_EIGHTH_SPEED); // ST7920 max speed is about 1.1 MHz break;
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */
break;
case U8G_COM_MSG_STOP: case U8G_COM_MSG_STOP:
break; break;
case U8G_COM_MSG_RESET: case U8G_COM_MSG_RESET:
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
break; break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
break; break;
case U8G_COM_MSG_CHIP_SELECT: case U8G_COM_MSG_CHIP_SELECT:
u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select
break; break;
case U8G_COM_MSG_WRITE_BYTE: case U8G_COM_MSG_WRITE_BYTE:
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val); u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
break; break;
case U8G_COM_MSG_WRITE_SEQ: { case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
arg_val--; arg_val--;
}
} }
break; }
break;
case U8G_COM_MSG_WRITE_SEQ_P: { case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
arg_val--; arg_val--;
}
} }
break; }
} break;
return 1;
} }
return 1;
}
#endif // TARGET_LPC1768 #endif // DOGLCD
#endif // TARGET_LPC1768

143
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp
View File

@ -55,97 +55,102 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
#include <U8glib.h> #include "../../inc/MarlinConfigPre.h"
#include "SoftwareSPI.h"
#include "../Delay.h"
#define SPI_SPEED 3 // About 1 MHz #if ENABLED(DOGLCD)
static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL; #include <U8glib.h>
static uint8_t SPI_speed = 0; #include "SoftwareSPI.h"
static uint8_t rs_last_state = 255; #include "../Delay.h"
static void u8g_com_LPC1768_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) #define SPI_SPEED 3 // About 1 MHz
{
uint8_t i;
if ( rs != rs_last_state) { // time to send a command/data byte static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL;
rs_last_state = rs; static uint8_t SPI_speed = 0;
static uint8_t rs_last_state = 255;
if ( rs == 0 ) static void u8g_com_LPC1768_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
/* command */ uint8_t i;
swSpiTransfer(0x0F8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
else
/* data */
swSpiTransfer(0x0FA, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
DELAY_US(40); // give the controller some time to process the data: 20 is bad, 30 is OK, 40 is safe if (rs != rs_last_state) { // time to send a command/data byte
} rs_last_state = rs;
swSpiTransfer(val & 0x0F0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); if (rs == 0)
swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); /* command */
swSpiTransfer(0x0F8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
else
/* data */
swSpiTransfer(0x0FA, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
DELAY_US(40); // give the controller some time to process the data: 20 is bad, 30 is OK, 40 is safe
} }
uint8_t u8g_com_HAL_LPC1768_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) swSpiTransfer(val & 0x0F0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
}
uint8_t u8g_com_HAL_LPC1768_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
{
switch(msg)
{ {
switch(msg) case U8G_COM_MSG_INIT:
{ SCK_pin_ST7920_HAL = u8g->pin_list[U8G_PI_SCK];
case U8G_COM_MSG_INIT: MOSI_pin_ST7920_HAL_HAL = u8g->pin_list[U8G_PI_MOSI];
SCK_pin_ST7920_HAL = u8g->pin_list[U8G_PI_SCK];
MOSI_pin_ST7920_HAL_HAL = u8g->pin_list[U8G_PI_MOSI];
u8g_SetPIOutput(u8g, U8G_PI_CS); u8g_SetPIOutput(u8g, U8G_PI_CS);
u8g_SetPIOutput(u8g, U8G_PI_SCK); u8g_SetPIOutput(u8g, U8G_PI_SCK);
u8g_SetPIOutput(u8g, U8G_PI_MOSI); u8g_SetPIOutput(u8g, U8G_PI_MOSI);
u8g_Delay(5); u8g_Delay(5);
SPI_speed = swSpiInit(SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL); SPI_speed = swSpiInit(SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL);
u8g_SetPILevel(u8g, U8G_PI_CS, 0); u8g_SetPILevel(u8g, U8G_PI_CS, 0);
u8g_SetPILevel(u8g, U8G_PI_SCK, 0); u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
u8g_SetPILevel(u8g, U8G_PI_MOSI, 0); u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */ u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */
break; break;
case U8G_COM_MSG_STOP: case U8G_COM_MSG_STOP:
break; break;
case U8G_COM_MSG_RESET: case U8G_COM_MSG_RESET:
if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
break; break;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
break; break;
case U8G_COM_MSG_CHIP_SELECT: case U8G_COM_MSG_CHIP_SELECT:
if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_CS]) u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_CS]) u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select
break; break;
case U8G_COM_MSG_WRITE_BYTE: case U8G_COM_MSG_WRITE_BYTE:
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val); u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
break; break;
case U8G_COM_MSG_WRITE_SEQ: { case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
arg_val--; arg_val--;
}
} }
break; }
break;
case U8G_COM_MSG_WRITE_SEQ_P: { case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr; uint8_t *ptr = (uint8_t*) arg_ptr;
while (arg_val > 0) { while (arg_val > 0) {
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
arg_val--; arg_val--;
}
} }
break; }
} break;
return 1;
} }
return 1;
}
#endif //TARGET_LPC1768 #endif // DOGLCD
#endif // TARGET_LPC1768

6
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_sw_spi.cpp
View File

@ -55,6 +55,10 @@
#ifdef TARGET_LPC1768 #ifdef TARGET_LPC1768
#include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD)
#include <U8glib.h> #include <U8glib.h>
#include "SoftwareSPI.h" #include "SoftwareSPI.h"
@ -120,4 +124,6 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
return 1; return 1;
} }
#endif // DOGLCD
#endif // TARGET_LPC1768 #endif // TARGET_LPC1768

2
Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp
View File

@ -65,7 +65,7 @@
* beginning. * beginning.
*/ */
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)

53
Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp
View File

@ -67,43 +67,43 @@
/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */ /* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
static const uint8_t u8g_dev_st7565_64128n_HAL_init_seq[] PROGMEM = { static const uint8_t u8g_dev_st7565_64128n_HAL_init_seq[] PROGMEM = {
U8G_ESC_CS(0), // disable chip U8G_ESC_CS(0), // disable chip
U8G_ESC_ADR(0), // instruction mode U8G_ESC_ADR(0), // instruction mode
U8G_ESC_CS(1), // enable chip U8G_ESC_CS(1), // enable chip
U8G_ESC_RST(15), // do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ U8G_ESC_RST(15), // do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
0x0A2, // 0x0A2: LCD bias 1/9 (according to Displaytech 64128N datasheet) 0x0A2, // 0x0A2: LCD bias 1/9 (according to Displaytech 64128N datasheet)
0x0A0, // Normal ADC Select (according to Displaytech 64128N datasheet) 0x0A0, // Normal ADC Select (according to Displaytech 64128N datasheet)
0x0C8, // common output mode: set scan direction normal operation/SHL Select, 0x0C0 --> SHL = 0, normal, 0x0C8 --> SHL = 1 0x0C8, // common output mode: set scan direction normal operation/SHL Select, 0x0C0 --> SHL = 0, normal, 0x0C8 --> SHL = 1
0x040, // Display start line for Displaytech 64128N 0x040, // Display start line for Displaytech 64128N
0x028 | 0x04, // power control: turn on voltage converter 0x028 | 0x04, // power control: turn on voltage converter
U8G_ESC_DLY(50), // delay 50 ms U8G_ESC_DLY(50), // delay 50 ms
0x028 | 0x06, // power control: turn on voltage regulator 0x028 | 0x06, // power control: turn on voltage regulator
U8G_ESC_DLY(50), // delay 50 ms U8G_ESC_DLY(50), // delay 50 ms
0x028 | 0x07, // power control: turn on voltage follower 0x028 | 0x07, // power control: turn on voltage follower
U8G_ESC_DLY(50), // delay 50 ms U8G_ESC_DLY(50), // delay 50 ms
0x010, // Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N 0x010, // Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N
0x0A6, // display normal, bit val 0: LCD pixel off. 0x0A6, // display normal, bit val 0: LCD pixel off.
0x081, // set contrast 0x081, // set contrast
0x01E, // Contrast value. Setting for controlling brightness of Displaytech 64128N 0x01E, // Contrast value. Setting for controlling brightness of Displaytech 64128N
0x0AF, // display on 0x0AF, // display on
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
0x0A5, // display all points, ST7565 0x0A5, // display all points, ST7565
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
0x0A4, // normal display 0x0A4, // normal display
U8G_ESC_CS(0), // disable chip U8G_ESC_CS(0), // disable chip
U8G_ESC_END // end of sequence U8G_ESC_END // end of sequence
}; };
static const uint8_t u8g_dev_st7565_64128n_HAL_data_start[] PROGMEM = { static const uint8_t u8g_dev_st7565_64128n_HAL_data_start[] PROGMEM = {
@ -211,7 +211,6 @@ uint8_t u8g_dev_st7565_64128n_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg); return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg);
} }
U8G_PB_DEV(u8g_dev_st7565_64128n_HAL_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_HAL_fn, U8G_COM_HAL_SW_SPI_FN); U8G_PB_DEV(u8g_dev_st7565_64128n_HAL_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_HAL_fn, U8G_COM_HAL_SW_SPI_FN);
uint8_t u8g_dev_st7565_64128n_HAL_2x_buf[WIDTH*2] U8G_NOCOMMON ; uint8_t u8g_dev_st7565_64128n_HAL_2x_buf[WIDTH*2] U8G_NOCOMMON ;

2
Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp
View File

@ -53,7 +53,7 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)

14
Marlin/src/lcd/dogm/u8g_dev_uc1701_mini12864_HAL.cpp
View File

@ -57,7 +57,7 @@
*/ */
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfigPre.h"
#if ENABLED(DOGLCD) #if ENABLED(DOGLCD)
@ -108,10 +108,8 @@ static const uint8_t u8g_dev_uc1701_mini12864_HAL_data_start[] PROGMEM = {
U8G_ESC_END /* end of sequence */ U8G_ESC_END /* end of sequence */
}; };
uint8_t u8g_dev_uc1701_mini12864_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) uint8_t u8g_dev_uc1701_mini12864_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) {
{ switch(msg) {
switch(msg)
{
case U8G_DEV_MSG_INIT: case U8G_DEV_MSG_INIT:
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS); u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq); u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq);
@ -140,10 +138,8 @@ uint8_t u8g_dev_uc1701_mini12864_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg); return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
} }
uint8_t u8g_dev_uc1701_mini12864_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) uint8_t u8g_dev_uc1701_mini12864_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg) {
{ switch(msg) {
switch(msg)
{
case U8G_DEV_MSG_INIT: case U8G_DEV_MSG_INIT:
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS); u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq); u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_init_seq);

3
Marlin/src/lcd/dogm/ultralcd_st7920_u8glib_rrd_AVR.cpp
View File

@ -24,12 +24,13 @@
// file u8g_dev_st7920_128x64_HAL.cpp for the HAL version. // file u8g_dev_st7920_128x64_HAL.cpp for the HAL version.
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfig.h"
#include "../../HAL/Delay.h"
#if ENABLED(U8GLIB_ST7920) #if ENABLED(U8GLIB_ST7920)
#if !(defined(U8G_HAL_LINKS) || defined(__SAM3X8E__)) #if !(defined(U8G_HAL_LINKS) || defined(__SAM3X8E__))
#include "../../HAL/Delay.h"
#define ST7920_CLK_PIN LCD_PINS_D4 #define ST7920_CLK_PIN LCD_PINS_D4
#define ST7920_DAT_PIN LCD_PINS_ENABLE #define ST7920_DAT_PIN LCD_PINS_ENABLE
#define ST7920_CS_PIN LCD_PINS_RS #define ST7920_CS_PIN LCD_PINS_RS

13
Marlin/src/lcd/lcdprint_u8g.cpp
View File

@ -8,11 +8,8 @@
*/ */
#include "../inc/MarlinConfigPre.h" #include "../inc/MarlinConfigPre.h"
#include "../inc/MarlinConfig.h"
#define USE_LCDPRINT_U8G ENABLED(ULTRA_LCD) && ENABLED(DOGLCD) #if ENABLED(DOGLCD)
#if USE_LCDPRINT_U8G
#include <U8glib.h> #include <U8glib.h>
extern U8GLIB *pu8g; extern U8GLIB *pu8g;
@ -72,9 +69,9 @@ int lcd_put_u8str_max_rom(const char * utf8_str_P, pixel_len_t max_length) {
return ret; return ret;
} }
#else // !USE_LCDPRINT_U8G #else // !ULTRA_LCD
#define _lcd_write(a) TRACE("Write LCD: %c (%d)", (a), (int)(a)); #define _lcd_write(a) TRACE("Write LCD: %c (%d)", (a), (int)(a));
#define _lcd_setcursor(col, row) TRACE("Set cursor LCD: (%d,%d)", (col), (row)); #define _lcd_setcursor(col, row) TRACE("Set cursor LCD: (%d,%d)", (col), (row));
#endif // !USE_LCDPRINT_U8G #endif // !ULTRA_LCD