Wyświetlacz oparty na sterowniku CS1621/HT1621

Tutaj zamieszczamy wyniki i recenzje z testowanych zestawów / podzespołów, jakie będą dostępne dla użytkowników forum
Awatar użytkownika
StaryAnoda_NEW
Newb
Newb
Posty: 67
Rejestracja: środa 04 kwie 2018, 16:48

Wyświetlacz oparty na sterowniku CS1621/HT1621

Postautor: StaryAnoda_NEW » środa 02 maja 2018, 21:09

Swego czasu wpadł mi w ręce bardzo ciekawy, a zarazem tani wyświetlacz oparty na sterowniku CS1621/HT1621. Cena jego nie przekracza 5 złotych.
1.jpg


Jak dobrze się przyjrzymy zauważymy tam litery (kVArh kWh)co może nam sugerować, że zostały wyprodukowane do liczników energii elektrycznej. Dokumentacja wyświetlacza dostępna jest pod linkiem:
CBS084A00-TJN.pdf


Wyświetlacz komunikuję się przy użyciu interfejsu synchronicznego szeregowego podobnego do znanego nam SPI, ale tylko na pozór otwierając dział 10. Timing Characteristics, na stronie 11 widzimy że w tym protokole występują dwie linie zegarowe /RD /RW, jedna linia danych DATA, oraz pin wyboru układu /CS. Ramka danych jest 13 bitowa.

Podłączenie do naszej płytki STM8SVLDISCOVERRY:

Pin 1 /CS ----- PB0 Wybór układu
Pin 2 /RD ---- PB1 Sygnał zegarowy dla odczytu danych
Pin 3 /WR ---- PB2 Sygnał zegarowy dla zapisu danych
Pin 4 DATA ---- PB3 Transmisja danych zarówno dla odczytu jak i zapisu
Pin 5 VSS ---- GND
Pin 6 VDD ---- VCC Zasilanie, w naszym przypadku 3.3V lub 5.0V
Pin 7 IRQ ---- NC
2.jpg


Założenie zworki JP1 na pozycję U5V umożliwi nam zasilenie całej płytki napięciem 5V. Nasz wyświetlacz może pracować co prawda przy napięciu 3.3V, jednak widoczność poszczególnych segmentów będzie pozostawiała wiele do życzenia.

Zobaczmy schemat pojedynczej ramki dla operacji zapisu i odczytu:
3.png


Funkcje dla zapisu i odczytu prezentują się następująco:

Kod: Zaznacz cały

void CS1621_HT1621_spi_write_data(uint16_t data)
{
 uint16_t cnt = 0x1000;

 CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_OUTPUT);

 CS1621_HT1621_CS_LOW;
 while(cnt)
 {
  if(data & cnt)
  {
   CS1621_HT1621_DATA_HIGH;
  }
  else
  {
   CS1621_HT1621_DATA_LOW;
  }
  CS1621_HT1621_WR_LOW;
  CS1621_HT1621_WR_HIGH;
  cnt >>= 0x1;
 }
 CS1621_HT1621_CS_HIGH;
}

uint8_t CS1621_HT1621_spi_read_data(uint16_t address)
{
 uint16_t cnt = 0x100;
 uint8_t return_data = 0;

 CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_OUTPUT);

 CS1621_HT1621_CS_LOW;
 while(cnt)
 {
  if(address & cnt)
  {
   CS1621_HT1621_DATA_HIGH;
  }
  else
  {
   CS1621_HT1621_DATA_LOW;
  }
  CS1621_HT1621_WR_LOW;
  CS1621_HT1621_WR_HIGH;
  cnt >>= 0x1;
 }

 CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_INPUT);

 cnt = 0x8;
 while(cnt)
 {
  return_data <<= 0x1;
  CS1621_HT1621_RD_LOW;
  CS1621_HT1621_RD_HIGH;
  if(CS1621_HT1621_DATA_IS_HIGH) return_data |= 0x1;
  cnt >>= 0x1;
 }
 CS1621_HT1621_CS_HIGH;
return return_data;
}


