[STM8] 发现一个宝贝

/*

 */



#include <mcs51/8051.h>

void delay(int);



void main(void)

{

 int i;

 P2=0x01;

 delay(500);

 while(1)

 {

  for(i=0;i<7;i++)

  {

     P2<<=1;

     delay(500);

  }

   P2=0x01;

 delay(500);

 }

}

void delay(int x)

{

   int i,j;

   for(i=x;i>0l;i--)

     for(j=110;j>0;j--);

}

/* Simple "Hello World" UART output  */

#include <string.h>

#include <stdint.h>

#include "stm8.h"



/* Simple busy loop delay */

void delay(unsigned long count) {

    while (count--)

        nop();

}



int uart_write(const char *str) {

    char i;

    for(i = 0; i < strlen(str); i++) {

        while(!(UART1_SR & UART_SR_TXE)); // !Transmit data register empty

        UART1_DR = str[i];

    }

    return(i); // Bytes sent

}



int main(void)

{

    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    // Setup UART1 (TX=D5)

    UART1_CR2 |= UART_CR2_TEN; // Transmitter enable

    // UART1_CR2 |= UART_CR2_REN; // Receiver enable

    UART1_CR3 &= ~(UART_CR3_STOP1 | UART_CR3_STOP2); // 1 stop bit

    // 9600 baud: UART_DIV = 16000000/9600 ~ 1667 = 0x0683

    UART1_BRR2 = 0x03; UART1_BRR1 = 0x68; // 0x0683 coded funky way (see ref manual)



    while(1) {

        uart_write("Hello World!\r\n");

        delay(400000L);

    }

}

/*

 * Blink a LED every second using timer TIM2 and its Update/Overflow interrupt

 */

#include <stdint.h>

#include "stm8.h"



/* Build in LED is in pin B5 (STM8S103 board) or D3 (STM8S003F3 board) */

#ifdef STM8S103

#define LED_PORT    PB

#define LED_PIN     PIN5

#else

#define LED_PORT    PD

#define LED_PIN     PIN3

#endif



/* TIM2 Update/Overflow interrupt handling routine */

void TIM2_update(void) __interrupt(TIM2_OVR_UIF_IRQ) {

    // Blink internal LED. Port B (or D) output data register. Flip pin 5 (or 3)

    PORT(LED_PORT, ODR) ^= LED_PIN;



    // Clear Timer 2 Status Register 1 Update Interrupt Flag (UIF) (bit 0)

    TIM2_SR1 &= ~TIM_SR1_UIF;

}



int main(void)

{

    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    /* GPIO of LED pin setup */

    // Set pin data direction as output

    PORT(LED_PORT, DDR)  |= LED_PIN; // i.e. PB_DDR |= (1 << 5);

    // Set pin as "Push-pull"

    PORT(LED_PORT, CR1)  |= LED_PIN; // i.e. PB_CR1 |= (1 << 5);



    /* TIM2 setup */

    // Prescaler register

    TIM2_PSCR = 14; // 2^14==16384, 16MHz/16384==976.5625 Hz

    // set Counter Auto-Reload Registers - TIM2_ARR=977 == 0x03D1, about once per second

    TIM2_ARRH = 0x03;

    TIM2_ARRL = 0xd1;

    // TIM2_IER (Interrupt Enable Register), Update interrupt (UIE) (bit 0)

    TIM2_IER |= TIM_IER_UIE;

    // TIM2_CR1 – Timer 2 Control Register 1, Counter ENable bit (CEN) (bit 0)

    TIM2_CR1 |= TIM_CR1_CEN;



    /* Loop infinitely waiting for an interrupt */

        while(1) {

        wfi();

    }

}

/*

 * 8 digit 7-segment LED display with MAX7219 controller chip

 * DIN <-> C6 (MOSI)

 * CS  <-> D2 (slave select)

 * CLK <-> C5 (clock)

 */



#include <stdint.h>

#include "stm8.h"



