ATNEL tech-forum 2015-01-21T08:57:37+01:00 https://forum.atnel.pl/feed.php?f=56&t=10310&mode 2015-01-21T08:57:37+01:00 2015-01-21T08:57:37+01:00 https://forum.atnel.pl/viewtopic.php?t=10310&p=115074#p115074 <![CDATA[Re: attiny 26 - programowy UART.]]> Statystyki: Napisane przez miremeryt — 21 sty 2015, o 08:57

]]> 2015-01-21T06:12:12+01:00 2015-01-21T06:12:12+01:00 https://forum.atnel.pl/viewtopic.php?t=10310&p=115066#p115066 <![CDATA[Re: attiny 26 - programowy UART.]]> . Teraz przetrawię uwagi, szkoda, że nadal bez praktyki. Może dotrze cokolwiek do mnie :oops:
Przede wszystkim dziękuję za szybki odzew.

Statystyki: Napisane przez miremeryt — 21 sty 2015, o 06:12

]]> 2015-01-20T23:00:12+01:00 2015-01-20T23:00:12+01:00 https://forum.atnel.pl/viewtopic.php?t=10310&p=115053#p115053 <![CDATA[Re: attiny 26 - programowy UART.]]> Wstawianie listingów programów w postach.

miremeryt napisał(a):

2) Jak pozbyć się warninga w pliku softuart.

Masz złą nazwę przerwania. Sprawdź sobie w Eclipse.

[syntax=c]#define WITH_STDIO_DEMO 0[/syntax]
Mówi, że nie używasz stdio, ale mimo to wywal to z kodu. Możesz też pozbyć się funkcji operujących na łańcuchach znaków z pamięci flash jeśli nie będziesz miał ich zbyt dużo. Dzięki temu zaoszczędzisz pamięć programu, ale każdy napis wtedy zajmie pamięć RAM.

Usuń zbędne:
[syntax=c]static const char pstring[] PROGMEM =
"adapted for Atmel AVR and this demo by Martin Thomas\r\n";

softuart_puts_P( "\r\nSoftuart Demo-Application\r\n" ); // "implicit" PSTR
softuart_puts_p( PSTR("generic softuart driver code by Colin Gittins\r\n") ); // explicit PSTR
softuart_puts_p( pstring ); // pstring defined with PROGMEM[/syntax]
To zajmuje jakieś 130 bajtów pamięci programu.

Statystyki: Napisane przez Krauser — 20 sty 2015, o 23:00

]]> 2015-01-20T16:57:33+01:00 2015-01-20T16:57:33+01:00 https://forum.atnel.pl/viewtopic.php?t=10310&p=114978#p114978 <![CDATA[attiny 26 - programowy UART.]]> W oparciu o jego parametry (wzmocnienie różnicowe) chciałem zbudować miernik, ale komunikujący się przez UART. Otrzeźwienie przyszło, gdy spojrzałem w notę katalogową. Nie ma sprzętowego UARTA "Tyskie z Polska..." No i zacząłem brnąć. Na razie ściągnąłem (ukradłem) programowy uart i trochę go dostosowałem:

Plik nagłówkowy:

[syntax=c]/*
* softuart.h
*
* Created on: 20-01-2015
* Author: Mirek
*/

#ifndef SOFTUART_H_
#define SOFTUART_H_

#define SOFTUART_BAUD_RATE 9600

#if defined (__AVR_ATtiny26__) // || defined (__AVR_ATtiny45__) || defined (__AVR_ATtiny85__)

#define SOFTUART_RXPIN PINB
#define SOFTUART_RXDDR DDRB
#define SOFTUART_RXBIT PB4

#define SOFTUART_TXPORT PORTB
#define SOFTUART_TXDDR DDRB
#define SOFTUART_TXBIT PB5

#define SOFTUART_T_COMP_LABEL TIM0_COMPA_vect
#define SOFTUART_T_COMP_REG OCR0A
#define SOFTUART_T_CONTR_REGA TCCR0A
#define SOFTUART_T_CONTR_REGB TCCR0B
#define SOFTUART_T_CNT_REG TCNT0
#define SOFTUART_T_INTCTL_REG TIMSK