Kod był uruchamiany i testowany na już wcześniej wspomnianej płytce STM8SVLDISCOVERY z mikrokontrolerem STM8S003K3.
Biblioteka w pełni konfigurowalna należy dostosować piny GPIO do swojego mikrokontrolera (pliki CS1621_HT1621_spi_software.c oraz CS1621_HT1621_spi_software.h). Na STM32F103C8 też pięknie działa :
3.jpg


main.c

Kod: Zaznacz cały

#include <iostm8s003.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdint.h>


#include "CS1621_HT1621.h"


int main(void)
{
   CS1621_HT1621_init();
   
   CS1621_HT1621_set_dot(0, 1);
   CS1621_HT1621_set_dot(1, 1);
   CS1621_HT1621_set_dot(2, 1);
   CS1621_HT1621_set_dot(3, 1);

   CS1621_HT1621_set_icons(0, 1);
   CS1621_HT1621_set_icons(1, 1);
   CS1621_HT1621_set_icons(2, 1);
   CS1621_HT1621_set_icons(3, 1);
   CS1621_HT1621_set_icons(4, 1);
   CS1621_HT1621_set_icons(5, 1);
   CS1621_HT1621_set_icons(6, 1);
   CS1621_HT1621_set_icons(7, 1);

   CS1621_HT1621_set_digit_value(0, 0);
   CS1621_HT1621_set_digit_value(1, 1);
   CS1621_HT1621_set_digit_value(2, 2);
   CS1621_HT1621_set_digit_value(3, 3);
   CS1621_HT1621_set_digit_value(4, 4);
   CS1621_HT1621_set_digit_value(5, 5);
   CS1621_HT1621_set_digit_value(6, 6);
   CS1621_HT1621_set_digit_value(7, 7);
   CS1621_HT1621_set_digit_value(8, 8);

   CS1621_HT1621_set_segment(9, CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_E | CS1621_HT1621_SEGMENT_F);
   CS1621_HT1621_set_segment(10, CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_G | CS1621_HT1621_SEGMENT_F);
 
   while(true)
   {
   }
   return EXIT_SUCCESS;
}


CS1621_HT1621_spi_software.h

Kod: Zaznacz cały

#ifndef CS1621_HT1621_SPI_SOFTWARE
#define CS1621_HT1621_SPI_SOFTWARE


#define CS1621_HT1621_CS_LOW (PB_ODR &= ~0b00000001)
#define CS1621_HT1621_CS_HIGH (PB_ODR |= 0b00000001)

#define CS1621_HT1621_RD_LOW (PB_ODR &= ~0b00000010)
#define CS1621_HT1621_RD_HIGH (PB_ODR |= 0b00000010)

#define CS1621_HT1621_WR_LOW (PB_ODR &= ~0b00000100)
#define CS1621_HT1621_WR_HIGH (PB_ODR |= 0b00000100)

#define CS1621_HT1621_DATA_LOW (PB_ODR &= ~0b00001000)
#define CS1621_HT1621_DATA_HIGH (PB_ODR |= 0b00001000)

#define CS1621_HT1621_DATA_IS_HIGH (PB_IDR & 0b00001000)


void CS1621_HT1621_spi_software_init(void);
void CS1621_HT1621_spi_write_data(uint16_t data);
uint8_t CS1621_HT1621_spi_read_data(uint16_t address);


#endif


CS1621_HT1621_spi_software.c

Kod: Zaznacz cały

#include <iostm8s003.h>
#include <stdint.h>


#include "CS1621_HT1621_spi_software.h"
 
 
typedef enum
{
    CS1621_HT1621_DATA_PIN_OUTPUT = 0,
    CS1621_HT1621_DATA_PIN_INPUT
}
CS1621_HT1621_data_pin_mode;
 

void CS1621_HT1621_set_data_mode(CS1621_HT1621_data_pin_mode mode)
{
   if(mode == CS1621_HT1621_DATA_PIN_OUTPUT)
   {
      PB_DDR |= 0x08;
      PB_CR1 |= 0x08;
      CS1621_HT1621_DATA_HIGH;
   }
   else
   {
      PB_DDR &= ~0x08;
      PB_CR1 &= ~0x08;
      CS1621_HT1621_DATA_LOW;
   }
}