/* Build in LED is in pin B5 (STM8S103 board) or D3 (STM8S003F3 board) */

#ifdef STM8S103

#define LED_PORT    PB

#define LED_PIN     PIN5

#else

#define LED_PORT    PD

#define LED_PIN     PIN3

#endif



/* TIM1 Update/Overflow interrupt handling routine */

void TIM1_update(void) __interrupt(TIM1_OVR_UIF_IRQ) {

    // Blink internal LED. Port B (or D) output data register. Flip pin 5 (or 3)

    PORT(LED_PORT, ODR) ^= LED_PIN;



    // Clear Timer Status Register 1 Update Interrupt Flag (UIF) (bit 0)

    TIM1_SR1 &= ~TIM_SR1_UIF;

}





void setup_spi() {

    // SPI port setup: MISO is pullup in, MOSI & SCK are push-pull out

    PC_DDR |= PIN5 | PIN6; // clock and MOSI

    PC_CR1 |= PIN5 | PIN6 | PIN7;



    // CS/SS (PD2) as output

    PD_DDR |= PIN2;

    PD_CR1 |= PIN2;

    PD_ODR |= PIN2; // CS high



    // SPI registers: First reset everything

    SPI_CR1 = 0;

    SPI_CR2 = 0;



    // SPI_CR1 LSBFIRST=0 (MSB is transmitted first)

    SPI_CR1 &= ~SPI_CR1_LSBFIRST;

    // Baud Rate Control: 0b111 = fmaster / 256 (62,500 baud)

    SPI_CR1 |= SPI_CR1_BR(0b111);

    // SPI_CR1 CPOL=0 (Clock Phase, The first clock transition is the first data capture edge)

    SPI_CR1 &= ~SPI_CR1_CPOL;

    // SPI_CR1 CPHA=0 (Clock Polarity, SCK to 0 when idle)

    SPI_CR1 &= ~SPI_CR1_CPHA;



    SPI_CR2 |= SPI_CR2_SSM; // bit 1 SSM=1 Software slave management, enabled

    SPI_CR2 |= SPI_CR2_SSI; // bit 0 SSI=1 Internal slave select, Master mode

    SPI_CR1 |= SPI_CR1_MSTR;  // CR1 bit 2 MSTR = 1, Master configuration.

}



uint8_t SPIOut(uint8_t data) {

    SPI_CR1 |= SPI_CR1_MSTR;;  // MSTR = 1, Master device.

    SPI_CR1 |= SPI_CR1_SPE; // SPE, SPI Enable, Peripheral enabled

    SPI_DR = data;

    while (SPI_SR & SPI_SR_BSY); // SPI is busy in communication or Tx buffer is not empty

    SPI_CR1 &= ~SPI_CR1_SPE; // Disable SPI

    data = SPI_DR;

    return data; // Not yet used.

}



void output_max(uint8_t address, uint8_t data) {

    PD_ODR &= ~PIN2; // CS low

    SPIOut(address);

    SPIOut(data);

    PD_ODR |= PIN2; // CS high

}



void init_max7219() {

    uint8_t i;

    output_max(0x0f, 0x00); //display test register - test mode off

    output_max(0x0c, 0x01); //shutdown register - normal operation

    output_max(0x0b, 0x07); //scan limit register - display digits 0 thru 7

    output_max(0x0a, 0x01); //intensity register (1 = 3/32 on.  0xf is max)

    output_max(0x09, 0xff); //decode mode register - CodeB decode all digits

    // Blank all digits

    for (i=1; i <= 8; i++) {

        output_max(i, 0xf);

    }

}



void display_number(uint32_t number) {

    uint8_t pos=1;

    if (number == 0)

        output_max(pos++, 0);

    while (number > 0) {

        uint8_t digit = number % 10;

        output_max(pos++, digit);

        number /= 10;

    }

    // clear rest of digits

    while (pos <= 8) {

        output_max(pos++, 0xf);

    }

}



int main(void)

