main.c

gehe zur Dokumentation dieser Datei

/****************************************************************************/
/****************************************************************************/
/* Device header file */
#if defined(__XC16__)
    #include <xc.h>
#elif defined(__C30__)
    #if defined(__PIC24E__)
        #include <p24Exxxx.h>
    #elif defined (__PIC24F__)||defined (__PIC24FK__)
    #include <p24Fxxxx.h>
    #elif defined(__PIC24H__)
    #include <p24Hxxxx.h>
    #endif
#endif

#define DOGM163_norm            /* Define Displaytype for Init                     */


#include <stdint.h>        /* Includes uint16_t definition                    */
#include <stdbool.h>       /* Includes true/false definition                  */
#include <stdio.h>
#include <string.h>
#include "system.h"        /* System funct/params, like osc/peripheral config */
#include "user.h"          /* User funct/params, such as InitApp    */
#include <pps.h>
#include "DOG.h"

/****************************************************************************/
#define LCD_LED_TRIS  TRISBbits.TRISB15  // LED Pin TRIS 0=OUT 1=INP
#define LCD_LED       LATBbits.LATB15
#define LCD_RS_TRIS   TRISBbits.TRISB14  // LCD RS Control=0 Data=1
#define LCD_RS        LATBbits.LATB14
#define LCD_CS_TRIS   TRISBbits.TRISB13  // LCD CS ChipSelect 0 aktiv 1 aus
#define LCD_CS        LATBbits.LATB13


/****************************************************************************/
/* i.e. uint16_t <variable_name>; */
 struct {
   char line1[16] ;
   char line2[16] ;
   char line3[16] ;
 } LCD;
 char display[3][16];
 char *displayptr = display[0];
/****************************************************************************/
/****************************************************************************/
void Delayms( uint16_t t)
{
    T2CON = 0x8000;     // enable tmr1, Tcy, 1:1
    while (t--)
    {
        TMR2 = 0;
        while (TMR2<16000);
    }
} // Delayms

/****************************************************************************/
int WriteSPI1(uint8_t data)
{
    SPI1BUF = data;                // write to buffer for TX
    while( !SPI1STATbits.SPIRBF);  // wait for transfer to complete
    return SPI1BUF;                // read the received value
}//WriteSPI1

/****************************************************************************/
void Clear_LCD(void)
{
  LCD_CS = 0;
  LCD_RS = 0;   //Commandmode
  WriteSPI1(0x01);
  Delayms(20);
  LCD_RS = 0;
  LCD_CS = 1;
}

/****************************************************************************/
void SetContrast(uint8_t contrast)
{
  uint8_t temp = 0;
  if (contrast > 63)                  // Limit max =63
    {
    contrast =63;
    }
  LCD_RS = 0;   //Command
  LCD_CS = 0;
  //Lower Bits
  temp = contrast ;
  WriteSPI1(0x70+(temp & 0b00000011));
  //Higher bits
  contrast = contrast >>4;
  WriteSPI1(0x54+(contrast & 0b00000011));

  Delayms(20);
  LCD_CS = 1;
  LCD_RS = 0;
}
/****************************************************************************/
void Init_LCD(void)
{
  LCD_LED  = 1;               // LCD Beleuchtung einschalten
  LCD_CS   = 0;
  LCD_RS   = 0 ;              // Commandmode
  Delayms(50);                // ca. 50ms Wartezeit nach dem Einschalten
  WriteSPI1(FUNCTIONSET_IT1); // 8bit Datenlänge 2Zeilen Instruction Table 1
  WriteSPI1(BIASSET);         // Biasset 1/5 3 zeiliges Display
  WriteSPI1(POWERCONTROL);    // Booster ON, Contrastset C5,C4
  WriteSPI1(FOLLOWERCONTROL); // Follower and Gain set
  WriteSPI1(CONTRASTSET);     // Contrastset C3,C2,C1,C0
  Delayms(50);
  WriteSPI1(FUNCTIONSET_IT0); // Instruction Table 0
  WriteSPI1(DISPLAY_ON_OFF);  // Display ON,Cursor ON, Cursor blinken
  WriteSPI1(CLEARDISPLAY);    // Cleardisplay,Cursor Home
  WriteSPI1(ENTRYMODESET);    // Cursor autoincrement
  LCD_RS = 1;                 // Datamode
  LCD_CS = 1;                 // deselect
  LCD_LED  = 0;
}

void Write_LCD_Data(uint8_t zeichen)
{
    LCD_CS = 0;
    LCD_RS = 1;             // Datamode
    WriteSPI1(zeichen);
    LCD_RS = 1;
    LCD_CS = 1;
}