void CS1621_HT1621_spi_software_init(void)
{
    PB_DDR |= 0x0f;
   PB_CR1 |= 0x0f;
   
   CS1621_HT1621_CS_HIGH;
   CS1621_HT1621_WR_HIGH;
   CS1621_HT1621_RD_HIGH;
   CS1621_HT1621_DATA_HIGH;
}

void CS1621_HT1621_spi_write_data(uint16_t data)
{
   uint16_t cnt = 0x1000;

   CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_PIN_OUTPUT);

   CS1621_HT1621_CS_LOW;
   while(cnt)
   {
      if(data & cnt)
      {
         CS1621_HT1621_DATA_HIGH;
      }
      else
      {
         CS1621_HT1621_DATA_LOW;
      }
      CS1621_HT1621_WR_LOW;
      CS1621_HT1621_WR_HIGH;
      cnt >>= 0x1;
   }
   CS1621_HT1621_CS_HIGH;
}

uint8_t CS1621_HT1621_spi_read_data(uint16_t address)
{
   uint16_t cnt = 0x100;
   uint8_t return_data = 0;

   CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_PIN_OUTPUT);

   CS1621_HT1621_CS_LOW;
   while(cnt)
   {
      if(address & cnt)
      {
         CS1621_HT1621_DATA_HIGH;
      }
      else
      {
         CS1621_HT1621_DATA_LOW;
      }
      CS1621_HT1621_WR_LOW;
      CS1621_HT1621_WR_HIGH;
      cnt >>= 0x1;
   }

   CS1621_HT1621_set_data_mode(CS1621_HT1621_DATA_PIN_INPUT);

   cnt = 0x8;
   while(cnt)
   {
      return_data <<= 0x1;
      CS1621_HT1621_RD_LOW;
      CS1621_HT1621_RD_HIGH;
      if(CS1621_HT1621_DATA_IS_HIGH) return_data |= 0x1;
      cnt >>= 0x1;
   }
   CS1621_HT1621_CS_HIGH;
return return_data;
}


CS1621_HT1621.h

Kod: Zaznacz cały

#ifndef CS1621_HT1621
#define CS1621_HT1621


#define CS1621_HT1621_COMMAND_ID (1<<0xC)
#define CS1621_HT1621_WRITE_ID   (5<<0xA)
#define CS1621_HT1621_READ_ID    (6<<0x6)

#define CS1621_HT1621_SYS_DIS   (0x0)
#define CS1621_HT1621_SYS_EN    (0x4)
#define CS1621_HT1621_LCD_OFF   (0x8)
#define CS1621_HT1621_LCD_ON    (0xC)
#define CS1621_HT1621_TIMER_DIS (0x10)
#define CS1621_HT1621_WDT_DIS   (0x14)
#define CS1621_HT1621_TIMER_EN  (0x18)
#define CS1621_HT1621_WDT_EN    (0x1C)
#define CS1621_HT1621_TONE_OFF  (0x20)
#define CS1621_HT1621_TONE_ON   (0x24)
#define CS1621_HT1621_CLR_TIME  (0x30)
#define CS1621_HT1621_CLR_WDT   (0x38)

#define CS1621_HT1621_XTAL_32_K (0x50)
#define CS1621_HT1621_RC_256_K  (0x60)
#define CS1621_HT1621_EXT_256_K (0x70)

#define CS1621_HT1621_BIAS_1_2_2_COMMONS_OPTION (0x80)
#define CS1621_HT1621_BIAS_1_2_3_COMMONS_OPTION (0x90)
#define CS1621_HT1621_BIAS_1_2_4_COMMONS_OPTION (0xA0)

#define CS1621_HT1621_BIAS_1_3_2_COMMONS_OPTION (0x84)
#define CS1621_HT1621_BIAS_1_3_3_COMMONS_OPTION (0x94)
#define CS1621_HT1621_BIAS_1_3_4_COMMONS_OPTION (0xA4)