{

    uint32_t counter = 0;



    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    // Setup internal LED

    PORT(LED_PORT, DDR)  |= LED_PIN;

    PORT(LED_PORT, CR1)  |= LED_PIN;



    setup_spi();

    init_max7219();



    /* TIM1 setup: Generate interrupt every 1000ms */

    TIM1_CR1 = 0;

    // Just for fun, let's count down (TIM1 can do that)

    TIM1_CR1 |= TIM_CR1_DIR;

    // Prescaler: divide clock with 16000 (0x3E7F + 1) (to 1ms)

    TIM1_PSCRH = 0x0E;

    TIM1_PSCRL = 0x7F;

    // Auto-reload registers. Count to 1000 (0x03E8)

    TIM1_ARRH = 0x13;

    TIM1_ARRL = 0xE8;

    // TIM1_IER (Interrupt Enable Register), Update interrupt (UIE) (bit 0)

    TIM1_IER |= TIM_IER_UIE;

    // TIM1_CR1 – Timer Control Register 1, Counter ENable bit (CEN) (bit 0)

    TIM1_CR1 |= TIM_CR1_CEN;



    /* Loop infinitely waiting for an interrupt */

    while(1) {

        wfi();

        display_number(counter++);

        if (counter > 99999999) // In case we are running this for years :-)

            counter = 0;

    }

}

/*

 * DS18B20 input to port D4

 * 8 digit 7-segment LED display with MAX7219 controller chip

 * DIN <-> C6 (MOSI)

 * CS  <-> D2 (slave select)

 * CLK <-> C5 (clock)

 */



#include <stdint.h>

#include "stm8.h"



/* 1-Wire (DS18B20 data) pin */

#define OW_PORT PA

#define OW_PIN  PIN3





/* Simple busy loop delay */

void delay(unsigned long count) {

    while (count--)

        nop();

}



/* For LED-display */

void setup_spi() {

    // SPI port setup: MISO is pullup in, MOSI & SCK are push-pull out

    PC_DDR |= PIN5 | PIN6; // clock and MOSI

    PC_CR1 |= PIN5 | PIN6 | PIN7;



    // CS/SS (PD2) as output

    PD_DDR |= PIN2;

    PD_CR1 |= PIN2;

    PD_ODR |= PIN2; // CS high



    // SPI registers: First reset everything

    SPI_CR1 = 0;

    SPI_CR2 = 0;



    // SPI_CR1 LSBFIRST=0 (MSB is transmitted first)

    SPI_CR1 &= ~SPI_CR1_LSBFIRST;

    // Baud Rate Control: 0b111 = fmaster / 256 (62,500 baud)

    SPI_CR1 |= SPI_CR1_BR(0b111);

    // SPI_CR1 CPOL=0 (Clock Phase, The first clock transition is the first data capture edge)

    SPI_CR1 &= ~SPI_CR1_CPOL;

    // SPI_CR1 CPHA=0 (Clock Polarity, SCK to 0 when idle)

    SPI_CR1 &= ~SPI_CR1_CPHA;



    SPI_CR2 |= SPI_CR2_SSM; // bit 1 SSM=1 Software slave management, enabled

    SPI_CR2 |= SPI_CR2_SSI; // bit 0 SSI=1 Internal slave select, Master mode

    SPI_CR1 |= SPI_CR1_MSTR;  // CR1 bit 2 MSTR = 1, Master configuration.

}



uint8_t SPIOut(uint8_t data) {

    SPI_CR1 |= SPI_CR1_MSTR;;  // MSTR = 1, Master device.

    SPI_CR1 |= SPI_CR1_SPE; // SPE, SPI Enable, Peripheral enabled

    SPI_DR = data;

    while (SPI_SR & SPI_SR_BSY); // SPI is busy in communication or Tx buffer is not empty

    SPI_CR1 &= ~SPI_CR1_SPE; // Disable SPI

    data = SPI_DR;

    return data; // Not yet used.

}