void Write_LCD_Command(uint8_t zeichen)
{
    LCD_CS = 0;
    LCD_RS = 0 ;           // Commandmode
    WriteSPI1(zeichen);
    LCD_RS = 1;
    LCD_CS = 1;
}
void eaDogM_WriteChr(char value)
{
   LCD_CS = 0;             //output_low(EADOGM_PIN_CSB);
   LCD_RS = 1;             //output_high(EADOGM_PIN_RS);
   WriteSPI1(value);       //eaDogM_outSPI(value);
   LCD_RS = 0;
   LCD_CS =1;              //output_high(EADOGM_PIN_CSB);
//   Delayms(1);
}
void eaDogM_WriteString(char *strPtr)
{
    while (*strPtr != 0x00)
    {
    eaDogM_WriteChr(*strPtr);
    strPtr ++;
    }
}


void WriteString(char *strPtr, uint8_t lng)
{
    while (lng >0 )
    {
    eaDogM_WriteChr(*strPtr);
    strPtr ++;
    lng --;
    }
}

/****************************************************************************/
//
void Set_Cursor_DOGM163 (char row, char column)
{
    // Dislay Position ist Zeile Spalte der DDRAM Adresse. RS=0!
    // 00 01 02 03 .... 0F
    // 10 11 12 13 .... 1F
    // 20 21 22 23 .... 2F
    // DB7 = 1, DB6-DB0 = variable
    // Da, DB7 eine 1 ist wird immer 0x80 oder 128 dazu addiert (CHARACTER_BUFFER_BASE_ADDRESS)
    // Bsp. Zeile 2, Spalte 3 bedeutet 0x12, damit muss ans DDRAM 0x80 + 0x12 = 0x92 geschickt werden.
    // Eleganter geht es natürlich mit den beiden Konstanten, da eine neue Zeile genau nach der Zeilenlänge
    // an der ersten Position beginnt. Aus 0x0F (Spalte 16) wird 0x10, Spalte und 0x80 dazu addiert und fertig.
    Write_LCD_Command (CHARACTER_BUFFER_BASE_ADDRESS + row * CHARACTERS_PER_ROW + column);
}
/******************************************************************************/
/* Main Program                                                               */
/******************************************************************************/

int16_t main(void)
{

    /* Configure the oscillator for the device */
    ConfigureOscillator();

    /* Initialize IO ports and peripherals, remap ports */
    ClrWdt();
    InitApp();
    LCD_CS = 1;  // inaktiv
    LCD_RS = 1;  // Datamode

    /* TODO <INSERT USER APPLICATION CODE HERE> */
    int loopcounter;
 
    char s[16]="Contrast is",t[16];
    char  *strPtr = t;
    int  y,z=99;
    Init_LCD();
    while(1)
    
    {
        ClrWdt();
        LCD_LED=1;
        Clear_LCD();
        strcpy (s,"DOGM163 & PIC24");
        y = sprintf(t,"%s",s);
        eaDogM_WriteString(t);
        Set_Cursor_DOGM163 (1,3);
        strcpy (s,"SPI - Modus");
        y = sprintf(t,"%s",s);
        eaDogM_WriteString(t);
        Delayms(300);
        Clear_LCD();

        for( z = 1 ;z<64;z++)
        {

          strcpy (s,"Contrast is");
          y = sprintf(t," %s:",s);
        Set_Cursor_DOGM163 (0,0);
        y = sprintf(t, "%s: %+04.1i",s,z);
        WriteString(strPtr,y);
        Set_Cursor_DOGM163 (1,0);
        y = sprintf(t, "Length   is: %03i",y);
        WriteString(strPtr,y);
    //    eaDogM_WriteString(t);
        Set_Cursor_DOGM163 (2,0);
        y = sprintf(t, "Loops   are: %03i",loopcounter);
        WriteString(strPtr,y);
      //  eaDogM_WriteString(t);
        Delayms(100);
        void SetContrast(uint8_t z) ;
        ClrWdt();
        }
  //    for (a =0;a<256;a++)
  //      {
  //      LCD_LED=1;
/*
   for (b=0;b<48;b++)
          {
          Write_LCD(a);
          }
        Delayms(500);
        LCD_LED=0; */
 //       Clear_LCD();
    //    txt ="test";
 //       LCD.line1[] = "1111111111111111" ;
   //     LCD.line2[] = "2222222222222222" ;
     //   LCD.line3[] = "3333333333333333" ;

  //      eaDogM_WriteString(s); // wegen Feldname = Pointer auf Feld
 //       eaDogM_WriteString(LCD.line2);
 //       eaDogM_WriteString(LCD.line3);
 //       a=1;
 //       Delayms(500);
          loopcounter ++;
      }
}