ATNEL tech-forum 2015-07-04T18:35:37+01:00 https://forum.atnel.pl/feed.php?f=4&t=12184&mode 2015-07-04T18:35:37+01:00 2015-07-04T18:35:37+01:00 https://forum.atnel.pl/viewtopic.php?t=12184&p=133620#p133620 <![CDATA[Re: MMA8452 Obsługa]]> Statystyki: Napisane przez sq5rix — 4 lip 2015, o 18:35

]]> 2015-07-03T16:43:26+01:00 2015-07-03T16:43:26+01:00 https://forum.atnel.pl/viewtopic.php?t=12184&p=133547#p133547 <![CDATA[Re: MMA8452 Obsługa]]> Ruszyła komunikacja. Przyszedł czas na sprawdzenia czy potrafię uruchomić samego scalaka żeby zaczął mierzyć.
W celu sprawdzenia dopisałem taką funkcję:
[syntax=c]uint8_t MMA8452Q_readPL(void){

uint8_t temp;
TWI_read_buf(MMA8452Q_addr,PL_STATUS,1,&temp);
if(temp & 0x40)
return LOCKOUT;
else
return ((temp & 0x6) >> 1);

}[/syntax]
Ma ona za zdanie odczytać położenie i zwrócić odpowiadającą mu wartość.

W pliku main.c wygląda to tak :
[syntax=c]while(1){

if(MMA8452Q_avalible()){
ssd1306_CLR();

GFX_PutInt(0,page1*8,MMA8452Q_readPL(),1,1,0);
ssd1306_display();

_delay_ms(500);
}
}[/syntax]
Niestety mimo wielu prób ciągle zwraca mi jedna i te samą wartość.
Mam pytanie czy dobrze używam funkcji TWI_read_buf() (To jest ta z BB) ?
Wygląda to tak jak by się zacinał na ustawieniach początkowych i nic dalej nie robił.

Statystyki: Napisane przez TomTea — 3 lip 2015, o 16:43

]]> 2015-07-02T16:27:55+01:00 2015-07-02T16:27:55+01:00 https://forum.atnel.pl/viewtopic.php?t=12184&p=133472#p133472 <![CDATA[Re: MMA8452 Obsługa]]> http://atnel.pl/instrukcja-atb-rev-1-04.html, że gdy rozłączasz zworki J8 i J9 to równocześnie "odłączasz" też te rezystory R29 i R31.

Statystyki: Napisane przez anshar — 2 lip 2015, o 16:27

]]> 2015-07-02T14:41:10+01:00 2015-07-02T14:41:10+01:00 https://forum.atnel.pl/viewtopic.php?t=12184&p=133470#p133470 <![CDATA[MMA8452 Obsługa]]> Chciałem napisać bibliotekę do akcelerometru MMA8452, coś w stylu Mirka o OLED. Chciałem przeszczepić kod z Arduino na AVR.
Robiłem to na podstawie tego kodu: (umieszczę link bo dużo do wyklejania by było)
GitHub:
mma8452.c
mma8452.h

Stworzyłem na tej podstawie własną bibliotekę oraz napisałem prosty program do wyświetlania jednej wartości (tak żeby zobaczyć czy w ogóle coś działa):

mma8452q.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <util/delay.h>
#include <stdbool.h>

#include "../I2C_TWI/i2c_twi.h"
#include "mma8452q.h"

void MMA8452Q_init(TMMA8452Q_Scale fsr, TMMA8452Q_ODR odr){

MMA8452Q_standby();
MMA8452Q_setScale(fsr);
MMA8452Q_setODR(odr);
MMA8452Q_setupPL();
MMA8452Q_setupTap(0x80, 0x80, 0x80);
MMA8452Q_active();
}

void MMA8452Q_read(TMMA8452Q *ac){
uint8_t buf[6];

TWI_read_buf(MMA8452Q_addr,OUT_X_MSB,6,buf);
ac->x = ((short)(buf[0] << 8 | buf[1])) >> 4;
ac->y = ((short)(buf[2] << 8 | buf[3])) >> 4;
ac->z = ((short)(buf[4] << 8 | buf[5])) >> 4;


}

uint8_t MMA8452Q_avalible(void){
uint8_t temp;
TWI_read_buf(MMA8452Q_addr,STATUS,1,temp);

return(temp >> 3);
}

/*
* byte MMA8452Q::available()
{
return (readRegister(STATUS) & 0x08) >> 3;
}
*/