void output_max(uint8_t address, uint8_t data) {

    PD_ODR &= ~PIN2; // CS low

    SPIOut(address);

    SPIOut(data);

    PD_ODR |= PIN2; // CS high

}



void init_max7219() {

    uint8_t i;

    output_max(0x0f, 0x00); //display test register - test mode off

    output_max(0x0c, 0x01); //shutdown register - normal operation

    output_max(0x0b, 0x07); //scan limit register - display digits 0 thru 7

    output_max(0x0a, 0x01); //intensity register (1 = 3/32 on.  0xf is max)

    output_max(0x09, 0xff); //decode mode register - CodeB decode all digits

    // Blank all digits

    for (i=1; i <= 8; i++) {

        output_max(i, 0xf);

    }

}



void display_number_dot(uint32_t number, uint8_t dot_pos, uint8_t is_negative) {

    uint8_t pos=1;

    if (number == 0)

        output_max(pos++, 0);

    while (number > 0 || dot_pos >= pos) {

        uint8_t digit = number % 10;

        if (pos == dot_pos) {

            digit = digit | 0x80;

        }

        output_max(pos++, digit);

        number /= 10;

    }

    if (is_negative) {

        output_max(pos++, 0xa);

    }

    // clear rest of digits

    while (pos <= 8) {

        output_max(pos++, 0xf);

    }

}



/********************** OneWire/DS18B20 routines ***************************/

void delay_us(uint16_t i) {

    if (i < 9) { // FIXME: Really ugly

        nop();

        return;

    }

    TIM2_CNTRH = 0;

    TIM2_CNTRL = 0;

    TIM2_EGR = 0x01; // Update Generation

    while(1) {

        volatile uint16_t counter = (((TIM2_CNTRH) << 8) | TIM2_CNTRL);

        if (i-6 < counter)

            return;

    }

}



#define OW_INPUT_MODE()     PORT(OW_PORT,DDR) &= ~OW_PIN

#define OW_OUTPUT_MODE()    PORT(OW_PORT,DDR) |= OW_PIN

#define OW_LOW()            PORT(OW_PORT,ODR) &= ~OW_PIN

#define OW_HIGH()           PORT(OW_PORT,ODR) |= OW_PIN

#define OW_READ()           (PORT(OW_PORT,IDR) & OW_PIN)



void ow_pull_low(unsigned int us) {

    OW_OUTPUT_MODE();

    OW_LOW();

    delay_us(us);

    OW_INPUT_MODE();

}



void ow_write_byte(uint8_t out) {

    uint8_t i;

    for (i=0; i < 8; i++) {

        if ( out & ((uint8_t)1<<i) ) {

            // write 1

            ow_pull_low(1);

            delay_us(60);

        } else {

            // write 0

            ow_pull_low(60);

            delay_us(1);

        }

    }

}



uint8_t ow_read_byte() {

    uint8_t val = 0;

    uint8_t i;

    for (i=0; i < 8; i++) {

        ow_pull_low(1);

        delay_us(5);

        if (OW_READ()) {

            val |= ((uint8_t)1<<i);

        }

        delay_us(55);

    }

    return val;

}



unsigned int ow_init() {



    uint8_t input;



    ow_pull_low(480);

    delay_us(60);



    input = !OW_READ();

    delay_us(420);



    return input;

}



unsigned int ow_convert_temperature() {

    int cycles = 1; // For debugging purposes



    ow_write_byte(0x44); // Convert Temperature



    while (1) {

        ow_pull_low(1);

        delay_us(5);

        if (OW_READ()) {

            return cycles;

        }

        delay_us(55);

        cycles++;

    }

}