#define CS1621_HT1621_TONE_4_K    (0x100)
#define CS1621_HT1621_TONE_2_K    (0x180)
#define CS1621_HT1621_IRQ_DIS    (0x200)
#define CS1621_HT1621_IRQ_EN    (0x220)
#define CS1621_HT1621_F1    (0x280)
#define CS1621_HT1621_F2    (0x284)
#define CS1621_HT1621_F4   (0x288)
#define CS1621_HT1621_F8    (0x28C)
#define CS1621_HT1621_F16    (0x290)
#define CS1621_HT1621_F32    (0x294)
#define CS1621_HT1621_F64   (0x298)
#define CS1621_HT1621_F128    (0x29C)
#define CS1621_HT1621_TEST    (0x380)
#define CS1621_HT1621_NORMAL    (0x38C)

#define CS1621_HT1621_SEGMENT_A (1<<0x4)
#define CS1621_HT1621_SEGMENT_B (1<<0x0)
#define CS1621_HT1621_SEGMENT_C (1<<0x2)
#define CS1621_HT1621_SEGMENT_D (1<<0x7)
#define CS1621_HT1621_SEGMENT_E (1<<0x6)
#define CS1621_HT1621_SEGMENT_F (1<<0x5)
#define CS1621_HT1621_SEGMENT_G (1<<0x1)


void CS1621_HT1621_init(void);
void CS1621_HT1621_clear(void);
void CS1621_HT1621_set_digit_value(uint8_t digit, uint8_t value);
void CS1621_HT1621_set_dot(uint8_t dot, uint8_t state);
void CS1621_HT1621_set_icons(uint8_t icons, uint8_t state);
void CS1621_HT1621_set_segment(uint8_t digit, uint8_t segment);
void CS1621_HT1621_display_all_characters(void);


#endif


CS1621_HT1621.c

Kod: Zaznacz cały

#include <iostm8s003.h>
#include <stdint.h>


#include "CS1621_HT1621.h"
#include "CS1621_HT1621_spi_software.h"


static const uint8_t CS1621_HT1621_array_characters[11] =
{
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_E | CS1621_HT1621_SEGMENT_F,
   CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C,   
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_E | CS1621_HT1621_SEGMENT_G,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_G,
    CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_F | CS1621_HT1621_SEGMENT_G,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_F | CS1621_HT1621_SEGMENT_G,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_E | CS1621_HT1621_SEGMENT_F | CS1621_HT1621_SEGMENT_G,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_E | CS1621_HT1621_SEGMENT_F | CS1621_HT1621_SEGMENT_G ,
   CS1621_HT1621_SEGMENT_A | CS1621_HT1621_SEGMENT_B | CS1621_HT1621_SEGMENT_C | CS1621_HT1621_SEGMENT_D | CS1621_HT1621_SEGMENT_F | CS1621_HT1621_SEGMENT_G,
   0
};


void CS1621_HT1621_init(void)
{
   CS1621_HT1621_spi_software_init();

   CS1621_HT1621_spi_write_data(CS1621_HT1621_COMMAND_ID | CS1621_HT1621_SYS_EN);
   CS1621_HT1621_spi_write_data(CS1621_HT1621_COMMAND_ID | CS1621_HT1621_LCD_ON);
   CS1621_HT1621_spi_write_data(CS1621_HT1621_COMMAND_ID | CS1621_HT1621_BIAS_1_3_4_COMMONS_OPTION);

   CS1621_HT1621_clear();
}

static void CS1621_HT1621_write_data_to_the_ram(uint16_t data)
{
   CS1621_HT1621_spi_write_data(CS1621_HT1621_WRITE_ID | data);
}

static uint8_t CS1621_HT1621_read_data_from_the_ram(uint8_t address)
{
   return CS1621_HT1621_spi_read_data(CS1621_HT1621_READ_ID | address);
}

void CS1621_HT1621_clear(void)
{
   uint8_t i = 0;

   for(i = 0; i < 0x18; i++)
   {
      CS1621_HT1621_write_data_to_the_ram(i<<4);
   }
}

