andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Prevent compilation of unused u8g-oriented code

pull/1/head
Scott Lahteine 7 years ago
parent
35258dd50b
commit
fb608938f8
14 changed files with 419 additions and 401 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 160
      Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_shared_hw_spi.cpp
  2. 9
      Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
  3. 10
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_hw_spi.cpp
  4. 198
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp
  5. 18
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction
  6. 167
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp
  7. 165
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp
  8. 6
      Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_sw_spi.cpp
  9. 2
      Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp
  10. 53
      Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp
  11. 2
      Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp
  12. 14
      Marlin/src/lcd/dogm/u8g_dev_uc1701_mini12864_HAL.cpp
  13. 3
      Marlin/src/lcd/dogm/ultralcd_st7920_u8glib_rrd_AVR.cpp
  14. 13
      Marlin/src/lcd/lcdprint_u8g.cpp

160
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"
// #include "src/core/macros.h"
// #include "Configuration.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
void spiBegin();
void spiInit(uint8_t spiRate);
void spiSend(uint8_t b);
void spiSend(const uint8_t* buf, size_t n);
#include <Arduino.h> #if ENABLED(DOGLCD)
#include "../../core/macros.h"
#include "fastio_Due.h"
#include <U8glib.h>
void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) { #include "../../Marlin.h"
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
}
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) #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 spiInit(uint8_t spiRate);
void spiSend(uint8_t b);
void spiSend(const uint8_t* buf, size_t n);
#include <Arduino.h>
#include "fastio_Due.h"
void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
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
}
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)
{ {
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: {
uint8_t *ptr = (uint8_t*) arg_ptr; case U8G_COM_MSG_WRITE_SEQ_P: {
while (arg_val > 0) { uint8_t *ptr = (uint8_t*) arg_ptr;
spiSend(*ptr++); while (arg_val > 0) {
arg_val--; spiSend(*ptr++);
} 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

10
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 <inttypes.h> #include "../../inc/MarlinConfigPre.h"
//#include "src/core/macros.h" #if ENABLED(DOGLCD)
//#include "Configuration.h"
//#include <inttypes.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

198
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)
//#define I2C_CMD_MODE 0x080
#define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040
//#define U8G_I2C_OPT_FAST 16
uint8_t u8g_com_ssd_I2C_start_sequence(u8g_t *u8g) {
/* 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;
u8g->pin_list[U8G_PI_SET_A0] = 0;
return 1;
}
uint8_t u8g_com_HAL_LPC1768_ssd_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) { #if ENABLED(DOGLCD)
switch(msg) {
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]);
u8g_com_ssd_I2C_start_sequence(u8g);
break;
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_RESET:
/* Currently disabled, but it could be enable. Previous restrictions have been removed */
/* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */
break;
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: #include <U8glib.h>
//u8g->pin_list[U8G_PI_SET_A0] = 1;
//if (u8g_com_arduino_ssd_start_sequence(u8g) == 0) #define I2C_SLA (0x3C*2)
// return u8g_i2c_stop(), 0; //#define I2C_CMD_MODE 0x080
if (u8g_i2c_send_byte(arg_val) == 0) #define I2C_CMD_MODE 0x000
return u8g_i2c_stop(), 0; #define I2C_DATA_MODE 0x040
// u8g_i2c_stop();
break; //#define U8G_I2C_OPT_FAST 16
uint8_t u8g_com_ssd_I2C_start_sequence(u8g_t *u8g) {
/* are we requested to set the a0 state? */
if (u8g->pin_list[U8G_PI_SET_A0] == 0) return 1;
case U8G_COM_MSG_WRITE_SEQ: { /* 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;
u8g->pin_list[U8G_PI_SET_A0] = 0;
return 1;
}
uint8_t u8g_com_HAL_LPC1768_ssd_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
switch(msg) {
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]);
u8g_com_ssd_I2C_start_sequence(u8g);
break;
case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_RESET:
/* Currently disabled, but it could be enable. Previous restrictions have been removed */
/* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */
break;
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--;
}
}
// u8g_i2c_stop();
break;
case U8G_COM_MSG_WRITE_SEQ_P: {
//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;
while (arg_val > 0) {
if (u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0)
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) */ u8g_i2c_start(0); // send slave address and write bit
u8g->pin_list[U8G_PI_A0_STATE] = arg_val; u8g_i2c_send_byte(arg_val ? 0x40 : 0x80); // Write to ? Graphics DRAM mode : Command mode
u8g->pin_list[U8G_PI_SET_A0] = 1; /* force a0 to set again */ break;
u8g_i2c_start(0); // send slave address and write bit } // switch
u8g_i2c_send_byte(arg_val ? 0x40 : 0x80); // Write to ? Graphics DRAM mode : Command mode return 1;
break; }
} // switch #endif // DOGLCD
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

167
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);
uint8_t u8g_com_HAL_LPC1768_ST7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) spiSend(val << 4);
{ }
switch(msg)
{ uint8_t u8g_com_HAL_LPC1768_ST7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
case U8G_COM_MSG_INIT: switch(msg) {
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:
break; case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_RESET:
u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val); case U8G_COM_MSG_RESET:
break; u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
break;
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; case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
break; u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
break;
case U8G_COM_MSG_CHIP_SELECT:
u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select case U8G_COM_MSG_CHIP_SELECT:
break; u8g_SetPILevel(u8g, U8G_PI_CS, arg_val); //note: the st7920 has an active high chip select
break;
case U8G_COM_MSG_WRITE_BYTE:
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val); case U8G_COM_MSG_WRITE_BYTE:
break; u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
break;
case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr; case U8G_COM_MSG_WRITE_SEQ: {
while (arg_val > 0) { uint8_t *ptr = (uint8_t*) arg_ptr;
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); while (arg_val > 0) {
arg_val--; u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
} arg_val--;
} }
break; }
break;
case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr; case U8G_COM_MSG_WRITE_SEQ_P: {
while (arg_val > 0) { uint8_t *ptr = (uint8_t*) arg_ptr;
u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); while (arg_val > 0) {
arg_val--; u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
} arg_val--;
} }
break; }
} break;
return 1;
} }
return 1;
}
#endif // DOGLCD
#endif // TARGET_LPC1768 #endif // TARGET_LPC1768