void display_ds_temperature(uint8_t high, uint8_t low) {

    uint8_t is_negative = 0;

    uint16_t decimals = 0; // 4 decimals (e.g. decimals 625 means 0.0625)

    uint16_t i;



    uint16_t temp = ((int16_t)high << 8) | low;

    if (temp & 0x8000) {

        is_negative = 1;

        temp = (~temp) + 1;

    }

    low = temp & 0x0f;

    temp = temp >> 4;



    // low[3:0] mean values 0.5,0.25,0.125 and 0.0625

    for (i=625; i <= 5000; i=i*2) {

        if (low & 0x01) {

            decimals += i;

        }

        low = low >> 1;

    }



    // Display temperature rounded to one decimal

    display_number_dot((temp*1000 + ((decimals+5)/10) + 50)/100, 2, is_negative);

}



void read_ds18b20() {

    uint8_t i;

    uint8_t scratchpad[9];



    if (ow_init()) {

        ow_write_byte(0xcc); // Skip ROM

        ow_convert_temperature();



        ow_init();

        ow_write_byte(0xcc); // Skip ROM

        ow_write_byte(0xbe); // Read Scratchpad

        for (i=0; i<9; i++) {

            scratchpad[i] = ow_read_byte();

        }



        display_ds_temperature(scratchpad[1], scratchpad[0]);



    } else {

        /* DS18B20 was not detected */

        output_max(0x8, 0xa);

    }

}



/***************************************************************************/







int main(void)

{

    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    // Timer setup (for delay_us)

    TIM2_PSCR = 0x4; // Prescaler: to 1MHz

    TIM2_CR1 |= TIM_CR1_CEN; // Start timer



    setup_spi();

    init_max7219();



    while(1) {

        read_ds18b20();

        delay(10000L);

    }

}

/* The "Hello world!" of microcontrollers. Blink LED on/off */

#include <stdint.h>

#include "stm8.h"





/* Build in LED is in pin B5 (STM8S103 board) or D3 (STM8S003F3 board) */

#ifdef STM8S103

#define LED_PORT    PB

#define LED_PIN     PIN5

#else

#define LED_PORT    PD

#define LED_PIN     PIN3

#endif



/* Simple busy loop delay */

void delay(unsigned long count) {

    while (count--)

        nop();

}



int main(void)

{

    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    /* GPIO setup */

    // Set pin data direction as output

    PORT(LED_PORT, DDR)  |= LED_PIN; // i.e. PB_DDR |= (1 << 5);

    // Set pin as "Push-pull"

    PORT(LED_PORT, CR1)  |= LED_PIN; // i.e. PB_CR1 |= (1 << 5);



        while(1) {

        // LED on

        PORT(LED_PORT, ODR) |= LED_PIN; // PB_ODR |= (1 << 5);

        delay(100000L);

        // LED off

        PORT(LED_PORT, ODR) &= ~LED_PIN; // PB_ODR &= ~(1 << 5);

        delay(300000L);

    }

}

/*

 * Analog input to port D4

 * 8 digit 7-segment LED display with MAX7219 controller chip

 * DIN <-> C6 (MOSI)

 * CS  <-> D2 (slave select)

 * CLK <-> C5 (clock)

 */



#include <stdint.h>

#include "stm8.h"



/* Simple busy loop delay */

void delay(unsigned long count) {

    while (count--)

        nop();

}



void init_adc() {

    ADC_CSR = 0;

    ADC_CR1 = 0;

    ADC_CR2 = 0;

    ADC_CR3 = 0;



/*

    ADC_DRH = 0;

    ADC_DRL = 0;

    ADC_TDRH = 0;

    ADC_TDRL = 0;

    ADC_HTRH = 0;

    ADC_HTRL = 0;

    ADC_LTRH = 0;

    ADC_LTRL = 0;

    ADC_AWSRH = 0;

    ADC_AWSRL = 0;

    ADC_AWCRH = 0;

    ADC_AWCRL = 0;

*/

    ADC_CSR = 2; // Select channel 2 (AIN2=PC4)



    ADC_CR1 |= ADC_CR1_ADON; // ADON

    ADC_CR2 &= ~ADC_CR2_ALIGN; // Align left



    delay(1000); // Give little time to be ready for first conversion

}