void CS1621_HT1621_set_digit_value(uint8_t digit, uint8_t value)
{
   uint8_t data = 0;
   
   if(digit == 0)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x17);
      data = (data & 0x8);
      data = (data | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x17<<0x4) | data);
      CS1621_HT1621_write_data_to_the_ram((0x16<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 1)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x15);
      data = (data & 0x8);
      data = (data | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x15<<0x4) | data);
      CS1621_HT1621_write_data_to_the_ram((0x14<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 2)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x13);
      data = (data & 0x8);
      data = (data | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x13<<0x4) | data);
      CS1621_HT1621_write_data_to_the_ram((0x12<<0x4) | (CS1621_HT1621_array_characters[value]>>0x04));
   }
   else if(digit == 3)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x11);
      data = (data & 0x8);
      data = (data | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x11<<0x4) | data);
      CS1621_HT1621_write_data_to_the_ram((0x10<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 4)
   {
      CS1621_HT1621_write_data_to_the_ram((0xF<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0xE<<0x4) |  (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 5)
   {
      CS1621_HT1621_write_data_to_the_ram((0xD<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0xC<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 6)
   {
      CS1621_HT1621_write_data_to_the_ram((0xB<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0xA<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 7)
   {
      CS1621_HT1621_write_data_to_the_ram((0x9<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x8<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 8)
   {
      CS1621_HT1621_write_data_to_the_ram((0x7<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x6<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 9)
   {
      CS1621_HT1621_write_data_to_the_ram((0x5<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x4<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
   else if(digit == 10)
   {
      CS1621_HT1621_write_data_to_the_ram((0x3<<0x4) | (0xF & CS1621_HT1621_array_characters[value]));
      CS1621_HT1621_write_data_to_the_ram((0x2<<0x4) | (CS1621_HT1621_array_characters[value]>>0x4));
   }
}

void CS1621_HT1621_set_dot(uint8_t dot, uint8_t state)
{
   uint8_t data = 0;
   
   if(dot == 0)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x17);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x17<<0x4) | data);
   }
   else if(dot == 1)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x15);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x15<<0x4) | data);
   }
   else if(dot == 2)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x13);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x13<<0x4) | data);
   }
   else if(dot == 3)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x11);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x11<<0x4) | data);
   }
}

void CS1621_HT1621_set_icons(uint8_t icons, uint8_t state)
{
   uint8_t data = 0;
   
   if(icons == 0)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x1);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x1<<0x4) | data);
   }
   else if(icons == 1)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x1);
      if(state) data |= 0x4;
      else data &= ~0x4;
      CS1621_HT1621_write_data_to_the_ram((0x1<<0x4) | data);
   }
   else if(icons == 2)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x1);
      if(state) data |= 0x2;
      else data &= ~0x2;
      CS1621_HT1621_write_data_to_the_ram((0x1<<0x4) | data);
   }
   else if(icons == 3)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x1);
      if(state) data |= 0x1;
      else data &= ~0x1;
      CS1621_HT1621_write_data_to_the_ram((0x1<<0x4) | data);
   }
   else if(icons == 4)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x0);
      if(state) data |= 0x8;
      else data &= ~0x8;
      CS1621_HT1621_write_data_to_the_ram((0x0<<0x4) | data);
   }
   else if(icons == 5)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x0);
      if(state) data |= 0x4;
      else data &= ~0x4;
      CS1621_HT1621_write_data_to_the_ram((0x0<<0x4) | data);
   }
   else if(icons == 6)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x0);
      if(state) data |= 0x2;
      else data &= ~0x2;
      CS1621_HT1621_write_data_to_the_ram((0x0<<0x4) | data);
   }
   else if(icons == 7)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x0);
      if(state) data |= 0x1;
      else data &= ~0x1;
      CS1621_HT1621_write_data_to_the_ram((0x0<<0x4) | data);
   }
}