#define SOFTUART_CMPINT_EN_MASK (1 << OCIE0A)

#define SOFTUART_CTC_MASKA (1 << WGM01)
#define SOFTUART_CTC_MASKB (0)

/* "A timer interrupt must be set to interrupt at three times
the required baud rate." */
#define SOFTUART_PRESCALE (8)
// #define SOFTUART_PRESCALE (1)

#if (SOFTUART_PRESCALE == 8)
#define SOFTUART_PRESC_MASKA (0)
#define SOFTUART_PRESC_MASKB (1 << CS01)
#elif (SOFTUART_PRESCALE==1)
#define SOFTUART_PRESC_MASKA (0)
#define SOFTUART_PRESC_MASKB (1 << CS00)
#else
#error "prescale unsupported"
#endif

/* "A timer interrupt must be set to interrupt at three times
the required baud rate." */
#define SOFTUART_PRESCALE (8)
// #define SOFTUART_PRESCALE (1)

#if (SOFTUART_PRESCALE == 8)
#define SOFTUART_PRESC_MASKA (0)
#define SOFTUART_PRESC_MASKB (1 << CS01)
#elif (SOFTUART_PRESCALE==1)
#define SOFTUART_PRESC_MASKA (0)
#define SOFTUART_PRESC_MASKB (1 << CS00)
#else
#error "prescale unsupported"
#endif

#else
#error "no defintions available for this AVR"
#endif


#define SOFTUART_TIMERTOP ( F_CPU/SOFTUART_PRESCALE/SOFTUART_BAUD_RATE/3 - 1)

#if (SOFTUART_TIMERTOP > 0xff)
#warning "Check SOFTUART_TIMERTOP: increase prescaler, lower F_CPU or use a 16 bit timer"
#endif

#define SOFTUART_IN_BUF_SIZE 32

// Init the Software Uart
void softuart_init(void);

// Clears the contents of the input buffer.
void softuart_flush_input_buffer( void );

// Tests whether an input character has been received.
unsigned char softuart_kbhit( void );

// Reads a character from the input buffer, waiting if necessary.
char softuart_getchar( void );

// To check if transmitter is busy
unsigned char softuart_transmit_busy( void );

// Writes a character to the serial port.
void softuart_putchar( const char );

// Turns on the receive function.
void softuart_turn_rx_on( void );

// Turns off the receive function.
void softuart_turn_rx_off( void );

// Write a NULL-terminated string from RAM to the serial port
void softuart_puts( const char *s );

// Write a NULL-terminated string from program-space (flash)
// to the serial port. example: softuart_puts_p(PSTR("test"))
void softuart_puts_p( const char *prg_s );

// Helper-Macro - "automatically" inserts PSTR
// when used: include avr/pgmspace.h before this include-file
#define softuart_puts_P(s___) softuart_puts_p(PSTR(s___))


#endif
/* SOFTUART_H_ */[/syntax]

Plik Softuart.C:
[syntax=c]/*
* softuart.c
*
* Created on: 20-01-2015
* Author: Mirek
*/


#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

#include "softuart.h"

#define SU_TRUE 1
#define SU_FALSE 0

// startbit and stopbit parsed internally (see ISR)
#define RX_NUM_OF_BITS (8)
volatile static char inbuf[SOFTUART_IN_BUF_SIZE];
volatile static unsigned char qin;
static unsigned char qout;
volatile static unsigned char flag_rx_off;
volatile static unsigned char flag_rx_ready;

// 1 Startbit, 8 Databits, 1 Stopbit = 10 Bits/Frame
#define TX_NUM_OF_BITS (10)
volatile static unsigned char flag_tx_busy;
volatile static unsigned char timer_tx_ctr;
volatile static unsigned char bits_left_in_tx;
volatile static unsigned short internal_tx_buffer; /* ! mt: was type uchar - this was wrong */

#define set_tx_pin_high() ( SOFTUART_TXPORT |= ( 1 << SOFTUART_TXBIT ) );
#define set_tx_pin_low() ( SOFTUART_TXPORT &= ~( 1 << SOFTUART_TXBIT ) );
#define get_rx_pin_status() ( SOFTUART_RXPIN & ( 1 << SOFTUART_RXBIT ) );