uint16_t analog_read() {

    ADC_CR1 &= ~ADC_CR1_CONT; // Single conversion mode

    ADC_CR1 |= ADC_CR1_ADON; // Start conversion

    do { nop(); } while ((ADC_CSR >> 7) == 0);

    ADC_CSR &= ~ADC_CSR_EOC; // Clear "End of conversion"-flag

    return (ADC_DRH << 2) | (ADC_DRL >> 6);  // Left aligned

}



/* For LED-display */

void setup_spi() {

    // SPI port setup: MISO is pullup in, MOSI & SCK are push-pull out

    PC_DDR |= PIN5 | PIN6; // clock and MOSI

    PC_CR1 |= PIN5 | PIN6 | PIN7;



    // CS/SS (PD2) as output

    PD_DDR |= PIN2;

    PD_CR1 |= PIN2;

    PD_ODR |= PIN2; // CS high



    // SPI registers: First reset everything

    SPI_CR1 = 0;

    SPI_CR2 = 0;



    // SPI_CR1 LSBFIRST=0 (MSB is transmitted first)

    SPI_CR1 &= ~SPI_CR1_LSBFIRST;

    // Baud Rate Control: 0b111 = fmaster / 256 (62,500 baud)

    SPI_CR1 |= SPI_CR1_BR(0b111);

    // SPI_CR1 CPOL=0 (Clock Phase, The first clock transition is the first data capture edge)

    SPI_CR1 &= ~SPI_CR1_CPOL;

    // SPI_CR1 CPHA=0 (Clock Polarity, SCK to 0 when idle)

    SPI_CR1 &= ~SPI_CR1_CPHA;



    SPI_CR2 |= SPI_CR2_SSM; // bit 1 SSM=1 Software slave management, enabled

    SPI_CR2 |= SPI_CR2_SSI; // bit 0 SSI=1 Internal slave select, Master mode

    SPI_CR1 |= SPI_CR1_MSTR;  // CR1 bit 2 MSTR = 1, Master configuration.

}



uint8_t SPIOut(uint8_t data) {

    SPI_CR1 |= SPI_CR1_MSTR;;  // MSTR = 1, Master device.

    SPI_CR1 |= SPI_CR1_SPE; // SPE, SPI Enable, Peripheral enabled

    SPI_DR = data;

    while (SPI_SR & SPI_SR_BSY); // SPI is busy in communication or Tx buffer is not empty

    SPI_CR1 &= ~SPI_CR1_SPE; // Disable SPI

    data = SPI_DR;

    return data; // Not yet used.

}



void output_max(uint8_t address, uint8_t data) {

    PD_ODR &= ~PIN2; // CS low

    SPIOut(address);

    SPIOut(data);

    PD_ODR |= PIN2; // CS high

}



void init_max7219() {

    uint8_t i;

    output_max(0x0f, 0x00); //display test register - test mode off

    output_max(0x0c, 0x01); //shutdown register - normal operation

    output_max(0x0b, 0x07); //scan limit register - display digits 0 thru 7

    output_max(0x0a, 0x01); //intensity register (1 = 3/32 on.  0xf is max)

    output_max(0x09, 0xff); //decode mode register - CodeB decode all digits

    // Blank all digits

    for (i=1; i <= 8; i++) {

        output_max(i, 0xf);

    }

}



void display_number(uint32_t number) {

    uint8_t pos=1;

    if (number == 0)

        output_max(pos++, 0);

    while (number > 0) {

        uint8_t digit = number % 10;

        output_max(pos++, digit);

        number /= 10;

    }

    // clear rest of digits

    while (pos <= 8) {

        output_max(pos++, 0xf);

    }

}



int main(void)

{

    /* Set clock to full speed (16 Mhz) */

    CLK_CKDIVR = 0;



    init_adc();

    setup_spi();

    init_max7219();



    while(1) {

        display_number(analog_read());

        delay(100000L);

    }

}