165
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; static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL;
static uint8_t SPI_speed = 0;
static uint8_t rs_last_state = 255;
if ( rs != rs_last_state) { // time to send a command/data byte static void u8g_com_LPC1768_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
rs_last_state = rs; uint8_t i;
if ( rs == 0 ) if (rs != rs_last_state) { // time to send a command/data byte
/* command */ rs_last_state = rs;
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 == 0)
} /* 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);
swSpiTransfer(val & 0x0F0, 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
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) 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_SCK);
u8g_SetPIOutput(u8g, U8G_PI_CS); u8g_SetPIOutput(u8g, U8G_PI_MOSI);
u8g_SetPIOutput(u8g, U8G_PI_SCK); u8g_Delay(5);
u8g_SetPIOutput(u8g, U8G_PI_MOSI);
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_SCK, 0);
u8g_SetPILevel(u8g, U8G_PI_CS, 0); u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
u8g_SetPILevel(u8g, U8G_PI_MOSI, 0); u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */
break;
u8g->pin_list[U8G_PI_A0_STATE] = 0; /* inital RS state: command mode */
break; case U8G_COM_MSG_STOP:
break;
case U8G_COM_MSG_STOP:
break; case U8G_COM_MSG_RESET:
if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
case U8G_COM_MSG_RESET: break;
if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
break; 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;
case U8G_COM_MSG_ADDRESS: /* define cmd (arg_val = 0) or data mode (arg_val = 1) */ break;
u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
break; 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
case U8G_COM_MSG_CHIP_SELECT: break;
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; case U8G_COM_MSG_WRITE_BYTE:
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
case U8G_COM_MSG_WRITE_BYTE: break;
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
break; case U8G_COM_MSG_WRITE_SEQ: {
uint8_t *ptr = (uint8_t*) arg_ptr;
case U8G_COM_MSG_WRITE_SEQ: { while (arg_val > 0) {
uint8_t *ptr = (uint8_t*) arg_ptr; u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
while (arg_val > 0) { arg_val--;
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
arg_val--;
}
} }
break; }
break;
case U8G_COM_MSG_WRITE_SEQ_P: {
uint8_t *ptr = (uint8_t*) arg_ptr; case U8G_COM_MSG_WRITE_SEQ_P: {
while (arg_val > 0) { uint8_t *ptr = (uint8_t*) arg_ptr;
u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++); while (arg_val > 0) {
arg_val--; u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
} arg_val--;
} }
break; }
} break;
return 1;
} }
return 1;
}
#endif // DOGLCD
#endif //TARGET_LPC1768 #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

Write Preview
Loading…
Cancel
Save