ISR(SOFTUART_T_COMP_LABEL)
{
static unsigned char flag_rx_waiting_for_stop_bit = SU_FALSE;
static unsigned char rx_mask;

static unsigned char timer_rx_ctr;
static unsigned char bits_left_in_rx;
static unsigned char internal_rx_buffer;

unsigned char start_bit, flag_in;
unsigned char tmp;

// Transmitter Section
if ( flag_tx_busy == SU_TRUE ) {
tmp = timer_tx_ctr;
if ( --tmp == 0 ) { // if ( --timer_tx_ctr <= 0 )
if ( internal_tx_buffer & 0x01 ) {
set_tx_pin_high();
}
else {
set_tx_pin_low();
}
internal_tx_buffer >>= 1;
tmp = 3; // timer_tx_ctr = 3;
if ( --bits_left_in_tx == 0 ) {
flag_tx_busy = SU_FALSE;
}
}
timer_tx_ctr = tmp;
}

// Receiver Section
if ( flag_rx_off == SU_FALSE ) {
if ( flag_rx_waiting_for_stop_bit ) {
if ( --timer_rx_ctr == 0 ) {
flag_rx_waiting_for_stop_bit = SU_FALSE;
flag_rx_ready = SU_FALSE;
inbuf[qin] = internal_rx_buffer;
if ( ++qin >= SOFTUART_IN_BUF_SIZE ) {
// overflow - reset inbuf-index
qin = 0;
}
}
}
else { // rx_test_busy
if ( flag_rx_ready == SU_FALSE ) {
start_bit = get_rx_pin_status();
// test for start bit
if ( start_bit == 0 ) {
flag_rx_ready = SU_TRUE;
internal_rx_buffer = 0;
timer_rx_ctr = 4;
bits_left_in_rx = RX_NUM_OF_BITS;
rx_mask = 1;
}
}
else { // rx_busy
tmp = timer_rx_ctr;
if ( --tmp == 0 ) { // if ( --timer_rx_ctr == 0 ) {
// rcv
tmp = 3;
flag_in = get_rx_pin_status();
if ( flag_in ) {
internal_rx_buffer |= rx_mask;
}
rx_mask <<= 1;
if ( --bits_left_in_rx == 0 ) {
flag_rx_waiting_for_stop_bit = SU_TRUE;
}
}
timer_rx_ctr = tmp;
}
}
}
}

static void io_init(void)
{
// TX-Pin as output
SOFTUART_TXDDR |= ( 1 << SOFTUART_TXBIT );
// RX-Pin as input
SOFTUART_RXDDR &= ~( 1 << SOFTUART_RXBIT );
}

static void timer_init(void)
{
unsigned char sreg_tmp;

sreg_tmp = SREG;
cli();

//SOFTUART_T_COMP_REG = SOFTUART_TIMERTOP; /* set top */

//SOFTUART_T_CONTR_REGA = SOFTUART_CTC_MASKA | SOFTUART_PRESC_MASKA;
//SOFTUART_T_CONTR_REGB = SOFTUART_CTC_MASKB | SOFTUART_PRESC_MASKB;

//SOFTUART_T_INTCTL_REG |= SOFTUART_CMPINT_EN_MASK;

SOFTUART_T_CNT_REG = 0; /* reset counter */

SREG = sreg_tmp;
}

void softuart_init( void )
{
flag_tx_busy = SU_FALSE;
flag_rx_ready = SU_FALSE;
flag_rx_off = SU_FALSE;

set_tx_pin_high(); /* mt: set to high to avoid garbage on init */

io_init();
timer_init();
}

static void idle(void)
{
// timeout handling goes here
// - but there is a "softuart_kbhit" in this code...
// add watchdog-reset here if needed
}

void softuart_turn_rx_on( void )
{
flag_rx_off = SU_FALSE;
}

void softuart_turn_rx_off( void )
{
flag_rx_off = SU_TRUE;
}

char softuart_getchar( void )
{
char ch;

while ( qout == qin ) {
idle();
}
ch = inbuf[qout];
if ( ++qout >= SOFTUART_IN_BUF_SIZE ) {
qout = 0;

}

return( ch );
}