void MMA8452Q_active (void){
uint8_t c;
TWI_read_buf(MMA8452Q_addr,CTRL_REG1, 1, c);
c = c | 0x01;
TWI_write_buf(MMA8452Q_addr,CTRL_REG1, 1, c);
}

/*
* void MMA8452Q::active()
{
byte c = readRegister(CTRL_REG1);
writeRegister(CTRL_REG1, c | 0x01); //Set the active bit to begin detection
}
*/

void MMA8452Q_setupPL(void){
uint8_t temp;
// 1. Enable P/L
TWI_read_buf(MMA8452Q_addr,PL_CFG,1,temp);
temp = temp | 0x40;
TWI_write_buf(MMA8452Q_addr,PL_CFG,1,temp);// Set PL_EN (enable)
// 2. Set the debounce rate
temp = 0x50;
TWI_write_buf(MMA8452Q_addr,PL_COUNT,1,temp);// Debounce counter at 100ms (at 800 hz)
}

void MMA8452Q_setupTap (uint8_t xThs, uint8_t yThs, uint8_t zThs){
// Set up single and double tap - 5 steps:
// for more info check out this app note:
// http://cache.freescale.com/files/sensors/doc/app_note/AN4072.pdf
// Set the threshold - minimum required acceleration to cause a tap.
uint8_t temp = 0;
if (!(xThs & 0x80)) // If top bit ISN'T set
{
temp |= 0x3; // Enable taps on x
TWI_write_buf(MMA8452Q_addr,PULSE_THSX,1,xThs);
}
if (!(yThs & 0x80))
{
temp |= 0xC; // Enable taps on y
TWI_write_buf(MMA8452Q_addr,PULSE_THSY,1,yThs);
}
if (!(zThs & 0x80))
{
temp |= 0x30; // Enable taps on z
TWI_write_buf(MMA8452Q_addr,PULSE_THSZ,1,zThs);
}
// Set up single and/or double tap detection on each axis individually.
temp = temp | 0x40;
TWI_write_buf(MMA8452Q_addr,PULSE_CFG,1,temp);
// Set the time limit - the maximum time that a tap can be above the thresh
temp = 0x30;
TWI_write_buf(MMA8452Q_addr,PULSE_TMLT,1,temp);
// Set the pulse latency - the minimum required time between pulses
temp = 0xA0;
TWI_write_buf(MMA8452Q_addr,PULSE_LTCY,1,temp);
// Set the second pulse window - maximum allowed time between end of
//latency and start of second pulse
temp = 0xFF;
TWI_write_buf(MMA8452Q_addr,PULSE_WIND,1,temp);
}

void MMA8452Q_setODR (TMMA8452Q_ODR odr){
uint8_t ctrl;
TWI_read_buf(MMA8452Q_addr,CTRL_REG1,1,ctrl);
ctrl &= 0xCF; // Mask out data rate bits
ctrl |= (odr << 3);
TWI_write_buf(MMA8452Q_addr,CTRL_REG1,1,ctrl);
}


void MMA8452Q_setScale (TMMA8452Q_Scale fsr){
uint8_t cfg;
TWI_read_buf(MMA8452Q_addr,XYZ_DATA_CFG,1,cfg);
cfg &= 0xFC; // Mask out scale bits
cfg |= (fsr >> 2); // Neat trick, see page 22. 00 = 2G, 01 = 4A, 10 = 8G
TWI_write_buf(MMA8452Q_addr,XYZ_DATA_CFG,1,cfg);
}

void MMA8452Q_standby(void){
uint8_t c;
TWI_read_buf(MMA8452Q_addr,CTRL_REG1,1,c);
c = c & ~(0x01);
TWI_write_buf(MMA8452Q_addr,CTRL_REG1,1,c);

}

//uint8_t MMA8452_readRegister(TMMA8452Q_Register reg){

//}[/syntax]

mma8452q.h
[syntax=c]#ifndef MMA8452Q_MMA8452Q_H_
#define MMA8452Q_MMA8452Q_H_

#define MMA8452Q_addr 0x1D // 0x01C lub 0x1D