void CS1621_HT1621_set_segment(uint8_t digit, uint8_t segment)
{
   uint8_t data = 0;
   
   if(digit == 0)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x17);
      data = data & 0x8;
      segment = data | segment;
      CS1621_HT1621_write_data_to_the_ram((0x17<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x16<<0x4) | (segment)>>0x4);
   }
   else if(digit == 1)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x15);
      data = data & 0x8;
      segment = data | segment;
      CS1621_HT1621_write_data_to_the_ram((0x15<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x14<<0x4) | (segment>>0x4));
   }
   else if(digit == 2)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x13);
      data = data & 0x8;
      segment = data | segment;
      CS1621_HT1621_write_data_to_the_ram((0x13<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x12<<0x4) | (segment>>0x04));
   }
   else if(digit == 3)
   {
      data = CS1621_HT1621_read_data_from_the_ram(0x11);
      data = data & 0x8;
      segment = data | segment;
      CS1621_HT1621_write_data_to_the_ram((0x11<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x10<<0x4) | (segment>>0x4));
   }
   else if(digit == 4)
   {
      CS1621_HT1621_write_data_to_the_ram((0xF<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0xE<<0x4) | (segment>>0x4));
   }
   else if(digit == 5)
   {
      CS1621_HT1621_write_data_to_the_ram((0xD<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0xC<<0x4) | (segment>>0x4));
   }
   else if(digit == 6)
   {
      CS1621_HT1621_write_data_to_the_ram((0xB<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0xA<<0x4) | (segment>>0x4));
   }
   else if(digit == 7)
   {
      CS1621_HT1621_write_data_to_the_ram((0x9<<0x4) |  (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x8<<0x4) | (segment>>0x4));
   }
   else if(digit == 8)
   {
      CS1621_HT1621_write_data_to_the_ram((0x7<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x6<<0x4) | (segment>>0x4));
   }
   else if(digit == 9)
   {
      CS1621_HT1621_write_data_to_the_ram((0x5<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x4<<0x4) | (segment>>0x4));
   }
   else if(digit == 10)
   {
      CS1621_HT1621_write_data_to_the_ram((0x3<<0x4) | (0xF & segment));
      CS1621_HT1621_write_data_to_the_ram((0x2<<0x4) | (segment>>0x4));
   }
}

void CS1621_HT1621_display_all_characters(void)
{
   uint8_t i = 0;

   for(i = 0; i < 0x18; i++)
   {
      CS1621_HT1621_write_data_to_the_ram((i<<0x4) | 0xF);
   }
}


Przykład bardziej zaawansowanej biblioteki kolegi Antystatycznego:
[LCD AV-CBS084A00-TJN] Test
Paczka dla STM32F103C8:
STM32F103C8+CS1621_HT1621.rar
Nie masz wymaganych uprawnień, aby zobaczyć pliki załączone do tego posta.
Ostatnio zmieniony czwartek 03 maja 2018, 10:09 przez StaryAnoda_NEW, łącznie zmieniany 2 razy.
done is better than perfect

Awatar użytkownika
Antystatyczny
Geek
Geek
Posty: 1096
Rejestracja: czwartek 03 wrz 2015, 22:02

Re: Wyświetlacz oparty na sterowniku CS1621/HT1621

Postautor: Antystatyczny » środa 02 maja 2018, 21:21

Ładnie, bardzo ładnie. Niektóre miejsca można nieco scalić (zoptymalizować) kosztem czytelności, ale dopóki działa... Niech działa ;) Wrzuć gotową paczkę z Atollic'a :) W wolnej chwili przetestuję na jakimś F103...
"The true sign of intelligence is not knowledge but imagination" Albert Einstein.

Awatar użytkownika
StaryAnoda_NEW
Newb
Newb
Posty: 67
Rejestracja: środa 04 kwie 2018, 16:48

Re: Wyświetlacz oparty na sterowniku CS1621/HT1621

Postautor: StaryAnoda_NEW » środa 02 maja 2018, 21:34

Ok jak tylko przygotuję, ponieważ pod F103 było pisane w innym IDE :)
done is better than perfect

Awatar użytkownika
StaryAnoda_NEW
Newb
Newb
Posty: 67
Rejestracja: środa 04 kwie 2018, 16:48

Re: Wyświetlacz oparty na sterowniku CS1621/HT1621

Postautor: StaryAnoda_NEW » czwartek 03 maja 2018, 10:08

Ok w pierwszym poście dodałem paczkę dla Atollica w wersji 9.0.1.
done is better than perfect


Wróć do „Jak to działa – czyli kącik testera”

Kto jest online

Użytkownicy przeglądający to forum: Obecnie na forum nie ma żadnego zarejestrowanego użytkownika i 1 gość