unsigned char softuart_kbhit( void )
{
return( qin != qout );
}

void softuart_flush_input_buffer( void )
{
qin = 0;
qout = 0;
}

unsigned char softuart_transmit_busy( void )
{
return ( flag_tx_busy == SU_TRUE ) ? 1 : 0;
}

void softuart_putchar( const char ch )
{
while ( flag_tx_busy == SU_TRUE ) {
; // wait for transmitter ready
// add watchdog-reset here if needed;
}

// invoke_UART_transmit
timer_tx_ctr = 3;
bits_left_in_tx = TX_NUM_OF_BITS;
internal_tx_buffer = ( ch << 1 ) | 0x200;
flag_tx_busy = SU_TRUE;
}

void softuart_puts( const char *s )
{
while ( *s ) {
softuart_putchar( *s++ );
}
}

void softuart_puts_p( const char *prg_s )
{
char c;

while ( ( c = pgm_read_byte( prg_s++ ) ) ) {
softuart_putchar(c);
}
}[/syntax]

oraz testowego pliku main.c:

[syntax=c]/*
* main.c
*
* Created on: 20-01-2015
* Author: Mirek
*/

#define WITH_STDIO_DEMO 0 /* 1: enable, 0: disable */

#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include<avr/io.h>
#include "softuart.h"


#if WITH_STDIO_DEMO
#include <stdio.h>

// interface between avr-libc stdio and software-UART
static int my_stdio_putchar( char c, FILE *stream )
{
if ( c == '\n' ) {
softuart_putchar( '\r' );
}
softuart_putchar( c );

return 0;
}

FILE suart_stream = FDEV_SETUP_STREAM( my_stdio_putchar, NULL, _FDEV_SETUP_WRITE );

static void stdio_demo_func( void )
{
stdout = &suart_stream;
printf( "This output done with printf\n" );
printf_P( PSTR("This output done with printf_P\n") );
}
#endif /* WITH_STDIO_DEMO */


int main(void)
{
char c;
static const char pstring[] PROGMEM =
"adapted for Atmel AVR and this demo by Martin Thomas\r\n";
unsigned short cnt = 0;
#if (F_CPU > 4000000UL)
#define CNTHALLO (unsigned int)(0xFFFF)
#else
#define CNTHALLO (unsigned int)(0xFFFF/3)
#endif

softuart_init();
softuart_turn_rx_on(); /* redundant - on by default */

sei();

softuart_puts_P( "\r\nSoftuart Demo-Application\r\n" ); // "implicit" PSTR
softuart_puts_p( PSTR("generic softuart driver code by Colin Gittins\r\n") ); // explicit PSTR
softuart_puts_p( pstring ); // pstring defined with PROGMEM
softuart_puts( "--\r\n" ); // string "from RAM"

#if WITH_STDIO_DEMO
stdio_demo_func();
#endif

for (;;) {

if ( softuart_kbhit() ) {
c = softuart_getchar();
softuart_putchar( '[' );
softuart_putchar( c );
softuart_putchar( ']' );
}

cnt++;
if (cnt == CNTHALLO) {
cnt = 0;
softuart_puts_P( " Hello " );
}

}

return 0;
/* never reached */
}[/syntax].

Otóż mam kilka pytań:

1) Czy w trakcie modyfikacji nie wyciąłem za dużo?
2) Jak pozbyć się warninga w pliku softuart.
"[ ISR(SOFTUART_T_COMP_LABEL) ]"
3) Czy wystarczy pamięci na procedury ADC?

Kompilacja mimo warninga pokazuje 818 bajtów pamięci flash 39,9 %, oraz 52 bajty zajętości pamięci SRAM co stanowi 40,6% zajętości. Może jakieś sugestie zoptymalizowania kodu?
Co przerzucić do eepromu?

Na razie nie mam możliwości przetestowania układu w praktyce, więc działam po omacku. Będę wdzięczny za wszelkie sugestie i proszę o cierpliwość dla "Zielonego" MK

Statystyki: Napisane przez miremeryt — 20 sty 2015, o 16:57

]]>