///////////////////////////////////
// MMA8452Q Register Definitions //
///////////////////////////////////
typedef enum {
STATUS = 0x00,
OUT_X_MSB = 0x01,
OUT_X_LSB = 0x02,
OUT_Y_MSB = 0x03,
OUT_Y_LSB = 0x04,
OUT_Z_MSB = 0x05,
OUT_Z_LSB = 0x06,
SYSMOD = 0x0B,
INT_SOURCE = 0x0C,
WHO_AM_I = 0x0D,
XYZ_DATA_CFG = 0x0E,
HP_FILTER_CUTOFF = 0x0F,
PL_STATUS = 0x10,
PL_CFG = 0x11,
PL_COUNT = 0x12,
PL_BF_ZCOMP = 0x13,
P_L_THS_REG = 0x14,
FF_MT_CFG = 0x15,
FF_MT_SRC = 0x16,
FF_MT_THS = 0x17,
FF_MT_COUNT = 0x18,
TRANSIENT_CFG = 0x1D,
TRANSIENT_SRC = 0x1E,
TRANSIENT_THS = 0x1F,
TRANSIENT_COUNT = 0x20,
PULSE_CFG = 0x21,
PULSE_SRC = 0x22,
PULSE_THSX = 0x23,
PULSE_THSY = 0x24,
PULSE_THSZ = 0x25,
PULSE_TMLT = 0x26,
PULSE_LTCY = 0x27,
PULSE_WIND = 0x28,
ASLP_COUNT = 0x29,
CTRL_REG1 = 0x2A,
CTRL_REG2 = 0x2B,
CTRL_REG3 = 0x2C,
CTRL_REG4 = 0x2D,
CTRL_REG5 = 0x2E,
OFF_X = 0x2F,
OFF_Y = 0x30,
OFF_Z = 0x31
} TMMA8452Q_Register ;

////////////////////////////////
// MMA8452Q Misc Declarations //
////////////////////////////////
typedef enum {SCALE_2G = 2, SCALE_4G = 4, SCALE_8G = 8} TMMA8452Q_Scale ; // Possible full-scale settings
typedef enum {ODR_800, ODR_400, ODR_200, ODR_100, ODR_50, ODR_12, ODR_6, ODR_1} TMMA8452Q_ODR ; // possible data rates
// Possible portrait/landscape settings
#define PORTRAIT_U 0
#define PORTRAIT_D 1
#define LANDSCAPE_R 2
#define LANDSCAPE_L 3
#define LOCKOUT 0x40


typedef struct {

uint16_t x;
uint16_t y;
uint16_t z;
uint8_t buf[5]; //bufor

}TMMA8452Q;

//Funkcje
void MMA8452Q_standby(void);//Tryb wstrzymania, konieczne przy konfiguracji rejestrów
void MMA8452Q_setScale (TMMA8452Q_Scale fsr);//Ustawianie skali
void MMA8452Q_setODR (TMMA8452Q_ODR odr);
void MMA8452Q_setupPL(void);
void MMA8452Q_setupTap (uint8_t xThs, uint8_t yThs, uint8_t zThs);
void MMA8452Q_active (void);
uint8_t MMA8452Q_avalible(void);
void MMA8452Q_init(TMMA8452Q_Scale fsr, TMMA8452Q_ODR odr);
void MMA8452Q_read(TMMA8452Q *ac);


#endif /* MMA8452Q_MMA8452Q_H_ */[/syntax]

main.c
[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <util/delay.h>
#include <stdbool.h>

#include "OLED/ssd1306.h"
#include "I2C_TWI/i2c_twi.h"
#include "MMA8452Q/mma8452q.h"

TMMA8452Q akc;

int main (void){


ssd1306_Init(SSD1306_SWITCHCAPVCC, REFRESH_MAX);

MMA8452Q_init(SCALE_8G, ODR_6);

//TU PRZESTAJE DZIAŁAĆ

GFX_PutString(0,0,"Test MMA8452",1,1,0);
ssd1306_display();




while(1){

if(MMA8452Q_avalible()){
MMA8452Q_read(&akc);

ssd1306_CLR();
GFX_PutInt(0,page1*8,akc.x,1,1,0);
ssd1306_display();

_delay_ms(500);
}
}
}[/syntax]

Niestety program przestaje działać zaraz po wykonaniu MMA8452Q_init() :/

A teraz pytanie gdzie mogę popełniać błąd ? Może gdzieś w komunikacji robię ?

p.s. Dorzucam zdjęcie jak jest podłączone wszystko.
PC1 -> SDA
PC0 -> SCL
Obrazek

Statystyki: Napisane przez TomTea — 2 lip 2015, o 14:41

]]>